Minor renames of functions

Author: jakobnissen

Diff for: NEWS.md

@@ -1,3 +1,11 @@
+## Release 0.5.0
+
+__Breaking changes__
+* Renamed `unwrap_err` and `expect_err` to `unwrap_error` and `expect_error`.
+
+__New features__
+* `@unwrap_error_or` and `unwrap_error_or` mirrors their non-error equivalents.
+
 ## Release 0.4
 __Breaking changes__
 ErrorTypes is no longer based on SumTypes. SumTypes tries to solve a more general problem, and as such requires more compiler tricks. That both obfuscated ErrorTypes' behaviour and made it a more heavy dependency than it needed to be.

Diff for: Project.toml

@@ -1,7 +1,7 @@
 name = "ErrorTypes"
 uuid = "7f495686-c6d2-4c77-9e8e-e4c865675f9d"
 authors = ["Jakob Nybo Nissen <[email protected]>"]
-version = "0.4.0"
+version = "0.5.0"
 
 [compat]
 julia = "1.3"

Diff for: src/ErrorTypes.jl

@@ -48,11 +48,7 @@ end
 
 function Result{T1, E1}(x::Result{T2, E2}) where {T1, T2 <: T1, E1, E2 <: E1}
     inner = x.x
-    if inner isa Err
-        Result{T1, E1}(Err{E1}(unsafe, inner.x))
-    else
-        Result{T1, E1}(Ok{T1}(unsafe, inner.x))
-    end
+    return Result{T1, E1}(inner isa Err ? Err(inner.x) : Ok(inner.x))
 end
 
 function Base.convert(::Type{Result{T1, E1}}, x::Result{T2, E2}) where {T1, T2 <: T1, E1, E2 <: E1}
@@ -88,12 +84,7 @@ is_error(x::Result) = x.x isa Err
 Option(x::Result{T, E}) where {T, E} = is_error(x) ? none(T) : Option{T}(x.x)
 function Result(x::Option{T}, v::E) where {T, E}
     data = x.x
-    inner = if x.x isa Err
-        Err{E}(unsafe, v)
-    else
-        x.x
-    end
-    return Result{T, E}(inner)
+    return Result{T, E}(data isa Err ? Err(v) : x.x)
 end
 
 some(x::T) where T = Option{T}(Ok{T}(unsafe, x))
@@ -141,6 +132,15 @@ macro var"?"(expr)
     end
 end
 
+macro unwrap_t_or(expr, T, exec)
+    quote
+        local res = $(esc(expr))
+        isa(res, Result) || throw(TypeError(Symbol("@unwrap_or"), Result, res))
+        local data = res.x
+        data isa $(esc(T)) ? data.x : $(esc(exec))
+    end
+end
+
 # Note: jldoctests crashes on this ATM, even if it works correctly.
 """
     @unwrap_or(expr, exec)
@@ -166,12 +166,16 @@ julia> skip_inv_sum([2,1,0,1,2])
 ```
 """
 macro unwrap_or(expr, exec)
-    quote
-        local res = $(esc(expr))
-        isa(res, Result) || throw(TypeError(Symbol("@unwrap_or"), Result, res))
-        local data = res.x
-        data isa Ok ? data.x : $(esc(exec))
-    end
+    return :(@unwrap_t_or $(esc(expr)) Ok $(esc(exec)))
+end
+
+"""
+    @unwrap_error_or(expr, exec)
+
+Same as `@unwrap_or`, but unwraps errors.
+"""
+macro unwrap_error_or(expr, exec)
+    return :(@unwrap_t_or $(esc(expr)) Err $(esc(exec)))
 end
 
 @noinline throw_unwrap_err() = error("unwrap on unexpected type")
@@ -182,42 +186,30 @@ end
 If `x` is of the associated error type, throw an error. Else, return the contained
 result type.
 """
-function unwrap(x::Result)
-    data = x.x
-    data isa Ok ? data.x : throw_unwrap_err()
-end
+unwrap(x::Result) = @unwrap_or x throw_unwrap_err()
 
 """
-    unwrap_err(x::Result)
+    unwrap_error(x::Result)
 
 If `x` contains an `Err`, return the content of the `Err`. Else, throw an error.
 """
-function unwrap_err(x::Result)
-    data = x.x
-    data isa Err ? data.x : throw_unwrap_err()
-end
+unwrap_error(x::Result) = @unwrap_error_or x throw_unwrap_err()
 
 """
     expect(x::Result, s::AbstractString)
 
 If `x` is of the associated error type, error with message `s`. Else, return
 the contained result type.
 """
-function expect(x::Result, s::AbstractString)
-    data = x.x
-    data isa Ok ? data.x : error(s)
-end
+expect(x::Result, s::AbstractString) = @unwrap_or x error(s)
 
 """
-    expect_err(x::Result, s::AbstractString)
+    expect_error(x::Result, s::AbstractString)
 
 If `x` contains an `Err`, return the content of the `Err`. Else, throw an error
 with message `s`.
 """
-function expect_err(x::Result, s::AbstractString)
-    data = x.x
-    data isa Err ? data.x : error(s)
-end
+expect_error(x::Result, s::AbstractString) = @unwrap_error_or x error(s)
 
 """
     and_then(f, ::Type{T}, x::Result{O, E})
@@ -229,11 +221,7 @@ If `f(unwrap(x))` is not a `T`, this functions throws an error.
 """
 function and_then(f, ::Type{T}, x::Result{O, E})::Result{T, E} where {T, O, E}
     data = x.x
-    if data isa Ok
-        Result{T, E}(Ok{T}(unsafe, f(data.x)))
-    else
-        Result{T, E}(Err{E}(unsafe, data.x))
-    end
+    Result{T, E}(data isa Ok ? Ok(f(data.x)) : Err(data.x))
 end
 
 """
@@ -243,6 +231,14 @@ If `x` is an error value, return `v`. Else, unwrap `x` and return its content.
 """
 unwrap_or(x::Result, v) = @unwrap_or x v
 
+
+"""
+    unwrap_error_or(x::Result, v)
+
+Like `unwrap_or`, but unwraps an error.
+"""
+unwrap_error_or(x::Result, v) = @unwrap_error_or x v
+
 """
     flatten(x::Option{Option{T}})
 
@@ -269,8 +265,8 @@ base(x::Option{T}) where T = Some(@unwrap_or x (return nothing))
 
 export Ok, Err, Result, Option,
     is_error, some, none,
-    unwrap, unwrap_err, expect, expect_err,
-    and_then, unwrap_or, flatten, base,
-    @?, @unwrap_or
+    unwrap, unwrap_error, expect, expect_error,
+    and_then, unwrap_or, unwrap_error_or, flatten, base,
+    @?, @unwrap_or, @unwrap_error_or
 
 end

Diff for: test/runtests.jl

@@ -47,28 +47,35 @@ using Test
     @test_throws ErrorException unwrap(Result{Int, String}(Err("foo")))
     @test_throws ErrorException unwrap(Result{Bool, Bool}(Err(true)))
 
+    # unwrap_or
     @test unwrap_or(Result{Int, Float64}(Ok(5)), 11) === 5
     @test unwrap_or(Result{Nothing, Nothing}(Ok(nothing)), 1) === nothing
     @test unwrap_or(Result{String, Dict}(Err(Dict())), "hello") == "hello"
     @test unwrap_or(Result{Int, Int}(Err(1)), 1 + 1) === 2
+
+    # unwrap_error_or
+    @test unwrap_error_or(Result{Integer, AbstractFloat}(Err(1.1)), 1.2) === 1.1
+    @test unwrap_error_or(Result{UInt8, UInt8}(Err(0x00)), Dict()) === 0x00
+    @test unwrap_error_or(Result{Dict, String}(Ok(Dict())), missing) === missing
+    @test unwrap_error_or(Result{Int, UInt}(Ok(55)), UInt(1)) === UInt(1)
 
     # expect
     @test expect(Result{Nothing, Int}(Ok(nothing)), "foo") === nothing
     @test expect(convert(Result{Int,Int}, Ok(17)), " ") === 17
     @test_throws ErrorException expect(Result{Int, UInt}(Err(UInt(11))), "bar")
     @test_throws ErrorException expect(Result{Bool, Bool}(Err(true)), "foo")
 
-    # unwrap_err
-    @test unwrap_err(Result{String, UInt}(Err(UInt(19)))) == UInt(19)
-    @test unwrap_err(Result{AbstractDict, String}(Err("bar"))) == "bar"
-    @test_throws ErrorException unwrap_err(Result{Int, Int}(Ok(1)))
-    @test_throws ErrorException unwrap_err(Result{String, Int}(Ok("bar")))
+    # unwrap_error
+    @test unwrap_error(Result{String, UInt}(Err(UInt(19)))) == UInt(19)
+    @test unwrap_error(Result{AbstractDict, String}(Err("bar"))) == "bar"
+    @test_throws ErrorException unwrap_error(Result{Int, Int}(Ok(1)))
+    @test_throws ErrorException unwrap_error(Result{String, Int}(Ok("bar")))
 
     # expect_err
-    @test expect_err(Result{Vector, AbstractString}(Err("x")), "foo") == "x"
-    @test expect_err(Result{Int, UInt8}(Err(0xa4)), "mistake!") == 0xa4
-    @test_throws ErrorException expect_err(Result{Int, UInt8}(Ok(15)), "foobar")
-    @test_throws ErrorException expect_err(Result{Vector, AbstractString}(Ok([])), "xx")
+    @test expect_error(Result{Vector, AbstractString}(Err("x")), "foo") == "x"
+    @test expect_error(Result{Int, UInt8}(Err(0xa4)), "mistake!") == 0xa4
+    @test_throws ErrorException expect_error(Result{Int, UInt8}(Ok(15)), "foobar")
+    @test_throws ErrorException expect_error(Result{Vector, AbstractString}(Ok([])), "xx")
 
     # and_then
     @test and_then(x -> x + 1, Float64, Result{Float64, String}(Ok(5.0))) === Result{Float64, String}(Ok(6.0))
@@ -170,6 +177,7 @@ end
 end
 
 @testset "@unwrap_or" begin
+    # @unwrap_or
     not_zero(x::Int)::Option{Int} = iszero(x) ? none : some(1 + x)
 
     function my_sum(f, it)
@@ -191,6 +199,11 @@ end
     @test my_sum(not_zero_two, [1,2,0,2,0,1]) === 3.0
 
     @test_throws TypeError @unwrap_or (1 + 1) "foo"
+
+    # @unwrap_error_or
+    @test (@unwrap_error_or none(Integer) missing) === nothing
+    @test (@unwrap_error_or some(55) missing) === missing
+    @test (@unwrap_error_or Result{UInt8, String}(Err("Someerr")) missing) == "Someerr"
 end
 
 # I only have this to get 100% code coverage and make sure printing doesn't error