Function declaration without parens and with types

[edemaine]

Function Declaration without Parens

I'd like to be able to write this:

function add x, y
  x + y
---
function add(x, y) {
  return x + y
}

I think it nicely parallels add x, y being equivalent to add(x,y).

Where this needs discussion is how to properly add types. The arguments are easy:

function add x: number, y: number
  x + y

But where should the return type go? Some options:

function add x: number, y: number : number
  x + y

• Double type annotation could make sense but a bit hard to read

function add x: number, y: number => number
  x + y

• Similar to TypeScript's (x: number, y: number) => number.
• Also support -> as we already do in TypeScript arrow types.

function add x: number, y: number, return: number
  x + y

• Parallels how this gets typed in TypeScript
• Parallels Civet's existing support for let return: number (but that triggers a different meaning for return).

function add x: number, y: number returns: number
  x + y

• See Named and unnamed return variable, return vs. return.value #744 (comment)

Alternatively, we could allow skipping parentheses when not specifying types, but require parentheses when specifying types.

Typing Function in Function Declaration

A related issue is wanting to type an entire function with an already defined type T, instead of typing individual arguments and the return value. Currently you have to switch to const f: T = ... instead of using function. This was mentioned as an annoyance in the Gripescript section of https://shoptalkshow.com/553/.

Notation

The obvious notation would be

function f: T
  ...

Unfortunately this already has a meaning in Civet, which is function f(): T, e.g., function f: void. And it's even worse if we have e.g. function f(x, y): T.

Some alternatives:

function f as T
  ...

function f :: T
  ...

Output

Another issue is what to actually compile this to. Ideally we'd preserve the hoisting nature of function.

1. We could rewrite to var f: T = function f ... and actually hoist the declaration to the top of the function.
2. We could compile to something like

   function f(arguments: Parameters<T>): ReturnType<T> {
     var [a, b] = arguments
     ...
   }

   This would need testing when T is a union type; I think it wouldn't behave as well as the first option.

[STRd6]

What do you think it should look like if the function takes a type parameter and passes that type parameter to another type?

Some ideas:

function f<T>: Type<T> x, y
function f<T> as Type<T> x, y
function f<T> :: Type<T> x, y