Summary: Lambda syntax

[Collin Fagan]

Hi Stefan,

I was trying to get a little feedback on some of my ideas but I guess
it got missed.

Can we use : in the lambda syntax? Off the top of my head I think it's
only used in the for-each loop and the ternary operator.

If : is up for grabs then my next question is: can we infix this
operator instead of prefixing it?

Examples: (borrowed from an earlier post by Rémi Forax)

A function that takes an int and returns an int:

int(int)

becomes

int:(int)

and ...

A function that takes an int and returns nothing:
void:(int)

A function that takes two ints and returns an int:
int:(int, int)

A function that throws an Exception:
int:(int) throws Exception

A function that takes a function that throws an Exception:
int:(int:(int) throws Exception)

Grammar:
ResultType :( TypeList ) throws ExceptionList

This syntax reads left to right in a way that is similar to method
signatures, with the method name replaced by a ':' .

Now when we get to the curry examples I would like to customize the
assignment operator. Since I chose ':' how about using ':='   as the
"curry operator" ?

Examples: (borrowed from an earlier post by Bob Foster)

class A {
 void foo(int x) { ... }
 void :(int) fun = { ... }
}

// curry examples
A a = new A();
void:() f1 := a.foo(2);
void:() f2 := a.foo();
void:() f3 := A.fun(2);

Finally, to stay with the theme, invoking a lambda would use '::'

f1::();
f2::();
f3::();

Optionally this syntax could be: f1.:(); or f1:.(); but I found
neither of those particularly compelling.

I *think* the : is no harder to type then the #. (At least on the
English keyboards I'm used to.)
The := construct is used in other languages (like Pascal, Eiffel and
Smalltalk) but admittedly not for curring.
The :: construct is used in C++, but again, not in the way I plan on using it.

I could continue to flesh this out into a real proposal if people
found the syntax compelling. If I've committed any egregious sin in my
post I apologize.

Thank you,

- Collin

On Thu, Mar 18, 2010 at 6:09 PM, Stefan Schulz <schulz at the-loom.de> wrote:
> So I summed up the proposed lambda syntaxes, hopefully picked all of
> them from the list. The summary is below, and the nicer to read document
> version is as before at the following URL:
>   http://docs.google.com/View?id=ddhp95vd_15gqnv8xqm
>
> In case of mistakes or missed proposals, let me know.
>
> Cheers,
> Stefan
>
>
> 0. Common syntax
> Block:
>     { BlockStatements }
>
> BlockStatements:
>     BlockStatement
>     BlockStatements BlockStatement
>
> BlockStatement:
>     LocalVariableDeclarationStatement
>     ClassDeclaration
>     Statement
>
> ParameterList:
>     Parameter
>     Parameter, ParameterList
>
> Parameter:
>     Type Identifier
>
> 1. Straw-man, latest
> Proposes two lambda definitions: lambda expressions and statements.
> Return type is inferred and throws meant to be transparent.
>
> LambdaExpression:
>     # ( ParameterListopt ) ( Expression )
>     # ( ParameterListopt ) Block
>
> Examples:
> #() ( 7 );
> #(Event e) { handle(e); }
> #(File f) { return f.getName(); };
> #(#R(A)(throws E) l, A a) ( #() ( l.(a) ) );
>
>
> 2. Rémy Forax, 05 Jan 2010
> Proposes to use a keyword lambda instead of #.
>
> LambdaExpression:
>     lambda ( ParameterListopt ) ( Expression )
>     lambda ( ParameterListopt ) Block
>
> Examples:
> lambda() ( 7 );
> lambda(Event e) { handle(e); };
> lambda(File f) { return f.getName(); };
> lambda(#R(A)(throws E) l, A a) ( lambda() ( l.(a) ) );
>
> 3. Peter Levart, 26 Jan 2010
> LambdaExpression:
>     # ( ParametersListopt ResultParameteropt ) Block
>
> ResultParameter:
>     : Parameter
>
> Examples:
> #(: int i) { i = 7 };
> #(Event e) { handle(e); };
> #(File f : String s) { s = f.getName(); };
> #(#(A: R throws E) l, A a : #(: R throws E) c) { c = #(: R r) { r =
> l.(a); }; };
>
> 4. Peter Levart, 1 Feb 2010
> LambdaExpression:
>     # ( ParameterListopt -> ReturnTypeopt ) Block
>
> Examples:
> #(->int) { return 7; };
> #(Event e -> void) { handle(e); };
> #(File f -> String) { return f.getName(); };
> #(#(A -> R throws E) l, A a
>   -> #(-> R throws E)) { return #(->R) { return l.(a); }; };
>
> 5. Neal Gafter, 9 Feb 2010
> LambdaExpression:
>     ( ParameterListopt ) -> Expression
>     ( ParameterListopt ) -> Block
>
> Examples:
> () -> 7;
> (Event e) -> { handle(e); };
> (File f) -> { return f.getName(); };
> ((A) -> R throws E l, A a) -> () -> l.(a);
>
> 6. BGGA
> LambdaExpression:
>     { ParameterListopt => BlockStatementsopt Expressionopt }
>
> Examples:
> { => 7 }
> { Event e => handle(e); };
> { File f => f.getName() };
> { { A => R throws E } l, A a => { => l.(a) } };
>
> 7. Peter Levart, 2 Mar 2010
> LambdaExpression:
>     ( ParameterListopt -> BlockStatementsopt Expression )
>
> Examples:
> ( -> 7 );
> ( Event e -> handle(e); void };
> ( File f -> f.getName() );
> ( (A -> R throws E ) l, A a -> ( -> l.(a) ) );
>
> 8. Howard Lovatt, 11 Mar 2010
> LambdaExpression:
>     new #< Signature > ( BlockStatementsopt Expression )
> Signature:
>     ReturnType ( ParameterListopt ) Throwsopt
>
> Examples:
> new #< int() > (7);
> new #< void(Event e) > (handle(e); null);
> new #< String(File f) > (f.getName());
> #< #< R() throws E >( #< R( A ) throws E > l, A a ) >
>   ( new #< R() throws E >()( l.( a ) );
>
> 9. C++ (via Stephen Colebourne), 14 Mar 2010
> (translated to lambda-use)
>
> LambdaExpression:
>     [ Accessorsopt ] ParameterDeclopt ReturnTypeDeclopt {
> BlockStatementsopt }
>
> ParameterDecl:
>     ( ParameterList )
>
> ReturnTypeDecl:
>     -> ReturnType
>
> Accessors:
>     &
>     =
>     Closings
>
> Closings:
>     Closing
>     Closing, Closings
>
> Closing:
>     & Identifier
>     Identifier
>     this
>
> Examples:
> [] { return 7; };
> [] (Event e) { handle(e); };
> [] (File f) { return file.getName(); };
> [] (R (*l)(A), A a) { return []{ return l.(a); };
>
> 10. Rémi Forax, 14 Mar 2010
> LambdaExpression:
>     ( ParameterListopt ) ( Expression )
>     ( ParameterListopt ) Block
>
> Examples:
> () ( 7 );
> (Event e) { handle(e); }
> (File f) { return f.getName(); };
> (R(A)(throws E) l, A a) ( () ( l.(a) ) );
>
> 11. Peter Levart, 17 Mar 2010
> LambdaExpression:
>     ( ParameterListopt : Expression )
>     { ParameterListopt : BlockStatements }
>
> FunctionInvocationExpression:
>     FunctionTypedExpression [ ExpressionListopt ]
>
> Examples:
> (:7);
> { Event e : handle(e); };
> { File f : return f.getName(); };
> ( [ A : R throws E ] l, A a : (: l[a]) );
>
>
>
>