There is no way to express the type of a function.

[SebastianMestre]

We have no way to write the type of a function: no special syntax, and no name bound to the typefunc.

We need this.

a few options:

(a,b,c)=>d
fn(a,b,c)=>d
fn<:a,b,c,d:>

I am open to sugestions.

[lushoBarlett]

I like the third one a lot actually. I think the first one is not bad. The second seems ambiguous, but it might be as consistent as the third one for example (given that we prioritize consistency). I'll give it some thought, perhaps when I write some code I will have a better idea.

[SebastianMestre]

Tbh I don't like any of them

[lushoBarlett]

Some other options are, for example:
a -> b -> c -> d
(a, b, c) -> d
a, b, c, d
a, b, c -> d

Concrete example of the second one

x : (a, b, c) -> d = fn(p, q, t) { ... };

Tbh I don't like any of them

I don't think we have much of a choice, there are not many ways to express the types of functions that don't look arbitrarily weird, what are you trying to accomplish with the syntax?

[SebastianMestre]

more ideas (sorted roughly by expected difficulty of integrating into our hand-written parser):

(fn a, b, c, d);
(fn a b c d);
(fn a, b, c => d);
(fn a b c => d);
(fn a, b, c) d;
fn:(a, b, c) d;
:(a, b, c) d;
fn|a, b, c| => d;
|a, b, c| d;
|a, b, c| => d;
(a, b, c => d);
(a, b, c): d;
(a b c => d);
fn(:a, :b, :c) d;
fn(a, b, c): d;
fn(a, b, c) d;

examples:

Int := int<::>;
const : (a, b -> a) = fn (x, y) => x;
sum : (Int Int => Int) = fn(x, y) => x + y;
div : fn:(Int, Int) maybe<:Int:> = fn (x, y) => if (y == 0)
    then maybe<:Int:>.nothing
    else maybe<:int:>.just(x / y);

kinda weird, but maybe we can get creative with style?

// like this?
const : (a, b -> a)
      = fn (x, y) => x;

// or like this?
sum
  : (Int Int => Int)
  = fn(x, y) => x + y;

// Or like this, which I think makes sense when the types are longer
div : fn: (Int, Int) maybe<:Int:> =
    fn (x, y) => if (y == 0)
        then maybe<:Int:>.nothing
        else maybe<:int:>.just(x / y);

[SebastianMestre]

I kinda like the fn: (a, b, c) d one

[SebastianMestre]

adding -> solves some problems, but I don't want to be adding new symbols willy nilly. Same thing for the |a, b, c| d one: it looks really nice imo, but it uses the | symbol, which I'm not sold on.

[lushoBarlett]

Well you could add the => symbol instead, which already exists.

[SebastianMestre]

Well you could add the => symbol instead, which already exists.

-> solves problems because it's a new symbol. Using => is unhelpful

[SebastianMestre]

I don't think we have much of a choice, there are not many ways to express the types of functions that don't look arbitrarily weird, what are you trying to accomplish with the syntax?

I want it to:

• be reasonably terse, so writing types is not too onerous.
• not be too loaded, so the types of the arguments and return type don't get lost.
• either have a right-pointing arrow, or look similar to a function literal

EDIT:

I don't think it's unreasonable to change other parts of the syntax to make this happen. In fact, we should probably re-think most of the syntax soon, tbh.

[lushoBarlett]

we should probably re-think most of the syntax soon

Well if that's the case, then isn't it reasonable to just pick one syntax temporarily, so we can get the rest of the implementation out of the way? I would like to implement it for implementation's sake and worry about the final syntax later.

I do agree with your terms of what the type should accomplish.

[SebastianMestre]

Ok, let's go with this for now

fn:(a, b, c) => d;

[SebastianMestre]

quick idea for implementation:

parse into CST::FunctionTypeLiteral

when converting into AST, convert into a PolyCall where the callee is a new AST node: FunctionTypeFunc (alternatively, during desugaring)

ct_eval-ing a FunctionTypeFunc should give a TypeFuncHandle pointing to the function type func