Hi,
based on this
f = x -> x^2
f(10)
I’d like to develop a function with two inputs
f1(a,b) = a,b -> a^2+b
f1(2,1)
but this returns (2, λ). What are the meaning of lambda returned here and the right syntax for this?
1 Like
λ refers to the anonymous function b->a^2+b
Simply do
f1(a,b) = a^2+b
3 Likes
This also works if you want an anonymous function rather than a generic function.
julia> f1 = (a, b) -> a^2 + b
#3 (generic function with 1 method)
julia> f1(2, 1)
5
2 Likes
Oh I see
julia> f1(a,b) = a^2 + b
f1 (generic function with 1 method)julia> f2 = (a, b) -> a^2 + b
#44 (generic function with 1 method)
But what is anonymous function used for? This seems not to be explained in its documentation
https://docs.julialang.org/en/v1/manual/functions/#man-anonymous-functions-1
Just a little explanation, if you are curious. The code gets interpeted as
f1(a, b) = a, (b -> a^2+b)
which gets interpreted as
f1(a, b) = return a, (b -> a^2+b)
which produces the obvious error.
1 Like
“Anonymous” literally means “without a name” and you use them whenever your function might not merit being named. For example, if I want to add 1.3 to each item of a list, defining add1point3(x) might seem a bit silly. So I can instead say map(x -> x + 1.3, list) and avoiding giving that operation a special name.
3 Likes
If you have a function that takes a function as an argument, it can more concise to define an anonymous function right in the outer function argument list.
A trivial example:
julia> d = rand(10)
10-element Array{Float64,1}:
0.3551247514375906
0.3340804663050978
0.6544044171195078
0.9508829086833299
0.6444864931672418
0.3549102821541359
0.3284450308572071
0.8639674871803269
0.1763711097796281
0.32769620811874867
julia> findfirst(x -> x>0.5, d)
3
1 Like
There may be an implicit doubt in @1634’s question that remains to be answered: Ok, anonymous functions can be used as “throw-away functions” in arguments for map, findfirst, etc., without ever giving them a name. But what’s the difference between a “named” function and an anonymous one when it is (so to speak) “given” a name, i.e. assigned to a variable?
There are two notetworthy differences that I know of:
- Such variables are just containers that may be “emptied” or “reused” for another thing later on, unless they are declared as
const, whereas function names are constant by definition. For instance:
julia> foo(x) = x.^2
foo (generic function with 1 method)
julia> foo(3)
9
julia> foo = 0
ERROR: invalid redefinition of constant foo
[...]
julia> bar = x -> x.^2
#7 (generic function with 1 method)
julia> bar(3)
9
julia> bar = 0
0
- Since they don’t have real names, I can’t define methods for different number or types of arguments. (If someone else does know how to do it, just excuse my ignorance!)
3 Likes
There is no explicit syntax AFAIK, but one could easily get around this by defining a macro that converts
@multianon begin
(a::Int, b::Int) = a + b
(a::Float64, b::Float64) = a * b
end
to
let
f(a::Int, b::Int) = a + b
f(a::Float64, b::Float64) = a * b
f
end
where f would be replaced by the macroexpander hygienically.
It’s just that there is little point in doing so.
1 Like
Can’t you do
foo = x -> …
(::typeof(foo))(x, y) = …
?
2 Likes