Missing interop: add asmissing and frommissing

src/Maybe.jl

@@ -23,11 +23,14 @@ Since there is no name clash with `Base` API, `using Maybe.Extras`
 imports the API defined in `Maybe.Extras`.
 """
 baremodule Extras
-export getnested, ifnothing, maybe, defaultto
+export asmissing, defaultto, definite, frommissing, getnested, ifnothing, maybe
 function maybe end
 function ifnothing end
 function defaultto end
 function getnested end
+function definite end
+function asmissing end
+function frommissing end
 end
 
 const X = Extras

src/docs/asmissing.md

@@ -0,0 +1,23 @@
+    Maybe.Extras.asmissing(x)
+
+Translate `Union{Nothing,T,Some{T},Some{Some{T}},...}` to
+`Union{T,Missing}`.
+
+This is a shorthand of `something(definite(x), missing)`.
+
+# Examples
+```julia
+julia> using Maybe.Extras
+
+julia> asmissing(1)
+1
+
+julia> asmissing(nothing)
+missing
+
+julia> asmissing(Some(Some(1)))
+1
+
+julia> asmissing(Some(Some(nothing)))
+missing
+```

src/docs/definite.md

@@ -0,0 +1,18 @@
+    Maybe.Extras.definite(x)
+
+Unwrap `Some` recursively and obtain a non-`Some` value.  The returned
+value is `nothing` if `x` is `nothing` or `nothing` wrapped in `Some`
+(possibly multiple times).
+
+# Examples
+```julia
+julia> using Maybe.Extras
+
+julia> definite(Some(Some(Some(1))))
+1
+
+julia> definite(Some(Some(Some(nothing))))
+
+julia> something(definite(Some(Some(nothing))), 2)
+2
+```

src/extras.jl

@@ -26,3 +26,11 @@ Maybe.Extras.defaultto(c) = Maybe.Extras.ifnothing(() -> c)
 @inline Maybe.Extras.getnested(x, k, keys...) =
     Maybe.Extras.getnested(@something(Maybe.get(x, k), return), keys...)
 @inline Maybe.Extras.getnested(x) = Some(x)
+
+Maybe.Extras.definite(x) = x
+Maybe.Extras.definite(x::Some) = Maybe.Extras.definite(something(x))
+
+Maybe.Extras.asmissing(x) = something(Maybe.Extras.definite(x), missing)
+
+Maybe.Extras.frommissing(::Missing) = nothing
+Maybe.Extras.frommissing(x) = Some(x)