Expressões lambda sem parâmetros no cálculo de Haskell e / ou lambda

Em linguagens ansiosas como Scheme e Python, você pode usar uma expressão lambda sem parâmetros para atrasar a avaliação, por exemplo, em Scheme (Chicken Scheme):

#;1> (define (make-thunk x) (lambda () (+ x 1)))
#;2> (define t (make-thunk 1))
#;3> (t)
2

Na linha 2, té vinculado à expressão não avaliada (lambda () (+ 1 1)), que é avaliada 2na linha 3.

Da mesma forma, em Python:

>>> def make_thunk(x): return lambda: x + 1
... 
>>> t = make_thunk(1)
>>> t()
2

Usando essa técnica, é possível implementar uma avaliação lenta em um idioma ansioso.

Então, eu esperava que Haskell não tivesse expressões lambda sem parâmetros, porque a linguagem já é preguiçosa e não há necessidade de criar expressões atrasadas. Para minha surpresa, descobri que em Haskell é possível escrever a expressão lambda

\() -> "s"

que só pode ser aplicado ao ()valor da seguinte forma:

(\() -> "s") ()

dando o resultado

"s"

A aplicação desta função a qualquer argumento que não seja ()lança uma exceção (pelo menos até onde pude ver durante meus testes). Isso parece diferente da avaliação atrasada em Scheme e Python, porque a expressão ainda precisa de um argumento para ser avaliado. Então, o que uma expressão lambda sem variáveis ​​(como \() -> "s") significa em Haskell e para que ela pode ser útil?

Além disso, eu ficaria curioso para saber se existem expressões lambda sem parâmetros semelhantes em (alguma variedade de) cálculo lambda.

Bem, as outras respostas cobrem o que \() -> "something"significa em Haskell: uma função unária que toma ()como argumento.

• O que é uma função sem argumentos? - Um valor. Na verdade, ocasionalmente pode ser útil pensar em variáveis ​​como funções nulas que avaliam seu valor. A letsintaxe-para uma função sem argumentos (que na verdade não existe) acaba fornecendo uma associação de variável:let x = 42 in ...

• O cálculo lambda tem funções nulas? - Não. Toda função usa exatamente um argumento. No entanto, esse argumento pode ser uma lista ou a função pode retornar outra função que aceita o próximo argumento. Haskell prefere a última solução, de modo que a b cna verdade são duas chamadas de função ((a b) c). Para simular funções nulas, você deve passar algum valor de espaço reservado não utilizado.

Você está interpretando mal o que ()significa em Haskell. Não é a falta de um valor, é o único valor do tipo Unit (o tipo em si é referido por um conjunto vazio de parênteses ()).

Como os lambdas podem ser construídos para usar a correspondência de padrões, a expressão lambda \() -> "s"está dizendo explicitamente "crie uma função anônima, esperando uma entrada que corresponda ao ()padrão". Não há muito sentido em fazê-lo, mas certamente é permitido.

Também é possível usar a correspondência de padrões com lambdas de outras maneiras, por exemplo:

map (\(a, b) -> a + b) [(1,2), (3,4), (5,6)] -- uses pattern matching to destructured tuples

map (\(Name first _) -> first) [Name "John" "Smith", Name "Jane" "Doe"] -- matches a "Name" data type and its first field

map (\(x:_) -> x) [[1,2,3], [4,5,6]] -- matches the head of a list

() -> "s"é uma função lambda que usa um argumento:

ghci> :t (\() -> "s")
(\() -> "s") :: () -> [Char]

(), a tupla vazia (às vezes conhecida como Unidade), é um tipo completo em Haskell. Ele possui apenas um membro (ignorando _|_*), que também é escrito como (). Veja a definição de ():

data () = ()

Isso significa que o formulário no lado esquerdo da sua expressão lambda é sintaticamente uma correspondência de padrão que corresponde ()ao único membro do tipo (). Há apenas uma maneira válida de chamá-lo (que é fornecer ()como argumento) porque há apenas um membro válido do tipo ().

Essa função não é muito útil no Haskell, porque, por padrão, os termos são preguiçosamente avaliados de qualquer maneira, como você observou na sua pergunta.

Para uma explicação muito mais detalhada, consulte esta resposta .

_{* _|_é chamado "inferior" ou "indefinido". Sempre verifica o tipo, mas trava o seu programa. O exemplo clássico de como obter um _|_é let x = x in x.}