This syntax gives Kotlin great DSL capabilities, it makes functions look like language constructions. For example: with(car) { startUp() goToDestination() } Here with looks like it is language construction, whereas it is a simple function, receiving lambda as the last parameter. And this leads to such elegant things like Kotlin HTML DSL
Lambda’s take the same signature as regular functions, and you can give reg a default: f = lambda X, model, reg=1e3: cost(X, model, reg=reg, sparse=np.random.rand(10,10)) What default you give it depends on what default the cost function has assigned to that same parameter. These defaults are stored on that function in the cost.__defaults__ structure, matching … Read more
There are precedents for using a noun in the Framework, e.g. Enumerable.Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector) Enumerable.Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) Enumerable.GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) ConcurrentDictionary<TKey,TValue>.GetOrAdd(TKey key, Func<TKey, TValue> valueFactory); The noun is often an appropriate verb with an agentive suffix. In your example I would … Read more
And: Func<Order, bool> predicate3 = order => predicate1(order) && predicate2(order); Or: Func<Order, bool> predicate3 = order => predicate1(order) || predicate2(order);
The one thing you could test for is code object equality: >>> x = lambda x: x >>> y = lambda y: y >>> x.__code__.co_code ‘|\x00\x00S’ >>> x.__code__.co_code == y.__code__.co_code True Here the bytecode for both functions is the same. You’ll perhaps need to verify more aspects of the code objects (constants and closures spring … Read more
Primitive optionals haven’t map, flatMap and filter methods by design. Moreover, according to Java8 in Action p.305 you shouldn’t use them. The justification of use primitive on streams are the performance reasons. In case of huge number of elements, boxing/unboxing overhead is significant. But this is senselessly since there is only one element in Optional. … Read more
I’m afraid this is not possible. The following demonstrates the type of a function with vararg. A vararg parameter is represented by an Array: fun withVarargs(vararg x: String) = Unit val f: KFunction1<Array<out String>, Unit> = ::withVarargs This behavior is also suggested in the docs: Inside a function a vararg-parameter of type T is visible … Read more
Let’s look at the relevant part of the Java Language Specification, 15.13. Method Reference Expressions. It lists the following ways to a create method reference: MethodReference: ExpressionName :: [TypeArguments] Identifier ReferenceType :: [TypeArguments] Identifier Primary :: [TypeArguments] Identifier super :: [TypeArguments] Identifier TypeName . super :: [TypeArguments] Identifier ClassType :: [TypeArguments] new ArrayType :: new … Read more
I believe that your first sample actually creates an anonymous function that is able to take on many different signatures whose body is the single statement Console.WriteLine…. Because it can match different signatures, it does not cause a problem. In the second sample, the lambda syntax itself defines a function that takes no parameters with … Read more
I suppose you are not talking about pattern matching in the sense of applying a regular expression on a string, but as applied in Haskell. For instance using wildcards: head (x:_) = x tail (_:xs) = xs Java 8 will not support that natively, with Lambda expression there are, however, ways to do so, like … Read more