Explicit declaration of function types can not handle tuple-valued return types

[Bearmarshal]

All these examples fail due to an explicitly declared tuple-valued return type of fun:

class Foo {
  fun : int -> (int, int)
  ...
}

class Bar {
  def bar(fun : int -> (int, int)) : void {
    ();
  }
  ...
}

class Main {
  def main() : void {
    let fun = ( \ (x : int) -> (x, x+1)) : int -> (int, int);
    ();
  }
}

The third example, however, succeeds if you remove the explicit type declaration. This, however, is not an option in the first and second case.

[ghost]

     arrow = do lhs <- parens (commaSep typ)
                     <|> do {ty <- nonArrow ; return [ty]}
                 reservedOp "->"
                 rhs <- nonArrow
                 return $ arrowType lhs rhs

rhs <- nonArrow should be rhs <- typ right? The current implementation also fails for functions returning maybes as well as functions returning functions.

[Bearmarshal]

While this is fixed for primitive types, see issue #364.

[TobiasWrigstad]

Fixed