Comparison with ResultTypes

[ararslan]

First of all, neat package!

Rust's Result type is mentioned in the README, so it may be worthwhile to compare and contrast this approach in the README with Eric Davies' Julia implementation, ResultTypes.jl.

[KristofferC]

Hadn't seen that. Looking at it, they are indeed eerily similar. Implementation is a bit different, I use

struct Expected{T,E}
    v::Union{T,E}
    ok::Bool
end

while ResultTypes uses

struct Result{T, E <: Exception}
    result::Union{Some{T}, Nothing}
    error::Union{E, Nothing}
end

[KristofferC]

Here is a benchmark:

julia> using ResultTypes, Expect, BenchmarkTools

julia> @noinline function rt_integer_division(x::Int, y::Int)::Result{Int, DivideError}
           if y == 0
               return DivideError()
           else
               return div(x, y)
           end
       end

julia> @noinline function expect_integer_division(x::Int, y::Int)::Expect{Int, DivideError}
           if y == 0
               return DivideError()
           else
               return div(x, y)
           end
       end

julia> @noinline function rt_func2(x, y)
           r = rt_integer_division(x, y)
           if ResultTypes.iserror(r)
               return 0
           else
               return unwrap(r)
           end
       end

julia> @noinline function expect_func2(x, y)
           r = safe_divide(x, y)
           if !isassigned(r)
               return 0
           else
               return r[]
           end
       end

julia> @btime for i = 1:10 rt_func2(3, i % 2) end
  79.357 ns (0 allocations: 0 bytes)

julia> @btime for i = 1:10 expect_func2(3, i % 2) end
  80.165 ns (0 allocations: 0 bytes)

julia> @btime rt_func2(3, 0)
  8.279 ns (0 allocations: 0 bytes)
0

julia> @btime expect_func2(3, 0)
  8.576 ns (0 allocations: 0 bytes)
0

So performance seems pretty much identical.