• Robert Fraser (40/40) May 26 2009 Hey all,
• Robert Fraser (3/4) May 26 2009 And don't forget to take your fun fun (a banger in the mouth if you get
• Ary Borenszweig (7/60) May 28 2009 I like the 'x(y, z) syntax because its short. Too much fun is not fun. :...

Robert Fraser <fraserofthenight gmail.com> writes:

Hey all,

Without revealing too much I'm currently working on a programming 
language for a research project (it's implemented in D, of course!). I'm 
trying to figure out a good syntax for type annotations. I realized that 
under my current scheme the "fun" keyword in my language now serves 
three purposes:
- syntax sugar for declaring a function
- a type annotation for a function
- introducing a literal function/lambda

So a lazy evaluation/application could be written something like:

fun fun $a() lazyApply(fun $a($b) f, $b x) => fun $a() => f(x);

Where the first "fun" starts a function declaration, the next two 
indicate function types, and the last one indicates a lambda expression. 
This, if you'll forgive the pun, might not be so fun. Of course, since 
the language supports type inference, it could be written more simply as 
one of:

fun lazyApply(f, x) => fun() => f(x);
fun lazyApply(f, x) => f (x);

(All are equavalent to the D2 closure function:

T delegate() lazyApply(t, U)(T delegate(U) f, U x)
	{ return T() { return f(x); } }

)

What do you think of this? Do I need to find a different syntax? Some 
other possible syntaxes I thought of (where x, y, and z are types)

{y, z -> x}
{(y, z) -> x}
'x(y, z)
\x(y, z) (Might be confusing since \ introduces lambda expressions in 
other languages)

Which would make the above monstrosity look like:

fun {-> $a} lazyApply({$b -> $a} f, $b x) => fun {-> $a} => f(x);
fun {() -> $a} lazyApply({($b) -> $a} f, $b x) => fun {() -> $a} => f(x);
fun '$a() lazyApply('$a($b) f, $b x) => fun '$a() => f(x);
fun \$a() lazyApply(\$a($b) f, $b x) => fun \$a() => f(x);

The short versions would remain the same in all cases:

fun lazyApply(f, x) => fun() => f(x);
fun lazyApply(f, x) => f (x);

Any thoughts/suggestions?

Thanks,
Robert

Robert Fraser <fraserofthenight gmail.com> writes:

Robert Fraser wrote:
 fun fun $a() lazyApply(fun $a($b) f, $b x) => fun $a() => f(x);

And don't forget to take your fun fun (a banger in the mouth if you get 
the reference :-)).

Ary Borenszweig <ary esperanto.org.ar> writes:

Robert Fraser wrote:
 Hey all,
 
 Without revealing too much I'm currently working on a programming 
 language for a research project (it's implemented in D, of course!). I'm 
 trying to figure out a good syntax for type annotations. I realized that 
 under my current scheme the "fun" keyword in my language now serves 
 three purposes:
 - syntax sugar for declaring a function
 - a type annotation for a function
 - introducing a literal function/lambda
 
 So a lazy evaluation/application could be written something like:
 
 fun fun $a() lazyApply(fun $a($b) f, $b x) => fun $a() => f(x);
 
 Where the first "fun" starts a function declaration, the next two 
 indicate function types, and the last one indicates a lambda expression. 
 This, if you'll forgive the pun, might not be so fun. Of course, since 
 the language supports type inference, it could be written more simply as 
 one of:
 
 fun lazyApply(f, x) => fun() => f(x);
 fun lazyApply(f, x) => f (x);
 
 (All are equavalent to the D2 closure function:
 
 T delegate() lazyApply(t, U)(T delegate(U) f, U x)
     { return T() { return f(x); } }
 
 )
 
 What do you think of this? Do I need to find a different syntax? Some 
 other possible syntaxes I thought of (where x, y, and z are types)
 
 {y, z -> x}
 {(y, z) -> x}
 'x(y, z)
 \x(y, z) (Might be confusing since \ introduces lambda expressions in 
 other languages)
 
 Which would make the above monstrosity look like:
 
 fun {-> $a} lazyApply({$b -> $a} f, $b x) => fun {-> $a} => f(x);
 fun {() -> $a} lazyApply({($b) -> $a} f, $b x) => fun {() -> $a} => f(x);
 fun '$a() lazyApply('$a($b) f, $b x) => fun '$a() => f(x);
 fun \$a() lazyApply(\$a($b) f, $b x) => fun \$a() => f(x);
 
 The short versions would remain the same in all cases:
 
 fun lazyApply(f, x) => fun() => f(x);
 fun lazyApply(f, x) => f (x);
 
 Any thoughts/suggestions?

I like the 'x(y, z) syntax because its short. Too much fun is not fun. :-P

Do you need an extra symbol to denote a function type? Can't you just write:

fun $a() lazyApply($a($b) f, $b x) => fun $a() => f(x);

Do you have ambiguities with that? I don't know your language, but if 
you only use function types when declaring a type, then I think there's 
no problem.