haskell - GHCi "deja"-¿qué hace?

let

Question

Agradecería que alguien pudiera señalar a los doctores sobre lo que "deja" en GHCi, o en su defecto, explicarlo convincentemente :-).

Hasta donde puedo decir, "let" (sin "in") no es parte del lenguaje Haskell per se, y por otro lado, tampoco parece ser un comando GHCI, ya que no está prefijado por dos puntos .

Answer 1

Aquí está la parte relevante de la documentation .

Las sentencias GHCI se ejecutan como cómputo de IO. Así que let es lo mismo que tienes dentro de una món IO donde unes una expresión que no sea IO usando let .

Answer 2

Los comandos GHCI se ejecutan en la mónada IO y utilizan la sintaxis do, por lo que se aplican las reglas de deslumbramiento. De Real World Haskell

doNotation4 =
    do let val1 = expr1
           val2 = expr2
           {- ... etc. -}
           valN = exprN
       act1
       act2
       {- ... etc. -}
       actN

se traduce a:

translated4 =
    let val1 = expr1
        val2 = expr2
        {- ... etc. -}
        valN = exprN
    in do act1
          act2
          {- ... etc. -}
          actN

Answer 3

Mientras programa en GHCi, es como programar en la mónada IO con la sintaxis do , por lo que, por ejemplo, puede ejecutar directamente una acción IO , o usar la sintaxis de enlace monádico como r <- someIOFun .

let también es parte de do así que también puedes usar esto. Creo que está siendo desajustado en let .. in <rest of the computation> , así que por ejemplo cuando haces esto:

ghci> let a = 1
ghci> someFun
ghci> someFun2

Es como:

let a = 1 in
do someFun
   someFun2

Answer 4

Para obtener más detalles TcRnDriver.lhs del código, este comentario en TcRnDriver.lhs podría estar iluminando:

--------------------------------------------------------------------------
                Typechecking Stmts in GHCi

Here is the grand plan, implemented in tcUserStmt

        What you type The IO [HValue] that hscStmt returns
        ------------- ------------------------------------
        let pat = expr ==> let pat = expr in return [coerce HVal x, coerce HVal y, ...]
                                        bindings: [x,y,...]

        pat <- expr ==> expr >>= / pat -> return [coerce HVal x, coerce HVal y, ...]
                                        bindings: [x,y,...]

        expr (of IO type) ==> expr >>= / it -> return [coerce HVal it]
          [NB: result not printed] bindings: [it]

        expr (of non-IO type, ==> let it = expr in print it >> return [coerce HVal it]
          result showable) bindings: [it]

        expr (of non-IO type,
          result not showable) ==> error

Por lo tanto, un comando en el indicador de GHCi puede tener hasta tres efectos: se evalúa algún código, se imprimen algunas cosas y se enlazan algunos nombres de variables. Su caso (el primero en el comentario) vincula variables, pero no imprime.

La sintaxis se asemeja a la notación do, por lo que la respuesta de @ sinan es algo correcta, pero en realidad no es lo que está sucediendo debajo del capó; de lo contrario, por ejemplo, nunca se imprimiría nada.