add Returns

[jw3126]

This PR adds Always Returns which represents "constant" functions. So instead of writing

f = (args...; kw...) -> 42

you can do f = Returns(42).
Benefits are:

• Possibility to dispatch on Returns:

mymap(f, x::Array) = ...
mymap(f::Returns, x::Array) = FillArrays.Fill(f.value, size(x))

• Easier to debug:

Stacktrace:
 [1] filter(Returns(42), a::UnitRange{Int64})

instead of

Stacktrace:
 [1] filter(f::var"#1#2", a::UnitRange{Int64})

[rfourquet]

Always sounds like a duration belonging to the Dates module :)

[mbauman]

Are there any cases where this is helpful in Base code itself?

[vtjnash]

Would it be too much of a pun to define this using (c::Core.Const)(x...; y...) = c.val? 😂

[jw3126]

Are there any cases where this is helpful in Base code itself?

I think so. A pattern which I personally use often is ntuple(_ -> 3, len) and I also found this in julia. e.g.

julia/test/abstractarray.jl

Line 302 in e32e94e

trailing5 = CartesianIndex(ntuple(x->1, max(ndims(B)-5, 0)))

Another one is _ -> true

julia/test/bitarray.jl

Line 1311 in e32e94e

@test findprev(x->true, b1, 5) == 5

So I estimate, there is probably > 100 places in julia where Always could be used. Mainly in tests, but some also in Base code. I will convert a couple of them now and if triage is in favor of this, I will hunt all of them down. Or maybe 80% of them.

[jw3126]

Always sounds like a duration belonging to the Dates module :)

We can use another name of course. Names that came to my mind were Always, Const, Constant, Return. Looked at this naming problem in isolation Const would be my first choice. But as @vtjnash pointed out it collides a bit with Core.Const.

[JeffBezanson]

Common lisp calls this constantly.

[JeffBezanson]

Suggestion from triage: call it Returns(val), which should make it very clear that it's a function that ... returns the given value.

[jw3126]

Suggestion from triage: call it Returns(val), which should make it very clear that it's a function that ... returns the given value.

Sounds good. So this means triage is in favor of adding this functionality?

[jw3126]

I changed most of the constant lambdas in Base and test into Returns. From my point of view, this PR is ready.

[jw3126]

bump

[jw3126]

Bunp

[rfourquet]

Was Return mentioned as an alternative to Returns ? Verbs are generally used in imperative form, like fill/Fill, map, filter, Iterators.[tT]ake, etc.

[jw3126]

Was Return mentioned as an alternative to Returns ? Verbs are generally used in imperative form, like fill/Fill, map, filter, Iterators.[tT]ake, etc.

It was mentioned above but not discussed further I think.

[jw3126]

So how to move forward from here? Should this be renamed from Returns to Return?

[MasonProtter]

Return was discussed on the triage call, but people felt it was too different a concept from the return keyword. Returns was felt to be more descriptive and easier to differentiate.

[StefanKarpinski]

I'm amused by how every usage of this made the code longer. I suppose the advantage is that Returns(val) is only compiled once per argument type instead of having a different function object each type that's compiled separately.

[jw3126]

I'm amused by how every usage of this made the code longer. I suppose the advantage is that Returns(val) is only compiled once per argument type instead of having a different function object each type that's compiled separately.

@StefanKarpinski in general the main selling points of Returns are better printing, the possibility to dispatch on it and less work for the compiler in case of repetitions.
I think in most of the replacements in this PR, none of these are super strong arguments. It was more about consistency for me.

[mbauman]

I too was skeptical about this initially, but then immediately found myself wanting to use it for DataStructure.jl's DefaultDict, which calls Callable default values upon access. DefaultDict(Returns(identity)) is more readable and obvious than DefaultDict(x->identity) which feels odd to me.

[kmsquire]

more readable and obvious than DefaultDict(x->identity) which feels odd to me.

That does seem odd—are you storing a function in the dictionary (certainly possible), or do you mean DefaultDict(identity)?

[mbauman]

Yes, I was storing a transformer function in a dict. Type stability is overrated. :)

[JeffBezanson]

This also has an advantage when the value might be expensive to compute, e.g. Returns(expensive()) instead of val = expensive(); x->val. Admittedly that case is probably rare.