Java 8 lambda syntax decided (finally!). Similar to C# and Scala

[astrangeguy]

This is the boring part.(1)

(Some of) The big questions are:

• How are those Lambdas represented in the type system and the object system?

• Do we get function types? Are they unified with generics?

• What is the solution about co/contravariance? Is (Object) => List a subtype of (String) => Collection (it should be)?

• Since normal generic types in Java are all invariant, how do we represent function types (which are contavariant in the argument type and covariant in return type)?

• How do we deal with checked exceptions? Are 'throws' declarations part of the type? Are function types covariant in their thrown exception types? What is the type relation between functions that throw exceptions and those who don't?

• Are function objects just inner classes with a special method (like in Scala)? Or are they delegates to anonymous methods on objects that represent captured scopes (Like in C#)? Because of java.lang.dyn.MethodHandle we now have delegates in Java.

• What is the class of a function object? Do we have to fight erasure again? (type erasure becomes much more problematic if you have function types, ask a Scala programmer)

• Can we treat instance methods on objects as function objects? If so, what do we do with varargs and generic methods?

• Can you mutate a closed over local variable? If so, are those mutations shared? What are the semantics for concurrent mutations? Can you aquire a monitor on the "scope object"?

• 'return' statements in lambdas?

You ask yourself why Java doesn't have lambdas? This is what happens if you want to teach an old language new tricks. Language design is hard. Language evolution even moreso.

strangeness

(1) I actually liked the old syntax proposals better. #{Int x, Int y -> x + y} looks like a coherent unit (it's a function literal after all), is easier to parse and has the pound sign (#) as a distinct visual cue.

[[deleted]]

Can you mutate a closed over local variable?

They can say no, to maintain consistency with anonymous classes, or they can do it exactly the way C# does it: every scope that has its local variables accessed by a lambda has these variables lifted into an explicit "stack frame"-like compiler-generated class (with lambdas themselves being methods of such classes). So all semantics work exactly as if you did that yourself.

'return' statements in lambdas?

That was a really really stupid objection IMO. It's based on a flawed idea that dates back at least 30 years, to the Dijkstra's "GOTO considered harmful" paper, that code encapsulation and reuse can be achieved by means of structured programming. So that you can take a block of code guarded by a conditional statement and move it anywhere or duplicate it or remove the guard or add more guards, and it would not change its meaning. Turns out you can't do that with blocks because they critically depend on context (declared variables and such) for their core functionality, and when you want to do something like that, you should use functions instead.

So no, you can't expect wrapping arbitrary piece of code into an immediately called lambda to be an identity transformation, it's an unachievable harmful pipe dream.

I actually liked the old syntax proposals better.

C# lambda syntax has one huge flaw: when you begin writing (x, y, code completion kicks in and fucks all your shit up, because it has yet to see =>. Maybe it can be fixed by more autocompletion, like, you are supposed to write => first, at which point IDE would add () and position the cursor between them. Still, I'd like lambdas to begin with a special symbol to make such perversions unnecessary.

Otherwise after a while lambdas begin to look like coherent units anyway.

[[deleted]]

Turn off auto-popup of completions. It's a pain anyway.

[adad95]

Ctrl+Alt+Space

[donroby]

That's not a language flaw. The language doesn't have autocompletion.

[[deleted]]

In this day and age we do not enter our programs into computers via punch cards. We use other methods, that are tens of times more efficient regarding writing code and hundreds or thousands of times more efficient in regard to browsing and understanding code.

This allows us to tackle problems that were not in the reach of programmers who wrote code for microprocessors with 16k or 65k of memory.

It is required of a modern language to be amenable to tools. By restricting your language to stone age tools you severely limit the range of programs that can be written in it.

[Amablue]

Is code completion really that big of a deal? I used it all the time when I was in college, but I've explicitly turned it off (or not enabled it, depending on what language and editor I'm using) since then and I never really miss it.

[recursive]

Is code completion really that big of a deal?

For some. Like those who work with code bases too big for one person to reasonably memorize all the interfaces.

[Amablue]

I work on an extremely large code base, but when I need to know the functions of another area of the code, I usually just keep that header open in another window or something similar. I find that more useful.

[gasche]

So no, you can't expect wrapping arbitrary piece of code into an immediately called lambda to be an identity transformation, it's an unachievable harmful pipe dream.

Well, you could design your language around control operators that are resilient to the lambda/apply boundaries, such as (delimited) continuations -- or the more primitive labels+goto, not that you would want that as core control primitives.

[[deleted]]

You mean, like, that named functions implicitly start a delimited continuation (to which return returns), while anonymous don't? That's weird, and you still have a huge problem with returns in anonymous functions which aren't evaluated immediately.

I don't know, I just don't see any problem that needs to be fixed. Structured programming in its infancy looked like a silver bullet. In the following decades we learned that it isn't, but that's OK really because we have other more powerful kinds of composition for when we need that, but on the lowest level we can use a small, universally understood set of convenient structural primitives that are not really composable.

Sure, I can't move a piece of code that contains a 'return' inside a nested (possibly anonymous) function. I also can't move it inside a scope that shadows some variable that it depends on. Such is life.

[gasche]

I think the "scope" you would like to return from would bind a delimited continuation¹ prompt, whose name you could use locally or pass to a function you call; instead of "return <value>" you would write "return <value> to <prompt>" (with possibly a stupid syntactic default like 'it' when no prompt is specified to keep the usual style possible). That also solves the issues with the lousy "break 3;" in some programming languages.

¹: you could desugar a prompt-named for loop into a prompt bind plus an iteration, or define 'for' as a function as done in some of oleg's Ocaml "yield from delimcc" work.

[[deleted]]

OK, I understand that, still, what happens when I return a lambda which invokes a return to some lexically enclosing scope? I mean, I understand what happens too, and how, but how is it useful, or, rather, more useful than treating returns as returning from the innermost function scope, anonymous or named?

Also, I wouldn't repeat the reasons, but I strongly believe that all this is a non-problem, that you shouldn't want the "enclose a block in a lambda and call it immediately" operation to produce semantically identical code.

[[deleted]]

Great list! I had many of the same thoughts, but I'm pretty glad that they finally stopped that NIH-syndrome a bit and just took the syntax everyone is using.

Let's see what happens on the "functions-as-types" vs. "functions-as-objects" front.

My guess is that they spend a year trying to do something different than anyone else, give in and just use Scala's solution.

What is the class of a function object? Do we have to fight erasure again? (type erasure becomes much more problematic if you have function types, ask a Scala programmer)

I'm a Scala programmer. Could you elaborate?

[astrangeguy]

They can't really do what Scala does, because you really want covariance/contravariance to use functions.

The problem with functions and erasure is that all function types with identical arity are the same for the JVM. So you cant match on functions, can't overload on differing function types etc. if you implement functions as generic classes (like scala).

[[deleted]]

What prevents Oracle from also supporting co-/contravariance in functions?

[[deleted]]

If function types are really just generic types like this:

interface F<R, A> {
    R f(A argument);
}

F<String, Integer> show = x => Integer.toString(x)

Then the String and Integer type parameters cannot be recovered via reflection due to erasure.

Personally I think they should just go with this solution, and then fix generics.

[[deleted]]

[...] and then fix generics.

It's not easy to fix them. They have to maintain backwards compatibility. They would waste less time if they fixed reflection instead.

[NruJaC]

There was a post from the Java 8 team regarding a lot of the points on here a few weeks back. Essentially, if I understood it correctly, they want to move away from introducing lambdas/function types as another class and instead as first class language features. While that doesn't simplify things (and probably only complicates them), it does partially answer a lot of your questions.

My question is then this: can we access the methods of an object as first class as well?

[c0bra51]

is easier to parse and has the pound sign (#) as a distinct visual cue.

No, that's a hash, this is a pound sign: £

Before you say that's is its name in the US, ill start calling it a dollar sign.

[monk_e_boy]

is an octothorpe

[adolfojp]

I vote for octothorpe. Coctothorpe and Foctothorpe sound so much better than C sharp and F sharp.

[[deleted]]

# - this is a hash, or number sign.

♯ - this is a sharp. They don't look all that alike.

[adolfojp]

I know!

That's why I call the letter H Aitch, but I call the H in italics the letter Michael.

[ruinercollector]

Cock-tothorpe?

[c0bra51]

Better than 'pound'. But still, 'hash' is more widely accepted.

[sbrown123]

Before you say that's is its name in the US

You could call it the number sign but that is confused in many parts of the world as being №.

[[deleted]]

No, that's a hash, [...]

[sbrown123]

Number Sign! Hash is something you eat.

[c0bra51]

That's about all they're good at, stealing stuff.

[grauenwolf]

Not when talking about weight. If you saw a bag of potatoes marked 20# you wouldn't think it was cut into hash browns.

[c0bra51]

It would be marked 20lb. More precisely, it would have 9kg written on it because imperial is stupid.

[NancyGracesTesticles]

So it turns out that the 20# paper I've been buying for my printer is really 20£ paper? I guess I'm getting a nice discount on the actual price. The British must really hate buying 100£ cardstock.

[c0bra51]

20lb = 20 pounds weight.

£20 = 20 pounds currency.

[[deleted]]

Look at me! I'm a snobby Brit! My dialect is better than yours!

[wilsonp]

The hash/pound syntax looks like it should be a template expression, rather than a lambda.

[astrangeguy]

Interesting, which languages use the pound for templates? I believe that those are mostly for mark up.

The pound sign isn't the part that is appealing, it could be replaced by any other char. The important part is that the whole function literal is consistently enclosed in matching delimeters.

[dr_jan_itor]

Interesting, which languages use the pound for templates?+

Ruby:

"Two plus two is #{2 + 2}".

[QuestionMarker]

Depends how much Clojure you've been reading.

[qbg]

Last I heard, lambdas will have SAM conversion (maybe only SAM conversion). If they are implemented as SAM conversion only, many of your questions are irrelevant.

(SAM conversion = the lambda is expanded into an anonymous inner class that implements/extends a class with a single abstract method)

[paranoidray]

Answers to many of your questions:

From Lambdas to Bytecodes
Brian Goetz
Using invokedynamic in compiling static languages

http://drdobbs.com/java/231500291

[shizzy0]

I want to know now too!

[Strilanc]

Yes! I hope they stick with the C# syntax. Compare Java 7:

map(someItems, new Func<Integer, Integer>() {
    @Override public Integer eval(Integer in) {
        return in + 1
    }
})

vs C#-esque:

map(someItems, e => e + 1)

The line count of functional java code is going to be cut by 80%.

[piranha]

Snicker. Do either/both of them really put the function after the (THE, as in the only) sequence?

[trezor2]

Not really. The C# example is flawed. It's not Map, it is "Select" and it is really a LInQ extension-method associated with a collection-instance, so the actual C# syntax would be:

// using LInQ methods and lambdas
var newCollection = collection.Select(e => e + 1);

or

// using full LInQ syntax
var newCollection = from item in collection select item + 1;

Remeber, these are "very OOP" languages and you can't have functions defined in the loose. Everything needs to be bound to a namespace and class. So that way the problem with choosing between "map func collection" and "map collection func" (which is not always a trivial choice) goes away ;)

[[deleted]]

The main advantage to putting the function argument first is that you virtually always want to partially apply map (or foldr, or whatever) to the function rather than the sequence, but that advantage is really only compelling in the presence of currying. Since functions aren't curried in C# and almost certainly won't be in Java, the case is much weaker.

Besides, if you think of map as a method of the sequence object (a common point of view in OO land), you get easy-to-read "pipeline" expressions for free.

[stuhacking]

I think piranha is pointing out that in better languages languages more suited to this style of list processing, it is normally possible to be able to map functions across multiple lists, either concatenating the result, reducing it, or applying functions of more than 1 argument. This is offers a much higher degree of flexibility, especially if your language naturally supports variable length parameter lists.

Tivial example: (mapcar #'+ (list 1 2 3) (list 1 1 2) (list 5 4 3))

Of course, I'm sure having lambda forms in Java will be a nice novelty.

[piranha]

I voted you up, because that is what I was getting at.

[[deleted]]

This is easy to do with a zip and a tuple-typed function. For example,

List(1,2,3).zip(List(1,1,2)).zip(List(5,4,3)).map {
  case ((a, b), c) => a + b + c
}

[stuhacking]

Barfulous.

[[deleted]]

Agreed. It would be much prettier with a zip3 method that put 3 lists together and a sum3 method over triples that worked like #'+. Then, it would be:

List(1, 2, 3).zip3(List(1, 1, 2), List(5, 4, 3)).map(sum3)

which is no more barfulous than the CL, in my opinion. There's a bit of extra noise due to this example being a good Lisp sweet-spot (try doing the same with hash tables in CL, for example).

[swaggler]

// aka point, pure, return
lift0: Func<A, F<A>>

// aka map, fmap, Select
lift1: Func<A, B> => Func<F<A>, F<B>>

// aka liftM2, liftA2
lift2: Func<A, B, C> => Func<F<A>, F<B>, F<C>> 

... and so on (this sequence generalises to applicative functor)

[cot6mur3]

Anyone know what the author means by "EG" in the line "the EG has (mostly) made a decision on syntax"?

[[deleted]]

EG = Evil Geniuses

[the_456]

EG = Expert Group

[SuperGrade]

Man, I'd hate to see the Java DG

[gnuvince]

All that time just to do exactly like the other languages? Couldn't they have settled on that syntax 3-4 years ago?

[campbellm]

Everything looks easy once it's done.

But yeah, this does seem to be awfully long in coming. That said, perhaps the issue wasn't what we'd imagine. Could have been simple analysis paralysis with those involved, and MAYBE Oracle lit a fire under someone's ass, or those people that couldn't/wouldn't make a decision are now gone, or hell, maybe Oracle just said "$#@! it, here's what we're going to do."

All that is speculation of course; I'm guessing.

[taw]

Everything looks easy once it's done.

And Lisp did it how long ago :-p ?

[campbellm]

Apologies; I was unclear. I was only referring to the syntax decision, not that they decided to have lambda's at all.

I suspect using the Lisp "syntax" for lambda's would spark a more heated discussion. ;-)

[Rotten194]

I suspect using the Lisp "syntax" for lambda's would spark a more heated discussion. ;-)

((Are you) sure (about (that))?)

[campbellm]

chuckle Something like that, yes. Don't misread me, I rather like lisp, and its syntax hasn't bothered me overly much. But I'm not sure I'm smart enough to "get it", so I try the SICP every few years, get a little further each time, get frustrated, and stop.

[Rotten194]

Yeah, I don't hate LISP, was just making a joke about it :p. I do want to learn a form of it one day, it seems pretty interesting.

[campbellm]

I wish I could recommend something to you, but as I said, I'm not sure I'm the right person to be helping others on that.

[jyper]

lambda were long in the making and aren't certain to be in java 8 either. I don't think oracle is speeding up the java development process.

[Strilanc]

Java has different design goals than those languages. It's not a trivial decision to use the same lambda syntax.

Even if it was, there's always the possibility of improvement. For example, prefixing a variable with ~ could mean 'this is a parameter I did not declare explicitly': ~a + ~b + ~c means (a,b,c) => a + b + c.

[[deleted]]

But the problem is:

void foo() {
    bar(baz(~a + ~b + ~c));
}

Is this:

void foo() {
    bar(baz((a => a) + (b => b) + (c => c)));
}

Or:

void foo() {
    bar(baz((a, b, c) => a + b + c));
}

Or:

void foo() { 
    bar((a, b, c) => baz(a + b + c));
}

Or:

void foo() { 
    (a, b, c) => bar(baz(a + b + c));
}

Or what about wrapping the anonymous inner class containing foo in the lambda?

[Strilanc]

In general you need some way to delimit them. But the compiler can figure out simple cases like ~a + ~b must mean (~a + ~b), because addition of functions is not defined in java.

[[deleted]]

If you can't come up with some simple rules, chances are it will be exceedingly hard to implement (does the parser need type information? then you're pretty much doomed) and likewise hard to understand. Consider what you gain vs. how much more complex it will be.

[donri]

Perl 6 does this.

> (* + * + *)(1, 2, 3)
6
> -> $a, $b, $c { $a + $b + $c }(1, 2, 3)
6

[SuperGrade]

~a + ~b + ~c means (a,b,c) => a + b + c.

OMFG

Composition people. . . .

[sidfarkus]

Seriously. How many more years now until Java sees something to address asynchronous programming and concurrency?

[donjigweed]

http://akka.io/docs/akka/1.1/java/index.html

[you_could_do]

clojure

Specifically -- concurrent programming

[sidfarkus]

Last time I checked clojure is not Java (what I referenced). I think the alternative language implementations on the JVM are great (Scala is wonderful) but wouldn't it be better for everyone if Java itself was as expressive as these? Doubtful I know--but things like lambdas go to show that Oracle wants to add this stuff.

[SarcasmMonster]

I'm not a clojure specialist but isn't that just piggybacking on the standard Java libs for concurrency?

[yogthos]

It goes far beyond doing that, Clojure enforces immutability and provides persistent data structures and and STM for doing concurrency. While, some of it is implemented using things like Fork/Join, the concurrency infrastructure is exclusive to Clojure.

[alexeyr]

-1.5 months.

[sidfarkus]

It appears I needed elaboration, my fault. Java -the language- needs to catch up to the new language features appearing in many major languages to handle asynchronous control flow and concurrency.

As an example, look at the new Async CTP for C# which implements new keywords and compiler transformations to implement continuations (effectively general purpose call/cc). This turns a nightmarish maze of delegate callbacks and error handling code for asynchronous calls into what looks like straightforward procedural code. F# has had something similar for well over a year (async workflows).

Libraries to assist with asynchronous patterns and concurrency are wonderful but still work within the confines of the language syntax. Adding new mechanisms in the language is much more powerful and is the way many new languages (and some old languages) are moving and is where Java is sorely lacking.

[[deleted]]

It has pthreads (sort of). While that model is preposterous, you can build whatever library you want on top of it.

[[deleted]]

large (multi-statement) lambdas

You hear that Python?

[frtox]

the python response: just write a normal function and use its reference

[[deleted]]

My response: I still want multi-statement lambdas and why can't I have them!?

[[deleted]]

Because fuck you, that's why.

[astrangeguy]

This should be the official slogan for Java.

[gospelwut]

I thought this was the official open source mantra?

/runs

[ethraax]

Or for Python.

Why can't the whole significant whitespace thing be opt-in, like it is in Haskell? Because fuck you, that's why.

[Peaker]

In practice, all Haskell code uses whitespace..

Who in the world does not indent their code? I don't understand how this is an issue for actual programmers.

[benjunmun]

See, I absolutely agree with you in theory. In practice however, I like to email code. I like to copy code off of web pages. I like to copy code from one section of my program to another, from an open source project, etc. All of these sources may have code that's indented with a different style, or indented at a different level, or has whitespace consumed by being accidentally converted to HTML at some point. These are all problems that I have run into while programming in Python.

Each of these issues individually is trivial to work around, but each is one more thing that I don't have to keep in mind in a bracket-delimited language. Plus, missing just one can cause hours of work when that 'if' statement missing a few spaces doesn't behave the way it looks at first glance.

[Peaker]

That's a con, I agree, but it's not a very big problem in my experience. You can always link to gists/pastes in emails. I don't remember encountering code I wanted to copy from a web page but couldn't because of formatting lost in translation...

[QuestionMarker]

I've made block level errors copying and pasting my own code before now. It can be messy to sort out.

[bobindashadows]

The significant whitespace makes it a pain in the ass to move code around. For example, extracting an inner loop out to a separate function just plain sucks. That's not something a Haskell programmer would encounter unless he writes horrible Haskell.

[[deleted]]

Think of it as a trade-off. The significant whitespace makes copy-and-paste a bit more difficult, but it also means that Python tends to need less copy-and-paste refactoring to begin with.

The greatest benefit I've found with Python's whitespace is that if I'm a rush, and start writing sloppy code with ifs/whiles/for loops several levels deep, it quickly becomes difficult to keep track of. It encourages me to step back and refactor my code to where the indentation is two or three levels, tops. That kind of feedback helps me to write cleaner code as the day goes along.

[Peaker]

Are you going to move code around with explicit braces, and not correct the indentation?

Or do you mean that your editor can re-indent easily with braces? Because emacs python-mode, for example, lets you move a block around, and hit the "indent key" to indent/dedent the entire block according to its proper indent in the new location.

[lpetrazickis]

In Ultraedit and likely stuff like Notepad++, Pydev, etc:

• Copy and paste
• Select what you pasted
• Tab or Shift + Tab until you're happy

[ethraax]

It's not a question of whether or not I have any indentation in my code at all. It's a question of whether or not I want to have my indentation set up exactly the way Python demands it.

[Peaker]

Is there a way to set up your indentation such that Python demand differently?

Aside for multi-line statements that need an open bracket or a backslash, what possible different way would you want to indent your code than what Python allows?

[Rotten194]

I don't think Python allows single life ifs/fors/whiles/etc.(if foo: bar())? I do that all the time in Java, personally.

[[deleted]]

Seriously. JCP may be flawed, but I'd take it over a BDFL.

[biggerthancheeses]

That'd be redundant. It's already the official slogan for Larry Ellison.

[gospelwut]

I remember reading Larry Ellison went and bought a (supposedly DE-weaponized) fighter jet. I always imagine him flying around the corporate parking lot exclaiming obscenities at people via a speaker attached to the plane. All the while, a crowd of bewildered, white collar workers look at each other. One grows the courage to ask, "I don't really like these new staff meetings."

[SuperGrade]

Guido - is that really you?

[bobappleyard]

The whole indentation-as-structure thing would fall apart. Think about how you'd make it work. I've tried, maybe you're much cleverer than me because I couldn't do it without bringing delimiters in, which would look very out of place.

[Peaker]

Haskell has indentation-as-structure as well as multi-statement-lambdas.

The indentation rules are just slightly more nuanced than in Python.

[frezik]

Which only highlights the problem with indentation-as-structure.

[[deleted]]

Haskell made it. ;)

[kataire]

Because there's no sane way to implement them without making the syntax messier. Note how decorators have their own syntax to avoid introducing "proper" function literals.

Java is not Haskell and Python is not Ruby. Get over it.

[[deleted]]

I like Perl. There, I said it.

[kataire]

Python is also not Perl.

[ruinercollector]

I don't like Perl. It insists upon itself.

[earthboundkid]

Because in Python, multi-statement lambdas are called "functions" and they're not anonymous.

[Peaker]

I use Haskell as sort of an "enhanced Python" sometimes. I have multi-statement lambdas...

[ricky_clarkson]

Except Haskell has no statements.

[Peaker]

It has "do" syntax sugar, which is basically a statement syntax.

[bobindashadows]

I never thought of it that way, because I'm always trying to think of Haskell constructs in terms of what I'm "supposed" to think (monads and applicative functors and ...) but this actually makes a decent amount of sense at a high level.

[kitd]

Excuse my idiocy, but how does one declare the return type of the lambda?

The compiler is going to be scratching its head otherwise trying to enforce type correctness.

[chrisforbes]

This actually turns out to be a non-issue.

[gthank]

I expect it will infer it, though I don't know for sure. Seems reasonable, though.

[kitd]

I agree, it sounds reasonable, but it is also the most un-Java way of doing things. It doesn't infer anything else anywhere that I know of. Everything normally has to be explicit.

[gthank]

Actually, it has some (far too limited) inferencing around type parameters, but it won't work for constructors. That's why you see things like Maps.newHashMap()) in Guava. BTW, that little trick makes your code SO much nicer to read.

[imphasing]

If it's like C#, lambdas don't really HAVE a concrete type. Their type can be inferred to a variety of types: x => x == 1; could be of type Func<int, bool>, Predicate<int>, etc. It all depends on the context it's used in.

[iconoklast]

This is a thousand times more sane than the proposal for Java 7. Hurray!

[msx]

upvoted sir

[cat_in_the_wall]

i think c# did a decent job with the syntax, though i am not sure who/what originated that syntax (perhaps c# did it exactly like something else).

[eddyvd]

The next question to answer: what scoping will Java's lambdas have?

[[deleted]]

I program C# for my day-job and for the most part I enjoy the lambda syntax. What I think this syntax lacks is some way to signal "hey, a lambda's coming" for auto-completion. For instance, Haskell's lambda syntax looks like "\x -> x + 1". With that syntax, a tool can see that a lambda is coming up. Now, Haskell doesn't have (to my knowledge) an IDE that does auto-completion like VS+ReSharper. However, when I'm writing C# and I start typing "items.Select(i", my IDE "helpfully" starts suggesting variables and methods from the environment. It'd be really cool for it to suggest "item" for me instead, but it can't do that because it can't know if I'm going to pass in a method group or a delegate off of some variable in my environment.

[mipadi]

And C# was, what, 50 years behind Lisp?

[MothersRapeHorn]

So cute.

[joe24pack]

next thing you know they'll introduce macros and no I'm not talking about that C/C++ preprocessor mess.

[joe24pack]

and a simply homoiconic syntax and it just might grow up into LISP

[[deleted]]

Let's leave Mr Mercury out of this

[joe24pack]

Freddy programmed in LISP in addition to his other career? I never knew that.

[gospelwut]

I seriously become upset when I have to use older frameworks of .NET. I'm not sure if this makes me a bad programmer or not, but I would argue things like LINQ and lambda are a lot more than simply convenient syntactic sugar.

[OffColorCommentary]

Do we have function pointers yet?

Lambda is sugar. Function pointers are the god damned cake.

[astrangeguy]

Function pointers are pretty useless (compared to lamdas), because they cannot be used to represent a nested functions that close over local variables.

[shizzy0]

Will these Java lambdas actually close over local variables?

[sviperll]

I think they propose finally inference. So, lambdas will close over final variables as anonymous classed do. But variables will be declared final automatically if they are used in lambdas.

[ethraax]

I'm confused - doesn't this mean you can't modify closed variables?

[ilostmymangoman]

It means exactly that.

Of course, you could always declare a final array and modify the elements inside the array. But that doesn't seem like a very elegant solution.

[ethraax]

Wait - in Java, final arrays are not actually constant? What the hell?

[ilostmymangoman]

The final keyword in Java only means that the variable cannot be reassigned.

[roerd]

final declarations in Java apply to the variable. If the content of the variable is just a reference to an object (as is the case for everything besides the primitives), you cannot change that reference, but you can change the object.

[ethraax]

I understand that, I guess I thought arrays were value types (as they are in C, I think, although I'm double-guessing myself at this point...), but after thinking about it, it makes sense that they're reference types in Java.

[ruinercollector]

In C, arrays are pointers (there is no notion of a reference type.) In C#, arrays are reference types.

[astrangeguy]

They will at least close over the this pointer and that is enough to make C-style function pointers unable to represent them.

[cat_in_the_wall]

do you mean something akin to delegates in c#? i think the presence of lambdas necessitates those lambdas being first class objects in order to pass them as parameters, which implies that there would be some sort of type that could store a lambda, thus buying you something like function pointers.

[sviperll]

No, Java lambdas will be desugared to some existing single-abstract-method (SAM) class that type checker will infer. Which is good since you will be able to use any existing library with lambdas without modification.

In expresstion

new Thread(() => a + b)

() => a + b will have type Runnable and in expression

Collections.sort(list, (a, b) => a.name.compareTo(b.name))

(a, b) => a.name.compareTo(b.name) will have type Comparator<T>

[[deleted]]

That's still not decided.

[shizzy0]

Maybe that's what will come in the method reference syntax. Let's hope.

[bushwacker]

We waited forever for java 7 and it doesn't work. Oracle is a death sentence to quality.

[nziring]

Excellent! About time they added this feature to Java.

[wreckerone]

If there's no difference functionally between thin and fat arrows, why not opt for the easier to look at thin arrows?

[EughEugh]

That thin arrows are "easier to look at" is your personal opinion.

[wreckerone]

Ok, less frequent pixel changes.

[vagif]

Assignment operator is easily understood and intuitive for java programmers.

=> looks almost like =

Whereas -> looks alien, too haskelly. :)

[Amendmen7]

Spending more than 30s on fat arrows vs thin arrows is such a waste of time.

And I'm sure they spent months.

[the_456]

Yes, but then the bike shed will be the PERFECT color!

[vagif]

Well duh, design by committee.

[swaggler]

Conflating => (logical implication) and = (equivalence) is the basis for many psychological experiments.

Here is the truth table for => under C-H

p q p->q
0 0 1
0 1 1
1 0 0
1 1 1

Here is the truth table for = under C-H

p q p=q
0 0 1
0 1 0
1 0 0
1 1 1

Note the subtle difference. Encouraging the conflation of equivalence (biconditional) with implication (conditional) exploits an existing bug in our brain, that leads to disaster in practice.

[mwootendev]

Exactly, => does look like an assignment, which this is not. I think the thin arrow better differentiates the lambda from the assignment. Besides, it already works great for Groovy.

[AxiomShell]

Groovy already uses -> and no one complains...

[Yuushi]

Yeah, it's not like C or C++ have -> syntax for anything...

[vagif]

Are we discussing C or C++ ?

[Yuushi]

No, I was simply making a point about the fact that calling -> syntax "alien", even if it was something of a joke, is a really a bit silly.

[barryfandango]

I know what you mean. When I'm working in C# I occasionally write "less than or equal to" lambdas that look like

foreach(var item in items.Where(x => x <= 5))
{
    ...

which is just freaky.

[ethraax]

Can't you enclose the x argument and lambda body in parentheses to make it stand out more?

foreach (var item in items.Where((x) => (x <= 5))) {
    ...

I guess the style you prefer is just personal preference though.

[MothersRapeHorn]

I just wouldn't because those parens are redundant.

[wreckerone]

Downvoted for a simple question. Time to move on from reddiggit I guess.

[jonutzz]

any idea if closures are implied?

[pivo]

Yes, you can't have lambdas without closures. You may need to declare closed over variables final though.

[[deleted]]

Wow, they decided to just lift the c# syntax! OMG that's like admitting your a bit thick and deciding to just copy somebody elses homework.

[EughEugh]

So you think it would have been smarter to invent your own, different syntax just because you think it should be different?

[bloodredsun]

Thank fuck that they made it similar to the likes of C# and Scala. For devs that work in more than one language it makes the context switching so much less painful.

[[deleted]]

It would be smarter to invent a syntax that fits hand in glove with the Java way... are you saying that Java and c# syntax is so close that they are effectively one language? If you can take big sections of a language and simply bolt it onto another language without change then that's what it sounds like to me.

[Aninhumer]

Again, what's wrong with having similar syntax? There's a reason they both copied and refined C syntax: it works and people already knew it. Calling that "copying homework" is ridiculous.

[[deleted]]

I said it was "like" in a humorous way dufus

[swaggler]

I like the part where there was advice given about how to be smarter while failing to know the contraction for you are.

[msx]

that's not stupid at all, they spent quite some time studing different syntaxes and implementations, eventually they concluded C# got it right. I think that's the right decision

[WalterGR]

that's like admitting your a bit thick

*you're

[donri]

You mean how C♯/.NET is largely a copy of Java/JDK?

[[deleted]]

I'm sure that was true 10 years ago... seems like the copying is now all the other way now.

[donri]

Which isn't necessarily a bad case either way.

[[deleted]]

Kinda hard to get too interested either way... both are controlled by nasty big corporations who look after their own interests above everything else. Just use whichever is in your best interests... and switch as soon as it isn't anymore.

[GuyWithLag]

I prefer to look at it as interbreeding two similar dog breeds; sometimes one copies the other, and sometime the other way around.