Isn't there a nicer way to combine multiple `Union{T, Nothing}`

Question

I'm very new to Julia but I've got a some background in Scheme/Rust/F#.

Today I wanted to make yesterday's AoC nicer without an explicit number of nested loops.

I arrived at this working solution, but I don't like the last if. In the languages mentioned above I would call a function (or use a computation expression) that gives me the first result that is not None. For Julia, I expected something to do that. It does, but unexpectedly in an eager fashion.

So When I tried return something(find(r, n, start + 1, which), find(r, n - 1, start + 1, extended)), that also evaluated the second argument when the first already had a result—and thus crashed.

Is there a macro/lazy version or something that I didn't find? How are you supposed to handle a case like that?

I also thought about (short-circuited) or'ing them together, but I guess Julia's strictness in that matter spoils that.

using DataStructures

function find(r::Array{Int}, n, start = 1, which = nil())::Union{Int,Nothing}
    if start <= length(r)
        extended = cons(start, which)
        with_current = sum(i -> r[i], extended)
        if with_current == 2020 && n == 1
            return prod(i -> r[i], extended)
        else
            # Unfortunately no :(
            #return something(find(r, n, start + 1, which), find(r, n - 1, start + 1, extended))
            re = find(r, n, start + 1, which)
            if isnothing(re)
                return find(r, n - 1, start + 1, extended)
            else
                re
            end
        end
    end
end

I fear there is no solution as nice as a monad. But you'd be in the same situation in Scheme, right? — phipsgabler, Dec 02 '20 at 15:45
this could be handled by writing a `@something` macro that would be lazy. — Bogumił Kamiński, Dec 02 '20 at 16:05
@phipsgabler Yes, in Scheme I would use a macro for that. Part of the question was is there already one for Julia. — primfaktor, Dec 03 '20 at 09:33
According to @BogumiłKamiński, the answer seems to be “no”. I would have thought this is such a common case that there has to be one. — primfaktor, Dec 03 '20 at 09:34

score 4 · Accepted Answer · answered Dec 03 '20 at 12:58

Let me comment more on it why it is not possible given the discussion in the comments.

In Julia function arguments are evaluated eagerly, so Julia evaluates both find(r, n, start + 1, which) and find(r, n - 1, start + 1, extended) before passing them to something function.

Now, with macros you have (I am not writing in a fully general case for simplicity and I hope I got the hygiene right :)):

julia> macro something(x, y)
           quote
               local vx = $(esc(x))
               isnothing(vx) ? $(esc(y)) : vx
           end
       end
@something (macro with 1 method)

julia> @something 1 2
1

julia> @something nothing 2
2

julia> @something 1 sqrt(-1)
1

julia> @something nothing sqrt(-1)
ERROR: DomainError with -1.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).

(in a full-blown version of the macro varargs and Some should be handled to replicate something exactly)

Maybe worth filing an issue to discuss adding this! – Milan Bouchet-Valat Dec 03 '20 at 21:55 — Milan Bouchet-Valat, Dec 03 '20 at 21:55

score 0 · Answer 2 · answered Dec 05 '20 at 17:56

Piqued by Bogumił's answer I wanted to write my first Julia macro. It took some time and numerous attempts to figure out syntax, hygiene and escaping but I'm quite happy now.

I thought it might be worth sharing and provide opportunity for suggestions/improvements.

A lazy `@something` analog to `Base.something`

function _something_impl(thing)
    :(something($(esc(thing))))
end

function _something_impl(thing, rest...)
    quote
        local evalued = $(esc(thing))
        if isnothing(evalued)
            $(_something_impl(rest...))
        else
            something(evalued)
        end
    end
end

macro something(things...)
    _something_impl(things...)
end

Version without exceptions

As I found exceptions raised from a macro like this not quite suitable, I also made a version that falls back to nothing.

function _something_nothing_impl(thing)
    quote
        local evaluated = $(esc(thing))
        if isa(evaluated, Some)
            evaluated.value
        else
            evaluated
        end
    end
end

function _something_nothing_impl(thing, rest...)
    quote
        local evalued = $(esc(thing))
        if isnothing(evalued)
            $(_something_nothing_impl(rest...))
        else
            something(evalued)
        end
    end
end

macro something_nothing(things...)
    _something_nothing_impl(things...)
end

Now I guess the recursive middle function could also generated by a macro. :)

Isn't there a nicer way to combine multiple `Union{T, Nothing}`

2 Answers2

A lazy @something analog to Base.something

Version without exceptions

A lazy `@something` analog to `Base.something`