On May 21, 3:18 pm, Felipe Almeida Lessa wrote:

I have no problems in defining those functions:

$ ghci GHCi, version 6.12.3:http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Loading package ffi-1.0 ... linking ... done. Prelude> let id2 :: t -> t; id2 = \x -> x Prelude> let a :: a -> a; a = a a

Note that I used ';'.  This is equivalent to writing

  let a :: a -> a       a = a a

If I try the syntax you were trying without ScopedTypeVariables, I get

Prelude> let a :: a -> a = a a <interactive>:1:4:     Illegal signature in pattern: a -> a         Use -XScopedTypeVariables to permit it

GHCi thinks that you were trying to define a function by pattern matches and there was a signature inside it, which is a different thing. As I said, I'm convinced that the argument of let is a pattern, on which a signature is allowed, and GHC correctly understands that, so

First, thanks to you and everybody for the alternative. But I'm still convinced that the syntax is supposed to work, and you're just workarounding the bug. that this declaration work: let (id :: Int -> Int) = \x -> x See both of: http://www.haskell.org/ghc/docs/7.0.3/html/users_guide/other-type-extensions... http://www.haskell.org/onlinereport/decls.html#sect4.4.3.2

This is the expected use for such thing:

Prelude> :s -XScopedTypeVariables Prelude> let id2 :: forall t. t -> t; id2 (x :: t) = x

Why does then the following declaration work? let (id :: Int -> Int) = \x -> x To me, this inconsistent behavior is a bug, and surely it is undesirable, because of inconsistency - the programmer needs to have sensible rules, about when let var : type = expr works and when not. Or at least a sensible error message. Moreover, the proposed solution not always works. Neither of these work: let f :: x -> x; g :: y -> y; (f, g) = (id, id) let f :: x -> x; g :: y -> y; (f, g) = (f, g) let (f :: forall a. a -> a, g :: forall a. a -> a) = (f, g) let (f :: forall a. a -> a, g :: forall a. a -> a) = (id, id) If you wonder why one , the tuple might be returned by another function. Additionally, I'd like to debug documentation. If, when looking up docs, I can't find a solution, either I miss something or the documentation is incomplete. In the second case, I'd like to propose fixes. I've just verified that the Haskell Report allows the syntax you describe, but of course it doesn't specify the behavior of the extension. But for instance I've not found type declaration for let bindings in Real World Haskell (a Gentle introduction to Haskell mentions them in one point of the document, without examples). Cheers, Paolo G. Giarrusso

On Sat, May 21, 2011 at 16:27, Brandon Allbery wrote:

On Sat, May 21, 2011 at 10:17, Paolo G. Giarrusso wrote:

...

First, thanks to you and everybody for the alternative. But I'm still convinced that the syntax is supposed to work, and you're just workarounding the bug.

Hm, I think we have differing expectations; the syntax everyone presented is the one that is normally used for such things in ghci, and while perhaps the one you tried is supposed to work, it's a bit unusual and therefore probably not very well tested.

Yes, it was my guess as well - and for some reason I missed the usual syntax. A sincere question about the usual syntax: where do you learn it? It's needed seldom enough that I don't see it often in tutorials. And Googling for "let type signature haskell" leads me to the Haskell report or to ScopedTypeVariables. Cheers, -- Paolo Giarrusso - Ph.D. Student http://www.informatik.uni-marburg.de/~pgiarrusso/

On Sat, May 21, 2011 at 17:13, Brandon Allbery wrote:

On Sat, May 21, 2011 at 10:49, Paolo Giarrusso wrote:

...

On Sat, May 21, 2011 at 16:27, Brandon Allbery wrote:

...

On Sat, May 21, 2011 at 10:17, Paolo G. Giarrusso wrote:

...

First, thanks to you and everybody for the alternative. But I'm still convinced that the syntax is supposed to work, and you're just workarounding the bug.

Hm, I think we have differing expectations; the syntax everyone presented is the one that is normally used for such things in ghci, and while perhaps the one you tried is supposed to work, it's a bit unusual and therefore probably not very well tested.

Yes, it was my guess as well - and for some reason I missed the usual syntax. A sincere question about the usual syntax: where do you learn it? It's

It's just the desugaring of layout, with the braces being optional because it's all on one line.  Since you can't use layout in ghci, you have to manually convert.

It is perhaps not entirely obvious (I was a bit surprised when, as a complete Haskell newbie, I decided to try it and it worked) that you can specify types in both let and where clauses in the same way you do at the top level:

Exactly. I've seen examples with where, but only today I've seen this example with let. Luckily I was aware of layout desugaring - that's explained in most tutorials I know.

...

let a :: a -> a     a = a a

Anyway, thanks. I hope some more advanced tutorial, some day, will also show such examples. -- Paolo Giarrusso - Ph.D. Student http://www.informatik.uni-marburg.de/~pgiarrusso/

On Sat, May 21, 2011 at 11:17 AM, Paolo G. Giarrusso wrote:

As I said, I'm convinced that the argument of let is a pattern, on which a signature is allowed, and GHC correctly understands that, so that this declaration work: let (id :: Int -> Int) = \x -> x

See both of: http://www.haskell.org/ghc/docs/7.0.3/html/users_guide/other-type-extensions... http://www.haskell.org/onlinereport/decls.html#sect4.4.3.2

Actually, it doesn't work ;-) Prelude> let (id2 :: Int -> Int) = \x -> x <interactive>:1:5: Illegal signature in pattern: Int -> Int Use -XScopedTypeVariables to permit it Patterns can't have types in Haskell 98 [1]. So you actually need to see what the ScopedTypeVariables say about it [2, 3]. The GHC user guide [3] is pretty clear saying that pattern type signatures can't bring new type variables into scope like you want. [1] http://www.haskell.org/onlinereport/exps.html#sect3.17.1 [2] http://hackage.haskell.org/trac/haskell-prime/wiki/ScopedTypeVariables [3] http://www.haskell.org/ghc/docs/7.0-latest/html/users_guide/other-type-exten...

To me, this inconsistent behavior is a bug, and surely it is undesirable, because of inconsistency - the programmer needs to have sensible rules, about when let var : type = expr works and when not. Or at least a sensible error message.

The bug seems to be with the error message. But the behaviour looks like what was expressed by the docs. I think you could file a bug about it.

Moreover, the proposed solution not always works. Neither of these work: let f :: x -> x; g :: y -> y; (f, g) = (id, id) let f :: x -> x; g :: y -> y; (f, g) = (f, g)

let (f :: forall a. a -> a, g :: forall a. a -> a) = (f, g) let (f :: forall a. a -> a, g :: forall a. a -> a) = (id, id)

If you wonder why one , the tuple might be returned by another function.

Prelude> let f :: x -> x; g :: y -> y; (f, g) = (id, id) <interactive>:1:40: Couldn't match expected type `forall x. x -> x' against inferred type `a -> a' In the expression: id In the expression: (id, id) In a pattern binding: (f, g) = (id, id) Prelude> :s -XNoMonoPatBinds Prelude> let f :: x -> x; g :: y -> y; (f, g) = (id, id) See [4]. [4] http://hackage.haskell.org/trac/haskell-prime/wiki/MonomorphicPatternBinding... Cheers! =) -- Felipe.

On Saturday 21 May 2011 16:17:53, Paolo G. Giarrusso wrote:

As I said, I'm convinced that the argument of let is a pattern, on which a signature is allowed, and GHC correctly understands that, so that this declaration work: let (id :: Int -> Int) = \x -> x

I don't think that Prelude> let a :: a -> a = a a (or even Prelude> let id2 :: t -> t = \x -> x ) is supposed to work: "The pattern in a pattern binding may only mention type variables that are already in scope." Both are pattern bindings and the mentioned type variable is not in scope.

See both of: http://www.haskell.org/ghc/docs/7.0.3/html/users_guide/other-type-extens ions.html#pattern-type-sigs http://www.haskell.org/onlinereport/decls.html#sect4.4.3.2

...

This is the expected use for such thing:

Prelude> :s -XScopedTypeVariables Prelude> let id2 :: forall t. t -> t; id2 (x :: t) = x

Why does then the following declaration work? let (id :: Int -> Int) = \x -> x

Because it doesn't mention any type variable.

To me, this inconsistent behavior is a bug, and surely it is undesirable, because of inconsistency - the programmer needs to have sensible rules, about when let var : type = expr works and when not. Or at least a sensible error message.

The error message definitely deserves improvement.