The prefix symbol : or ::

Tue Jun 21 05:25:39 PDT 2011

I think only ^ screams lambda, mainly because it is the greek letter lambda.   

    _____  

From: Collin Fagan [mailto:collin.fagan at gmail.com]
To: Stephen Colebourne [mailto:scolebourne at joda.org], lambda-dev [mailto:lambda-dev at openjdk.java.net]
Sent: Tue, 21 Jun 2011 12:57:22 +0100
Subject: The prefix symbol : or ::

I prefer ':' I think it screams less "I'm a lambda" but still lets one know
there is something different going on.

I think : is used only for labels (used vary rarely, right?) the for each
loop and the ternary operator. I'm not as skilled with grammers as others on
this board but all other uses require something else to make it valid. You
need 'for', '?' or an identifier.

Required examples:

:(x) { return x + 1; }
:{x -> x + 1}

If a single : introduces ambiguity then I suggest :: instead.

::(x) { return x + 1; }
::{x -> x + 1}

One could even use :: for method references.

personList.sort(::sortByLastName);

Or if it's static

personList.sort(Person::sortByLastName);

Collin
----

More Examples:

Syntax: Strawman with Single Colon

Generated examples

/*
* Syntax Poll Example:
*/
list.filter( :(Foo t){t.length() > 3} )
.map( :(Foo t){t.barCount} )
.max();

/*
* Student Filtering Multi-line:
*/
students.filter( :(student){
if (student == null || student.getName() == null){
return false;
} else {
return student.getName().equals("Smith");
}
} );

/*
* Student Filtering Single Line:
*/
students.filter( :(s){s != null && "Smith".equals(s.getName())});

/*
* Case Insensitive Comparator: Assignment
*/
Comparator<String> CASE_INSENSITIVE_ORDER = :(String s1, String s2){
int n1=s1.length(), n2=s2.length();
for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
char c1 = s1.charAt(i1);
char c2 = s2.charAt(i2);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
return c1 - c2;
}
}
}
}
n1 - n2;
};

/*
* Case Insensitive Comparator: Inline
*/
Collections.sort( :(String s1, String s2){
int n1=s1.length(), n2=s2.length();
for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
char c1 = s1.charAt(i1);
char c2 = s2.charAt(i2);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
return c1 - c2;
}
}
}
}
n1 - n2;
} );

/*
* Action Listener: (Adapted from
org.apache.cocoon.forms.formmodel.RowActionDefinition)
*/
button.addActionListener( :(ActionEvent actionEvent){
Repeater.RepeaterRow row =
Repeater.getParentRow(event.getSourceWidget());
Repeater repeater = (Repeater)row.getParent();
// Rotation: up in a table is left in a list!
repeater.moveRowLeft(repeater.indexOf(row));
} );

/*
* Action Listener: (Adapted from org.apache.batik.swing.JSVGCanvas)
*/
button.addActionListener( :(ActionEvent actionEvent){
if (gvtRoot == null) {
return;
}
AffineTransform rat = getRenderingTransform();
if (at != null) {
Dimension dim = getSize();
int x = dim.width / 2;
int y = dim.height / 2;
AffineTransform t = AffineTransform.getTranslateInstance(x, y);
t.concatenate(at);
t.translate(-x, -y);
t.concatenate(rat);
setRenderingTransform(t);
}
} );

More examples
Syntax: Strawman with Double Colon

Generated examples

/*
* Syntax Poll Example:
*/
list.filter(::(Foo t){t.length() > 3})
.map(::(Foo t){t.barCount})
.max();

/*
* Student Filtering Multi-line:
*/
students.filter(::(student){
if (student == null || student.getName() == null){
return false;
} else {
return student.getName().equals("Smith");
}
});

/*
* Student Filtering Single Line:
*/
students.filter(::(s){s != null && "Smith".equals(s.getName())});

/*
* Case Insensitive Comparator: Assignment
*/
Comparator<String> CASE_INSENSITIVE_ORDER = ::(String s1, String s2){
int n1=s1.length(), n2=s2.length();
for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
char c1 = s1.charAt(i1);
char c2 = s2.charAt(i2);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
return c1 - c2;
}
}
}
}
n1 - n2;
};

/*
* Case Insensitive Comparator: Inline
*/
Collections.sort(::(String s1, String s2){
int n1=s1.length(), n2=s2.length();
for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
char c1 = s1.charAt(i1);
char c2 = s2.charAt(i2);
if (c1 != c2) {
c1 = Character.toUpperCase(c1);
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1);
c2 = Character.toLowerCase(c2);
if (c1 != c2) {
return c1 - c2;
}
}
}
}
n1 - n2;
});

/*
* Action Listener: (Adapted from
org.apache.cocoon.forms.formmodel.RowActionDefinition)
*/
button.addActionListener(::(ActionEvent actionEvent){
Repeater.RepeaterRow row =
Repeater.getParentRow(event.getSourceWidget());
Repeater repeater = (Repeater)row.getParent();
// Rotation: up in a table is left in a list!
repeater.moveRowLeft(repeater.indexOf(row));
});

/*
* Action Listener: (Adapted from org.apache.batik.swing.JSVGCanvas)
*/
button.addActionListener(::(ActionEvent actionEvent){
if (gvtRoot == null) {
return;
}
AffineTransform rat = getRenderingTransform();
if (at != null) {
Dimension dim = getSize();
int x = dim.width / 2;
int y = dim.height / 2;
AffineTransform t = AffineTransform.getTranslateInstance(x, y);
t.concatenate(at);
t.translate(-x, -y);
t.concatenate(rat);
setRenderingTransform(t);
}
});

On Tue, Jun 21, 2011 at 5:06 AM, Jack Moxley <jack at moxley.co.uk> wrote:

> how about the @ it might be used for annotations as well but it could quite
> happily sit along side.
>
> @(x) { return x + 1; }
> @{x -> x + 1}
>
> _____
>
> From: Stephen Colebourne [mailto:scolebourne at joda.org]
> To: lambda-dev [mailto:lambda-dev at openjdk.java.net]
> Sent: Tue, 21 Jun 2011 10:35:18 +0100
> Subject: Re: The prefix symbol
>
> Prefix character summary after 15 hours:
>
> Use a #
> #(x) { return x + 1; }
> #{x -> x + 1}
>
> Use a ^
> ^(x) { return x + 1; }
> ^{x -> x + 1}
>
> Use a \ (from another thread)
> \(x) { return x + 1; }
> \{x -> x + 1}
>
> (I'm not listing keywords that have been suggested elsewhere)
>
> Issues around typing the various characters on different keyboards
> have been raised.
>
> Once again, does anyone have a character they prefer more than one of
> the three above that they want to be considered? Remember, this isn't
> a vote, or a discussion thread, but a "gathering the options" thread.
>
> Stephen
>
>
> On 20 June 2011 18:54, Stephen Colebourne <scolebourne at joda.org> wrote:
> > The four syntax families split into two types, those with a prefix
> > symbol and those without.
> >
> > The prefix symbol is commonly mentioned as #:
> >
> > #(x) { return x + 1; }
> > #{x -> x + 1}
> >
> >
> > *** If you have a strong desire to see any symbol other than #
> > considered then please respond to this thread. ***
> >
> > - Your reply MUST specify the symbol
> > - Your reply MUST give a brief justification
> > - Your reply MUST repeat the two examples above using your preferred
> symbol
> > - You SHOULD try to ensure that your alternate symbol choice would
> > parse acceptably
> > - You MAY reply to suggest a keyword, however you should expect that
> > to be rejected
> >
> > Thread rules:
> > - Only reply if you prefer your alternate symbol to #
> > - To discuss something, change the thread title
> > - Don't reply just to say "I don't want a prefix symbol"
> > - Responding with a symbol suggestion doesn't preclude your first
> > choice actually being "no prefix symbol"
> >
> > For example, my preferred choice of prefix symbol is #, thus I should
> > not respond to this thread!
> >
> > Stephen
> > (this is an experiment to see if we can focus on one particular
> > discussion element at a time)
> >
>
>
>
>
>
>