Use Supplier if it takes nothing, but returns something. Use Consumer if it takes something, but returns nothing. Use Callable if it returns a result and might throw (most akin to Thunk in general CS terms). Use Runnable if it does neither and cannot throw.
A lambda can only be converted to a function pointer if it does not capture, from the draft C++11 standard section 5.1.2 [expr.prim.lambda] says (emphasis mine): The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as … Read more
It requires mutable because by default, a function object should produce the same result every time it’s called. This is the difference between an object orientated function and a function using a global variable, effectively.
Create a custom Collector public static <T> Collector<T, ?, T> toSingleton() { return Collectors.collectingAndThen( Collectors.toList(), list -> { if (list.size() != 1) { throw new IllegalStateException(); } return list.get(0); } ); } We use Collectors.collectingAndThen to construct our desired Collector by Collecting our objects in a List with the Collectors.toList() collector. Applying an extra finisher … Read more
Well, you can use Expression.AndAlso / OrElse etc to combine logical expressions, but the problem is the parameters; are you working with the same ParameterExpression in expr1 and expr2? If so, it is easier: var body = Expression.AndAlso(expr1.Body, expr2.Body); var lambda = Expression.Lambda<Func<T,bool>>(body, expr1.Parameters[0]); This also works well to negate a single operation: static Expression<Func<T, … Read more
Yes, the code is standard conforming. The + triggers a conversion to a plain old function pointer for the lambda. What happens is this: The compiler sees the first lambda ([]{}) and generates a closure object according to §5.1.2. As the lambda is a non-capturing lambda, the following applies: 5.1.2 Lambda expressions [expr.prim.lambda] 6 The … Read more
The code that has to be executed for both alternatives is so similar that you can’t predict a result reliably. The underlying object structure might differ but that’s no challenge to the hotspot optimizer. So it depends on other surrounding conditions which will yield to a faster execution, if there is any difference. Combining two … Read more
Lambda expressions are a simpler syntax for anonymous delegates and can be used everywhere an anonymous delegate can be used. However, the opposite is not true; lambda expressions can be converted to expression trees which allows for a lot of the magic like LINQ to SQL. The following is an example of a LINQ to … Read more
As of the current JRE implementation, Function.identity() will always return the same instance while each occurrence of identifier -> identifier will not only create its own instance but even have a distinct implementation class. For more details, see here. The reason is that the compiler generates a synthetic method holding the trivial body of that … Read more
you may force the capture of a variable using an argument with a default value: >>> for i in [0,1,2,3]: … adders[i]=lambda a,i=i: i+a # note the dummy parameter with a default value … >>> print( adders[1](3) ) 4 the idea is to declare a parameter (cleverly named i) and give it a default value … Read more