Type ascription precedence inconsistency about dhall-haskell

[Gabriella439]

Yes, I agree that Dhall's parser should be encodable as an LALR grammar. This is actually how I originally wrote Dhall before I switched to using trifecta (which provides better support for error messages, but is an unrestricted parser combinator library).

For the inconsistent treatment of type annotation under lambda abstraction, the correct behavior should be that the type annotation binds tighter than the lambda abstraction, meaning that this:

\(x : Natural) -> x : Natural

... should be equivalent to this:

\(x : Natural) -> (x : Natural)

Like you mentioned, this would then make them consistent with Haskell, where the type annotation also binds tighter than lambda abstraction:

>>> :type (\x -> x :: Int)
(\x -> x :: Int) :: Int -> Int

I'll make the required change soon to this repository

Also, thanks for porting Dhall to Rust! :)

[Gabriella439]

I have a pull request out for this here: #30

If you have time could you take a look at that and see if it introduces any new shift-reduce or reduce-reduce conflicts?

[nanotech]

That solves it. Doing a one-to-one translation still produces a shift/reduce error between the two '[' Elements ']' rules, but as the ':' rules are at the same precedence now, that's easy to work around by replacing the '[' Elements ']' ':' ListLike ExprE rule with some post-parse pattern matching in the ExprC ':' ExprA rule as I tried to do previously.

Thanks!