4 ms·
Correct me if I'm wrong but I believe the C# compiler goes a step further and allows you to write those lambda arguments without the type annotation. Is there a
by statictype 16y ago
Correct me if I'm wrong but I believe the C# compiler goes a step further and allows you to write those lambda arguments without the type annotation. Is there a technical reason why the Java compiler can't do the same?
- StrawberryFrog 16y agoC# will infer lambda argument types from context, yes. So the code given: return Iterables.filter(employees, {Employee e -> e.isPartTime()}); Would be in C# (Since you'd also omit the { } and use "=>" not "->") something like this: return Iterables.filter(employees, e => e.isPartTime()); And it is a better C# idiom to make "filter" an extension method on IEumerable<T>. return employees.filter(e => e.isPartTime()); In fact, the existing extension method "Where()" is what you want. return employees.Where(e => e.isPartTime()); C# has had this for about 2 years now. And it is good. So, I'm looking at your code, and back to mine. Mine is shorter but still very readable (to me anyway). And it stays readable when you chain methods, e.g. return employees.Where(e => e.isPartTime()).ToArray(); I'll stay with mine right now.
- statictype 16y agoMinor nitpick: The lambda operator in C# is "=>"
- StrawberryFrog 16y agoWhoops, I have fixed that cut-and-paste error. I hadn't noticed that the java code had another gratuitous difference.
- jules 16y agoYou have to use => instead of ->. This got me many times too ;)
- StrawberryFrog 16y agoGood point - this is the first time it's got me, but then I don't look at much java.
- henrikschroder 16y agoThere was also a comment to the above saying that instead of writing: List<Ticket<ThingYouLove>> tickets = new ArrayList<Ticket<ThingYouLove>>(); You could write: List<Ticket<ThingYouLove>> tickets = new ArrayList<>();" Nice, but I prefer C# there as well where you use the var keyword, like this: var tickets = new ArrayList<Ticket<ThingYouLove>>();
- instcode 16y agoNice, but I prefer C# there as well where you use the var keyword, like this: var tickets = new ArrayList<Ticket<ThingYouLove>>(); Actually, JDK7 is better in this case because it helps developer to "program to an interface".
- henrikschroder 16y agoWhat do you mean, that you can do something like this? List<Foo<Bar>> list = new ArrayList<>(); Programming to an interface is relevant between method calls, not inside the scope of a single method, which is typically where you use the var keyword in C#. This is programming to an interface, in C#, using the var keyword: public List<Foo<Bar>> MyMethod(...) { List<Foo<Bar>> result = new ArrayList<Foo<Bar>>(); ... return result; } var list = MyMethod(...); //list will be of type List<Foo<Bar>> In Java, the above would then look like this: public List<Foo<Bar>> MyMethod(...) { List<Foo<Bar>> result = new ArrayList<>(); ... return result; } List<Foo<Bar>> list = MyMethod(...); You don't save more characters in either case, neither is promoting programming to an interface more than the other, but I still think the var keyword is the better construct, since it removes type declaration consistently. It basically means that the compiler should infer the type of the variable immediately, without me having to spell it out. The Java construct on the other hand means something like: "In the constructor to a generic class, infer the generic parameters from the type of the variable the result is assigned to", which is a weaker construct, a less expressive one, a less flexible one. Both are still syntactic sugar implemented as compiler tricks, but the C# one simply does more.
- StrawberryFrog 16y agoCould you expand on what "program to an interface" means to you in this context, I'm not getting it. Assume that I know what it means in the usual context, of depending on the services of an interface type not a concrete type.