Estou usando a biblioteca smtp-mail para enviar e-mails do meu aplicativo com a função sendMailWithLogin' .
Gostaria de saber se o e-mail foi entregue com sucesso ou se ele retornou. E se ele retornou, com qual código de erro? Todas as funções retornam IO ()e vasculhando o código, há muitas camadas de IO (). Existe alguma maneira de obter essas informações com esta biblioteca? Ou talvez haja alguma outra biblioteca que possa ser usada?
Tenho alguns cálculos marcados com um tipo ('A/'B) de um tipo específico (T). Gostaria de eventualmente depender do tipo do código, então mapeio o tipo de volta, usando uma instância:
data T = A | B -- also generates types 'A and 'B
class R (t :: T) where r :: Proxy t -> T
instance R 'A where r _ = A
instance R 'B where r _ = B
foo :: forall (t :: T) . R t => Bar T Int
foo = case r (Proxy :: Proxy t) of A -> ....
Isso é ok, mas eu me pergunto se eu posso poupar a escrita da R trestrição o tempo todo, se eu de qualquer forma tiver o tipo tanotado com o kind. Alguma reorganização desse esquema é possível para uso mais conveniente? Obrigado.
(Edição de título: originalmente escrevi família de tipos fechada, mas aqui é mais um conjunto fechado de tipos para o tipo fornecido.)
Estou tentando escrever uma função que pega uma instância de classe da minha classe personalizada VectorSpace(que tem o formato class VectorSpace t (n :: Nat) a where) e executa eliminação gaussiana nela. Atualmente, a função se parece com isso:
rowEchelon
:: ( forall m. KnownNat m
, forall n. KnownNat n
, Field a
, VectorSpace t m a
, VectorSpace t n a
)
=> (forall k b. t k b -> Int -> b) -- ^ Indexing function
-> t m (t n a) -- ^ Matrix
-> t m (t n a) -- ^ Resultant row-echelon matrix
rowEchelon indexFunc = loop 0 0
where
loop h k matrix
| h >= mLen || k >= nLen = matrix
| otherwise = undefined
mLen = natVal (Proxy :: Proxy m)
nLen = natVal (Proxy :: Proxy n)
com as seguintes extensões de linguagem:
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
No entanto, estou recebendo o seguinte erro:
• Illegal polymorphic type: forall (m1 :: Nat). KnownNat m1
A constraint must be a monotype
• In the type signature:
rowEchelon :: (forall m. KnownNat m,
forall n. KnownNat n,
Field a,
VectorSpace t m a,
VectorSpace t n a) =>
-- | Indexing function
(forall k b. t k b -> Int -> b)
-> -- | Matrix
t m (t n a)
-> -- | Resultant row-echelon matrix
t m (t n a)
• Perhaps you intended to use QuantifiedConstraints (typecheck)
Mas adicionar QuantifiedConstraintsleva ao seguinte aviso no forall m. KnownNat me forall n. KnownNat n:
This binding for ‘[m or n depending on the line]’ shadows the existing binding
e o seguinte erro em mLene nLen:
• Couldn't match kind ‘*’ with ‘GHC.Num.Natural.Natural’
When matching types
proxy0 :: Nat -> *
Proxy :: * -> *
Expected: proxy0 [n1 or n2]
Actual: Proxy n0
• In the first argument of ‘natVal’, namely ‘(Proxy :: Proxy [m or n])’
In the expression: natVal (Proxy :: Proxy [m or n])
In an equation for ‘nLen’: nLen = natVal (Proxy :: Proxy [m or n]) (typecheck -Wdeferred-type-errors)
Como posso resolver esse conflito de digitação?
Eu tento usar uma biblioteca regex-applicative .
Meu código é:
nicBeg = ((psym $ not . isSpace) $> (few anySym <> " adapter ")) *> some anySym
result = match nicBeg "abcd adapter NIC 1"
e vejo que resulté Just "bcd adapter NIC 1".
Mas a documentação *>diz:
*> :: forall (f :: Tipo -> Tipo) a b. Aplicativo f => fa -> fb -> fb
Definido em 'GHC.Base' (base-4.16.4.0)
Ações de sequência, descartando o valor do primeiro argumento.
Então, a questão é: por que a parte "bcd adapter" existe no resulte não apenas "NIC 1" (ele não foi descartado )? É um problema da biblioteca ou estou errado em algum lugar?
PS. A biblioteca tem um conceito de expressões RE "gananciosas".
PS. É fácil obter um resultado esperado: ((psym $ not . isSpace) *> (few anySym <> " adapter ")) *> some anySym (ou seja, substituir $>por *>)
Eu tenho um tipo de termo que, em essência, é:
data Term a = Term a Bool
deriving Show
O Boolé um tipo de ajudante, e é necessário apenas ocasionalmente. Gostaria que o usuário pudesse ignorá-lo se não for necessário. Ou seja, o seguinte deve funcionar:
main :: IO ()
main = print v
where v = "a"
=: Term "b" True
=: []
onde:
class Join a b where
(=:) :: a -> [b] -> [b]
infixr 1 =:
instance Join a (Term a) where
x =: y = Term x False : y
instance Join (Term a) (Term a) where
x =: y = x : y
Infelizmente, o GHC reclama:
a.hs:15:8-12: error: [GHC-39999]
• Ambiguous type variable ‘b0’ arising from a use of ‘print’
prevents the constraint ‘(Show b0)’ from being solved.
Relevant bindings include v :: [b0] (bound at a.hs:17:8)
Mas se eu escrever mainassim:
main :: IO ()
main = print v
where v :: [Term String]
v = "a"
=: Term "b" True
=: []
Então está tudo bem. (Observe que a única diferença é que dei vuma assinatura de tipo.)
Estou curioso para saber se existe algum truque moderno do GHC (famílias de tipos, famílias de tipos injetivos, famílias de tipos fechados, GADTs, etc., ou algum sinalizador mágico) que tornaria a assinatura de tipo desnecessária e permitiria que o GHC deduzisse o tipo sozinho, sem qualquer ajuda.
Aqui está o programa na íntegra:
data Term a = Term a Bool
deriving Show
class Join a b where
(=:) :: a -> [b] -> [b]
infixr 1 =:
instance Join a (Term a) where
x =: y = Term x False : y
instance Join (Term a) (Term a) where
x =: y = x : y
main :: IO ()
main = print v
where v :: [Term String] -- Want to avoid this signature and let GHC deduce it.
v = "a"
=: Term "b" True
=: []
E a questão é se há algum recurso ou truque do GHC que eu possa aplicar para que a assinatura de tipo em vnão seja necessária. Também estou feliz em mudar a Joinclasse ou adicionar novos parâmetros/dependências etc., desde que a definição local de vpossa ser escrita como está sem a assinatura de tipo.
Eu também apreciaria uma explicação de por que isso não seria possível, se houver uma boa razão legítima para que o que estou pedindo seja irracional. Parece-me que há informações de tipo suficientes para que o GHC deduza o tipo em si, mas suspeito que algum tipo de suposição de "mundo aberto" esteja acontecendo e nenhum dos truques de "família de tipos fechados" funcionará; se esse for realmente o caso. Para ser claro, estou perfeitamente feliz que a Joinclasse nunca seja instanciada em nenhum outro tipo.
Existe alguma maneira de fazer isso?
type V = VList
{- type V2 a = V (V a)
type V4 a = V2 (V2 a)
type V8 a = V4 (V4 a)
type V16 a = V8 (V8 a)
type V32 a = V16 (V16 a) -}
type C a b c = a (b c)
type D a b = a b b
type E = D C
type V2 a = V (V a)
type V4 = E V2
type V8 = E V4
type V16 = E V8
type V32 = E V16
Eu quero fazer esse tipo por exemplo
type Vector25 = C (C V16 V8) V Empty
Sem ter que fazer
type Vector25 = (V16 (V8 (V Empty))
Aqui está um módulo:
module Foo where
foo ws = let ws' = take 3 $ ws ++ repeat mempty
x = ws' !! 0
y = ws' !! 1
z = ws' !! 2
in [x, y, z]
e aqui vai mais um
module Foo where
foo ws = let (x:y:z:_) = take 3 $ ws ++ repeat mempty
in [x, y, z]
Via ghc -O2 -c foo.hs, eles compilam para 8072 e 5288 bytes, respectivamente. Não tenho certeza de qual é o melhor, nem como testá-los, mas acho que eles não podem se comportar de forma idêntica, em termos de desempenho, simplesmente porque são diferentes.
As duas funções se comportam de forma diferente? Se não, a diferença no binário gerado é devido a uma otimização perdida? Ou o quê?
Tenho uma pasta cheia de notas alfabetizadas de Haskell que estão organizadas sequencialmente assim:
\lhs_notes
'1 - Intro.lhs'
'2 - Seq.lhs'
...
E cada um desses arquivos define um módulo Intro, Seq, e assim por diante. Existe uma maneira de especificar em um .cabalarquivo caminhos explícitos para todos esses módulos? Porque para fins organizacionais, quero manter os nomes dos arquivos como estão, mas não tenho ideia de como fazer o cabal encontrar qualquer um desses módulos.
Aqui estou tentando reimplementar um máximo seguro usando dobras
import Data.ByteString (foldl')
maximum' :: Ord a => [a] -> Maybe a
maximum' = foldl (\ acc x -> max acc (Just x)) Nothing
maximum'' :: Ord a => [a] -> Maybe a
maximum'' = foldl' (\ acc x -> max acc (Just x)) Nothing
A primeira função que usa foldl está funcionando corretamente, mas a segunda dá este erro:
• Couldn't match expected type ‘a’
with actual type ‘GHC.Word.Word8’
‘a’ is a rigid type variable bound by
the type signature for:
maximum'' :: forall a. Ord a => [a] -> Maybe a
at /home/mali/Projects/Deneme/HigherOrder.hs:60:1-36
• In the first argument of ‘Just’, namely ‘x’
In the second argument of ‘max’, namely ‘(Just x)’
In the expression: max acc (Just x)
Não deveria foldl'ser apenas uma versão mais eficiente de foldl?
Tenho estudado profundamente foldTreea função em Haskell, que é definida da seguinte forma:
foldTree :: (a -> [b] -> b) -> Tree a -> b
foldTree f = go where
go (Node x ts) = f x (map go ts)
Recentemente me deparei com a seguinte interpretação da frase:
quando chamamos
f x vs, assumimos quexevsjá estão vinculados a valores conhecidos.
go (Node x ts) = f x (map go ts)
xjá está vinculado da maneira esperada e familiar.vsainda; a vinculação de vsé adiada até que a recursão em toda a subfloresta seja concluída.A menção de um elemento de tempo (usando termos como "já" e "ainda") me confunde. Para entender melhor isso, comecei a experimentar alguns conceitos emprestados de provas de dedução natural e indução. Especificamente, tentei conceituar o segundo argumento de fcomo segue:
[b]esteja definido.fem termos de combinação deste [b]tipo assumido com o atipo para definir a expressão geral foldTree f tree, onde treetem tipo Tree a.Como eu poderia refinar essa linha de pensamento em termos de suposições e não usar avaliação de função real, assumindo que está correta? Alternativamente, há outra perspectiva formal ou intuitiva que eu poderia adotar para entender melhor essa função e sua mecânica?