From 0b0bc91f13d5010a727e4f960997d4c386dd9c30 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Wed, 6 Sep 2017 23:01:39 +0200 Subject: [PATCH 01/16] Replace Nullable{T} with Union{Some{T}, Void} --- NEWS.md | 5 + base/broadcast.jl | 50 +-- base/channels.jl | 16 +- base/client.jl | 2 +- base/deprecated.jl | 17 +- base/docs/Docs.jl | 12 +- base/docs/basedocs.jl | 2 +- base/exports.jl | 7 +- base/gmp.jl | 10 +- base/int.jl | 6 +- base/iterators.jl | 12 +- base/libgit2/callbacks.jl | 58 +-- base/libgit2/config.jl | 10 +- base/libgit2/gitcredential.jl | 78 ++-- base/libgit2/index.jl | 6 +- base/libgit2/libgit2.jl | 30 +- base/libgit2/rebase.jl | 4 +- base/libgit2/reference.jl | 23 +- base/libgit2/remote.jl | 15 +- base/libgit2/repository.jl | 12 +- base/libgit2/status.jl | 4 +- base/libgit2/types.jl | 82 ++-- base/lock.jl | 6 +- base/methodshow.jl | 12 +- base/mpfr.jl | 2 +- base/nullable.jl | 419 ------------------ base/nullabletype.jl | 9 - base/parse.jl | 111 +++-- base/pkg/entry.jl | 4 +- base/pkg/pkg.jl | 6 +- base/pkg/read.jl | 4 +- base/precompile.jl | 100 ++--- base/process.jl | 26 +- base/repl/REPL.jl | 2 +- base/repl/REPLCompletions.jl | 2 +- base/socket.jl | 2 +- base/some.jl | 68 +++ base/stream.jl | 15 +- base/sysimg.jl | 5 +- base/threadcall.jl | 8 +- base/util.jl | 14 +- doc/src/manual/faq.md | 22 +- doc/src/manual/parallel-computing.md | 37 +- doc/src/manual/stacktraces.md | 2 +- doc/src/manual/style-guide.md | 2 - doc/src/manual/types.md | 187 -------- doc/src/stdlib/base.md | 16 +- examples/clustermanager/0mq/ZMQCM.jl | 4 +- .../clustermanager/simple/UnixDomainCM.jl | 7 +- stdlib/Dates/src/io.jl | 27 +- stdlib/Dates/src/parse.jl | 89 ++-- stdlib/Dates/src/types.jl | 20 +- stdlib/Dates/test/io.jl | 2 +- stdlib/DelimitedFiles/src/DelimitedFiles.jl | 23 +- stdlib/Distributed/src/cluster.jl | 89 ++-- stdlib/Distributed/src/macros.jl | 6 +- stdlib/Distributed/src/managers.jl | 50 +-- stdlib/Distributed/src/messages.jl | 2 +- stdlib/Distributed/src/process_messages.jl | 12 +- stdlib/Distributed/src/remotecall.jl | 31 +- stdlib/Distributed/src/workerpool.jl | 8 +- stdlib/Distributed/test/distributed_exec.jl | 22 +- stdlib/Distributed/test/topology.jl | 8 +- stdlib/Profile/src/Profile.jl | 4 +- test/ambiguous.jl | 2 + test/broadcast.jl | 11 +- test/ccall.jl | 4 +- test/choosetests.jl | 2 +- test/codegen.jl | 1 - test/compile.jl | 6 +- test/copy.jl | 8 +- test/core.jl | 12 +- test/libgit2-helpers.jl | 10 +- test/libgit2.jl | 69 ++- test/misc.jl | 6 +- test/parse.jl | 18 +- test/reflection.jl | 18 +- test/serialize.jl | 10 +- test/some.jl | 64 +++ test/spawn.jl | 2 +- test/specificity.jl | 4 +- test/strings/basic.jl | 10 +- 82 files changed, 851 insertions(+), 1352 deletions(-) delete mode 100644 base/nullable.jl delete mode 100644 base/nullabletype.jl create mode 100644 base/some.jl create mode 100644 test/some.jl diff --git a/NEWS.md b/NEWS.md index 0f7da3162e200..398ef04a38aeb 100644 --- a/NEWS.md +++ b/NEWS.md @@ -770,6 +770,11 @@ Deprecated or removed * `Associative` has been deprecated in favor of `AbstractDict` ([#25012]). + * `Nullable{T}` has been deprecated and moved to the Nullables package: + use `Union{T, Void}` or `Union{Some{T}, Void}` instead. `isnull(x)` can be replaced + with `x === nothing` and `unsafe_get(x)` with `get(x)`. + `NullException` has been removed ([#23642]). + Command-line option changes --------------------------- diff --git a/base/broadcast.jl b/base/broadcast.jl index 185bb1c6fae6c..a3d6d57547d4c 100644 --- a/base/broadcast.jl +++ b/base/broadcast.jl @@ -5,7 +5,7 @@ module Broadcast using Base.Cartesian using Base: Indices, OneTo, linearindices, tail, to_shape, _msk_end, unsafe_bitgetindex, bitcache_chunks, bitcache_size, dumpbitcache, - nullable_returntype, null_safe_op, hasvalue, isoperator + isoperator import Base: broadcast, broadcast! export BroadcastStyle, broadcast_indices, broadcast_similar, broadcast_getindex, broadcast_setindex!, dotview, @__dot__ @@ -45,7 +45,6 @@ Naturally you can specialize this for your particular `C` (e.g., `MyContainer`). struct Style{T} <: BroadcastStyle end BroadcastStyle(::Type{<:Tuple}) = Style{Tuple}() -BroadcastStyle(::Type{<:Nullable}) = Style{Nullable}() struct Unknown <: BroadcastStyle end BroadcastStyle(::Type{Union{}}) = Unknown() # ambiguity resolution @@ -142,7 +141,6 @@ BroadcastStyle(::BroadcastStyle, ::BroadcastStyle) = Unknown() BroadcastStyle(::Unknown, ::Unknown) = Unknown() BroadcastStyle(::S, ::Unknown) where S<:BroadcastStyle = S() # Precedence rules -BroadcastStyle(::Style{Nullable}, ::Scalar) = Style{Nullable}() BroadcastStyle(::Style{Tuple}, ::Scalar) = Style{Tuple}() BroadcastStyle(a::AbstractArrayStyle{0}, ::Style{Tuple}) = typeof(a)(Val(1)) BroadcastStyle(a::AbstractArrayStyle, ::Style{Tuple}) = a @@ -223,7 +221,6 @@ broadcast_indices() = () broadcast_indices(::Type{T}) where T = () broadcast_indices(A) = broadcast_indices(combine_styles(A), A) broadcast_indices(::Scalar, A) = () -broadcast_indices(::Style{Nullable}, A) = () broadcast_indices(::Style{Tuple}, A) = (OneTo(length(A)),) broadcast_indices(::DefaultArrayStyle{0}, A::Ref) = () broadcast_indices(::AbstractArrayStyle, A) = Base.axes(A) @@ -375,7 +372,7 @@ end Base.@propagate_inbounds _broadcast_getindex(::Type{T}, I) where T = T Base.@propagate_inbounds _broadcast_getindex(A, I) = _broadcast_getindex(combine_styles(A), A, I) Base.@propagate_inbounds _broadcast_getindex(::DefaultArrayStyle{0}, A::Ref, I) = A[] -Base.@propagate_inbounds _broadcast_getindex(::Union{Unknown,Scalar,Style{Nullable}}, A, I) = A +Base.@propagate_inbounds _broadcast_getindex(::Union{Unknown,Scalar}, A, I) = A Base.@propagate_inbounds _broadcast_getindex(::Any, A, I) = A[I] Base.@propagate_inbounds _broadcast_getindex(::Style{Tuple}, A::Tuple{Any}, I) = A[1] @@ -510,28 +507,20 @@ maptoTuple(f, a, b...) = Tuple{f(a), maptoTuple(f, b...).types...} # )::_broadcast_getindex_eltype(A) _broadcast_getindex_eltype(A) = _broadcast_getindex_eltype(combine_styles(A), A) _broadcast_getindex_eltype(::Scalar, ::Type{T}) where T = Type{T} -_broadcast_getindex_eltype(::Union{Unknown,Scalar,Style{Nullable}}, A) = typeof(A) +_broadcast_getindex_eltype(::Union{Unknown,Scalar}, A) = typeof(A) _broadcast_getindex_eltype(::BroadcastStyle, A) = eltype(A) # Tuple, Array, etc. -# An element type satisfying for all A: -# unsafe_get(A)::unsafe_get_eltype(A) -_unsafe_get_eltype(x::Nullable) = eltype(x) -_unsafe_get_eltype(::Type{T}) where T = Type{T} -_unsafe_get_eltype(x) = typeof(x) - # Inferred eltype of result of broadcast(f, xs...) combine_eltypes(f, A, As...) = Base._return_type(f, maptoTuple(_broadcast_getindex_eltype, A, As...)) -_nullable_eltype(f, A, As...) = - Base._return_type(f, maptoTuple(_unsafe_get_eltype, A, As...)) """ broadcast(f, As...) -Broadcasts the arrays, tuples, `Ref`s, nullables, and/or scalars `As` to a +Broadcasts the arrays, tuples, `Ref`s and/or scalars `As` to a container of the appropriate type and dimensions. In this context, anything -that is not a subtype of `AbstractArray`, `Ref` (except for `Ptr`s), `Tuple`, -or `Nullable` is considered a scalar. The resulting container is established by +that is not a subtype of `AbstractArray`, `Ref` (except for `Ptr`s) or `Tuple` +is considered a scalar. The resulting container is established by the following rules: - If all the arguments are scalars, it returns a scalar. @@ -540,10 +529,6 @@ the following rules: (expanding singleton dimensions), and treats `Ref`s as 0-dimensional arrays, and tuples as 1-dimensional arrays. -The following additional rule applies to `Nullable` arguments: If there is at -least one `Nullable`, and all the arguments are scalars or `Nullable`, it -returns a `Nullable` treating `Nullable`s as "containers". - A special syntax exists for broadcasting: `f.(args...)` is equivalent to `broadcast(f, args...)`, and nested `f.(g.(args...))` calls are fused into a single broadcast loop. @@ -602,14 +587,6 @@ julia> string.(("one","two","three","four"), ": ", 1:4) "three: 3" "four: 4" -julia> Nullable("X") .* "Y" -Nullable{String}("XY") - -julia> broadcast(/, 1.0, Nullable(2.0)) -Nullable{Float64}(0.5) - -julia> (1 + im) ./ Nullable{Int}() -Nullable{Complex{Float64}}() ``` """ @inline broadcast(f, A, Bs...) = @@ -656,21 +633,6 @@ function broadcast_nonleaf(f, s::NonleafHandlingTypes, ::Type{ElType}, shape::In return _broadcast!(f, dest, keeps, Idefaults, As, Val(nargs), iter, st, 1) end -@inline function broadcast(f, ::Style{Nullable}, ::Void, ::Void, a...) - nonnull = all(hasvalue, a) - S = _nullable_eltype(f, a...) - if Base._isleaftype(S) && null_safe_op(f, maptoTuple(_unsafe_get_eltype, - a...).types...) - Nullable{S}(f(map(unsafe_get, a)...), nonnull) - else - if nonnull - Nullable(f(map(unsafe_get, a)...)) - else - Nullable{nullable_returntype(S)}() - end - end -end - broadcast(f, ::Union{Scalar,Unknown}, ::Void, ::Void, a...) = f(a...) @inline broadcast(f, ::Style{Tuple}, ::Void, ::Void, A, Bs...) = diff --git a/base/channels.jl b/base/channels.jl index b48a8d0cf91be..cb445b0b67348 100644 --- a/base/channels.jl +++ b/base/channels.jl @@ -18,13 +18,13 @@ Other constructors: * `Channel(sz)`: equivalent to `Channel{Any}(sz)` """ mutable struct Channel{T} <: AbstractChannel - cond_take::Condition # waiting for data to become available - cond_put::Condition # waiting for a writeable slot + cond_take::Condition # waiting for data to become available + cond_put::Condition # waiting for a writeable slot state::Symbol - excp::Nullable{Exception} # Exception to be thrown when state != :open + excp::Union{Some{<:Exception}, Void} # Exception to be thrown when state != :open data::Vector{T} - sz_max::Int # maximum size of channel + sz_max::Int # maximum size of channel # Used when sz_max == 0, i.e., an unbuffered channel. waiters::Int @@ -42,7 +42,7 @@ mutable struct Channel{T} <: AbstractChannel if sz < 0 throw(ArgumentError("Channel size must be either 0, a positive integer or Inf")) end - ch = new(Condition(), Condition(), :open, Nullable{Exception}(), Vector{T}(), sz, 0) + ch = new(Condition(), Condition(), :open, nothing, Vector{T}(), sz, 0) if sz == 0 ch.takers = Vector{Task}() ch.putters = Vector{Task}() @@ -129,7 +129,7 @@ isbuffered(c::Channel) = c.sz_max==0 ? false : true function check_channel_state(c::Channel) if !isopen(c) - !isnull(c.excp) && throw(get(c.excp)) + c.excp !== nothing && throw(get(c.excp)) throw(closed_exception()) end end @@ -143,7 +143,7 @@ Close a channel. An exception is thrown by: """ function close(c::Channel) c.state = :closed - c.excp = Nullable{}(closed_exception()) + c.excp = Some(closed_exception()) notify_error(c) nothing end @@ -237,7 +237,7 @@ function close_chnl_on_taskdone(t::Task, ref::WeakRef) !isopen(c) && return if istaskfailed(t) c.state = :closed - c.excp = Nullable{Exception}(task_result(t)) + c.excp = Some(task_result(t)) notify_error(c) else close(c) diff --git a/base/client.jl b/base/client.jl index 26014d026a668..8ce6ff086f1aa 100644 --- a/base/client.jl +++ b/base/client.jl @@ -76,7 +76,7 @@ color_normal = text_colors[:normal] function repl_color(key, default) env_str = get(ENV, key, "") c = tryparse(Int, env_str) - c_conv = isnull(c) ? Symbol(env_str) : get(c) + c_conv = c === nothing ? Symbol(env_str) : get(c) haskey(text_colors, c_conv) ? c_conv : default end diff --git a/base/deprecated.jl b/base/deprecated.jl index 860f839acce0a..28d009bece659 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -1658,20 +1658,20 @@ import .Iterators.enumerate # PR #23640 # when this deprecation is deleted, remove all calls to it, and replace all keywords of: -# `payload::Union{CredentialPayload,Nullable{<:Union{AbstractCredential, CachedCredentials}}}` +# `payload::Union{CredentialPayload, Union{Some{<:Union{AbstractCredential, CachedCredentials}}, Void}}` # with `payload::CredentialPayload` from base/libgit2/libgit2.jl @eval LibGit2 function deprecate_nullable_creds(f, sig, payload) - if isa(payload, Nullable{<:Union{AbstractCredential, CachedCredentials}}) + if isa(payload, Union{Some{<:Union{AbstractCredential, CachedCredentials}}, Void}) # Note: Be careful not to show the contents of the credentials as it could reveal a # password. - if isnull(payload) - msg = "LibGit2.$f($sig; payload=Nullable()) is deprecated, use " + if payload === nothing + msg = "LibGit2.$f($sig; payload=nothing) is deprecated, use " msg *= "LibGit2.$f($sig; payload=LibGit2.CredentialPayload()) instead." p = CredentialPayload() else - cred = unsafe_get(payload) + cred = get(payload) C = typeof(cred) - msg = "LibGit2.$f($sig; payload=Nullable($C(...))) is deprecated, use " + msg = "LibGit2.$f($sig; payload=Some($C(...))) is deprecated, use " msg *= "LibGit2.$f($sig; payload=LibGit2.CredentialPayload($C(...))) instead." p = CredentialPayload(cred) end @@ -3244,6 +3244,11 @@ end @deprecate indices(a) axes(a) @deprecate indices(a, d) axes(a, d) +@deprecate_moved Nullable "Nullables" +@deprecate_moved NullException "Nullables" +@deprecate_moved isnull "Nullables" +@deprecate_moved unsafe_get "Nullables" + # END 0.7 deprecations # BEGIN 1.0 deprecations diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl index 5e5aa4c33056a..410bb7a79fcb0 100644 --- a/base/docs/Docs.jl +++ b/base/docs/Docs.jl @@ -142,7 +142,7 @@ linenumber, source code, and fielddocs. """ mutable struct DocStr text :: Core.SimpleVector - object :: Nullable + object :: Union{Some{<:Any}, Void} data :: Dict{Symbol, Any} end @@ -160,9 +160,9 @@ function docstr(binding::Binding, @nospecialize typesig = Union{}) end docstr(object, data = Dict()) = _docstr(object, data) -_docstr(vec::Core.SimpleVector, data) = DocStr(vec, Nullable(), data) -_docstr(str::AbstractString, data) = DocStr(Core.svec(str), Nullable(), data) -_docstr(object, data) = DocStr(Core.svec(), Nullable(object), data) +_docstr(vec::Core.SimpleVector, data) = DocStr(vec, nothing, data) +_docstr(str::AbstractString, data) = DocStr(Core.svec(str), nothing, data) +_docstr(object, data) = DocStr(Core.svec(), Some(object), data) _docstr(doc::DocStr, data) = (doc.data = merge(data, doc.data); doc) @@ -184,11 +184,11 @@ end @noinline formatdoc(buffer, d, part) = print(buffer, part) function parsedoc(d::DocStr) - if isnull(d.object) + if d.object === nothing md = formatdoc(d) md.meta[:module] = d.data[:module] md.meta[:path] = d.data[:path] - d.object = Nullable(md) + d.object = Some(md) end get(d.object) end diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl index cfc1bd47da829..7838db7b975ac 100644 --- a/base/docs/basedocs.jl +++ b/base/docs/basedocs.jl @@ -814,7 +814,7 @@ Void nothing The singleton instance of type `Void`, used by convention when there is no value to return -(as in a C `void` function). Can be converted to an empty [`Nullable`](@ref) value. +(as in a C `void` function) or when a variable or field holds no value. """ nothing diff --git a/base/exports.jl b/base/exports.jl index 3d2c355994b1d..19c8499477c2f 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -77,7 +77,6 @@ export MergeSort, Missing, NTuple, - Nullable, ObjectIdDict, OrdinalRange, Pair, @@ -100,6 +99,7 @@ export AbstractSerializer, SerializationState, Set, + Some, StepRange, StepRangeLen, StridedArray, @@ -150,7 +150,6 @@ export InvalidStateException, KeyError, MissingException, - NullException, ParseError, SystemError, StringIndexError, @@ -1145,10 +1144,6 @@ export unsafe_store!, unsafe_write, -# nullable types - isnull, - unsafe_get, - # Macros # parser internal @__FILE__, diff --git a/base/gmp.jl b/base/gmp.jl index 5cb20f3189e77..4bde7223cb29c 100644 --- a/base/gmp.jl +++ b/base/gmp.jl @@ -234,19 +234,17 @@ convert(::Type{Signed}, x::BigInt) = x hastypemax(::Type{BigInt}) = false function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool) - _n = Nullable{BigInt}() - # don't make a copy in the common case where we are parsing a whole String bstr = startpos == start(s) && endpos == endof(s) ? String(s) : String(SubString(s,startpos,endpos)) sgn, base, i = Base.parseint_preamble(true,Int(base_),bstr,start(bstr),endof(bstr)) if !(2 <= base <= 62) raise && throw(ArgumentError("invalid base: base must be 2 ≤ base ≤ 62, got $base")) - return _n + return nothing end if i == 0 raise && throw(ArgumentError("premature end of integer: $(repr(bstr))")) - return _n + return nothing end z = BigInt() if Base.containsnul(bstr) @@ -256,9 +254,9 @@ function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, end end if err != 0 raise && throw(ArgumentError("invalid BigInt: $(repr(bstr))")) - return _n + return nothing end - Nullable(flipsign!(z, sgn)) + Some(flipsign!(z, sgn)) end convert(::Type{BigInt}, x::Union{Clong,Int32}) = MPZ.set_si(x) diff --git a/base/int.jl b/base/int.jl index b5ff8dca27d79..83053f64a5fb0 100644 --- a/base/int.jl +++ b/base/int.jl @@ -603,12 +603,12 @@ macro big_str(s) print(bf, s[end]) seekstart(bf) n = tryparse(BigInt, String(take!(bf))) - !isnull(n) && return get(n) + n !== nothing && return get(n) else n = tryparse(BigInt, s) - !isnull(n) && return get(n) + n !== nothing && return get(n) n = tryparse(BigFloat, s) - !isnull(n) && return get(n) + n !== nothing && return get(n) end message = "invalid number format $s for BigInt or BigFloat" return :(throw(ArgumentError($message))) diff --git a/base/iterators.jl b/base/iterators.jl index 232fd5a766da7..e8a2e06b7c2e9 100644 --- a/base/iterators.jl +++ b/base/iterators.jl @@ -735,7 +735,7 @@ function next(P::ProductIterator, state) iter1 = first(iterators) value1, state1 = next(iter1, states[1]) tailstates = tail(states) - values = (value1, map(unsafe_get, nvalues)...) # safe if not done(P, state) + values = (value1, map(get, nvalues)...) # safe if not done(P, state) if done(iter1, state1) d, tailstates, nvalues = _prod_next(tail(iterators), tailstates, nvalues) if !d # only restart iter1 if not completely done @@ -753,10 +753,10 @@ function _prod_start(iterators) d, tailstates, tailnvalues = _prod_start(tail(iterators)) if done(iter1, state1) d = true - nvalue1 = Nullable{eltype(iter1)}() + nvalue1 = nothing else value1, state1 = next(iter1, state1) - nvalue1 = Nullable{eltype(iter1)}(value1) + nvalue1 = Some{eltype(iter1)}(value1) end return (d, (state1, tailstates...), (nvalue1, tailnvalues...)) end @@ -767,15 +767,15 @@ function _prod_next(iterators, states, nvalues) state1 = first(states) if !done(iter1, state1) value1, state1 = next(iter1, state1) - nvalue1 = Nullable{eltype(iter1)}(value1) + nvalue1 = Some{eltype(iter1)}(value1) return false, (state1, tail(states)...), (nvalue1, tail(nvalues)...) else d, tailstates, tailnvalues = _prod_next(tail(iterators), tail(states), tail(nvalues)) if d # all iterators are done - nvalue1 = Nullable{eltype(iter1)}() + nvalue1 = nothing else value1, state1 = next(iter1, start(iter1)) # iter cannot be done immediately - nvalue1 = Nullable{eltype(iter1)}(value1) + nvalue1 = Some{eltype(iter1)}(value1) end return d, (state1, tailstates...), (nvalue1, tailnvalues...) end diff --git a/base/libgit2/callbacks.jl b/base/libgit2/callbacks.jl index 5d5041695a755..09fc529b58306 100644 --- a/base/libgit2/callbacks.jl +++ b/base/libgit2/callbacks.jl @@ -114,8 +114,8 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, if isempty(cred.user) || username_ptr == Cstring(C_NULL) url = git_url(scheme=p.scheme, host=p.host) response = Base.prompt("Username for '$url'", default=cred.user) - isnull(response) && return user_abort() - cred.user = unsafe_get(response) + response === nothing && return user_abort() + cred.user = Base.get(response) end url = git_url(scheme=p.scheme, host=p.host, username=cred.user) @@ -124,8 +124,8 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, last_private_key = cred.prvkey if !isfile(cred.prvkey) || !revised || !haskey(ENV, "SSH_KEY_PATH") response = Base.prompt("Private key location for '$url'", default=cred.prvkey) - isnull(response) && return user_abort() - cred.prvkey = expanduser(unsafe_get(response)) + response === nothing && return user_abort() + cred.prvkey = expanduser(Base.get(response)) # Only update the public key if the private key changed if cred.prvkey != last_private_key @@ -138,8 +138,8 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, stale = !p.first_pass && cred.prvkey == last_private_key && cred.pubkey != cred.prvkey * ".pub" if isfile(cred.prvkey) && (stale || !isfile(cred.pubkey)) response = Base.prompt("Public key location for '$url'", default=cred.pubkey) - isnull(response) && return user_abort() - cred.pubkey = expanduser(unsafe_get(response)) + response === nothing && return user_abort() + cred.pubkey = expanduser(Base.get(response)) end # Ask for a passphrase when the private key exists and requires a passphrase @@ -148,12 +148,12 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, response = Base.winprompt( "Your SSH Key requires a password, please enter it now:", "Passphrase required", cred.prvkey; prompt_username=false) - isnull(response) && return user_abort() - cred.pass = unsafe_get(response)[2] + response === nothing && return user_abort() + cred.pass = Base.get(response)[2] else response = Base.prompt("Passphrase for $(cred.prvkey)", password=true) - isnull(response) && return user_abort() - cred.pass = unsafe_get(response) + response === nothing && return user_abort() + cred.pass = Base.get(response) isempty(cred.pass) && return user_abort() # Ambiguous if EOF or newline end end @@ -188,8 +188,8 @@ function authenticate_userpass(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayl git_cred = GitCredential(p.config, p.url) # Use `deepcopy` to ensure zeroing the `git_cred` doesn't also zero the `cred`s copy - cred.user = deepcopy(Base.get(git_cred.username, "")) - cred.pass = deepcopy(Base.get(git_cred.password, "")) + cred.user = deepcopy(git_cred.username === nothing ? "" : git_cred.username) + cred.pass = deepcopy(git_cred.password === nothing ? "" : git_cred.password) securezero!(git_cred) revised = true @@ -203,17 +203,17 @@ function authenticate_userpass(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayl response = Base.winprompt( "Please enter your credentials for '$url'", "Credentials required", username; prompt_username=true) - isnull(response) && return user_abort() - cred.user, cred.pass = unsafe_get(response) + response === nothing && return user_abort() + cred.user, cred.pass = Base.get(response) else response = Base.prompt("Username for '$url'", default=username) - isnull(response) && return user_abort() - cred.user = unsafe_get(response) + response === nothing && return user_abort() + cred.user = Base.get(response) url = git_url(scheme=p.scheme, host=p.host, username=cred.user) response = Base.prompt("Password for '$url'", password=true) - isnull(response) && return user_abort() - cred.pass = unsafe_get(response) + response === nothing && return user_abort() + cred.pass = Base.get(response) isempty(cred.pass) && return user_abort() # Ambiguous if EOF or newline end @@ -282,11 +282,11 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, # credential during the first callback by modifying the allowed types. The # modification only is in effect for the first callback since `allowed_types` cannot # be mutated. - if !isnull(p.explicit) - cred = unsafe_get(p.explicit) + if p.explicit !== nothing + cred = Base.get(p.explicit) # Copy explicit credentials to avoid mutating approved credentials. - p.credential = Nullable(deepcopy(cred)) + p.credential = Some(deepcopy(cred)) if isa(cred, SSHCredential) allowed_types &= Cuint(Consts.CREDTYPE_SSH_KEY) @@ -295,13 +295,13 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, else allowed_types &= Cuint(0) # Unhandled credential type end - elseif !isnull(p.cache) - cache = unsafe_get(p.cache) + elseif p.cache !== nothing + cache = Base.get(p.cache) cred_id = credential_identifier(p.scheme, p.host) # Perform a deepcopy as we do not want to mutate approved cached credentials if haskey(cache, cred_id) - p.credential = Nullable(deepcopy(cache[cred_id])) + p.credential = Some(deepcopy(cache[cred_id])) end end @@ -312,16 +312,16 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, # use ssh key or ssh-agent if isset(allowed_types, Cuint(Consts.CREDTYPE_SSH_KEY)) - if isnull(p.credential) || !isa(unsafe_get(p.credential), SSHCredential) - p.credential = Nullable(SSHCredential(p.username)) + if p.credential === nothing || !isa(Base.get(p.credential), SSHCredential) + p.credential = Some(SSHCredential(p.username)) end err = authenticate_ssh(libgit2credptr, p, username_ptr) err == 0 && return err end if isset(allowed_types, Cuint(Consts.CREDTYPE_USERPASS_PLAINTEXT)) - if isnull(p.credential) || !isa(unsafe_get(p.credential), UserPasswordCredential) - p.credential = Nullable(UserPasswordCredential(p.username)) + if p.credential === nothing || !isa(Base.get(p.credential), UserPasswordCredential) + p.credential = Some(UserPasswordCredential(p.username)) end err = authenticate_userpass(libgit2credptr, p) err == 0 && return err @@ -331,7 +331,7 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, # that explicit credentials were passed in, but said credentials are incompatible # with the requested authentication method. if err == 0 - if !isnull(p.explicit) + if p.explicit !== nothing ccall((:giterr_set_str, :libgit2), Void, (Cint, Cstring), Cint(Error.Callback), "The explicitly provided credential is incompatible with the requested " * "authentication methods.") diff --git a/base/libgit2/config.jl b/base/libgit2/config.jl index 9f5a7549b9b48..1e515eac44104 100644 --- a/base/libgit2/config.jl +++ b/base/libgit2/config.jl @@ -197,16 +197,16 @@ function Base.start(ci::GitConfigIter) err = ccall((:git_config_next, :libgit2), Cint, (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr) if err == Cint(Error.GIT_OK) - state = Nullable{ConfigEntry}(unsafe_load(entry_ptr_ptr[])) + state = Some(unsafe_load(entry_ptr_ptr[])) elseif err == Cint(Error.ITEROVER) - state = Nullable{ConfigEntry}() + state = nothing else throw(GitError(err)) end return state end -Base.done(ci::GitConfigIter, state) = isnull(state) +Base.done(ci::GitConfigIter, state) = state === nothing function Base.next(ci::GitConfigIter, state) entry = Base.get(state) @@ -214,9 +214,9 @@ function Base.next(ci::GitConfigIter, state) err = ccall((:git_config_next, :libgit2), Cint, (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr) if err == Cint(Error.GIT_OK) - state = Nullable{ConfigEntry}(unsafe_load(entry_ptr_ptr[])) + state = Some(unsafe_load(entry_ptr_ptr[])) elseif err == Cint(Error.ITEROVER) - state = Nullable{ConfigEntry}() + state = nothing else throw(GitError(err)) end diff --git a/base/libgit2/gitcredential.jl b/base/libgit2/gitcredential.jl index 09806ff6dedaf..da9668d4994a6 100644 --- a/base/libgit2/gitcredential.jl +++ b/base/libgit2/gitcredential.jl @@ -5,56 +5,42 @@ Git credential information used in communication with git credential helpers. Th named using the [input/output key specification](https://git-scm.com/docs/git-credential#IOFMT). """ mutable struct GitCredential - protocol::Nullable{String} - host::Nullable{String} - path::Nullable{String} - username::Nullable{String} - password::Nullable{String} + protocol::Union{String, Void} + host::Union{String, Void} + path::Union{String, Void} + username::Union{String, Void} + password::Union{String, Void} use_http_path::Bool function GitCredential( - protocol::Nullable{<:AbstractString}, - host::Nullable{<:AbstractString}, - path::Nullable{<:AbstractString}, - username::Nullable{<:AbstractString}, - password::Nullable{<:AbstractString}) + protocol::Union{AbstractString, Void}=nothing, + host::Union{AbstractString, Void}=nothing, + path::Union{AbstractString, Void}=nothing, + username::Union{AbstractString, Void}=nothing, + password::Union{AbstractString, Void}=nothing) c = new(protocol, host, path, username, password, true) finalizer(securezero!, c) return c end end -function GitCredential( - protocol::Union{AbstractString,Void}=nothing, - host::Union{AbstractString,Void}=nothing, - path::Union{AbstractString,Void}=nothing, - username::Union{AbstractString,Void}=nothing, - password::Union{AbstractString,Void}=nothing) - GitCredential( - Nullable{String}(protocol), - Nullable{String}(host), - Nullable{String}(path), - Nullable{String}(username), - Nullable{String}(password)) -end - function GitCredential(cfg::GitConfig, url::AbstractString) fill!(cfg, parse(GitCredential, url)) end function GitCredential(cred::UserPasswordCredential, url::AbstractString) git_cred = parse(GitCredential, url) - git_cred.username = Nullable{String}(deepcopy(cred.user)) - git_cred.password = Nullable{String}(deepcopy(cred.pass)) + git_cred.username = deepcopy(cred.user) + git_cred.password = deepcopy(cred.pass) return git_cred end function securezero!(cred::GitCredential) - !isnull(cred.protocol) && securezero!(unsafe_get(cred.protocol)) - !isnull(cred.host) && securezero!(unsafe_get(cred.host)) - !isnull(cred.path) && securezero!(unsafe_get(cred.path)) - !isnull(cred.username) && securezero!(unsafe_get(cred.username)) - !isnull(cred.password) && securezero!(unsafe_get(cred.password)) + cred.protocol !== nothing && securezero!(cred.protocol) + cred.host !== nothing && securezero!(cred.host) + cred.path !== nothing && securezero!(cred.path) + cred.username !== nothing && securezero!(cred.username) + cred.password !== nothing && securezero!(cred.password) return cred end @@ -79,14 +65,14 @@ function ismatch(url::AbstractString, git_cred::GitCredential) m === nothing && error("Unable to parse URL") # Note: missing URL groups match anything - (m[:scheme] === nothing ? true : isequal(Nullable(m[:scheme]), git_cred.protocol)) && - (m[:host] === nothing ? true : isequal(Nullable(m[:host]), git_cred.host)) && - (m[:path] === nothing ? true : isequal(Nullable(m[:path]), git_cred.path)) && - (m[:user] === nothing ? true : isequal(Nullable(m[:user]), git_cred.username)) + (m[:scheme] === nothing ? true : isequal(m[:scheme], git_cred.protocol)) && + (m[:host] === nothing ? true : isequal(m[:host], git_cred.host)) && + (m[:path] === nothing ? true : isequal(m[:path], git_cred.path)) && + (m[:user] === nothing ? true : isequal(m[:user], git_cred.username)) end function isfilled(cred::GitCredential) - !isnull(cred.username) && !isnull(cred.password) + cred.username !== nothing && cred.password !== nothing end function Base.parse(::Type{GitCredential}, url::AbstractString) @@ -112,11 +98,11 @@ function Base.copy!(a::GitCredential, b::GitCredential) end function Base.write(io::IO, cred::GitCredential) - !isnull(cred.protocol) && println(io, "protocol=", unsafe_get(cred.protocol)) - !isnull(cred.host) && println(io, "host=", unsafe_get(cred.host)) - !isnull(cred.path) && cred.use_http_path && println(io, "path=", unsafe_get(cred.path)) - !isnull(cred.username) && println(io, "username=", unsafe_get(cred.username)) - !isnull(cred.password) && println(io, "password=", unsafe_get(cred.password)) + cred.protocol !== nothing && println(io, "protocol=", cred.protocol) + cred.host !== nothing && println(io, "host=", cred.host) + cred.path !== nothing && cred.use_http_path && println(io, "path=", cred.path) + cred.username !== nothing && println(io, "username=", cred.username) + cred.password !== nothing && println(io, "password=", cred.password) nothing end @@ -130,7 +116,7 @@ function Base.read!(io::IO, cred::GitCredential) # https://git-scm.com/docs/git-credential#git-credential-codeurlcode copy!(cred, parse(GitCredential, value)) else - setfield!(cred, Symbol(key), Nullable(String(value))) + setfield!(cred, Symbol(key), String(value)) end end @@ -141,7 +127,7 @@ function fill!(cfg::GitConfig, cred::GitCredential) cred.use_http_path = use_http_path(cfg, cred) # When the username is missing default to using the username set in the configuration - if isnull(cred.username) + if cred.username === nothing cred.username = default_username(cfg, cred) end @@ -249,7 +235,7 @@ function credential_helpers(cfg::GitConfig, cred::GitCredential) end """ - default_username(config, git_cred) -> Nullable{String} + default_username(config, git_cred) -> Union{String, Void} Return the default username, if any, provided by the `config` which is valid for the specified `git_cred`. @@ -262,10 +248,10 @@ function default_username(cfg::GitConfig, cred::GitCredential) # Only use configuration settings where the URL applies to the git credential ismatch(url, cred) || continue - return Nullable{String}(value) + return value end - return Nullable{String}() + return nothing end function use_http_path(cfg::GitConfig, cred::GitCredential) diff --git a/base/libgit2/index.jl b/base/libgit2/index.jl index 7cea1a6f821e9..e4982e7024535 100644 --- a/base/libgit2/index.jl +++ b/base/libgit2/index.jl @@ -53,7 +53,7 @@ function write_tree!(idx::GitIndex) end function repository(idx::GitIndex) - if isnull(idx.owner) + if idx.owner === nothing throw(GitError(Error.Index, Error.ENOTFOUND, "Index does not have an owning repository.")) else return Base.get(idx.owner) @@ -182,8 +182,8 @@ function Base.find(path::String, idx::GitIndex) pos_ref = Ref{Csize_t}(0) ret = ccall((:git_index_find, :libgit2), Cint, (Ref{Csize_t}, Ptr{Void}, Cstring), pos_ref, idx.ptr, path) - ret == Cint(Error.ENOTFOUND) && return Nullable{Csize_t}() - return Nullable(pos_ref[]+1) + ret == Cint(Error.ENOTFOUND) && return nothing + return Some(pos_ref[]+1) end """ diff --git a/base/libgit2/libgit2.jl b/base/libgit2/libgit2.jl index 91ecc806b7e96..b8c60983c3582 100644 --- a/base/libgit2/libgit2.jl +++ b/base/libgit2/libgit2.jl @@ -262,7 +262,7 @@ Equivalent to `git fetch [|] []`. function fetch(repo::GitRepo; remote::AbstractString="origin", remoteurl::AbstractString="", refspecs::Vector{<:AbstractString}=AbstractString[], - payload::Union{CredentialPayload,Nullable{<:Union{AbstractCredential, CachedCredentials}}}=CredentialPayload()) + payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) p = reset!(deprecate_nullable_creds(:fetch, "repo", payload), GitConfig(repo)) rmt = if isempty(remoteurl) get(GitRemote, repo, remote) @@ -304,7 +304,7 @@ function push(repo::GitRepo; remote::AbstractString="origin", remoteurl::AbstractString="", refspecs::Vector{<:AbstractString}=AbstractString[], force::Bool=false, - payload::Union{CredentialPayload,Nullable{<:Union{AbstractCredential, CachedCredentials}}}=CredentialPayload()) + payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) p = reset!(deprecate_nullable_creds(:push, "repo", payload), GitConfig(repo)) rmt = if isempty(remoteurl) get(GitRemote, repo, remote) @@ -372,12 +372,12 @@ function branch!(repo::GitRepo, branch_name::AbstractString, force::Bool=false, # force branch creation set_head::Bool=true) # set as head reference on exit # try to lookup branch first - branch_ref = force ? Nullable{GitReference}() : lookup_branch(repo, branch_name) - if isnull(branch_ref) - branch_rmt_ref = isempty(track) ? Nullable{GitReference}() : lookup_branch(repo, "$track/$branch_name", true) + branch_ref = force ? nothing : lookup_branch(repo, branch_name) + if branch_ref === nothing + branch_rmt_ref = isempty(track) ? nothing : lookup_branch(repo, "$track/$branch_name", true) # if commit is empty get head commit oid commit_id = if isempty(commit) - if isnull(branch_rmt_ref) + if branch_rmt_ref === nothing with(head(repo)) do head_ref with(peel(GitCommit, head_ref)) do hrc GitHash(hrc) @@ -397,10 +397,10 @@ function branch!(repo::GitRepo, branch_name::AbstractString, cmt = GitCommit(repo, commit_id) new_branch_ref = nothing try - new_branch_ref = Nullable(create_branch(repo, branch_name, cmt, force=force)) + new_branch_ref = Some(create_branch(repo, branch_name, cmt, force=force)) finally close(cmt) - isnull(new_branch_ref) && throw(GitError(Error.Object, Error.ERROR, "cannot create branch `$branch_name` with `$commit_id`")) + new_branch_ref === nothing && throw(GitError(Error.Object, Error.ERROR, "cannot create branch `$branch_name` with `$commit_id`")) branch_ref = new_branch_ref end end @@ -520,7 +520,7 @@ function clone(repo_url::AbstractString, repo_path::AbstractString; branch::AbstractString="", isbare::Bool = false, remote_cb::Ptr{Void} = C_NULL, - payload::Union{CredentialPayload,Nullable{<:Union{AbstractCredential, CachedCredentials}}}=CredentialPayload()) + payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) # setup clone options lbranch = Base.cconvert(Cstring, branch) @Base.gc_preserve lbranch begin @@ -549,7 +549,7 @@ end function reset!(repo::GitRepo, committish::AbstractString, pathspecs::AbstractString...) obj = GitObject(repo, isempty(committish) ? Consts.HEAD_FILE : committish) # do not remove entries in the index matching the provided pathspecs with empty target commit tree - reset!(repo, Nullable(obj), pathspecs...) + reset!(repo, Some(obj), pathspecs...) end """ @@ -721,7 +721,7 @@ function merge!(repo::GitRepo; else with(head(repo)) do head_ref tr_brn_ref = upstream(head_ref) - if isnull(tr_brn_ref) + if tr_brn_ref === nothing throw(GitError(Error.Merge, Error.ERROR, "There is no tracking information for the current branch.")) end @@ -765,7 +765,7 @@ function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractSt head_ann = GitAnnotated(repo, head_ref) upst_ann = if isempty(upstream) brn_ref = LibGit2.upstream(head_ref) - if isnull(brn_ref) + if brn_ref === nothing throw(GitError(Error.Rebase, Error.ERROR, "There is no tracking information for the current branch.")) end @@ -777,7 +777,7 @@ function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractSt else GitAnnotated(repo, upstream) end - onto_ann = Nullable{GitAnnotated}(isempty(newbase) ? nothing : GitAnnotated(repo, newbase)) + onto_ann = isempty(newbase) ? nothing : Some(GitAnnotated(repo, newbase)) try sig = default_signature(repo) try @@ -794,7 +794,7 @@ function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractSt close(rbs) end finally - #!isnull(onto_ann) && close(get(onto_ann)) + #onto_ann !== nothing && close(get(onto_ann)) close(sig) end finally @@ -885,7 +885,7 @@ function restore(s::State, repo::GitRepo) opts = CheckoutOptions( checkout_strategy = Consts.CHECKOUT_FORCE | # check the index out to work Consts.CHECKOUT_REMOVE_UNTRACKED) # remove everything else - checkout_index(repo, Nullable(idx), options = opts) + checkout_index(repo, Some(idx), options = opts) read_tree!(idx, s.index) # restore index end diff --git a/base/libgit2/rebase.jl b/base/libgit2/rebase.jl index 579d17fba97ae..3a262fcaa6dfd 100644 --- a/base/libgit2/rebase.jl +++ b/base/libgit2/rebase.jl @@ -1,14 +1,14 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license function GitRebase(repo::GitRepo, branch::GitAnnotated, upstream::GitAnnotated; - onto::Nullable{GitAnnotated}=Nullable{GitAnnotated}(), + onto::Union{Some{GitAnnotated}, Void}=nothing, opts::RebaseOptions = RebaseOptions()) rebase_ptr_ptr = Ref{Ptr{Void}}(C_NULL) @check ccall((:git_rebase_init, :libgit2), Cint, (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{RebaseOptions}), rebase_ptr_ptr, repo.ptr, branch.ptr, upstream.ptr, - isnull(onto) ? C_NULL : Base.get(onto).ptr, Ref(opts)) + onto === nothing ? C_NULL : Base.get(onto).ptr, Ref(opts)) return GitRebase(repo, rebase_ptr_ptr[]) end diff --git a/base/libgit2/reference.jl b/base/libgit2/reference.jl index e703d215d3643..da3da75272f05 100644 --- a/base/libgit2/reference.jl +++ b/base/libgit2/reference.jl @@ -247,15 +247,15 @@ function head!(repo::GitRepo, ref::GitReference) end """ - lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Nullable{GitReference} + lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{Some{GitReference}, Void} Determine if the branch specified by `branch_name` exists in the repository `repo`. If `remote` is `true`, `repo` is assumed to be a remote git repository. Otherwise, it is part of the local filesystem. -Return a [`Nullable`](@ref), which will be null if the requested branch does -not exist yet. If the branch does exist, the `Nullable` contains a `GitReference` to -the branch. +Return either a [`Some`](@ref) object, or [`nothing`](@ref) if +the requested branch does not exist yet. If the branch does exist, the `Some` wrapper +contains a `GitReference` to the branch. """ function lookup_branch(repo::GitRepo, branch_name::AbstractString, @@ -267,23 +267,24 @@ function lookup_branch(repo::GitRepo, ref_ptr_ptr, repo.ptr, branch_name, branch_type) if err != Int(Error.GIT_OK) if err == Int(Error.ENOTFOUND) - return Nullable{GitReference}() + return nothing end if ref_ptr_ptr[] != C_NULL close(GitReference(repo, ref_ptr_ptr[])) end throw(Error.GitError(err)) end - return Nullable{GitReference}(GitReference(repo, ref_ptr_ptr[])) + return Some(GitReference(repo, ref_ptr_ptr[])) end """ - upstream(ref::GitReference) -> Nullable{GitReference} + upstream(ref::GitReference) -> Union{Some{GitReference}, Void} Determine if the branch containing `ref` has a specified upstream branch. -Return a [`Nullable`](@ref), which will be null if the requested branch does -not have an upstream counterpart. If the upstream branch does exist, the `Nullable` +Return either a [`Some`](@ref) object, or [`nothing`](@ref) if +the requested branch does not have an upstream counterpart. If +the upstream branch does exist, the `Some` wrapper contains a `GitReference` to the upstream branch. """ function upstream(ref::GitReference) @@ -293,14 +294,14 @@ function upstream(ref::GitReference) (Ref{Ptr{Void}}, Ptr{Void},), ref_ptr_ptr, ref.ptr) if err != Int(Error.GIT_OK) if err == Int(Error.ENOTFOUND) - return Nullable{GitReference}() + return nothing end if ref_ptr_ptr[] != C_NULL close(GitReference(ref.owner, ref_ptr_ptr[])) end throw(Error.GitError(err)) end - return Nullable{GitReference}(GitReference(ref.owner, ref_ptr_ptr[])) + return Some(GitReference(ref.owner, ref_ptr_ptr[])) end repository(ref::GitReference) = ref.owner diff --git a/base/libgit2/remote.jl b/base/libgit2/remote.jl index 67d328aa59171..717aa70360d17 100644 --- a/base/libgit2/remote.jl +++ b/base/libgit2/remote.jl @@ -61,17 +61,18 @@ function GitRemoteAnon(repo::GitRepo, url::AbstractString) end """ - lookup_remote(repo::GitRepo, remote_name::AbstractString) -> Nullable{GitRemote} + lookup_remote(repo::GitRepo, remote_name::AbstractString) -> Union{Some{GitRemote}, Void} -Determine if the `remote_name` specified exists within the `repo`. Return a -[`Nullable`](@ref), which will be null if the requested remote does not exist. If the remote -does exist, the `Nullable` contains a [`GitRemote`](@ref) to the remote name. +Determine if the `remote_name` specified exists within the `repo`. Return +either a [`Some`](@ref) object, or [`nothing`](@ref) if the requested remote +does not exist. If the remote does exist, the `Some` wrapper +contains a [`GitRemote`](@ref) to the remote name. # Examples ```julia repo = LibGit2.GitRepo(path) remote_name = "test" -isnull(LibGit2.lookup_remote(repo, remote_name)) # will return true +LibGit2.lookup_remote(repo, remote_name) # will return nothing ``` """ function lookup_remote(repo::GitRepo, remote_name::AbstractString) @@ -80,9 +81,9 @@ function lookup_remote(repo::GitRepo, remote_name::AbstractString) (Ptr{Ptr{Void}}, Ptr{Void}, Cstring), rmt_ptr_ptr, repo.ptr, remote_name) if err == Int(Error.GIT_OK) - return Nullable{GitRemote}(GitRemote(repo, rmt_ptr_ptr[])) + return Some(GitRemote(repo, rmt_ptr_ptr[])) elseif err == Int(Error.ENOTFOUND) - return Nullable{GitRemote}() + return nothing else throw(Error.GitError(err)) end diff --git a/base/libgit2/repository.jl b/base/libgit2/repository.jl index f73aea52af434..5c6491f5caac1 100644 --- a/base/libgit2/repository.jl +++ b/base/libgit2/repository.jl @@ -336,18 +336,18 @@ function checkout_tree(repo::GitRepo, obj::GitObject; end """ - checkout_index(repo::GitRepo, idx::Nullable{GitIndex} = Nullable{GitIndex}(); options::CheckoutOptions = CheckoutOptions()) + checkout_index(repo::GitRepo, idx::Union{Some{GitIndex}, Void} = nothing; options::CheckoutOptions = CheckoutOptions()) -Update the working tree of `repo` to match the index `idx`. If `idx` is null, the +Update the working tree of `repo` to match the index `idx`. If `idx` is `nothing`, the index of `repo` will be used. `options` controls how the checkout will be performed. See [`CheckoutOptions`](@ref) for more information. """ -function checkout_index(repo::GitRepo, idx::Nullable{GitIndex} = Nullable{GitIndex}(); +function checkout_index(repo::GitRepo, idx::Union{Some{GitIndex}, Void} = nothing; options::CheckoutOptions = CheckoutOptions()) @check ccall((:git_checkout_index, :libgit2), Cint, (Ptr{Void}, Ptr{Void}, Ptr{CheckoutOptions}), repo.ptr, - isnull(idx) ? C_NULL : Base.get(idx).ptr, + idx === nothing ? C_NULL : Base.get(idx).ptr, Ref(options)) end @@ -385,11 +385,11 @@ function cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions end """Updates some entries, determined by the `pathspecs`, in the index from the target commit tree.""" -function reset!(repo::GitRepo, obj::Nullable{<:GitObject}, pathspecs::AbstractString...) +function reset!(repo::GitRepo, obj::Union{Some{<:GitObject}, Void}, pathspecs::AbstractString...) @check ccall((:git_reset_default, :libgit2), Cint, (Ptr{Void}, Ptr{Void}, Ptr{StrArrayStruct}), repo.ptr, - isnull(obj) ? C_NULL : Base.get(obj).ptr, + obj === nothing ? C_NULL : Base.get(obj).ptr, collect(pathspecs)) return head_oid(repo) end diff --git a/base/libgit2/status.jl b/base/libgit2/status.jl index dcb0f2092bd21..4b70aacd439ae 100644 --- a/base/libgit2/status.jl +++ b/base/libgit2/status.jl @@ -48,6 +48,6 @@ function status(repo::GitRepo, path::String) ret = ccall((:git_status_file, :libgit2), Cint, (Ref{Cuint}, Ptr{Void}, Cstring), status_ptr, repo.ptr, path) - (ret == Cint(Error.ENOTFOUND) || ret == Cint(Error.EAMBIGUOUS)) && return Nullable{Cuint}() - return Nullable(status_ptr[]) + (ret == Cint(Error.ENOTFOUND) || ret == Cint(Error.EAMBIGUOUS)) && return nothing + return Some(status_ptr[]) end diff --git a/base/libgit2/types.jl b/base/libgit2/types.jl index a55676b953cc0..8df04c4f19af4 100644 --- a/base/libgit2/types.jl +++ b/base/libgit2/types.jl @@ -911,27 +911,27 @@ Base.isempty(obj::AbstractGitObject) = (obj.ptr == C_NULL) abstract type GitObject <: AbstractGitObject end for (typ, owntyp, sup, cname) in [ - (:GitRepo, nothing, :AbstractGitObject, :git_repository), - (:GitConfig, :(Nullable{GitRepo}), :AbstractGitObject, :git_config), - (:GitIndex, :(Nullable{GitRepo}), :AbstractGitObject, :git_index), - (:GitRemote, :GitRepo, :AbstractGitObject, :git_remote), - (:GitRevWalker, :GitRepo, :AbstractGitObject, :git_revwalk), - (:GitReference, :GitRepo, :AbstractGitObject, :git_reference), - (:GitDescribeResult, :GitRepo, :AbstractGitObject, :git_describe_result), - (:GitDiff, :GitRepo, :AbstractGitObject, :git_diff), - (:GitDiffStats, :GitRepo, :AbstractGitObject, :git_diff_stats), - (:GitAnnotated, :GitRepo, :AbstractGitObject, :git_annotated_commit), - (:GitRebase, :GitRepo, :AbstractGitObject, :git_rebase), - (:GitBlame, :GitRepo, :AbstractGitObject, :git_blame), - (:GitStatus, :GitRepo, :AbstractGitObject, :git_status_list), - (:GitBranchIter, :GitRepo, :AbstractGitObject, :git_branch_iterator), - (:GitConfigIter, nothing, :AbstractGitObject, :git_config_iterator), - (:GitUnknownObject, :GitRepo, :GitObject, :git_object), - (:GitCommit, :GitRepo, :GitObject, :git_commit), - (:GitBlob, :GitRepo, :GitObject, :git_blob), - (:GitTree, :GitRepo, :GitObject, :git_tree), - (:GitTag, :GitRepo, :GitObject, :git_tag), - (:GitTreeEntry, :GitTree, :AbstractGitObject, :git_tree_entry), + (:GitRepo, nothing, :AbstractGitObject, :git_repository), + (:GitConfig, :(Union{Some{GitRepo}, Void}), :AbstractGitObject, :git_config), + (:GitIndex, :(Union{Some{GitRepo}, Void}), :AbstractGitObject, :git_index), + (:GitRemote, :GitRepo, :AbstractGitObject, :git_remote), + (:GitRevWalker, :GitRepo, :AbstractGitObject, :git_revwalk), + (:GitReference, :GitRepo, :AbstractGitObject, :git_reference), + (:GitDescribeResult, :GitRepo, :AbstractGitObject, :git_describe_result), + (:GitDiff, :GitRepo, :AbstractGitObject, :git_diff), + (:GitDiffStats, :GitRepo, :AbstractGitObject, :git_diff_stats), + (:GitAnnotated, :GitRepo, :AbstractGitObject, :git_annotated_commit), + (:GitRebase, :GitRepo, :AbstractGitObject, :git_rebase), + (:GitBlame, :GitRepo, :AbstractGitObject, :git_blame), + (:GitStatus, :GitRepo, :AbstractGitObject, :git_status_list), + (:GitBranchIter, :GitRepo, :AbstractGitObject, :git_branch_iterator), + (:GitConfigIter, nothing, :AbstractGitObject, :git_config_iterator), + (:GitUnknownObject, :GitRepo, :GitObject, :git_object), + (:GitCommit, :GitRepo, :GitObject, :git_commit), + (:GitBlob, :GitRepo, :GitObject, :git_blob), + (:GitTree, :GitRepo, :GitObject, :git_tree), + (:GitTag, :GitRepo, :GitObject, :git_tag), + (:GitTreeEntry, :GitTree, :AbstractGitObject, :git_tree_entry), ] if owntyp === nothing @@ -963,11 +963,11 @@ for (typ, owntyp, sup, cname) in [ return obj end end - if isa(owntyp, Expr) && owntyp.args[1] == :Nullable + if isa(owntyp, Expr) && owntyp.args[1] == :Union && owntyp.args[2].args[1] == :Some @eval begin - $typ(ptr::Ptr{Void}, fin::Bool=true) = $typ($owntyp(), ptr, fin) - $typ(owner::$(owntyp.args[2]), ptr::Ptr{Void}, fin::Bool=true) = - $typ($owntyp(owner), ptr, fin) + $typ(ptr::Ptr{Void}, fin::Bool=true) = $typ(nothing, ptr, fin) + $typ(owner::$(owntyp.args[2].args[2]), ptr::Ptr{Void}, fin::Bool=true) = + $typ(Some(owner), ptr, fin) end end end @@ -1251,8 +1251,8 @@ A `CredentialPayload` instance is expected to be `reset!` whenever it will be us different URL. """ mutable struct CredentialPayload <: Payload - explicit::Nullable{AbstractCredential} - cache::Nullable{CachedCredentials} + explicit::Union{Some{<:AbstractCredential}, Void} + cache::Union{Some{CachedCredentials}, Void} allow_ssh_agent::Bool # Allow the use of the SSH agent to get credentials allow_git_helpers::Bool # Allow the use of git credential helpers allow_prompt::Bool # Allow prompting the user for credentials @@ -1260,7 +1260,7 @@ mutable struct CredentialPayload <: Payload config::GitConfig # Ephemeral state fields - credential::Nullable{AbstractCredential} + credential::Union{Some{<:AbstractCredential}, Void} first_pass::Bool use_ssh_agent::Bool use_env::Bool @@ -1273,8 +1273,8 @@ mutable struct CredentialPayload <: Payload host::String function CredentialPayload( - credential::Nullable{<:AbstractCredential}=Nullable{AbstractCredential}(), - cache::Nullable{CachedCredentials}=Nullable{CachedCredentials}(), + credential::Union{Some{<:AbstractCredential}, Void}=nothing, + cache::Union{Some{CachedCredentials}, Void}=nothing, config::GitConfig=GitConfig(); allow_ssh_agent::Bool=true, allow_git_helpers::Bool=true, @@ -1286,11 +1286,11 @@ mutable struct CredentialPayload <: Payload end function CredentialPayload(credential::AbstractCredential; kwargs...) - CredentialPayload(Nullable(credential), Nullable{CachedCredentials}(); kwargs...) + CredentialPayload(Some(credential), nothing; kwargs...) end function CredentialPayload(cache::CachedCredentials; kwargs...) - CredentialPayload(Nullable{AbstractCredential}(), Nullable(cache); kwargs...) + CredentialPayload(nothing, Some(cache); kwargs...) end """ @@ -1301,7 +1301,7 @@ the credential callback. If a `config` is provided the configuration will also b """ function reset!(p::CredentialPayload, config::GitConfig=p.config) p.config = config - p.credential = Nullable{AbstractCredential}() + p.credential = nothing p.first_pass = true p.use_ssh_agent = p.allow_ssh_agent p.use_env = true @@ -1325,11 +1325,11 @@ The `shred` keyword controls whether sensitive information in the payload creden should be destroyed. Should only be set to `false` during testing. """ function approve(p::CredentialPayload; shred::Bool=true) - isnull(p.credential) && return # No credentials were used - cred = unsafe_get(p.credential) + p.credential === nothing && return # No credentials were used + cred = Base.get(p.credential) - if !isnull(p.cache) - approve(unsafe_get(p.cache), cred, p.url) + if p.cache !== nothing + approve(Base.get(p.cache), cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers @@ -1350,11 +1350,11 @@ The `shred` keyword controls whether sensitive information in the payload creden should be destroyed. Should only be set to `false` during testing. """ function reject(p::CredentialPayload; shred::Bool=true) - isnull(p.credential) && return # No credentials were used - cred = unsafe_get(p.credential) + p.credential === nothing && return # No credentials were used + cred = Base.get(p.credential) - if !isnull(p.cache) - reject(unsafe_get(p.cache), cred, p.url) + if p.cache !== nothing + reject(Base.get(p.cache), cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers diff --git a/base/lock.jl b/base/lock.jl index 533795a1cf072..55bc2f669040d 100644 --- a/base/lock.jl +++ b/base/lock.jl @@ -11,7 +11,7 @@ Each `lock` must be matched with an `unlock`. This lock is NOT threadsafe. See `Threads.Mutex` for a threadsafe lock. """ mutable struct ReentrantLock - locked_by::Nullable{Task} + locked_by::Union{Some{Task}, Void} cond_wait::Condition reentrancy_cnt::Int @@ -41,7 +41,7 @@ Each successful `trylock` must be matched by an `unlock`. function trylock(rl::ReentrantLock) t = current_task() if rl.reentrancy_cnt == 0 - rl.locked_by = t + rl.locked_by = Some(t) rl.reentrancy_cnt = 1 return true elseif t == get(rl.locked_by) @@ -64,7 +64,7 @@ function lock(rl::ReentrantLock) t = current_task() while true if rl.reentrancy_cnt == 0 - rl.locked_by = t + rl.locked_by = Some(t) rl.reentrancy_cnt = 1 return elseif t == get(rl.locked_by) diff --git a/base/methodshow.jl b/base/methodshow.jl index c10805e5e5684..ca56c439dfd5c 100644 --- a/base/methodshow.jl +++ b/base/methodshow.jl @@ -102,7 +102,7 @@ function show_method_params(io::IO, tv) end end -function show(io::IO, m::Method; kwtype::Nullable{DataType}=Nullable{DataType}()) +function show(io::IO, m::Method; kwtype::Union{Some{DataType}, Void}=nothing) tv, decls, file, line = arg_decl_parts(m) sig = unwrap_unionall(m.sig) ft0 = sig.parameters[1] @@ -129,7 +129,7 @@ function show(io::IO, m::Method; kwtype::Nullable{DataType}=Nullable{DataType}() print(io, "(") join(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2] for d in decls[2:end]], ", ", ", ") - if !isnull(kwtype) + if kwtype !== nothing kwargs = kwarg_decl(m, get(kwtype)) if !isempty(kwargs) print(io, "; ") @@ -157,7 +157,7 @@ function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=tru what = startswith(ns, '@') ? "macro" : "generic function" print(io, "# $n $m for ", what, " \"", ns, "\":") end - kwtype = isdefined(mt, :kwsorter) ? Nullable{DataType}(typeof(mt.kwsorter)) : Nullable{DataType}() + kwtype = isdefined(mt, :kwsorter) ? Some(typeof(mt.kwsorter)) : nothing n = rest = 0 local last @@ -233,7 +233,7 @@ function url(m::Method) end end -function show(io::IO, ::MIME"text/html", m::Method; kwtype::Nullable{DataType}=Nullable{DataType}()) +function show(io::IO, ::MIME"text/html", m::Method; kwtype::Union{Some{DataType}, Void}=nothing) tv, decls, file, line = arg_decl_parts(m) sig = unwrap_unionall(m.sig) ft0 = sig.parameters[1] @@ -261,7 +261,7 @@ function show(io::IO, ::MIME"text/html", m::Method; kwtype::Nullable{DataType}=N print(io, "(") join(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2]*"" for d in decls[2:end]], ", ", ", ") - if !isnull(kwtype) + if kwtype !== nothing kwargs = kwarg_decl(m, get(kwtype)) if !isempty(kwargs) print(io, "; ") @@ -290,7 +290,7 @@ function show(io::IO, mime::MIME"text/html", ms::MethodList) ns = string(name) what = startswith(ns, '@') ? "macro" : "generic function" print(io, "$n $meths for ", what, " $ns:
    ") - kwtype = isdefined(mt, :kwsorter) ? Nullable{DataType}(typeof(mt.kwsorter)) : Nullable{DataType}() + kwtype = isdefined(mt, :kwsorter) ? Some(typeof(mt.kwsorter)) : nothing for meth in ms print(io, "
  • ") show(io, mime, meth; kwtype=kwtype) diff --git a/base/mpfr.jl b/base/mpfr.jl index 227335de7f2e9..1e20bcad0a9c3 100644 --- a/base/mpfr.jl +++ b/base/mpfr.jl @@ -125,7 +125,7 @@ function tryparse(::Type{BigFloat}, s::AbstractString, base::Int=0) !isempty(s) && Base.Unicode.isspace(s[end]) && return tryparse(BigFloat, rstrip(s), base) z = BigFloat() err = ccall((:mpfr_set_str, :libmpfr), Int32, (Ref{BigFloat}, Cstring, Int32, Int32), z, s, base, ROUNDING_MODE[]) - err == 0 ? Nullable(z) : Nullable{BigFloat}() + err == 0 ? Some(z) : nothing end convert(::Type{Rational}, x::BigFloat) = convert(Rational{BigInt}, x) diff --git a/base/nullable.jl b/base/nullable.jl deleted file mode 100644 index bb3075576eb1e..0000000000000 --- a/base/nullable.jl +++ /dev/null @@ -1,419 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -""" - NullException() - -An attempted access to a [`Nullable`](@ref) with no defined value. - -# Examples -```jldoctest -julia> a = Nullable{Int}() -Nullable{Int64}() - -julia> get(a) -ERROR: NullException() -Stacktrace: -[...] -``` -""" -struct NullException <: Exception -end - -""" - Nullable(x, hasvalue::Bool=true) - -Wrap value `x` in an object of type `Nullable`, which indicates whether a value is present. -`Nullable(x)` yields a non-empty wrapper and `Nullable{T}()` yields an empty instance of a -wrapper that might contain a value of type `T`. - -`Nullable(x, false)` yields `Nullable{typeof(x)}()` with `x` stored in the result's `value` -field. - -# Examples -```jldoctest -julia> Nullable(1) -Nullable{Int64}(1) - -julia> Nullable{Int64}() -Nullable{Int64}() - -julia> Nullable(1, false) -Nullable{Int64}() - -julia> dump(Nullable(1, false)) -Nullable{Int64} - hasvalue: Bool false - value: Int64 1 -``` -""" -Nullable(value::T, hasvalue::Bool=true) where {T} = Nullable{T}(value, hasvalue) -Nullable() = Nullable{Union{}}() - -eltype(::Type{Nullable{T}}) where {T} = T - -convert(::Type{Nullable{T}}, x::Nullable{T}) where {T} = x -convert(::Type{Nullable }, x::Nullable ) = x - -convert(t::Type{Nullable{T}}, x::Any) where {T} = convert(t, convert(T, x)) - -function convert(::Type{Nullable{T}}, x::Nullable) where T - return isnull(x) ? Nullable{T}() : Nullable{T}(convert(T, get(x))) -end - -convert(::Type{Nullable{T}}, x::T) where {T<:Nullable} = Nullable{T}(x) -convert(::Type{Nullable{T}}, x::T) where {T} = Nullable{T}(x) -convert(::Type{Nullable }, x::T) where {T} = Nullable{T}(x) - -convert(::Type{Nullable{T}}, ::Void) where {T} = Nullable{T}() -convert(::Type{Nullable }, ::Void) = Nullable{Union{}}() - -promote_rule(::Type{Nullable{S}}, ::Type{T}) where {S,T} = Nullable{promote_type(S, T)} -promote_rule(::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_type(S, T)} -promote_op(op::Any, ::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_op(op, S, T)} -promote_op(op::Type, ::Type{Nullable{S}}, ::Type{Nullable{T}}) where {S,T} = Nullable{promote_op(op, S, T)} - -function show(io::IO, x::Nullable) - if get(io, :compact, false) - if isnull(x) - print(io, "#NULL") - else - show(io, x.value) - end - else - print(io, "Nullable{") - showcompact(io, eltype(x)) - print(io, "}(") - if !isnull(x) - showcompact(io, x.value) - end - print(io, ')') - end -end - -""" - get(x::Nullable[, y]) - -Attempt to access the value of `x`. Returns the value if it is present; -otherwise, returns `y` if provided, or throws a `NullException` if not. - -# Examples -```jldoctest -julia> get(Nullable(5)) -5 - -julia> get(Nullable()) -ERROR: NullException() -Stacktrace: -[...] -``` -""" -@inline function get(x::Nullable{T}, y) where T - if isbits(T) - ifelse(isnull(x), y, x.value) - else - isnull(x) ? y : x.value - end -end - -get(x::Nullable) = isnull(x) ? throw(NullException()) : x.value - -""" - unsafe_get(x) - -Return the value of `x` for [`Nullable`](@ref) `x`; return `x` for -all other `x`. - -This method does not check whether or not `x` is null before attempting to -access the value of `x` for `x::Nullable` (hence "unsafe"). - -# Examples -```jldoctest -julia> x = Nullable(1) -Nullable{Int64}(1) - -julia> unsafe_get(x) -1 - -julia> x = Nullable{String}() -Nullable{String}() - -julia> unsafe_get(x) -ERROR: UndefRefError: access to undefined reference -Stacktrace: -[...] - -julia> x = 1 -1 - -julia> unsafe_get(x) -1 -``` -""" -unsafe_get(x::Nullable) = x.value -unsafe_get(x) = x - -""" - isnull(x) - -Return whether or not `x` is null for [`Nullable`](@ref) `x`; return -`false` for all other `x`. - -# Examples -```jldoctest -julia> x = Nullable(1, false) -Nullable{Int64}() - -julia> isnull(x) -true - -julia> x = Nullable(1, true) -Nullable{Int64}(1) - -julia> isnull(x) -false - -julia> x = 1 -1 - -julia> isnull(x) -false -``` -""" -isnull(x::Nullable) = !x.hasvalue -isnull(x) = false - -## Operators - -""" - null_safe_op(f::Any, ::Type, ::Type...)::Bool - -Returns whether an operation `f` can safely be applied to any value of the passed type(s). -Returns `false` by default. - -Custom types should implement methods for some or all operations `f` when applicable: -returning `true` means that the operation may be called on any bit pattern without -throwing an error (though returning invalid or nonsensical results is not a problem). -In particular, this means that the operation can be applied on the whole domain of the -type *and on uninitialized objects*. As a general rule, these properties are only true for -safe operations on `isbits` types. - -Types declared as safe can benefit from higher performance for operations on nullable: by -always computing the result even for null values, a branch is avoided, which helps -vectorization. -""" -null_safe_op(f::Any, ::Type, ::Type...) = false - -const NullSafeSignedInts = Union{Type{Int128}, Type{Int16}, Type{Int32}, - Type{Int64}, Type{Int8}} -const NullSafeUnsignedInts = Union{Type{Bool}, Type{UInt128}, Type{UInt16}, - Type{UInt32}, Type{UInt64}, Type{UInt8}} -const NullSafeInts = Union{NullSafeSignedInts, NullSafeUnsignedInts} -const NullSafeFloats = Union{Type{Float16}, Type{Float32}, Type{Float64}} -const NullSafeTypes = Union{NullSafeInts, NullSafeFloats} -const EqualOrLess = Union{typeof(isequal), typeof(isless)} - -null_safe_op(::typeof(identity), ::Type{T}) where {T} = isbits(T) - -null_safe_op(f::EqualOrLess, ::NullSafeTypes, ::NullSafeTypes) = true -null_safe_op(f::EqualOrLess, ::Type{Rational{S}}, ::Type{T}) where {S,T} = - null_safe_op(f, T, S) -# complex numbers can be compared for equality but not in general ordered -null_safe_op(::typeof(isequal), ::Type{Complex{S}}, ::Type{T}) where {S,T} = - null_safe_op(isequal, T, S) - -""" - isequal(x::Nullable, y::Nullable) - -If neither `x` nor `y` is null, compare them according to their values -(i.e. `isequal(get(x), get(y))`). Else, return `true` if both arguments are null, -and `false` if one is null but not the other: nulls are considered equal. - -# Examples -```jldoctest -julia> isequal(Nullable(5), Nullable(5)) -true - -julia> isequal(Nullable(5), Nullable(4)) -false - -julia> isequal(Nullable(5), Nullable()) -false - -julia> isequal(Nullable(), Nullable()) -true -``` -""" -@inline function isequal(x::Nullable{S}, y::Nullable{T}) where {S,T} - if null_safe_op(isequal, S, T) - (isnull(x) & isnull(y)) | (!isnull(x) & !isnull(y) & isequal(x.value, y.value)) - else - (isnull(x) & isnull(y)) || (!isnull(x) & !isnull(y) && isequal(x.value, y.value)) - end -end - -isequal(x::Nullable{Union{}}, y::Nullable{Union{}}) = true -isequal(x::Nullable{Union{}}, y::Nullable) = isnull(y) -isequal(x::Nullable, y::Nullable{Union{}}) = isnull(x) - -""" - isless(x::Nullable, y::Nullable) - -If neither `x` nor `y` is null, compare them according to their values -(i.e. `isless(get(x), get(y))`). Else, return `true` if only `y` is null, and `false` -otherwise: nulls are always considered greater than non-nulls, but not greater than -another null. - -# Examples -```jldoctest -julia> isless(Nullable(6), Nullable(5)) -false - -julia> isless(Nullable(5), Nullable(6)) -true - -julia> isless(Nullable(5), Nullable(4)) -false - -julia> isless(Nullable(5), Nullable()) -true - -julia> isless(Nullable(), Nullable()) -false - -julia> isless(Nullable(), Nullable(5)) -false -``` -""" -@inline function isless(x::Nullable{S}, y::Nullable{T}) where {S,T} - # NULL values are sorted last - if null_safe_op(isless, S, T) - (!isnull(x) & isnull(y)) | (!isnull(x) & !isnull(y) & isless(x.value, y.value)) - else - (!isnull(x) & isnull(y)) || (!isnull(x) & !isnull(y) && isless(x.value, y.value)) - end -end - -isless(x::Nullable{Union{}}, y::Nullable{Union{}}) = false -isless(x::Nullable{Union{}}, y::Nullable) = false -isless(x::Nullable, y::Nullable{Union{}}) = !isnull(x) - -==(x::Nullable, y::Nullable) = throw(NullException()) - -const nullablehash_seed = UInt === UInt64 ? 0x932e0143e51d0171 : 0xe51d0171 - -function hash(x::Nullable, h::UInt) - if isnull(x) - return h + nullablehash_seed - else - return hash(x.value, h + nullablehash_seed) - end -end - -# higher-order functions -""" - filter(p, x::Nullable) - -Return null if either `x` is null or `p(get(x))` is false, and `x` otherwise. - -# Examples -```jldoctest -julia> filter(isodd, Nullable(5)) -Nullable{Int64}(5) - -julia> filter(isodd, Nullable(4)) -Nullable{Int64}() - -julia> filter(isodd, Nullable{Int}()) -Nullable{Int64}() -``` -""" -function filter(p, x::Nullable{T}) where T - if isbits(T) - val = unsafe_get(x) - Nullable{T}(val, !isnull(x) && p(val)) - else - isnull(x) || p(unsafe_get(x)) ? x : Nullable{T}() - end -end - -""" -Return the given type if it is concrete, and `Union{}` otherwise. -""" -nullable_returntype(::Type{T}) where {T} = _isleaftype(T) ? T : Union{} - -""" - map(f, x::Nullable) - -Return `f` applied to the value of `x` if it has one, as a `Nullable`. If `x` -is null, then return a null value of type `Nullable{S}`. `S` is guaranteed to -be either `Union{}` or a concrete type. Whichever of these is chosen is an -implementation detail, but typically the choice that maximizes performance -would be used. If `x` has a value, then the return type is guaranteed to be of -type `Nullable{typeof(f(x))}`. - -# Examples -```jldoctest -julia> map(isodd, Nullable(1)) -Nullable{Bool}(true) - -julia> map(isodd, Nullable(2)) -Nullable{Bool}(false) - -julia> map(isodd, Nullable{Int}()) -Nullable{Bool}() -``` -""" -function map(f, x::Nullable{T}) where T - S = promote_op(f, T) - if _isleaftype(S) && null_safe_op(f, T) - Nullable(f(unsafe_get(x)), !isnull(x)) - else - if isnull(x) - Nullable{nullable_returntype(S)}() - else - Nullable(f(unsafe_get(x))) - end - end -end - -# We need the following function and specializations because LLVM cannot -# optimize !any(isnull, t) without further guidance. -hasvalue(x::Nullable) = x.hasvalue -hasvalue(x) = true -all(f::typeof(hasvalue), t::Tuple) = f(t[1]) & all(f, tail(t)) -all(f::typeof(hasvalue), t::Tuple{}) = true - -# Overloads of null_safe_op -# Unary operators - -# Note this list does not include sqrt since it can raise a DomainError -for op in (+, -, abs, abs2) - global null_safe_op - null_safe_op(::typeof(op), ::NullSafeTypes) = true - null_safe_op(::typeof(op), ::Type{Complex{S}}) where {S} = null_safe_op(op, S) - null_safe_op(::typeof(op), ::Type{Rational{S}}) where {S} = null_safe_op(op, S) -end - -null_safe_op(::typeof(~), ::NullSafeInts) = true -null_safe_op(::typeof(!), ::Type{Bool}) = true - -# Binary operators - -# Note this list does not include ^, ÷ and % -# Operations between signed and unsigned types are not safe: promotion to unsigned -# gives an InexactError for negative numbers -for op in (+, -, *, /, &, |, <<, >>, >>>, - scalarmin, scalarmax) - # to fix ambiguities - global null_safe_op - null_safe_op(::typeof(op), ::NullSafeFloats, ::NullSafeFloats) = true - null_safe_op(::typeof(op), ::NullSafeSignedInts, ::NullSafeSignedInts) = true - null_safe_op(::typeof(op), ::NullSafeUnsignedInts, ::NullSafeUnsignedInts) = true -end -for op in (+, -, *, /) - global null_safe_op - null_safe_op(::typeof(op), ::Type{Complex{S}}, ::Type{T}) where {S,T} = - null_safe_op(op, T, S) - null_safe_op(::typeof(op), ::Type{Rational{S}}, ::Type{T}) where {S,T} = - null_safe_op(op, T, S) -end diff --git a/base/nullabletype.jl b/base/nullabletype.jl deleted file mode 100644 index 8c1c9c3d1d91c..0000000000000 --- a/base/nullabletype.jl +++ /dev/null @@ -1,9 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -struct Nullable{T} - hasvalue::Bool - value::T - - Nullable{T}() where {T} = new(false) - Nullable{T}(value::T, hasvalue::Bool=true) where {T} = new(hasvalue, value) -end diff --git a/base/parse.jl b/base/parse.jl index 7181b3538c457..1e0aa7c28af8f 100644 --- a/base/parse.jl +++ b/base/parse.jl @@ -86,24 +86,23 @@ function parseint_preamble(signed::Bool, base::Int, s::AbstractString, startpos: end function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool) where T<:Integer - _n = Nullable{T}() sgn, base, i = parseint_preamble(T<:Signed, Int(base_), s, startpos, endpos) if sgn == 0 && base == 0 && i == 0 raise && throw(ArgumentError("input string is empty or only contains whitespace")) - return _n + return nothing end if !(2 <= base <= 62) raise && throw(ArgumentError("invalid base: base must be 2 ≤ base ≤ 62, got $base")) - return _n + return nothing end if i == 0 raise && throw(ArgumentError("premature end of integer: $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end c, i = parseint_next(s,i,endpos) if i == 0 raise && throw(ArgumentError("premature end of integer: $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end base = convert(T,base) @@ -116,13 +115,13 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: 'a' <= c <= 'z' ? c-'a'+a : base if d >= base raise && throw(ArgumentError("invalid base $base digit $(repr(c)) in $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end n *= base n += d if i > endpos n *= sgn - return Nullable{T}(n) + return Some(n) end c, i = next(s,i) Unicode.isspace(c) && break @@ -134,7 +133,7 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: 'a' <= c <= 'z' ? c-'a'+a : base if d >= base raise && throw(ArgumentError("invalid base $base digit $(repr(c)) in $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end (T <: Signed) && (d *= sgn) @@ -142,26 +141,26 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: n, ov_add = add_with_overflow(n, d) if ov_mul | ov_add raise && throw(OverflowError("overflow parsing $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end - (i > endpos) && return Nullable{T}(n) + (i > endpos) && return Some(n) c, i = next(s,i) end while i <= endpos c, i = next(s,i) if !Unicode.isspace(c) raise && throw(ArgumentError("extra characters after whitespace in $(repr(SubString(s,startpos,endpos)))")) - return _n + return nothing end end - return Nullable{T}(n) + return Some(n) end function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString{String}}, startpos::Int, endpos::Int, base::Integer, raise::Bool) if isempty(sbuff) raise && throw(ArgumentError("input string is empty")) - return Nullable{Bool}() + return nothing end orig_start = startpos @@ -179,9 +178,9 @@ function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString{String}}, p = pointer(sbuff) + startpos - 1 @gc_preserve sbuff begin (len == 4) && (0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), - p, "true", 4)) && (return Nullable(true)) + p, "true", 4)) && (return Some(true)) (len == 5) && (0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), - p, "false", 5)) && (return Nullable(false)) + p, "false", 5)) && (return Some(false)) end if raise @@ -192,7 +191,7 @@ function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString{String}}, throw(ArgumentError("invalid Bool representation: $(repr(substr))")) end end - return Nullable{Bool}() + return nothing end @inline function check_valid_base(base) @@ -205,8 +204,8 @@ end """ tryparse(type, str, [base]) -Like [`parse`](@ref), but returns a [`Nullable`](@ref) of the requested type. The result -will be null if the string does not contain a valid number. +Like [`parse`](@ref), but returns either a [`Some`](@ref) object wrapping a value +of the requested type, or [`nothing`](@ref) if the string does not contain a valid number. """ tryparse(::Type{T}, s::AbstractString, base::Integer) where {T<:Integer} = tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), false) @@ -223,21 +222,51 @@ end ## string to float functions ## -tryparse(::Type{Float64}, s::String) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) -tryparse(::Type{Float64}, s::SubString{String}) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) -tryparse_internal(::Type{Float64}, s::String, startpos::Int, endpos::Int) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) -tryparse_internal(::Type{Float64}, s::SubString{String}, startpos::Int, endpos::Int) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) - -tryparse(::Type{Float32}, s::String) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) -tryparse(::Type{Float32}, s::SubString{String}) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) -tryparse_internal(::Type{Float32}, s::String, startpos::Int, endpos::Int) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) -tryparse_internal(::Type{Float32}, s::SubString{String}, startpos::Int, endpos::Int) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) - +function tryparse(::Type{Float64}, s::String) + hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, + (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) + hasvalue ? Some(val) : nothing +end +function tryparse(::Type{Float64}, s::SubString{String}) + hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, + (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) + hasvalue ? Some(val) : nothing +end +function tryparse_internal(::Type{Float64}, s::String, startpos::Int, endpos::Int) + hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, + (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) + hasvalue ? Some(val) : nothing +end +function tryparse_internal(::Type{Float64}, s::SubString{String}, startpos::Int, endpos::Int) + hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, + (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) + hasvalue ? Some(val) : nothing +end +function tryparse(::Type{Float32}, s::String) + hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, + (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) + hasvalue ? Some(val) : nothing +end +function tryparse(::Type{Float32}, s::SubString{String}) + hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, + (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) + hasvalue ? Some(val) : nothing +end +function tryparse_internal(::Type{Float32}, s::String, startpos::Int, endpos::Int) + hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, + (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) + hasvalue ? Some(val) : nothing +end +function tryparse_internal(::Type{Float32}, s::SubString{String}, startpos::Int, endpos::Int) + hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, + (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) + hasvalue ? Some(val) : nothing +end tryparse(::Type{T}, s::AbstractString) where {T<:Union{Float32,Float64}} = tryparse(T, String(s)) - -tryparse(::Type{Float16}, s::AbstractString) = convert(Nullable{Float16}, tryparse(Float32, s)) +tryparse(::Type{Float16}, s::AbstractString) = + convert(Union{Some{Float16}, Void}, tryparse(Float32, s)) tryparse_internal(::Type{Float16}, s::AbstractString, startpos::Int, endpos::Int) = - convert(Nullable{Float16}, tryparse_internal(Float32, s, startpos, endpos)) + convert(Union{Some{Float16}, Void}, tryparse_internal(Float32, s, startpos, endpos)) ## string to complex functions ## @@ -248,7 +277,7 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String} end if i > e raise && throw(ArgumentError("input string is empty or only contains whitespace")) - return Nullable{Complex{T}}() + return nothing end # find index of ± separating real/imaginary parts (if any) @@ -266,35 +295,35 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String} iᵢ -= 1 if s[iᵢ] != 'i' raise && throw(ArgumentError("expected trailing \"im\", found only \"m\"")) - return Nullable{Complex{T}}() + return nothing end end if i₊ == 0 # purely real or imaginary value if iᵢ > 0 # purely imaginary x_ = tryparse_internal(T, s, i, iᵢ-1, raise) - isnull(x_) && return Nullable{Complex{T}}() + isnull(x_) && return nothing x = unsafe_get(x_) - return Nullable{Complex{T}}(Complex{T}(zero(x),x)) + return Some(Complex{T}(zero(x),x)) else # purely real - return Nullable{Complex{T}}(tryparse_internal(T, s, i, e, raise)) + return Some(tryparse_internal(T, s, i, e, raise)) end end if iᵢ < i₊ raise && throw(ArgumentError("missing imaginary unit")) - return Nullable{Complex{T}}() # no imaginary part + return nothing # no imaginary part end # parse real part re = tryparse_internal(T, s, i, i₊-1, raise) - isnull(re) && return Nullable{Complex{T}}() + re === nothing && return nothing # parse imaginary part im = tryparse_internal(T, s, i₊+1, iᵢ-1, raise) - isnull(im) && return Nullable{Complex{T}}() + im === nothing && return nothing - return Nullable{Complex{T}}(Complex{T}(unsafe_get(re), s[i₊]=='-' ? -unsafe_get(im) : unsafe_get(im))) + return Some(Complex{T}(get(re), s[i₊]=='-' ? -get(im) : get(im))) end # the ±1 indexing above for ascii chars is specific to String, so convert: @@ -306,7 +335,7 @@ tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int) wher startpos == start(s) && endpos == endof(s) ? tryparse(T, s) : tryparse(T, SubString(s, startpos, endpos)) function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, raise::Bool) where T<:Real result = tryparse_internal(T, s, startpos, endpos) - if raise && isnull(result) + if raise && result === nothing throw(ArgumentError("cannot parse $(repr(s[startpos:endpos])) as $T")) end return result diff --git a/base/pkg/entry.jl b/base/pkg/entry.jl index c4dbfc7a616ad..c81676307aa0a 100644 --- a/base/pkg/entry.jl +++ b/base/pkg/entry.jl @@ -312,7 +312,7 @@ function pin(pkg::AbstractString, head::AbstractString) end ref = LibGit2.lookup_branch(repo, branch) try - if !isnull(ref) + if ref !== nothing if LibGit2.revparseid(repo, branch) != id throw(PkgError("Package $pkg: existing branch $branch has " * "been edited and doesn't correspond to its original commit")) @@ -320,7 +320,7 @@ function pin(pkg::AbstractString, head::AbstractString) @info "Package $pkg: checking out existing branch $branch" else @info "Creating $pkg branch $branch" - ref = Nullable(LibGit2.create_branch(repo, branch, commit)) + ref = Some(LibGit2.create_branch(repo, branch, commit)) end # checkout selected branch diff --git a/base/pkg/pkg.jl b/base/pkg/pkg.jl index 69634126d3427..c09e58d07ba11 100644 --- a/base/pkg/pkg.jl +++ b/base/pkg/pkg.jl @@ -22,12 +22,12 @@ const META_BRANCH = "metadata-v2" struct PkgError <: Exception msg::AbstractString - ex::Nullable{Exception} + ex::Union{Some{<:Exception}, Void} end -PkgError(msg::AbstractString) = PkgError(msg, Nullable{Exception}()) +PkgError(msg::AbstractString) = PkgError(msg, nothing) function Base.showerror(io::IO, pkgerr::PkgError) print(io, pkgerr.msg) - if !isnull(pkgerr.ex) + if pkgerr.ex !== nothing pkgex = get(pkgerr.ex) if isa(pkgex, CompositeException) for cex in pkgex diff --git a/base/pkg/read.jl b/base/pkg/read.jl index 804e1d4c4f346..eda9e6127390c 100644 --- a/base/pkg/read.jl +++ b/base/pkg/read.jl @@ -64,7 +64,7 @@ function isfixed(pkg::AbstractString, prepo::LibGit2.GitRepo, avail::Dict=availa LibGit2.isdirty(prepo) && return true LibGit2.isattached(prepo) && return true LibGit2.need_update(prepo) - if isnull(find("REQUIRE", LibGit2.GitIndex(prepo))) + if find("REQUIRE", LibGit2.GitIndex(prepo)) === nothing isfile(pkg,"REQUIRE") && return true end head = string(LibGit2.head_oid(prepo)) @@ -185,7 +185,7 @@ function requires_path(pkg::AbstractString, avail::Dict=available(pkg)) head = LibGit2.with(LibGit2.GitRepo, pkg) do repo LibGit2.isdirty(repo, "REQUIRE") && return pkgreq LibGit2.need_update(repo) - if isnull(find("REQUIRE", LibGit2.GitIndex(repo))) + if find("REQUIRE", LibGit2.GitIndex(repo)) === nothing isfile(pkgreq) && return pkgreq end string(LibGit2.head_oid(repo)) diff --git a/base/precompile.jl b/base/precompile.jl index 5d5bbea92f4a7..7c4399ab36825 100644 --- a/base/precompile.jl +++ b/base/precompile.jl @@ -1068,28 +1068,28 @@ precompile(Tuple{typeof(Base._jl_spawn), String, Array{String, 1}, Ptr{Void}, Ba precompile(Tuple{Type{Base.Timer}, Int64, Float64}) precompile(Tuple{typeof(Base.sleep), Int64}) precompile(Tuple{typeof(Base._uv_hook_close), Base.PipeEndpoint}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{IO}}}) -precompile(Tuple{Type{Base.Nullable{IO}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{AbstractString}}}) -precompile(Tuple{Type{Base.Nullable{AbstractString}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Integer}}}) -precompile(Tuple{Type{Base.Nullable{Integer}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Union{Int64, Symbol}}}}) -precompile(Tuple{Type{Base.Nullable{Union{Int64, Symbol}}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Cmd}}}) -precompile(Tuple{Type{Base.Nullable{Base.Cmd}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Any}}}) -precompile(Tuple{Type{Base.Nullable{Any}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Bool}}}) -precompile(Tuple{Type{Base.Nullable{Bool}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Process}}}) -precompile(Tuple{Type{Base.Nullable{Base.Process}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Dict{K, V} where V where K}}}) -precompile(Tuple{Type{Base.Nullable{Base.Dict{K, V} where V where K}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Array{T, N} where N where T}}}) -precompile(Tuple{Type{Base.Nullable{Array{T, N} where N where T}}}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.Process}}, Base.Process}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Bool}}, Bool}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{IO}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{IO}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{AbstractString}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{AbstractString}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Integer}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Integer}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Cmd}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Base.Cmd}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Any}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Any}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Bool}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Bool}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Process}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Base.Process}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) +precompile(Tuple{Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) +precompile(Tuple{Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.Process}, Void}}, Base.Process}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Bool}, Void}}, Bool}) precompile(Tuple{typeof(Base.task_done_hook), Task}) precompile(Tuple{typeof(Base.getindex), Tuple{Array{Any, 1}, Tuple{}}, Int64}) precompile(Tuple{Type{Base.TCPSocket}}) @@ -1175,7 +1175,7 @@ precompile(Tuple{typeof(Base._uv_hook_close), Base.Timer}) precompile(Tuple{typeof(Base.notify), Base.Condition, Base.EOFError, Bool, Bool}) precompile(Tuple{typeof(Base.unpreserve_handle), Base.Timer}) precompile(Tuple{typeof(Base.disassociate_julia_struct), Base.Timer}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{AbstractString}}, Base.SubString{String}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{AbstractString}, Void}}, Base.SubString{String}}) precompile(Tuple{typeof(Base.connect!), Base.TCPSocket, Base.SubString{String}, UInt16}) precompile(Tuple{typeof(Base.notify), Base.Condition, Base.IPv4, Bool, Bool}) precompile(Tuple{typeof(Base.schedule), Task, Base.IPv4}) @@ -1184,7 +1184,7 @@ precompile(Tuple{typeof(Base.uv_status_string), Base.TCPSocket}) precompile(Tuple{typeof(Base._fd), Base.TCPSocket}) precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TCPSocket}) precompile(Tuple{typeof(Base.isopen), Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{AbstractString}}, String}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{AbstractString}, Void}}, String}) precompile(Tuple{typeof(Base.unpreserve_handle), Base.TCPSocket}) precompile(Tuple{typeof(Base.check_open), Base.TCPSocket}) precompile(Tuple{typeof(Base.stream_wait), Base.TCPSocket, Base.Condition}) @@ -1201,7 +1201,7 @@ precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{Int64, 1}}) precompile(Tuple{typeof(Base.read), Base.TCPSocket, Type{UInt8}}) precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.Nullable{Base.VersionNumber}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.Union{Some{Base.VersionNumber}, Void}}) precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{Int64}, Char}) precompile(Tuple{typeof(Base.close), Base.TCPSocket}) precompile(Tuple{typeof(Base.convert), Type{Base.AbstractChannel}, Base.Channel{Any}}) @@ -1270,28 +1270,28 @@ precompile(Tuple{typeof(Base.setindex!), Base.Dict{Int64, Void}, Void, Int64}) precompile(Tuple{Type{Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}}, Tuple{Int64}}) precompile(Tuple{typeof(Base.eachindex), Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}}) precompile(Tuple{typeof(Base.LinAlg.BLAS.set_num_threads), Int64}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{IO}}}) -precompile(Tuple{Type{Base.Nullable{IO}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{AbstractString}}}) -precompile(Tuple{Type{Base.Nullable{AbstractString}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Integer}}}) -precompile(Tuple{Type{Base.Nullable{Integer}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Union{Int64, Symbol}}}}) -precompile(Tuple{Type{Base.Nullable{Union{Int64, Symbol}}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Cmd}}}) -precompile(Tuple{Type{Base.Nullable{Base.Cmd}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Any}}}) -precompile(Tuple{Type{Base.Nullable{Any}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Bool}}}) -precompile(Tuple{Type{Base.Nullable{Bool}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Process}}}) -precompile(Tuple{Type{Base.Nullable{Base.Process}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Base.Dict{K, V} where V where K}}}) -precompile(Tuple{Type{Base.Nullable{Base.Dict{K, V} where V where K}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Nullable{Array{T, N} where N where T}}}) -precompile(Tuple{Type{Base.Nullable{Array{T, N} where N where T}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{IO}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{IO}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{AbstractString}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{AbstractString}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Integer}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Integer}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Cmd}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Base.Cmd}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Any}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Any}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Bool}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Bool}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Process}, Void}}}) +precompile(Tuple{Type{Base.Union{Some{Base.Process}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) +precompile(Tuple{Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) +precompile(Tuple{Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.VersionNumber}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.VersionNumber}) precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.uv_write), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.flush), Base.TCPSocket}) @@ -1313,12 +1313,12 @@ precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{WeakRef, Void}, WeakRef}) precompile(Tuple{typeof(Base._setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef, Int64}) precompile(Tuple{typeof(Base.setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef}) precompile(Tuple{Type{Base.Channel{Int64}}, Int64}) -precompile(Tuple{typeof(Base.get), Base.Nullable{Base.Dict{K, V} where V where K}, Base.Dict{Any, Any}}) +precompile(Tuple{typeof(Base.get), Base.Union{Some{Base.Dict{K, V}}, Void} where V where K, Base.Dict{Any, Any}}) precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Int64, Symbol}) precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Int64, Symbol, Int64}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.Dict{K, V} where V where K}}, Base.Dict{Any, Any}}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Integer}}, Int64}) -precompile(Tuple{typeof(Base.convert), Type{Base.Nullable{Base.VersionNumber}}, Base.VersionNumber}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}, Base.Dict{Any, Any}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Integer}, Void}}, Int64}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.VersionNumber}) precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Int64}) precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Int64}) precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Int64}) diff --git a/base/process.jl b/base/process.jl index acf983d8075cf..b412a40477565 100644 --- a/base/process.jl +++ b/base/process.jl @@ -391,7 +391,7 @@ function _uv_hook_close(proc::Process) notify(proc.closenotify) end -function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) +function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) spawn(redirect.cmd, (redirect.stream_no == STDIN_NO ? redirect.handle : stdios[1], redirect.stream_no == STDOUT_NO ? redirect.handle : stdios[2], @@ -399,12 +399,12 @@ function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Nullable{ProcessC chain=chain) end -function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) +function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) out_pipe = Libc.malloc(_sizeof_uv_named_pipe) in_pipe = Libc.malloc(_sizeof_uv_named_pipe) link_pipe(in_pipe, false, out_pipe, false) - if isnull(chain) - chain = Nullable(ProcessChain(stdios)) + if chain === nothing + chain = Some(ProcessChain(stdios)) end try spawn(cmds.a, (stdios[1], out_pipe, stdios[3]), chain=chain) @@ -418,12 +418,12 @@ function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nul get(chain) end -function spawn(cmds::ErrOrCmds, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) +function spawn(cmds::ErrOrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) out_pipe = Libc.malloc(_sizeof_uv_named_pipe) in_pipe = Libc.malloc(_sizeof_uv_named_pipe) link_pipe(in_pipe, false, out_pipe, false) - if isnull(chain) - chain = Nullable(ProcessChain(stdios)) + if chain === nothing + chain = Some(ProcessChain(stdios)) end try spawn(cmds.a, (stdios[1], stdios[2], out_pipe), chain=chain) @@ -505,7 +505,7 @@ function setup_stdio(anon::Function, stdio::StdIOSet) close_err && close_stdio(err) end -function spawn(cmd::Cmd, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) +function spawn(cmd::Cmd, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) if isempty(cmd.exec) throw(ArgumentError("cannot spawn empty command")) end @@ -515,15 +515,15 @@ function spawn(cmd::Cmd, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullabl pp.handle = _jl_spawn(cmd.exec[1], cmd.exec, loop, pp, in, out, err) end - if !isnull(chain) + if chain !== nothing push!(get(chain).processes, pp) end pp end -function spawn(cmds::AndCmds, stdios::StdIOSet; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) - if isnull(chain) - chain = Nullable(ProcessChain(stdios)) +function spawn(cmds::AndCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) + if chain === nothing + chain = Some(ProcessChain(stdios)) end setup_stdio(stdios) do in, out, err spawn(cmds.a, (in,out,err), chain=chain) @@ -555,7 +555,7 @@ spawn_opts_inherit(in::Redirectable=RawFD(0), out::Redirectable=RawFD(1), err::R Run a command object asynchronously, returning the resulting `Process` object. """ -spawn(cmds::AbstractCmd, args...; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) = +spawn(cmds::AbstractCmd, args...; chain::Union{Some{ProcessChain}, Void}=nothing) = spawn(cmds, spawn_opts_swallow(args...)...; chain=chain) function eachline(cmd::AbstractCmd; chomp::Bool=true) diff --git a/base/repl/REPL.jl b/base/repl/REPL.jl index b72ae82ba1f99..94460b0371151 100644 --- a/base/repl/REPL.jl +++ b/base/repl/REPL.jl @@ -980,7 +980,7 @@ function setup_interface( linfos = Base.LAST_SHOWN_LINE_INFOS str = String(take!(LineEdit.buffer(s))) n = tryparse(Int, str) - isnull(n) && @goto writeback + n === nothing && @goto writeback n = get(n) if n <= 0 || n > length(linfos) || startswith(linfos[n][1], "./REPL") @goto writeback diff --git a/base/repl/REPLCompletions.jl b/base/repl/REPLCompletions.jl index 7eb796261d2ce..0fe3e6597e417 100644 --- a/base/repl/REPLCompletions.jl +++ b/base/repl/REPLCompletions.jl @@ -372,7 +372,7 @@ function complete_methods(ex_org::Expr) t_in = Tuple{Core.Typeof(func), args_ex...} # Input types na = length(args_ex)+1 ml = methods(func) - kwtype = isdefined(ml.mt, :kwsorter) ? Nullable{DataType}(typeof(ml.mt.kwsorter)) : Nullable{DataType}() + kwtype = isdefined(ml.mt, :kwsorter) ? Some(typeof(ml.mt.kwsorter)) : nothing io = IOBuffer() for method in ml ms = method.sig diff --git a/base/socket.jl b/base/socket.jl index a0298ec1f05dc..6d7b90853b2d4 100644 --- a/base/socket.jl +++ b/base/socket.jl @@ -262,7 +262,7 @@ mutable struct TCPSocket <: LibuvStream readnotify::Condition connectnotify::Condition closenotify::Condition - sendbuf::Nullable{IOBuffer} + sendbuf::Union{Some{IOBuffer}, Void} lock::ReentrantLock throttle::Int diff --git a/base/some.jl b/base/some.jl new file mode 100644 index 0000000000000..8c05c22b72bb1 --- /dev/null +++ b/base/some.jl @@ -0,0 +1,68 @@ +# This file is a part of Julia. License is MIT: https://julialang.org/license + +""" + Some{T} + +A wrapper type used with `Union{Some{T}, Void}` to distinguish between the absence +of a value ([`nothing`](@ref)) and the presence of a `nothing` value (i.e. `Some(nothing)`). +It can also be used to force users of a function argument or of an object field +to explicitly handle the possibility of a field or argument being `nothing`, +either manually or by calling [`get`](@ref) before actually using the wrapped +value. +""" +struct Some{T} + value::T +end + +eltype(::Type{Some{T}}) where {T} = T + +promote_rule(::Type{Some{S}}, ::Type{Some{T}}) where {S,T} = Some{promote_type(S, T)} +promote_rule(::Type{Some{T}}, ::Type{Void}) where {T} = Union{Some{T}, Void} + +convert(::Type{Some{T}}, x::Some) where {T} = Some{T}(convert(T, x.value)) +convert(::Type{Union{Some{T}, Void}}, x::Some) where {T} = convert(Some{T}, x) + +convert(::Type{Union{T, Void}}, x::Any) where {T} = convert(T, x) +convert(::Type{Void}, x::Any) = throw(MethodError(convert, (Void, x))) +convert(::Type{Void}, x::Void) = nothing + +function show(io::IO, x::Some) + if get(io, :compact, false) + show(io, x.value) + else + print(io, "Some(") + show(io, x.value) + print(io, ')') + end +end + +""" + get(x::Some[, y]) + get(x::Void[, y]) + +Attempt to access the value wrapped in `x`. Return the value if +`x` is not [`nothing`](@ref) (i.e. it is a [`Some`](@ref) object). +If `x` is `nothing`, return `y` if provided, or throw a `MethodError` if not. + +# Examples +```jldoctest +julia> get(Some(5)) +5 + +julia> get(nothing) +ERROR: MethodError() +[...] + +julia> get(Some(1), 0) +1 + +julia> get(nothing, 0) +0 + +``` +""" +function get end + +get(x::Some) = x.value +get(x::Some, y) = x.value +get(x::Void, y) = y diff --git a/base/stream.jl b/base/stream.jl index e60d5386ce7a5..8542ab4edb491 100644 --- a/base/stream.jl +++ b/base/stream.jl @@ -104,7 +104,7 @@ mutable struct PipeEndpoint <: LibuvStream readnotify::Condition connectnotify::Condition closenotify::Condition - sendbuf::Nullable{IOBuffer} + sendbuf::Union{Some{IOBuffer}, Void} lock::ReentrantLock throttle::Int @@ -154,7 +154,7 @@ mutable struct TTY <: LibuvStream buffer::IOBuffer readnotify::Condition closenotify::Condition - sendbuf::Nullable{IOBuffer} + sendbuf::Union{Some{IOBuffer}, Void} lock::ReentrantLock throttle::Int @static if Sys.iswindows(); ispty::Bool; end @@ -166,7 +166,8 @@ mutable struct TTY <: LibuvStream PipeBuffer(), Condition(), Condition(), - nothing, ReentrantLock(), + nothing, + ReentrantLock(), DEFAULT_READ_BUFFER_SZ) associate_julia_struct(handle, tty) finalizer(uvfinalize, tty) @@ -847,7 +848,7 @@ end # - large isbits arrays are unbuffered and written directly function unsafe_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt) - if isnull(s.sendbuf) + if s.sendbuf === nothing return uv_write(s, p, UInt(n)) end @@ -867,7 +868,7 @@ function unsafe_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt) end function flush(s::LibuvStream) - if isnull(s.sendbuf) + if s.sendbuf === nothing return end buf = get(s.sendbuf) @@ -878,12 +879,12 @@ function flush(s::LibuvStream) return end -buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=PipeBuffer(bufsize); s) +buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=Some(PipeBuffer(bufsize)); s) ## low-level calls to libuv ## function write(s::LibuvStream, b::UInt8) - if !isnull(s.sendbuf) + if s.sendbuf !== nothing buf = get(s.sendbuf) if nb_available(buf) + 1 < buf.maxsize return write(buf, b) diff --git a/base/sysimg.jl b/base/sysimg.jl index fe9676f4f41f9..fbe2a65e30b22 100644 --- a/base/sysimg.jl +++ b/base/sysimg.jl @@ -85,7 +85,6 @@ end include("essentials.jl") include("ctypes.jl") include("gcutils.jl") -include("nullabletype.jl") include("generator.jl") include("reflection.jl") include("options.jl") @@ -242,8 +241,8 @@ include("multidimensional.jl") include("permuteddimsarray.jl") using .PermutedDimsArrays -# nullable types -include("nullable.jl") +# Some type +include("some.jl") include("broadcast.jl") using .Broadcast diff --git a/base/threadcall.jl b/base/threadcall.jl index b058018068f17..a1efb0a32d77d 100644 --- a/base/threadcall.jl +++ b/base/threadcall.jl @@ -1,7 +1,7 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license const max_ccall_threads = parse(Int, get(ENV, "UV_THREADPOOL_SIZE", "4")) -const thread_notifiers = [Nullable{Condition}() for i in 1:max_ccall_threads] +const thread_notifiers = Union{Some{Condition}, Void}[nothing for i in 1:max_ccall_threads] const threadcall_restrictor = Semaphore(max_ccall_threads) function notify_fun(idx) @@ -83,8 +83,8 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva # wait for a worker thread to be available acquire(threadcall_restrictor) - idx = findfirst(isnull, thread_notifiers) - thread_notifiers[idx] = Nullable{Condition}(Condition()) + idx = findfirst(x -> x === nothing, thread_notifiers) + thread_notifiers[idx] = Some(Condition()) # queue up the work to be done ccall(:jl_queue_work, Void, @@ -93,7 +93,7 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva # wait for a result & return it wait(get(thread_notifiers[idx])) - thread_notifiers[idx] = Nullable{Condition}() + thread_notifiers[idx] = nothing release(threadcall_restrictor) unsafe_load(convert(Ptr{rettype}, pointer(ret_arr))) diff --git a/base/util.jl b/base/util.jl index 9a600fb6506c7..21efffd492692 100644 --- a/base/util.jl +++ b/base/util.jl @@ -426,7 +426,7 @@ getpass(prompt::AbstractString) = unsafe_string(ccall(:getpass, Cstring, (Cstrin end """ - prompt(message; default="", password=false) -> Nullable{String} + prompt(message; default="", password=false) -> Union{Some{String}, Void} Displays the `message` then waits for user input. Input is terminated when a newline (\\n) is encountered or EOF (^D) character is entered on a blank line. If a `default` is provided @@ -445,10 +445,10 @@ function prompt(message::AbstractString; default::AbstractString="", password::B else print(msg) uinput = readline(chomp=false) - isempty(uinput) && return Nullable{String}() # Encountered an EOF + isempty(uinput) && return nothing # Encountered an EOF uinput = chomp(uinput) end - Nullable{String}(isempty(uinput) ? default : uinput) + Some(isempty(uinput) ? default : uinput) end # Windows authentication prompt @@ -501,9 +501,9 @@ if Sys.iswindows() outbuf_data, outbuf_size, pfSave, dwflags) # 2.3: If that failed for any reason other than the user canceling, error out. - # If the user canceled, just return a nullable + # If the user canceled, just return nothing if code == ERROR_CANCELLED - return Nullable{Tuple{String,String}}() + return nothing elseif code != ERROR_SUCCESS error(Base.Libc.FormatMessage(code)) end @@ -529,8 +529,8 @@ if Sys.iswindows() # Done. passbuf_ = passbuf[1:passlen[]-1] - result = Nullable((String(transcode(UInt8, usernamebuf[1:usernamelen[]-1])), - String(transcode(UInt8, passbuf_)))) + result = Some((String(transcode(UInt8, usernamebuf[1:usernamelen[]-1])), + String(transcode(UInt8, passbuf_)))) securezero!(passbuf_) securezero!(passbuf) diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md index 119777b343476..fa4ca2a17a91f 100644 --- a/doc/src/manual/faq.md +++ b/doc/src/manual/faq.md @@ -615,10 +615,10 @@ all/many future usages of the other functions in module Foo that depend on calli ### How does "null" or "nothingness" work in Julia? -Unlike many languages (for example, C and Java), Julia does not have a "null" value. When a reference -(variable, object field, or array element) is uninitialized, accessing it will immediately throw -an error. This situation can be detected using the [`isdefined`](@ref) or -[`isassigned`](@ref Base.isassigned) functions. +Unlike many languages (for example, C and Java), Julia objects cannot be "null" by default. +When a reference (variable, object field, or array element) is uninitialized, accessing it +will immediately throw an error. This situation can be detected using the +[`isdefined`](@ref) or [`isassigned`](@ref Base.isassigned) functions. Some functions are used only for their side effects, and do not need to return a value. In these cases, the convention is to return the value `nothing`, which is just a singleton object of type @@ -626,16 +626,20 @@ cases, the convention is to return the value `nothing`, which is just a singleto this convention, and that the REPL does not print anything for it. Some language constructs that would not otherwise have a value also yield `nothing`, for example `if false; end`. +For situations where a value `x` of type `T` exists only sometimes, the `Union{T, Void}` +type can be used. If the value itself can be `nothing` (notably, when `T` is `Any`), +the `Union{Some{T}, Void}` type is more appropriate since `x == nothing` then indicates +the absence of a value, and `get(x) == nothing` indicates the presence of a value equal +to `nothing`. + To represent missing data in the statistical sense (`NA` in R or `NULL` in SQL), use the [`missing`](@ref) object. See the [`Missing Values`](@ref missing) section for more details. The empty tuple (`()`) is another form of nothingness. But, it should not really be thought of as nothing but rather a tuple of zero values. -In code written for Julia prior to version 0.4 you may occasionally see `None`, which is quite -different. It is the empty (or "bottom") type, a type with no values and no subtypes (except itself). -This is now written as `Union{}` (an empty union type). You will generally not need to use this -type. +The empty (or "bottom") type, written as `Union{}` (an empty union type), is a type with +no values and no subtypes (except itself). You will generally not need to use this type. ## Memory @@ -713,7 +717,7 @@ You can lock your writes with a `ReentrantLock` like this: ```jldoctest julia> l = ReentrantLock() -ReentrantLock(Nullable{Task}(), Condition(Any[]), 0) +ReentrantLock(nothing, Condition(Any[]), 0) julia> @sync for i in 1:3 @async begin diff --git a/doc/src/manual/parallel-computing.md b/doc/src/manual/parallel-computing.md index 277e33459f236..afb9a6a7fdf15 100644 --- a/doc/src/manual/parallel-computing.md +++ b/doc/src/manual/parallel-computing.md @@ -57,10 +57,10 @@ argument implicitly loads module `Distributed`. $ ./julia -p 2 julia> r = remotecall(rand, 2, 2, 2) -Future(2, 1, 4, Nullable{Any}()) +Future(2, 1, 4, nothing) julia> s = @spawnat 2 1 .+ fetch(r) -Future(2, 1, 5, Nullable{Any}()) +Future(2, 1, 5, nothing) julia> fetch(s) 2×2 Array{Float64,2}: @@ -98,10 +98,10 @@ the operation for you: ```julia-repl julia> r = @spawn rand(2,2) -Future(2, 1, 4, Nullable{Any}()) +Future(2, 1, 4, nothing) julia> s = @spawn 1 .+ fetch(r) -Future(3, 1, 5, Nullable{Any}()) +Future(3, 1, 5, nothing) julia> fetch(s) 2×2 Array{Float64,2}: @@ -374,10 +374,10 @@ trials on two machines, and add together the results: julia> @everywhere include_string(Main, $(read("count_heads.jl", String)), "count_heads.jl") julia> a = @spawn count_heads(100000000) -Future(2, 1, 6, Nullable{Any}()) +Future(2, 1, 6, nothing) julia> b = @spawn count_heads(100000000) -Future(3, 1, 7, Nullable{Any}()) +Future(3, 1, 7, nothing) julia> fetch(a)+fetch(b) 100001564 @@ -1164,26 +1164,27 @@ appropriate fields initialized) to `launched` ```julia mutable struct WorkerConfig # Common fields relevant to all cluster managers - io::Nullable{IO} - host::Nullable{AbstractString} - port::Nullable{Integer} + io::Union{Some{<:IO}, Void} + host::Union{Some{<:AbstractString}, Void} + port::Union{Some{<:Integer}, Void} # Used when launching additional workers at a host - count::Nullable{Union{Int, Symbol}} - exename::Nullable{AbstractString} - exeflags::Nullable{Cmd} + count::Union{Some{Union{Int, Symbol}}, Void} + exename::Union{Some{<:Union{AbstractString, Cmd}}, Void} + exeflags::Union{Some{Cmd}, Void} # External cluster managers can use this to store information at a per-worker level # Can be a dict if multiple fields need to be stored. - userdata::Nullable{Any} + userdata::Union{Some{<:Any}, Void} # SSHManager / SSH tunnel connections to workers - tunnel::Nullable{Bool} - bind_addr::Nullable{AbstractString} - sshflags::Nullable{Cmd} - max_parallel::Nullable{Integer} + tunnel::Union{Some{Bool}, Void} + bind_addr::Union{Some{<:AbstractString}, Void} + sshflags::Union{Some{Cmd}, Void} + max_parallel::Union{Some{<:Integer}, Void} - connect_at::Nullable{Any} + # Used by Local/SSH managers + connect_at::Union{Some{<:Any}, Void} [...] end diff --git a/doc/src/manual/stacktraces.md b/doc/src/manual/stacktraces.md index 6d2a06b06ccda..d58ae3a9dbd35 100644 --- a/doc/src/manual/stacktraces.md +++ b/doc/src/manual/stacktraces.md @@ -85,7 +85,7 @@ julia> top_frame.line 236 julia> top_frame.linfo -Nullable{Core.MethodInstance}(MethodInstance for eval(::Module, ::Any)) +Some(MethodInstance for eval(::Module, ::Any)) julia> top_frame.inlined false diff --git a/doc/src/manual/style-guide.md b/doc/src/manual/style-guide.md index 6135d734acf21..9108bf3ef4d30 100644 --- a/doc/src/manual/style-guide.md +++ b/doc/src/manual/style-guide.md @@ -139,8 +139,6 @@ some alternatives to consider: * Determine whether there is a simple rule for when `x` is `nothing`. For example, often the field will start as `nothing` but get initialized at some well-defined point. In that case, consider leaving it undefined at first. - * If `x` really needs to hold no value at some times, define it as `::Nullable{T}` instead, as this - guarantees type-stability in the code accessing this field (see [Nullable types](@ref man-nullable-types)). ## Avoid elaborate container types diff --git a/doc/src/manual/types.md b/doc/src/manual/types.md index 9eacec5057752..21b167165da8f 100644 --- a/doc/src/manual/types.md +++ b/doc/src/manual/types.md @@ -1373,190 +1373,3 @@ It's worth noting that it's extremely easy to mis-use parametric "value" types, in unfavorable cases, you can easily end up making the performance of your code much *worse*. In particular, you would never want to write actual code as illustrated above. For more information about the proper (and improper) uses of `Val`, please read the more extensive discussion in [the performance tips](@ref man-performance-tips). - -## [Nullable Types: Representing Missing Values](@id man-nullable-types) - -In many settings, you need to interact with a value of type `T` that may or may not exist. To -handle these settings, Julia provides a parametric type called [`Nullable{T}`](@ref), which can be thought -of as a specialized container type that can contain either zero or one values. `Nullable{T}` provides -a minimal interface designed to ensure that interactions with missing values are safe. At present, -the interface consists of several possible interactions: - - * Construct a `Nullable` object. - * Check if a `Nullable` object has a missing value. - * Access the value of a `Nullable` object with a guarantee that a [`NullException`](@ref) - will be thrown if the object's value is missing. - * Access the value of a `Nullable` object with a guarantee that a default value of type - `T` will be returned if the object's value is missing. - * Perform an operation on the value (if it exists) of a `Nullable` object, getting a - `Nullable` result. The result will be missing if the original value was missing. - * Performing a test on the value (if it exists) of a `Nullable` - object, getting a result that is missing if either the `Nullable` - itself was missing, or the test failed. - * Perform general operations on single `Nullable` objects, propagating the missing data. - -### Constructing [`Nullable`](@ref) objects - -To construct an object representing a missing value of type `T`, use the `Nullable{T}()` function: - -```jldoctest -julia> x1 = Nullable{Int64}() -Nullable{Int64}() - -julia> x2 = Nullable{Float64}() -Nullable{Float64}() - -julia> x3 = Nullable{Vector{Int64}}() -Nullable{Array{Int64,1}}() -``` - -To construct an object representing a non-missing value of type `T`, use the `Nullable(x::T)` -function: - -```jldoctest -julia> x1 = Nullable(1) -Nullable{Int64}(1) - -julia> x2 = Nullable(1.0) -Nullable{Float64}(1.0) - -julia> x3 = Nullable([1, 2, 3]) -Nullable{Array{Int64,1}}([1, 2, 3]) -``` - -Note the core distinction between these two ways of constructing a `Nullable` object: -in one style, you provide a type, `T`, as a function parameter; in the other style, you provide -a single value of type `T` as an argument. - -### Checking if a `Nullable` object has a value - -You can check if a `Nullable` object has any value using [`isnull`](@ref): - -```jldoctest -julia> isnull(Nullable{Float64}()) -true - -julia> isnull(Nullable(0.0)) -false -``` - -### Safely accessing the value of a `Nullable` object - -You can safely access the value of a `Nullable` object using [`get`](@ref): - -```jldoctest -julia> get(Nullable{Float64}()) -ERROR: NullException() -Stacktrace: -[...] - -julia> get(Nullable(1.0)) -1.0 -``` - -If the value is not present, as it would be for `Nullable{Float64}`, a [`NullException`](@ref) -error will be thrown. The error-throwing nature of the `get` function ensures that any -attempt to access a missing value immediately fails. - -In cases for which a reasonable default value exists that could be used when a `Nullable` -object's value turns out to be missing, you can provide this default value as a second argument -to `get`: - -```jldoctest -julia> get(Nullable{Float64}(), 0.0) -0.0 - -julia> get(Nullable(1.0), 0.0) -1.0 -``` - -!!! tip - Make sure the type of the default value passed to `get` and that of the `Nullable` - object match to avoid type instability, which could hurt performance. Use [`convert`](@ref) - manually if needed. - -### Performing operations on `Nullable` objects - -`Nullable` objects represent values that are possibly missing, and it -is possible to write all code using these objects by first testing to see if -the value is missing with [`isnull`](@ref), and then doing an appropriate -action. However, there are some common use cases where the code could be more -concise or clear by using a higher-order function. - -The [`map`](@ref) function takes as arguments a function `f` and a `Nullable` value -`x`. It produces a `Nullable`: - - - If `x` is a missing value, then it produces a missing value; - - If `x` has a value, then it produces a `Nullable` containing - `f(get(x))` as value. - -This is useful for performing simple operations on values that might be missing -if the desired behaviour is to simply propagate the missing values forward. - -The [`filter`](@ref) function takes as arguments a predicate function `p` -(that is, a function returning a boolean) and a `Nullable` value `x`. -It produces a `Nullable` value: - - - If `x` is a missing value, then it produces a missing value; - - If `p(get(x))` is true, then it produces the original value `x`; - - If `p(get(x))` is false, then it produces a missing value. - -In this way, `filter` can be thought of as selecting only allowable -values, and converting non-allowable values to missing values. - -While `map` and `filter` are useful in specific cases, by far the most useful -higher-order function is [`broadcast`](@ref), which can handle a wide variety of cases, -including making existing operations work and propagate `Nullable`s. An example -will motivate the need for `broadcast`. Suppose we have a function that computes the -greater of two real roots of a quadratic equation, using the quadratic formula: - -```jldoctest nullableroot -julia> root(a::Real, b::Real, c::Real) = (-b + √(b^2 - 4a*c)) / 2a -root (generic function with 1 method) -``` - -We may verify that the result of `root(1, -9, 20)` is `5.0`, as we expect, -since `5.0` is the greater of two real roots of the quadratic equation. - -Suppose now that we want to find the greatest real root of a quadratic -equations where the coefficients might be missing values. Having missing values -in datasets is a common occurrence in real-world data, and so it is important -to be able to deal with them. But we cannot find the roots of an equation if we -do not know all the coefficients. The best solution to this will depend on the -particular use case; perhaps we should throw an error. However, for this -example, we will assume that the best solution is to propagate the missing -values forward; that is, if any input is missing, we simply produce a missing -output. - -The `broadcast` function makes this task easy; we can simply pass the -`root` function we wrote to `broadcast`: - -```jldoctest nullableroot -julia> broadcast(root, Nullable(1), Nullable(-9), Nullable(20)) -Nullable{Float64}(5.0) - -julia> broadcast(root, Nullable(1), Nullable{Int}(), Nullable{Int}()) -Nullable{Float64}() - -julia> broadcast(root, Nullable{Int}(), Nullable(-9), Nullable(20)) -Nullable{Float64}() -``` - -If one or more of the inputs is missing, then the output of -`broadcast` will be missing. - -There exists special syntactic sugar for the `broadcast` function -using a dot notation: - -```jldoctest nullableroot -julia> root.(Nullable(1), Nullable(-9), Nullable(20)) -Nullable{Float64}(5.0) -``` - -In particular, the regular arithmetic operators can be `broadcast` -conveniently using `.`-prefixed operators: - -```jldoctest -julia> Nullable(2) ./ Nullable(3) .+ Nullable(1.0) -Nullable{Float64}(1.66667) -``` diff --git a/doc/src/stdlib/base.md b/doc/src/stdlib/base.md index c2fb3c3a4dabc..3ab80f4372cc6 100644 --- a/doc/src/stdlib/base.md +++ b/doc/src/stdlib/base.md @@ -112,7 +112,6 @@ Core.:(===) Core.isa Base.isequal Base.isless -Base.isless(::Nullable, ::Nullable) Base.ifelse Base.lexcmp Base.lexless @@ -166,15 +165,16 @@ Base.instances ## Special Types ```@docs -Core.Void Core.Any -Base.Enums.@enum Core.Union Union{} Core.UnionAll Core.Tuple Base.Val Core.Vararg +Core.Void +Base.Some +Base.Enums.@enum ``` ## Generic Functions @@ -210,15 +210,6 @@ Base.@label Base.@polly ``` -## Nullables - -```@docs -Base.Nullable -Base.get(::Nullable, ::Any) -Base.isnull -Base.unsafe_get -``` - ## Missing Values ```@docs Base.Missing @@ -292,7 +283,6 @@ Base.KeyError Base.LoadError Base.MethodError Base.MissingException -Base.NullException Core.OutOfMemoryError Core.ReadOnlyMemoryError Core.OverflowError diff --git a/examples/clustermanager/0mq/ZMQCM.jl b/examples/clustermanager/0mq/ZMQCM.jl index f5f0127179196..31ddcc1176523 100644 --- a/examples/clustermanager/0mq/ZMQCM.jl +++ b/examples/clustermanager/0mq/ZMQCM.jl @@ -205,7 +205,7 @@ function launch(manager::ZMQCMan, params::Dict, launched::Array, c::Condition) io, pobj = open(`$(params[:exename]) worker.jl $i $(cluster_cookie())`, "r") wconfig = WorkerConfig() - wconfig.userdata = Dict(:zid=>i, :io=>io) + wconfig.userdata = Some(Dict(:zid=>i, :io=>io)) push!(launched, wconfig) notify(c) end @@ -221,7 +221,7 @@ function connect(manager::ZMQCMan, pid::Int, config::WorkerConfig) else #println("connect_w2w") zid = get(config.connect_at) - config.userdata = Dict{Symbol, Any}(:zid=>zid) + config.userdata = Some(Dict{Symbol, Any}(:zid=>zid)) end streams = setup_connection(zid, SELF_INITIATED) diff --git a/examples/clustermanager/simple/UnixDomainCM.jl b/examples/clustermanager/simple/UnixDomainCM.jl index f295dbf2b0608..2bc9dba5eed89 100644 --- a/examples/clustermanager/simple/UnixDomainCM.jl +++ b/examples/clustermanager/simple/UnixDomainCM.jl @@ -17,7 +17,7 @@ function launch(manager::UnixDomainCM, params::Dict, launched::Array, c::Conditi pobj = open(cmd) wconfig = WorkerConfig() - wconfig.userdata = Dict(:sockname=>sockname, :io=>pobj.out, :process=>pobj) + wconfig.userdata = Some(Dict(:sockname=>sockname, :io=>pobj.out, :process=>pobj)) push!(launched, wconfig) notify(c) catch e @@ -29,13 +29,14 @@ end function connect(manager::UnixDomainCM, pid::Int, config::WorkerConfig) if myid() == 1 # println("connect_m2w") - config.connect_at = get(config.userdata)[:sockname] # This will be useful in the worker-to-worker connection setup. + # This will be useful in the worker-to-worker connection setup. + config.connect_at = Some(get(config.userdata)[:sockname]) print_worker_stdout(get(config.userdata)[:io], pid) else # println("connect_w2w") sockname = get(config.connect_at) - config.userdata = Dict{Symbol, Any}(:sockname=>sockname) + config.userdata = Some(Dict{Symbol, Any}(:sockname=>sockname)) end t = time() diff --git a/stdlib/Dates/src/io.jl b/stdlib/Dates/src/io.jl index 379f2cf58b6a7..504c8787d5ef2 100644 --- a/stdlib/Dates/src/io.jl +++ b/stdlib/Dates/src/io.jl @@ -19,7 +19,8 @@ the argument out in the method definition. Return a tuple of 2 elements `(res, idx)`, where: -* `res` is a `Nullable{T}` - the result of the parsing, null if parsing failed. +* `res` is either a [`Some`](@ref) object holding the result of the parsing, + or `nothing` if parsing failed. * `idx` is an `Int` - if parsing failed, the index at which it failed; if parsing succeeded, `idx` is the index _after_ the index at which parsing ended. """ @@ -99,11 +100,11 @@ end for (tok, fn) in zip("uUeE", [monthabbr_to_value, monthname_to_value, dayabbr_to_value, dayname_to_value]) @eval @inline function tryparsenext(d::DatePart{$tok}, str, i, len, locale) word, i = tryparsenext_word(str, i, len, locale, max_width(d)) - val = isnull(word) ? 0 : $fn(get(word), locale) + val = word === nothing ? 0 : $fn(get(word), locale) if val == 0 - return Nullable{Int64}(), i + return nothing, i else - return Nullable{Int64}(val), i + return Some(val), i end end end @@ -113,7 +114,7 @@ struct Decimal3 end @inline function tryparsenext(d::DatePart{'s'}, str, i, len) ms, ii = tryparsenext_base10(str, i, len, min_width(d), max_width(d)) - if !isnull(ms) + if ms !== nothing val0 = val = get(ms) len = ii - i if len > 3 @@ -122,7 +123,7 @@ struct Decimal3 end else val *= Int64(10) ^ (3 - len) end - ms = Nullable{Int64}(val) + ms = Some(val) end return ms, ii end @@ -186,30 +187,28 @@ Delim(d::Char) = Delim{Char, 1}(d) Delim(d::String) = Delim{String, length(d)}(d) @inline function tryparsenext(d::Delim{Char, N}, str, i::Int, len) where N - R = Nullable{Bool} for j=1:N - i > len && return (R(), i) + i > len && return (nothing, i) c, i = next(str, i) - c != d.d && return (R(), i) + c != d.d && return (nothing, i) end - return R(true), i + return Some(true), i end @inline function tryparsenext(d::Delim{String, N}, str, i::Int, len) where N - R = Nullable{Bool} i1 = i i2 = start(d.d) for j = 1:N if i1 > len - return R(), i1 + return nothing, i1 end c1, i1 = next(str, i1) c2, i2 = next(d.d, i2) if c1 != c2 - return R(), i1 + return nothing, i1 end end - return R(true), i1 + return Some(true), i1 end @inline function format(io, d::Delim, dt, locale) diff --git a/stdlib/Dates/src/parse.jl b/stdlib/Dates/src/parse.jl index 35829f00e7b5a..6dcce55ef37ce 100644 --- a/stdlib/Dates/src/parse.jl +++ b/stdlib/Dates/src/parse.jl @@ -24,12 +24,13 @@ genvar(t::DataType) = Symbol(Base.Unicode.lowercase(string(Base.datatype_name(t) Parse the string according to the directives within the `DateFormat`. Parsing will start at character index `pos` and will stop when all directives are used or we have parsed up to the end of the string, `len`. When a directive cannot be parsed the returned value tuple -will be null if `raise` is false otherwise an exception will be thrown. +will be `nothing` if `raise` is false otherwise an exception will be thrown. Return a 3-element tuple `(values, pos, num_parsed)`: -* `values::Nullable{Tuple}`: A tuple which contains a value for each `DatePart` within the - `DateFormat` in the order in which they occur. If the string ends before we finish parsing - all the directives the missing values will be filled in with default values. +* `values::Union{Some{Tuple}, Void}`: Either `nothing`, or a `Some` object wrapping a tuple + which contains a value for each `DatePart` within the `DateFormat` in the order + in which they occur. If the string ends before we finish parsing all the directives + the missing values will be filled in with default values. * `pos::Int`: The character index at which parsing stopped. * `num_parsed::Int`: The number of values which were parsed and stored within `values`. Useful for distinguishing parsed values from default values. @@ -58,13 +59,13 @@ Return a 3-element tuple `(values, pos, num_parsed)`: begin if directives[i] <: DatePart name = value_names[vi] - nullable = Symbol(:nullable_, name) + val = Symbol(:val, name) vi += 1 quote pos > len && @goto done - $nullable, next_pos = tryparsenext(directives[$i], str, pos, len, locale) - isnull($nullable) && @goto error - $name = unsafe_get($nullable) + $val, next_pos = tryparsenext(directives[$i], str, pos, len, locale) + $val === nothing && @goto error + $name = get($val) pos = next_pos num_parsed += 1 directive_index += 1 @@ -72,8 +73,8 @@ Return a 3-element tuple `(values, pos, num_parsed)`: else quote pos > len && @goto done - nullable_delim, next_pos = tryparsenext(directives[$i], str, pos, len, locale) - isnull(nullable_delim) && @goto error + delim, next_pos = tryparsenext(directives[$i], str, pos, len, locale) + delim === nothing && @goto error pos = next_pos directive_index += 1 end @@ -95,7 +96,7 @@ Return a 3-element tuple `(values, pos, num_parsed)`: pos > len || @goto error @label done - return Nullable{$R}($(Expr(:tuple, value_names...))), pos, num_parsed + return Some{$R}($(Expr(:tuple, value_names...))), pos, num_parsed @label error if raise @@ -106,7 +107,7 @@ Return a 3-element tuple `(values, pos, num_parsed)`: throw(ArgumentError("Unable to parse date time. Expected directive $d at char $pos")) end end - return Nullable{$R}(), pos, 0 + return nothing, pos, 0 end end @@ -116,12 +117,12 @@ end Parse the string according to the directives within the `DateFormat`. The specified `TimeType` type determines the type of and order of tokens returned. If the given `DateFormat` or string does not provide a required token a default value will be used. When the string cannot be -parsed the returned value tuple will be null if `raise` is false otherwise an exception will +parsed the returned value tuple will be `nothing` if `raise` is false otherwise an exception will be thrown. Return a 2-element tuple `(values, pos)`: -* `values::Nullable{Tuple}`: A tuple which contains a value for each token as specified by - the passed in type. +* `values::Union{Some{Tuple}, Void}`: Either `nothing`, or a `Some` object wrapping a tuple + which contains a value for each token as specified by the passed in type. * `pos::Int`: The character index at which parsing stopped. """ @generated function tryparsenext_internal(::Type{T}, str::AbstractString, pos::Int, len::Int, @@ -151,15 +152,15 @@ Return a 2-element tuple `(values, pos)`: quote values, pos, num_parsed = tryparsenext_core(str, pos, len, df, raise) - isnull(values) && return Nullable{$R}(), pos + values === nothing && return nothing, pos $(assign_defaults...) - $value_tuple = unsafe_get(values) - return Nullable{$R}($(Expr(:tuple, output_names...))), pos + $value_tuple = get(values) + return Some{$R}($(Expr(:tuple, output_names...))), pos end end @inline function tryparsenext_base10(str::AbstractString, i::Int, len::Int, min_width::Int=1, max_width::Int=0) - i > len && (return Nullable{Int64}(), i) + i > len && (return nothing, i) min_pos = min_width <= 0 ? i : i + min_width - 1 max_pos = max_width <= 0 ? len : min(i + max_width - 1, len) d::Int64 = 0 @@ -173,9 +174,9 @@ end i = ii end if i <= min_pos - return Nullable{Int64}(), i + return nothing, i else - return Nullable{Int64}(d), i + return Some(d), i end end @@ -192,9 +193,9 @@ end i = ii end if word_end == 0 - return Nullable{SubString}(), i + return nothing, i else - return Nullable{SubString}(SubString(str, word_start, word_end)), i + return Some(SubString(str, word_start, word_end)), i end end @@ -204,56 +205,56 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF dm = dd = Int64(1) th = tm = ts = tms = Int64(0) - nv, i = tryparsenext_base10(s, i, end_pos, 1) - dy = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1) + dy = val === nothing ? (@goto error) : get(val) i > end_pos && @goto error c, i = next(s, i) c != '-' && @goto error i > end_pos && @goto done - nv, i = tryparsenext_base10(s, i, end_pos, 1, 2) - dm = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1, 2) + dm = val === nothing ? (@goto error) : get(val) i > end_pos && @goto done c, i = next(s, i) c != '-' && @goto error i > end_pos && @goto done - nv, i = tryparsenext_base10(s, i, end_pos, 1, 2) - dd = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1, 2) + dd = val === nothing ? (@goto error) : get(val) i > end_pos && @goto done c, i = next(s, i) c != 'T' && @goto error i > end_pos && @goto done - nv, i = tryparsenext_base10(s, i, end_pos, 1, 2) - th = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1, 2) + th = val === nothing ? (@goto error) : get(val) i > end_pos && @goto done c, i = next(s, i) c != ':' && @goto error i > end_pos && @goto done - nv, i = tryparsenext_base10(s, i, end_pos, 1, 2) - tm = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1, 2) + tm = val === nothing ? (@goto error) : get(val) i > end_pos && @goto done c, i = next(s, i) c != ':' && @goto error i > end_pos && @goto done - nv, i = tryparsenext_base10(s, i, end_pos, 1, 2) - ts = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, i = tryparsenext_base10(s, i, end_pos, 1, 2) + ts = val === nothing ? (@goto error) : get(val) i > end_pos && @goto done c, i = next(s, i) c != '.' && @goto error i > end_pos && @goto done - nv, j = tryparsenext_base10(s, i, end_pos, 1, 3) - tms = isnull(nv) ? (@goto error) : unsafe_get(nv) + val, j = tryparsenext_base10(s, i, end_pos, 1, 3) + tms = val === nothing ? (@goto error) : get(val) tms *= 10 ^ (3 - (j - i)) j > end_pos || @goto error @@ -268,19 +269,19 @@ end function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType pos, len = start(str), endof(str) values, pos = tryparsenext_internal(T, str, pos, len, df, true) - T(unsafe_get(values)...) + T(get(values)...) end function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType pos, len = start(str), endof(str) values, pos = tryparsenext_internal(T, str, pos, len, df, false) - if isnull(values) - Nullable{T}() - elseif isnull(validargs(T, unsafe_get(values)...)) + if values === nothing + nothing + elseif validargs(T, get(values)...) === nothing # TODO: validargs gets called twice, since it's called again in the T constructor - Nullable{T}(T(unsafe_get(values)...)) + Some(T(get(values)...)) else - Nullable{T}() + nothing end end @@ -299,7 +300,7 @@ number of components may be less than the total number of `DatePart`. quote pos, len = start(str), endof(str) values, pos, num_parsed = tryparsenext_core(str, pos, len, df, true) - t = unsafe_get(values) + t = get(values) types = $(Expr(:tuple, tokens...)) result = Vector{Any}(uninitialized, num_parsed) for (i, typ) in enumerate(types) diff --git a/stdlib/Dates/src/types.jl b/stdlib/Dates/src/types.jl index 5294b50cbfdd7..9e6696bddebe1 100644 --- a/stdlib/Dates/src/types.jl +++ b/stdlib/Dates/src/types.jl @@ -152,21 +152,21 @@ daysinmonth(y,m) = DAYSINMONTH[m] + (m == 2 && isleapyear(y)) # we can validate arguments in tryparse. """ - validargs(::Type{<:TimeType}, args...) -> Nullable{ArgumentError} + validargs(::Type{<:TimeType}, args...) -> Union{Some{ArgumentError}, Void} Determine whether the given arguments consitute valid inputs for the given type. -Returns a `Nullable{ArgumentError}` where null signifies success. +Returns either a `Some{ArgumentError}` object, or [`nothing`](@ref) in case of success. """ function validargs end """ - argerror([msg]) -> Nullable{ArgumentError} + argerror([msg]) -> Union{Some{ArgumentError}, Void} -Construct a `Nullable{ArgumentError}` with the given message, or null if no message -is provided. For use by `validargs`. +Construct a `Some{ArgumentError}` object wrapping the given message, +or [`nothing`](@ref) if no message is provided. For use by `validargs`. """ -argerror(msg::String) = Nullable(ArgumentError(msg)) -argerror() = Nullable{ArgumentError}() +argerror(msg::String) = Some(ArgumentError(msg)) +argerror() = nothing ### CONSTRUCTORS ### # Core constructors @@ -178,7 +178,7 @@ Construct a `DateTime` type by parts. Arguments must be convertible to [`Int64`] function DateTime(y::Int64, m::Int64=1, d::Int64=1, h::Int64=0, mi::Int64=0, s::Int64=0, ms::Int64=0) err = validargs(DateTime, y, m, d, h, mi, s, ms) - isnull(err) || throw(unsafe_get(err)) + err === nothing || throw(get(err)) rata = ms + 1000 * (s + 60mi + 3600h + 86400 * totaldays(y, m, d)) return DateTime(UTM(rata)) end @@ -201,7 +201,7 @@ Construct a `Date` type by parts. Arguments must be convertible to [`Int64`](@re """ function Date(y::Int64, m::Int64=1, d::Int64=1) err = validargs(Date, y, m, d) - isnull(err) || throw(unsafe_get(err)) + err === nothing || throw(get(err)) return Date(UTD(totaldays(y, m, d))) end @@ -218,7 +218,7 @@ Construct a `Time` type by parts. Arguments must be convertible to [`Int64`](@re """ function Time(h::Int64, mi::Int64=0, s::Int64=0, ms::Int64=0, us::Int64=0, ns::Int64=0) err = validargs(Time, h, mi, s, ms, us, ns) - isnull(err) || throw(unsafe_get(err)) + err === nothing || throw(get(err)) return Time(Nanosecond(ns + 1000us + 1000000ms + 1000000000s + 60000000000mi + 3600000000000h)) end diff --git a/stdlib/Dates/test/io.jl b/stdlib/Dates/test/io.jl index d6e0a2ad774d9..8ddf5367229de 100644 --- a/stdlib/Dates/test/io.jl +++ b/stdlib/Dates/test/io.jl @@ -439,7 +439,7 @@ end end end # Issue #21504 -@test isnull(tryparse(Dates.Date, "0-1000")) +@test tryparse(Dates.Date, "0-1000") === nothing @testset "parse milliseconds, Issue #22100" begin @test Dates.DateTime("2017-Mar-17 00:00:00.0000", "y-u-d H:M:S.s") == Dates.DateTime(2017, 3, 17) diff --git a/stdlib/DelimitedFiles/src/DelimitedFiles.jl b/stdlib/DelimitedFiles/src/DelimitedFiles.jl index f78ac9b73488b..7ff6dfa3c2832 100644 --- a/stdlib/DelimitedFiles/src/DelimitedFiles.jl +++ b/stdlib/DelimitedFiles/src/DelimitedFiles.jl @@ -523,18 +523,18 @@ end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Bool,2}, row::Int, col::Int) n = tryparse_internal(Bool, sbuff, startpos, endpos, 0, false) - isnull(n) || (cells[row, col] = unsafe_get(n)) - isnull(n) + n === nothing || (cells[row, col] = get(n)) + n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) where T<:Integer n = tryparse_internal(T, sbuff, startpos, endpos, 0, false) - isnull(n) || (cells[row, col] = unsafe_get(n)) - isnull(n) + n === nothing || (cells[row, col] = get(n)) + n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) where T<:Union{Real,Complex} n = tryparse_internal(T, sbuff, startpos, endpos, false) - isnull(n) || (cells[row, col] = unsafe_get(n)) - isnull(n) + n === nothing || (cells[row, col] = get(n)) + n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{<:AbstractString,2}, row::Int, col::Int) cells[row, col] = SubString(sbuff, startpos, endpos) @@ -546,15 +546,16 @@ function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Any,2}, if len > 0 # check Inteter ni64 = tryparse_internal(Int, sbuff, startpos, endpos, 0, false) - isnull(ni64) || (cells[row, col] = unsafe_get(ni64); return false) + ni64 === nothing || (cells[row, col] = get(ni64); return false) # check Bool nb = tryparse_internal(Bool, sbuff, startpos, endpos, 0, false) - isnull(nb) || (cells[row, col] = unsafe_get(nb); return false) - + nb === nothing || (cells[row, col] = get(nb); return false) + # check float64 - nf64 = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8}, Csize_t, Csize_t), sbuff, startpos-1, endpos-startpos+1) - isnull(nf64) || (cells[row, col] = unsafe_get(nf64); return false) + hasvalue, valf64 = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, + (Ptr{UInt8}, Csize_t, Csize_t), sbuff, startpos-1, endpos-startpos+1) + hasvalue && (cells[row, col] = valf64; return false) end cells[row, col] = SubString(sbuff, startpos, endpos) false diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index e658d639664c1..8d11a16269a66 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -4,47 +4,47 @@ abstract type ClusterManager end mutable struct WorkerConfig # Common fields relevant to all cluster managers - io::Nullable{IO} - host::Nullable{AbstractString} - port::Nullable{Integer} + io::Union{Some{<:IO}, Void} + host::Union{Some{<:AbstractString}, Void} + port::Union{Some{<:Integer}, Void} # Used when launching additional workers at a host - count::Nullable{Union{Int, Symbol}} - exename::Nullable{Union{AbstractString, Cmd}} - exeflags::Nullable{Cmd} + count::Union{Some{Union{Int, Symbol}}, Void} + exename::Union{Some{<:Union{AbstractString, Cmd}}, Void} + exeflags::Union{Some{Cmd}, Void} # External cluster managers can use this to store information at a per-worker level # Can be a dict if multiple fields need to be stored. - userdata::Nullable{Any} + userdata::Union{Some{<:Any}, Void} # SSHManager / SSH tunnel connections to workers - tunnel::Nullable{Bool} - bind_addr::Nullable{AbstractString} - sshflags::Nullable{Cmd} - max_parallel::Nullable{Integer} + tunnel::Union{Some{Bool}, Void} + bind_addr::Union{Some{<:AbstractString}, Void} + sshflags::Union{Some{Cmd}, Void} + max_parallel::Union{Some{<:Integer}, Void} # Used by Local/SSH managers - connect_at::Nullable{Any} + connect_at::Union{Some{<:Any}, Void} - process::Nullable{Process} - ospid::Nullable{Integer} + process::Union{Some{<:Process}, Void} + ospid::Union{Some{<:Integer}, Void} # Private dictionary used to store temporary information by Local/SSH managers. - environ::Nullable{Dict} + environ::Union{Some{<:Dict}, Void} # Connections to be setup depending on the network topology requested - ident::Nullable{Any} # Worker as identified by the Cluster Manager. + ident::Union{Some{<:Any}, Void} # Worker as identified by the Cluster Manager. # List of other worker idents this worker must connect with. Used with topology T_CUSTOM. - connect_idents::Nullable{Array} + connect_idents::Union{Some{<:Array}, Void} # Run multithreaded blas on worker - enable_threaded_blas::Nullable{Bool} + enable_threaded_blas::Union{Some{Bool}, Void} function WorkerConfig() wc = new() for n in 1:length(WorkerConfig.types) T = eltype(fieldtype(WorkerConfig, n)) - setfield!(wc, n, Nullable{T}()) + setfield!(wc, n, nothing) end wc end @@ -57,9 +57,9 @@ mutable struct Worker add_msgs::Array{Any,1} gcflag::Bool state::WorkerState - c_state::Condition # wait for state changes - ct_time::Float64 # creation time - conn_func::Nullable{Function} # Used to setup connections lazily + c_state::Condition # wait for state changes + ct_time::Float64 # creation time + conn_func::Union{Some{<:Function}, Void} # Used to setup connections lazily r_stream::IO w_stream::IO @@ -67,10 +67,11 @@ mutable struct Worker # serializer as part of the Worker object manager::ClusterManager config::WorkerConfig - version::Nullable{VersionNumber} # Julia version of the remote process + version::Union{Some{VersionNumber}, Void} # Julia version of the remote process function Worker(id::Int, r_stream::IO, w_stream::IO, manager::ClusterManager; - version=Nullable{VersionNumber}(), config=WorkerConfig()) + version::Union{Some{VersionNumber}, Void}=nothing, + config::WorkerConfig=WorkerConfig()) w = Worker(id) w.r_stream = r_stream w.w_stream = buffer_writes(w_stream) @@ -83,7 +84,7 @@ mutable struct Worker w end - Worker(id::Int) = Worker(id, Nullable{Function}()) + Worker(id::Int) = Worker(id, nothing) function Worker(id::Int, conn_func) @assert id > 0 if haskey(map_pid_wrkr, id) @@ -127,16 +128,16 @@ end exec_conn_func(id::Int) = exec_conn_func(worker_from_id(id)) function exec_conn_func(w::Worker) - if isnull(w.conn_func) + if w.conn_func === nothing return wait_for_conn(w) # Some other task may be trying to connect at the same time. end try f = get(w.conn_func) - w.conn_func = Nullable{Function}() + w.conn_func = nothing f() catch e - w.conn_func = () -> throw(e) + w.conn_func = Some(() -> throw(e)) rethrow(e) end nothing @@ -192,11 +193,11 @@ line option) and schedules tasks to process incoming TCP connections and request It does not return. """ -start_worker(out::IO=STDOUT) = start_worker(out, Nullable{AbstractString}()) -start_worker(cookie::AbstractString) = start_worker(STDOUT, Nullable{AbstractString}(cookie)) -start_worker(out::IO, cookie::AbstractString) = start_worker(out, Nullable{AbstractString}(cookie)) -function start_worker(out::IO, cookie_in::Nullable{AbstractString}) - if isnull(cookie_in) +start_worker(out::IO=STDOUT) = start_worker(out, nothing) +start_worker(cookie::AbstractString) = start_worker(STDOUT, Some(cookie)) +start_worker(out::IO, cookie::AbstractString) = start_worker(out, Some(cookie)) +function start_worker(out::IO, cookie_in::Union{Some{<:AbstractString}, Void}) + if cookie_in === nothing cookie = readline(STDIN) else cookie = get(cookie_in) @@ -388,8 +389,8 @@ function addprocs_locked(manager::ClusterManager; kwargs...) params[:lazy] = false end - if isnull(PGRP.lazy) || nprocs() == 1 - PGRP.lazy = Nullable{Bool}(params[:lazy]) + if PGRP.lazy === nothing || nprocs() == 1 + PGRP.lazy = Some(params[:lazy]) elseif isclusterlazy() != params[:lazy] throw(ArgumentError(string("Active workers with lazy=", isclusterlazy(), ". Cannot set lazy=", params[:lazy]))) @@ -488,8 +489,8 @@ function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launch for x in [:host, :tunnel, :sshflags, :exeflags, :exename, :enable_threaded_blas] setfield!(wconfig, x, getfield(fromconfig, x)) end - wconfig.bind_addr = bind_addr - wconfig.port = port + wconfig.bind_addr = Some(bind_addr) + wconfig.port = Some(port) let wconfig=wconfig @async begin @@ -679,9 +680,9 @@ mutable struct ProcessGroup workers::Array{Any,1} refs::Dict # global references topology::Symbol - lazy::Nullable{Bool} + lazy::Union{Some{Bool}, Void} - ProcessGroup(w::Array{Any,1}) = new("pg-default", w, Dict(), :all_to_all, Nullable{Bool}()) + ProcessGroup(w::Array{Any,1}) = new("pg-default", w, Dict(), :all_to_all, nothing) end const PGRP = ProcessGroup([]) @@ -695,18 +696,12 @@ function topology(t) t end -function isclusterlazy() - if isnull(PGRP.lazy) - return false - else - return get(PGRP.lazy) - end -end +isclusterlazy() = get(PGRP.lazy, false) get_bind_addr(pid::Integer) = get_bind_addr(worker_from_id(pid)) get_bind_addr(w::LocalProcess) = LPROC.bind_addr function get_bind_addr(w::Worker) - if isnull(w.config.bind_addr) + if w.config.bind_addr === nothing if w.id != myid() w.config.bind_addr = remotecall_fetch(get_bind_addr, w.id, w.id) end diff --git a/stdlib/Distributed/src/macros.jl b/stdlib/Distributed/src/macros.jl index 32e3ccaf53abb..26f51dc9991ed 100644 --- a/stdlib/Distributed/src/macros.jl +++ b/stdlib/Distributed/src/macros.jl @@ -27,13 +27,13 @@ returning a [`Future`](@ref) to the result. julia> addprocs(3); julia> f = @spawn myid() -Future(2, 1, 5, Nullable{Any}()) +Future(2, 1, 5, nothing) julia> fetch(f) 2 julia> f = @spawn myid() -Future(3, 1, 7, Nullable{Any}()) +Future(3, 1, 7, nothing) julia> fetch(f) 3 @@ -56,7 +56,7 @@ Accepts two arguments, `p` and an expression. julia> addprocs(1); julia> f = @spawnat 2 myid() -Future(2, 1, 3, Nullable{Any}()) +Future(2, 1, 3, nothing) julia> fetch(f) 2 diff --git a/stdlib/Distributed/src/managers.jl b/stdlib/Distributed/src/managers.jl index 9889a3c13fa08..91c5321fbb45a 100644 --- a/stdlib/Distributed/src/managers.jl +++ b/stdlib/Distributed/src/managers.jl @@ -209,15 +209,15 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched, write_cookie(io) wconfig = WorkerConfig() - wconfig.io = io.out - wconfig.host = host - wconfig.tunnel = params[:tunnel] - wconfig.sshflags = sshflags - wconfig.exeflags = exeflags - wconfig.exename = exename - wconfig.count = cnt - wconfig.max_parallel = params[:max_parallel] - wconfig.enable_threaded_blas = params[:enable_threaded_blas] + wconfig.io = Some(io.out) + wconfig.host = Some(host) + wconfig.tunnel = Some(params[:tunnel]) + wconfig.sshflags = Some(sshflags) + wconfig.exeflags = Some(exeflags) + wconfig.exename = Some(exename) + wconfig.count = Some(cnt) + wconfig.max_parallel = Some(params[:max_parallel]) + wconfig.enable_threaded_blas = Some(params[:enable_threaded_blas]) push!(launched, wconfig) @@ -330,9 +330,9 @@ function launch(manager::LocalManager, params::Dict, launched::Array, c::Conditi write_cookie(io) wconfig = WorkerConfig() - wconfig.process = io - wconfig.io = io.out - wconfig.enable_threaded_blas = params[:enable_threaded_blas] + wconfig.process = Some(io) + wconfig.io = Some(io.out) + wconfig.enable_threaded_blas = Some(params[:enable_threaded_blas]) push!(launched, wconfig) end @@ -387,21 +387,21 @@ ensure that messages are delivered and received completely and in order. workers. """ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) - if !isnull(config.connect_at) + if config.connect_at !== nothing # this is a worker-to-worker setup call. return connect_w2w(pid, config) end # master connecting to workers - if !isnull(config.io) + if config.io !== nothing (bind_addr, port) = read_worker_host_port(get(config.io)) - pubhost=get(config.host, bind_addr) - config.host = pubhost - config.port = port + pubhost = get(config.host, bind_addr) + config.host = Some(pubhost) + config.port = Some(port) else - pubhost=get(config.host) - port=get(config.port) - bind_addr=get(config.bind_addr, pubhost) + pubhost = get(config.host) + port = get(config.port) + bind_addr = get(config.bind_addr, pubhost) end tunnel = get(config.tunnel, false) @@ -437,12 +437,12 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) (s, bind_addr) = connect_to_worker(bind_addr, port) end - config.bind_addr = bind_addr + config.bind_addr = Some(bind_addr) # write out a subset of the connect_at required for further worker-worker connection setups - config.connect_at = (bind_addr, port) + config.connect_at = Some((bind_addr, port)) - if !isnull(config.io) + if config.io !== nothing let pid = pid redirect_worker_output(pid, get(config.io)) end @@ -453,8 +453,8 @@ end function connect_w2w(pid::Int, config::WorkerConfig) (rhost, rport) = get(config.connect_at) - config.host = rhost - config.port = rport + config.host = Some(rhost) + config.port = Some(rport) (s, bind_addr) = connect_to_worker(rhost, rport) (s,s) end diff --git a/stdlib/Distributed/src/messages.jl b/stdlib/Distributed/src/messages.jl index f78ed8f21b401..5a3c02a608eae 100644 --- a/stdlib/Distributed/src/messages.jl +++ b/stdlib/Distributed/src/messages.jl @@ -32,7 +32,7 @@ struct MsgHeader end # Special oid (0,0) uses to indicate a null ID. -# Used instead of Nullable to decrease wire size of header. +# Used instead of Union{Some, Void} to decrease wire size of header. null_id(id) = id == RRID(0, 0) struct CallMsg{Mode} <: AbstractMsg diff --git a/stdlib/Distributed/src/process_messages.jl b/stdlib/Distributed/src/process_messages.jl index fdbcc544629f8..2f1aae32e0cce 100644 --- a/stdlib/Distributed/src/process_messages.jl +++ b/stdlib/Distributed/src/process_messages.jl @@ -139,7 +139,7 @@ function message_handler_loop(r_stream::IO, w_stream::IO, incoming::Bool) wpid=0 # the worker r_stream is connected to. boundary = similar(MSG_BOUNDARY) try - version = process_hdr(r_stream, incoming) + version = Some(process_hdr(r_stream, incoming)) serializer = ClusterSerializer(r_stream) # The first message will associate wpid with r_stream @@ -309,17 +309,17 @@ function handle_msg(msg::JoinPGRPMsg, header, r_stream, w_stream, version) end lazy = msg.lazy - PGRP.lazy = Nullable{Bool}(lazy) + PGRP.lazy = Some(lazy) wait_tasks = Task[] for (connect_at, rpid) in msg.other_workers wconfig = WorkerConfig() - wconfig.connect_at = connect_at + wconfig.connect_at = Some(connect_at) let rpid=rpid, wconfig=wconfig if lazy # The constructor registers the object with a global registry. - Worker(rpid, Nullable{Function}(()->connect_to_peer(cluster_manager, rpid, wconfig))) + Worker(rpid, Some(()->connect_to_peer(cluster_manager, rpid, wconfig))) else t = @async connect_to_peer(cluster_manager, rpid, wconfig) push!(wait_tasks, t) @@ -350,8 +350,8 @@ function handle_msg(msg::JoinCompleteMsg, header, r_stream, w_stream, version) w = map_sock_wrkr[r_stream] environ = get(w.config.environ, Dict()) environ[:cpu_cores] = msg.cpu_cores - w.config.environ = environ - w.config.ospid = msg.ospid + w.config.environ = Some(environ) + w.config.ospid = Some(msg.ospid) w.version = version ntfy_channel = lookup_ref(header.notify_oid) diff --git a/stdlib/Distributed/src/remotecall.jl b/stdlib/Distributed/src/remotecall.jl index 845ca6bf075e3..56cd35f13b53f 100644 --- a/stdlib/Distributed/src/remotecall.jl +++ b/stdlib/Distributed/src/remotecall.jl @@ -22,10 +22,11 @@ mutable struct Future <: AbstractRemoteRef where::Int whence::Int id::Int - v::Nullable{Any} + v::Union{Some{<:Any}, Void} - Future(w::Int, rrid::RRID) = Future(w, rrid, Nullable{Any}()) - Future(w::Int, rrid::RRID, v) = (r = new(w,rrid.whence,rrid.id,v); return test_existing_ref(r)) + Future(w::Int, rrid::RRID) = Future(w, rrid, nothing) + Future(w::Int, rrid::RRID, v::Union{Some{<:Any}, Void}) = + (r = new(w,rrid.whence,rrid.id,v); return test_existing_ref(r)) Future(t::Tuple) = new(t[1],t[2],t[3],t[4]) # Useful for creating dummy, zeroed-out instances end @@ -65,7 +66,7 @@ function test_existing_ref(r::AbstractRemoteRef) found = getkey(client_refs, r, nothing) if found !== nothing @assert r.where > 0 - if isa(r, Future) && isnull(found.v) && !isnull(r.v) + if isa(r, Future) && found.v === nothing && r.v !== nothing # we have recd the value from another source, probably a deserialized ref, send a del_client message send_del_client(r) found.v = r.v @@ -90,8 +91,8 @@ function finalize_ref(r::AbstractRemoteRef) send_del_client(r) else # send_del_client only if the reference has not been set - isnull(r.v) && send_del_client(r) - r.v = Nullable{Any}() + r.v === nothing && send_del_client(r) + r.v = nothing end r.where = 0 end @@ -182,7 +183,7 @@ or to use a local [`Channel`](@ref) as a proxy: isready(c) # will not block """ function isready(rr::Future) - !isnull(rr.v) && return true + rr.v !== nothing && return true rid = remoteref_id(rr) return if rr.where == myid() @@ -281,7 +282,7 @@ end channel_type(rr::RemoteChannel{T}) where {T} = T -serialize(s::ClusterSerializer, f::Future) = serialize(s, f, isnull(f.v)) +serialize(s::ClusterSerializer, f::Future) = serialize(s, f, f.v === nothing) serialize(s::ClusterSerializer, rr::RemoteChannel) = serialize(s, rr, true) function serialize(s::ClusterSerializer, rr::AbstractRemoteRef, addclient) if addclient @@ -315,7 +316,7 @@ end # Future and RemoteChannel are serializable only in a running cluster. # Serialize zeroed-out values to non ClusterSerializer objects function serialize(s::AbstractSerializer, ::Future) - zero_fut = Future((0,0,0,Nullable{Any}())) + zero_fut = Future((0,0,0,nothing)) invoke(serialize, Tuple{AbstractSerializer, Any}, s, zero_fut) end @@ -478,7 +479,7 @@ end Wait for a value to become available for the specified future. """ -wait(r::Future) = (!isnull(r.v) && return r; call_on_owner(wait_ref, r, myid()); r) +wait(r::Future) = (r.v !== nothing && return r; call_on_owner(wait_ref, r, myid()); r) """ wait(r::RemoteChannel, args...) @@ -488,9 +489,9 @@ Wait for a value to become available on the specified remote channel. wait(r::RemoteChannel, args...) = (call_on_owner(wait_ref, r, myid(), args...); r) function fetch(r::Future) - !isnull(r.v) && return get(r.v) - v=call_on_owner(fetch_ref, r) - r.v=v + r.v !== nothing && return get(r.v) + v = call_on_owner(fetch_ref, r) + r.v = Some(v) send_del_client(r) v end @@ -525,9 +526,9 @@ All asynchronous remote calls return `Future`s and set the value to the return value of the call upon completion. """ function put!(rr::Future, v) - !isnull(rr.v) && error("Future can be set only once") + rr.v !== nothing && error("Future can be set only once") call_on_owner(put_future, rr, v, myid()) - rr.v = v + rr.v = Some(v) rr end function put_future(rid, v, callee) diff --git a/stdlib/Distributed/src/workerpool.jl b/stdlib/Distributed/src/workerpool.jl index 1c444062e6a4f..47cf59550c7de 100644 --- a/stdlib/Distributed/src/workerpool.jl +++ b/stdlib/Distributed/src/workerpool.jl @@ -185,7 +185,7 @@ performs a `remote_do` on it. """ remote_do(f, pool::AbstractWorkerPool, args...; kwargs...) = remotecall_pool(remote_do, f, pool, args...; kwargs...) -const _default_worker_pool = Ref{Nullable}(Nullable{WorkerPool}()) +const _default_worker_pool = Ref{Union{Some{WorkerPool}, Void}}(nothing) """ default_worker_pool() @@ -195,11 +195,11 @@ const _default_worker_pool = Ref{Nullable}(Nullable{WorkerPool}()) function default_worker_pool() # On workers retrieve the default worker pool from the master when accessed # for the first time - if isnull(_default_worker_pool[]) + if _default_worker_pool[] === nothing if myid() == 1 - _default_worker_pool[] = Nullable(WorkerPool()) + _default_worker_pool[] = Some(WorkerPool()) else - _default_worker_pool[] = Nullable(remotecall_fetch(()->default_worker_pool(), 1)) + _default_worker_pool[] = Some(remotecall_fetch(()->default_worker_pool(), 1)) end end return get(_default_worker_pool[]) diff --git a/stdlib/Distributed/test/distributed_exec.jl b/stdlib/Distributed/test/distributed_exec.jl index 80112777bb264..ab7e03457c950 100644 --- a/stdlib/Distributed/test/distributed_exec.jl +++ b/stdlib/Distributed/test/distributed_exec.jl @@ -83,10 +83,10 @@ end function testf(id) f=Future(id) @test isready(f) == false - @test isnull(f.v) == true + @test f.v === nothing put!(f, :OK) @test isready(f) == true - @test isnull(f.v) == false + @test f.v !== nothing @test_throws ErrorException put!(f, :OK) # Cannot put! to a already set future @test_throws MethodError take!(f) # take! is unsupported on a Future @@ -104,9 +104,9 @@ function test_futures_dgc(id) # remote value should be deleted after a fetch @test remotecall_fetch(k->(yield();haskey(Distributed.PGRP.refs, k)), id, fid) == true - @test isnull(f.v) == true + @test f.v === nothing @test fetch(f) == id - @test isnull(f.v) == false + @test f.v !== nothing yield(); # flush gc msgs @test remotecall_fetch(k->(yield();haskey(Distributed.PGRP.refs, k)), id, fid) == false @@ -115,7 +115,7 @@ function test_futures_dgc(id) f = remotecall(myid, id) fid = remoteref_id(f) @test remotecall_fetch(k->(yield();haskey(Distributed.PGRP.refs, k)), id, fid) == true - @test isnull(f.v) == true + @test f.v === nothing finalize(f) yield(); # flush gc msgs @test remotecall_fetch(k->(yield();haskey(Distributed.PGRP.refs, k)), id, fid) == false @@ -260,8 +260,8 @@ function test_regular_io_ser(ref::Distributed.AbstractRemoteRef) v = getfield(ref2, fld) if isa(v, Number) @test v === zero(typeof(v)) - elseif isa(v, Nullable) - @test v === Nullable{Any}() + elseif isa(v, Union{Some, Void}) + @test v === nothing else error(string("Add test for field ", fld)) end @@ -1060,8 +1060,8 @@ function launch(manager::ErrorSimulator, params::Dict, launched::Array, c::Condi io = open(detach(setenv(cmd, dir=dir))) wconfig = WorkerConfig() - wconfig.process = io - wconfig.io = io.out + wconfig.process = Some(io) + wconfig.io = Some(io.out) push!(launched, wconfig) notify(c) end @@ -1421,8 +1421,8 @@ function launch(manager::WorkerArgTester, params::Dict, launched::Array, c::Cond manager.write_cookie && Distributed.write_cookie(io) wconfig = WorkerConfig() - wconfig.process = io - wconfig.io = io.out + wconfig.process = Some(io) + wconfig.io = Some(io.out) push!(launched, wconfig) notify(c) diff --git a/stdlib/Distributed/test/topology.jl b/stdlib/Distributed/test/topology.jl index ff898351d3f52..4a0872dbedf28 100644 --- a/stdlib/Distributed/test/topology.jl +++ b/stdlib/Distributed/test/topology.jl @@ -48,10 +48,10 @@ function launch(manager::TopoTestManager, params::Dict, launched::Array, c::Cond Distributed.write_cookie(io) wconfig = WorkerConfig() - wconfig.process = io - wconfig.io = io.out - wconfig.ident = i - wconfig.connect_idents = collect(i+2:2:manager.np) + wconfig.process = Some(io) + wconfig.io = Some(io.out) + wconfig.ident = Some(i) + wconfig.connect_idents = Some(collect(i+2:2:manager.np)) push!(launched, wconfig) end diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl index a948f09896c37..0a6f547bd86c6 100644 --- a/stdlib/Profile/src/Profile.jl +++ b/stdlib/Profile/src/Profile.jl @@ -429,7 +429,7 @@ function print_flat(io::IO, lilist::Vector{StackFrame}, n::Vector{Int}, Base.print(io, rpad(rtruncto(string(li.file), wfile), wfile, " "), " ") Base.print(io, lpad(string(li.line), wline, " "), " ") fname = string(li.func) - if !li.from_c && !isnull(li.linfo) + if !li.from_c && li.linfo !== nothing fname = sprint(show_spec_linfo, li) end Base.print(io, rpad(ltruncto(fname, wfunc), wfunc, " ")) @@ -492,7 +492,7 @@ function tree_format(lilist::Vector{StackFrame}, counts::Vector{Int}, level::Int ")") else fname = string(li.func) - if !li.from_c && !isnull(li.linfo) + if !li.from_c && li.linfo !== nothing fname = sprint(show_spec_linfo, li) end strs[i] = string(base, diff --git a/test/ambiguous.jl b/test/ambiguous.jl index 7f292a7a0d2a3..2a7aa3c8e1efb 100644 --- a/test/ambiguous.jl +++ b/test/ambiguous.jl @@ -288,6 +288,8 @@ end pop!(need_to_handle_undef_sparam, which(Base.one, Tuple{Type{Union{Missing, T}} where T})) pop!(need_to_handle_undef_sparam, which(Base.oneunit, Tuple{Type{Union{Missing, T}} where T})) pop!(need_to_handle_undef_sparam, which(Base.nonmissingtype, Tuple{Type{Union{Missing, T}} where T})) + pop!(need_to_handle_undef_sparam, which(Base.convert, (Type{Union{Some{T}, Void}} where T, Some))) + pop!(need_to_handle_undef_sparam, which(Base.convert, (Type{Union{T, Void}} where T, Some))) @test need_to_handle_undef_sparam == Set() end end diff --git a/test/broadcast.jl b/test/broadcast.jl index 444b088012772..849d44be7f694 100644 --- a/test/broadcast.jl +++ b/test/broadcast.jl @@ -518,10 +518,10 @@ Base.BroadcastStyle(a2::Broadcast.ArrayStyle{AD2C}, a1::Broadcast.ArrayStyle{AD1 end # broadcast should only "peel off" one container layer -@test get.([Nullable(1), Nullable(2)]) == [1, 2] +@test getindex.([Ref(1), Ref(2)]) == [1, 2] let io = IOBuffer() - broadcast(x -> print(io, x), [Nullable(1.0)]) - @test String(take!(io)) == "Nullable{Float64}(1.0)" + broadcast(x -> print(io, x), [Ref(1.0)]) + @test String(take!(io)) == "Base.RefValue{Float64}(1.0)" end # Test that broadcast's promotion mechanism handles closures accepting more than one argument. @@ -575,9 +575,6 @@ end @test isequal( [Set([1]), Set([2])] .∪ Set([3]), [Set([1, 3]), Set([2, 3])]) - - @test isequal(@inferred(broadcast(foo, "world", Nullable(1))), - Nullable("hello")) end @testset "broadcast resulting in tuples" begin @@ -608,7 +605,7 @@ end # end # Issue #22180 -@test isequal(convert.(Nullable, [1,2]), [Nullable(1), Nullable(2)]) +@test convert.(Any, [1, 2]) == [1, 2] # Issue #24944 let n = 1 diff --git a/test/ccall.jl b/test/ccall.jl index 770f6c0763ba8..1ca337c6ec262 100644 --- a/test/ccall.jl +++ b/test/ccall.jl @@ -1242,8 +1242,8 @@ end @test_throws(UndefVarError(:Something_not_defined_20835), eval(:(f20835(x) = ccall(:fn, Something_not_defined_20835, (Ptr{typeof(x)},), x)))) -@noinline f21104at(::Type{T}) where {T} = ccall(:fn, Void, (Nullable{T},), 0) -@noinline f21104rt(::Type{T}) where {T} = ccall(:fn, Nullable{T}, ()) +@noinline f21104at(::Type{T}) where {T} = ccall(:fn, Void, (Some{T},), Some(0)) +@noinline f21104rt(::Type{T}) where {T} = ccall(:fn, Some{T}, ()) @test code_llvm(DevNull, f21104at, (Type{Float64},)) === nothing @test code_llvm(DevNull, f21104rt, (Type{Float64},)) === nothing @test_throws(ErrorException("ccall: the type of argument 1 doesn't correspond to a C type"), diff --git a/test/choosetests.jl b/test/choosetests.jl index aa8e1ceb31800..b619a00cad52c 100644 --- a/test/choosetests.jl +++ b/test/choosetests.jl @@ -46,7 +46,7 @@ function choosetests(choices = []) "combinatorics", "sysinfo", "env", "rounding", "ranges", "mod2pi", "euler", "show", "lineedit", "replcompletions", "repl", "replutil", "sets", "goto", "llvmcall", "llvmcall2", "grisu", - "nullable", "meta", "stacktraces", "libgit2", "docs", + "some", "meta", "stacktraces", "libgit2", "docs", "markdown", "serialize", "misc", "threads", "enums", "cmdlineargs", "i18n", "libdl", "int", "checked", "bitset", "floatfuncs", "compile", "inline", diff --git a/test/codegen.jl b/test/codegen.jl index 7664b90d29854..2937e80593118 100644 --- a/test/codegen.jl +++ b/test/codegen.jl @@ -169,7 +169,6 @@ breakpoint_ptrstruct(a::RealStruct) = ccall(:jl_breakpoint, Void, (Ref{PtrStruct},), a) if opt_level > 0 - @test !contains(get_llvm(isequal, Tuple{Nullable{BigFloat}, Nullable{BigFloat}}), "%gcframe") @test !contains(get_llvm(pointer_not_safepoint, Tuple{}), "%gcframe") compare_large_struct_ir = get_llvm(compare_large_struct, Tuple{typeof(create_ref_struct())}) @test contains(compare_large_struct_ir, "call i32 @memcmp") diff --git a/test/compile.jl b/test/compile.jl index daafb6091e8c6..e7743eff2718c 100644 --- a/test/compile.jl +++ b/test/compile.jl @@ -128,8 +128,8 @@ try struct Value18343{T, R} pool::Pool18343{R, Value18343{T, R}} end - Base.convert(::Type{Nullable{S}}, ::Value18343{Nullable}) where {S} = 2 - Base.convert(::Type{Nullable{Value18343}}, ::Value18343{Nullable}) = 2 + Base.convert(::Type{Some{S}}, ::Value18343{Some}) where {S} = 2 + Base.convert(::Type{Some{Value18343}}, ::Value18343{Some}) = 2 Base.convert(::Type{Ref}, ::Value18343{T}) where {T} = 3 @@ -252,7 +252,7 @@ try some_method, Tuple{typeof(Base.include), String}, Core.svec(), typemax(UInt)) @test Foo.some_linfo::Core.MethodInstance === some_linfo - PV = Foo.Value18343{Nullable}.body.types[1] + PV = Foo.Value18343{Some}.body.types[1] VR = PV.types[1].parameters[1] @test PV.types[1] === Array{VR,1} @test pointer_from_objref(PV.types[1]) === diff --git a/test/copy.jl b/test/copy.jl index 103ad6c849d81..96b6f9a706455 100644 --- a/test/copy.jl +++ b/test/copy.jl @@ -83,7 +83,13 @@ end end # issue #14027 -@test isnull(deepcopy(Nullable{Array}())) +struct Nullable14027{T} + hasvalue::Bool + value::T + + Nullable14027{T}() where {T} = new(false) +end +@test !deepcopy(Nullable14027{Array}()).hasvalue @testset "issue #15250" begin a1 = Core.svec(1, 2, 3, []) diff --git a/test/core.jl b/test/core.jl index 254ccdd38afb8..d00edb0d35e5a 100644 --- a/test/core.jl +++ b/test/core.jl @@ -3234,17 +3234,21 @@ f11858(Any[Type{Foo11858}, Type{Bar11858}, typeof(g11858)]) @test Bar11858(1).x == 1.0 # issue 11904 +struct Nullable11904{T} + value::T + hasvalue::Bool +end @noinline throw_error() = error() foo11904(x::Int) = x -@inline function foo11904(x::Nullable{S}) where S +@inline function foo11904(x::Nullable11904{S}) where S if isbits(S) - Nullable(foo11904(x.value), x.hasvalue) + Nullable11904(foo11904(x.value), x.hasvalue) else throw_error() end end -@test !isnull(foo11904(Nullable(1))) +@test foo11904(Nullable11904(1, true)).hasvalue # issue 11874 struct Foo11874 @@ -3469,7 +3473,7 @@ call13007(::Type{Array}) = 1 @test length(Base._methods(call13007, Tuple{Type{x} where x<:Array}, 4, typemax(UInt))) == 2 # detecting cycles during type intersection, e.g. #1631 -cycle_in_solve_tvar_constraints(::Type{Nullable{S}}, x::S) where {S} = 0 +cycle_in_solve_tvar_constraints(::Type{Some{S}}, x::S) where {S} = 0 cycle_in_solve_tvar_constraints(::Type{T}, x::Val{T}) where {T} = 1 @test length(methods(cycle_in_solve_tvar_constraints)) == 2 diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl index d7fc9cb067667..2ca3d2d062355 100644 --- a/test/libgit2-helpers.jl +++ b/test/libgit2-helpers.jl @@ -12,7 +12,7 @@ without having to authenticate against a real server. function credential_loop( valid_credential::AbstractCredential, url::AbstractString, - user::Nullable{<:AbstractString}, + user::Union{Some{<:AbstractString}, Void}, allowed_types::UInt32, payload::CredentialPayload; shred::Bool=true) @@ -32,7 +32,7 @@ function credential_loop( num_authentications += 1 # Check if the callback provided us with valid credentials - if !isnull(payload.credential) && get(payload.credential) == valid_credential + if payload.credential !== nothing && get(payload.credential) == valid_credential LibGit2.approve(payload, shred=shred) break end @@ -60,7 +60,7 @@ end function credential_loop( valid_credential::UserPasswordCredential, url::AbstractString, - user::Nullable{<:AbstractString}=Nullable{String}(), + user::Union{Some{<:AbstractString}, Void}=nothing, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) credential_loop(valid_credential, url, user, 0x000001, payload, shred=shred) @@ -69,7 +69,7 @@ end function credential_loop( valid_credential::SSHCredential, url::AbstractString, - user::Nullable{<:AbstractString}=Nullable{String}(), + user::Union{Some{<:AbstractString}, Void}=nothing, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) credential_loop(valid_credential, url, user, 0x000046, payload, shred=shred) @@ -81,5 +81,5 @@ function credential_loop( user::AbstractString, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) - credential_loop(valid_credential, url, Nullable(user), payload, shred=shred) + credential_loop(valid_credential, url, Some(user), payload, shred=shred) end diff --git a/test/libgit2.jl b/test/libgit2.jl index b008bd3ed1480..86898fd7846bd 100644 --- a/test/libgit2.jl +++ b/test/libgit2.jl @@ -371,7 +371,7 @@ end @test cred.use_http_path cred.use_http_path = false - @test get(cred.path, "") == "dir/file" + @test cred.path == "dir/file" @test sprint(write, cred) == expected end @@ -752,7 +752,7 @@ mktempdir() do dir @test LibGit2.name(brref) == "refs/heads/master" @test LibGit2.shortname(brref) == master_branch @test LibGit2.ishead(brref) - @test isnull(LibGit2.upstream(brref)) + @test LibGit2.upstream(brref) === nothing # showing the GitReference to this branch show_strs = split(sprint(show, brref), "\n") @@ -766,19 +766,19 @@ mktempdir() do dir # create a branch *without* setting its tip as HEAD LibGit2.branch!(repo, test_branch, string(commit_oid1), set_head=false) # null because we are looking for a REMOTE branch - @test isnull(LibGit2.lookup_branch(repo, test_branch, true)) - # not null because we are now looking for a LOCAL branch + @test LibGit2.lookup_branch(repo, test_branch, true) === nothing + # not nothing because we are now looking for a LOCAL branch LibGit2.with(Base.get(LibGit2.lookup_branch(repo, test_branch, false))) do tbref @test LibGit2.shortname(tbref) == test_branch - @test isnull(LibGit2.upstream(tbref)) + @test LibGit2.upstream(tbref) === nothing end - @test isnull(LibGit2.lookup_branch(repo, test_branch2, true)) + @test LibGit2.lookup_branch(repo, test_branch2, true) === nothing # test deleting the branch LibGit2.branch!(repo, test_branch2; set_head=false) LibGit2.with(Base.get(LibGit2.lookup_branch(repo, test_branch2, false))) do tbref @test LibGit2.shortname(tbref) == test_branch2 LibGit2.delete_branch(tbref) - @test isnull(LibGit2.lookup_branch(repo, test_branch2, true)) + @test LibGit2.lookup_branch(repo, test_branch2, true) === nothing end end branches = map(b->LibGit2.shortname(b[1]), LibGit2.GitBranchIter(repo)) @@ -1278,7 +1278,7 @@ mktempdir() do dir # check index for file LibGit2.with(LibGit2.GitIndex(repo)) do idx i = find(test_file, idx) - @test !isnull(i) + @test i !== nothing idx_entry = idx[get(i)] @test idx_entry !== nothing idx_entry_str = sprint(show, idx_entry) @@ -1286,7 +1286,7 @@ mktempdir() do dir @test LibGit2.stage(idx_entry) == 0 i = find("zzz", idx) - @test isnull(i) + @test i === nothing idx_str = sprint(show, idx) @test idx_str == "GitIndex:\nRepository: $(LibGit2.repository(idx))\nNumber of elements: 1\n" @@ -1300,11 +1300,11 @@ mktempdir() do dir # check non-existent file status st = LibGit2.status(repo, "XYZ") - @test isnull(st) + @test st === nothing # check file status st = LibGit2.status(repo, test_file) - @test !isnull(st) + @test st !== nothing @test LibGit2.isset(get(st), LibGit2.Consts.STATUS_CURRENT) # modify file @@ -1353,7 +1353,7 @@ mktempdir() do dir remote_name = "test" url = "https://test.com/repo" - @test isnull(LibGit2.lookup_remote(repo, remote_name)) + @test LibGit2.lookup_remote(repo, remote_name) === nothing for r in (repo, path) # Set just the fetch URL @@ -1364,7 +1364,7 @@ mktempdir() do dir @test LibGit2.push_url(remote) == "" LibGit2.remote_delete(repo, remote_name) - @test isnull(LibGit2.lookup_remote(repo, remote_name)) + @test LibGit2.lookup_remote(repo, remote_name) === nothing # Set just the push URL LibGit2.set_remote_push_url(r, remote_name, url) @@ -1374,7 +1374,7 @@ mktempdir() do dir @test LibGit2.push_url(remote) == url LibGit2.remote_delete(repo, remote_name) - @test isnull(LibGit2.lookup_remote(repo, remote_name)) + @test LibGit2.lookup_remote(repo, remote_name) === nothing # Set the fetch and push URL LibGit2.set_remote_url(r, remote_name, url) @@ -1384,7 +1384,7 @@ mktempdir() do dir @test LibGit2.push_url(remote) == url LibGit2.remote_delete(repo, remote_name) - @test isnull(LibGit2.lookup_remote(repo, remote_name)) + @test LibGit2.lookup_remote(repo, remote_name) === nothing end # Invalid remote name @test_throws LibGit2.GitError LibGit2.set_remote_url(repo, "", url) @@ -1569,19 +1569,18 @@ mktempdir() do dir # No credential settings in configuration. cred = LibGit2.GitCredential("https", "github.com") username = LibGit2.default_username(cfg, cred) - @test isnull(username) + @test username === nothing # Add a credential setting for a specific for a URL LibGit2.set!(cfg, "credential.https://github.com.username", "foo") cred = LibGit2.GitCredential("https", "github.com") username = LibGit2.default_username(cfg, cred) - @test !isnull(username) - @test get(username) == "foo" + @test username == "foo" cred = LibGit2.GitCredential("https", "mygithost") username = LibGit2.default_username(cfg, cred) - @test isnull(username) + @test username === nothing # Add a global credential setting after the URL specific setting. The first # setting to match will be the one that is used. @@ -1589,13 +1588,11 @@ mktempdir() do dir cred = LibGit2.GitCredential("https", "github.com") username = LibGit2.default_username(cfg, cred) - @test !isnull(username) - @test get(username) == "foo" + @test username == "foo" cred = LibGit2.GitCredential("https", "mygithost") username = LibGit2.default_username(cfg, cred) - @test !isnull(username) - @test get(username) == "bar" + @test username == "bar" end end @@ -1613,13 +1610,11 @@ mktempdir() do dir cred = LibGit2.GitCredential("https", "github.com") username = LibGit2.default_username(cfg, cred) - @test !isnull(username) - @test get(username) == "" + @test username == "" cred = LibGit2.GitCredential("https", "mygithost", "path") username = LibGit2.default_username(cfg, cred) - @test !isnull(username) - @test get(username) == "name" + @test username == "name" end end end @@ -1753,7 +1748,7 @@ mktempdir() do dir function without_path(cred) c = deepcopy(cred) - c.path = Nullable() + c.path = nothing c end @@ -1826,7 +1821,7 @@ mktempdir() do dir url *= "github.com:test/package.jl" quote include($LIBGIT2_HELPER_PATH) - credential_loop($cred, $url, Nullable{String}($username)) + credential_loop($cred, $url, $username) end end @@ -2124,7 +2119,7 @@ mktempdir() do dir include($LIBGIT2_HELPER_PATH) payload = CredentialPayload(allow_prompt=false, allow_ssh_agent=true, allow_git_helpers=false) - credential_loop($valid_cred, $url, Nullable{String}($username), payload) + credential_loop($valid_cred, $url, $username, payload) end end @@ -2421,10 +2416,10 @@ mktempdir() do dir https_ex = quote include($LIBGIT2_HELPER_PATH) LibGit2.with(LibGit2.GitConfig($config_path, LibGit2.Consts.CONFIG_LEVEL_APP)) do cfg - payload = CredentialPayload(Nullable{AbstractCredential}(), - Nullable{CachedCredentials}(), cfg, + payload = CredentialPayload(nothing, + nothing, cfg, allow_git_helpers=true) - credential_loop($valid_cred, $url, Nullable{String}(), payload, shred=false) + credential_loop($valid_cred, $url, nothing, payload, shred=false) end end @@ -2448,7 +2443,7 @@ mktempdir() do dir include($LIBGIT2_HELPER_PATH) payload = CredentialPayload($valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop($valid_cred, "ssh://github.com/repo", Nullable(""), + credential_loop($valid_cred, "ssh://github.com/repo", Some(""), Cuint(LibGit2.Consts.CREDTYPE_SSH_KEY), payload) end @@ -2465,7 +2460,7 @@ mktempdir() do dir include($LIBGIT2_HELPER_PATH) payload = CredentialPayload($valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop($valid_cred, "https://github.com/repo", Nullable(""), + credential_loop($valid_cred, "https://github.com/repo", Some(""), Cuint(LibGit2.Consts.CREDTYPE_USERPASS_PLAINTEXT), payload) end @@ -2488,7 +2483,7 @@ mktempdir() do dir valid_cred = LibGit2.UserPasswordCredential("foo", "bar") payload = CredentialPayload(valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop(valid_cred, "foo://github.com/repo", Nullable(""), + credential_loop(valid_cred, "foo://github.com/repo", Some(""), $allowed_types, payload) end @@ -2510,7 +2505,7 @@ mktempdir() do dir ex = quote include($LIBGIT2_HELPER_PATH) valid_cred = LibGit2.UserPasswordCredential($valid_username, $valid_password) - user = Nullable{String}() + user = nothing payload = CredentialPayload(allow_git_helpers=false) first_result = credential_loop(valid_cred, $(urls[1]), user, payload) LibGit2.reset!(payload) diff --git a/test/misc.jl b/test/misc.jl index 8ee89c78102ee..84199a6ce063a 100644 --- a/test/misc.jl +++ b/test/misc.jl @@ -683,10 +683,10 @@ if Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0")))) Demo_20254(string.(arr)) end - _unsafe_get_19433(x::NTuple{1}) = (unsafe_get(x[1]),) - _unsafe_get_19433(xs::Vararg) = (unsafe_get(xs[1]), _unsafe_get_19433(xs[2:end])...) + _get(x::NTuple{1}) = (get(x[1]),) + _get_19433(xs::Vararg) = (get(xs[1]), _get_19433(xs[2:end])...) - f_19433(f_19433, xs...) = f_19433(_unsafe_get_19433(xs)...) + f_19433(f_19433, xs...) = f_19433(_get_19433(xs)...) @testset "test this does not crash, issue #19433 and #20254" begin @test_throws StackOverflowError Demo_20254() diff --git a/test/parse.jl b/test/parse.jl index 2792058e18237..9911f92a71c6b 100644 --- a/test/parse.jl +++ b/test/parse.jl @@ -59,15 +59,15 @@ for T in vcat(subtypes(Signed), subtypes(Unsigned)) # Test `tryparse_internal` with part of a string let b = " " - result = @test_throws ArgumentError get(Base.tryparse_internal(Bool, b, 7, 11, 0, true)) + result = @test_throws ArgumentError Base.tryparse_internal(Bool, b, 7, 11, 0, true) exception_bool = result.value @test exception_bool.msg == "input string only contains whitespace" - result = @test_throws ArgumentError get(Base.tryparse_internal(Int, b, 7, 11, 0, true)) + result = @test_throws ArgumentError Base.tryparse_internal(Int, b, 7, 11, 0, true) exception_int = result.value @test exception_int.msg == "input string is empty or only contains whitespace" - result = @test_throws ArgumentError get(Base.tryparse_internal(UInt128, b, 7, 11, 0, true)) + result = @test_throws ArgumentError Base.tryparse_internal(UInt128, b, 7, 11, 0, true) exception_uint = result.value @test exception_uint.msg == "input string is empty or only contains whitespace" end @@ -75,7 +75,7 @@ for T in vcat(subtypes(Signed), subtypes(Unsigned)) # Test that the entire input string appears in error messages let s = " false true " result = @test_throws(ArgumentError, - get(Base.tryparse_internal(Bool, s, start(s), endof(s), 0, true))) + Base.tryparse_internal(Bool, s, start(s), endof(s), 0, true)) @test result.value.msg == "invalid Bool representation: $(repr(s))" end @@ -212,8 +212,8 @@ end @test parse(Int, "2") === 2 @test parse(Bool, "true") === true @test parse(Bool, "false") === false -@test get(tryparse(Bool, "true")) === get(Nullable{Bool}(true)) -@test get(tryparse(Bool, "false")) === get(Nullable{Bool}(false)) +@test tryparse(Bool, "true") === Some(true) +@test tryparse(Bool, "false") === Some(false) @test_throws ArgumentError parse(Int, "2", 1) @test_throws ArgumentError parse(Int, "2", 63) @@ -225,9 +225,9 @@ end # error throwing branch from #10560 @test_throws ArgumentError Base.tryparse_internal(Bool, "foo", 1, 2, 10, true) -@test tryparse(Float64, "1.23") === Nullable(1.23) -@test tryparse(Float32, "1.23") === Nullable(1.23f0) -@test tryparse(Float16, "1.23") === Nullable(Float16(1.23)) +@test tryparse(Float64, "1.23") === Some(1.23) +@test tryparse(Float32, "1.23") === Some(1.23f0) +@test tryparse(Float16, "1.23") === Some(Float16(1.23)) # parsing complex numbers (#22250) @testset "complex parsing" begin diff --git a/test/reflection.jl b/test/reflection.jl index d471f005db531..24e3a781562df 100644 --- a/test/reflection.jl +++ b/test/reflection.jl @@ -580,35 +580,35 @@ function has_backslashes(mod::Module) continue end h = has_backslashes(f) - isnull(h) || return h + h === nothing || return h end - return Nullable{Method}() + return nothing end function has_backslashes(f::Function) for m in methods(f) h = has_backslashes(m) - isnull(h) || return h + h === nothing || return h end - return Nullable{Method}() + return nothing end function has_backslashes(meth::Method) if '\\' in string(meth.file) - return Nullable{Method}(meth) + return Some(meth) else - return Nullable{Method}() + return nothing end end -has_backslashes(x) = Nullable{Method}() +has_backslashes(x) = nothing h16850 = has_backslashes(Base) if Sys.iswindows() - if isnull(h16850) + if h16850 === nothing @warn """No methods found in Base with backslashes in file name, skipping test for `Base.url`""" else @test !('\\' in Base.url(get(h16850))) end else - @test isnull(h16850) + @test h16850 === nothing end # Adds test for PR #17636 diff --git a/test/serialize.jl b/test/serialize.jl index 770654007e41f..2f68f74fd9dbb 100644 --- a/test/serialize.jl +++ b/test/serialize.jl @@ -357,11 +357,17 @@ create_serialization_stream() do s # user-defined type array end # corner case: undefined inside immutable struct +struct MyNullable{T} + hasvalue::Bool + value::T + + MyNullable{T}() where {T} = new(false) +end create_serialization_stream() do s - serialize(s, Nullable{Any}()) + serialize(s, MyNullable{Any}()) seekstart(s) n = deserialize(s) - @test isa(n, Nullable) + @test isa(n, MyNullable) @test !isdefined(n, :value) end diff --git a/test/some.jl b/test/some.jl new file mode 100644 index 0000000000000..ced400855e8bd --- /dev/null +++ b/test/some.jl @@ -0,0 +1,64 @@ +# This file is a part of Julia. License is MIT: https://julialang.org/license + +## eltype() + +@test eltype(Some(1)) === Int + +## promote() + +@test promote_type(Some{Int}, Some{Float64}) === Some{Float64} + +## convert() + +# These conversions must fail to prevent ambiguities +# when a value to wrap is already a Some or a Void +@test_throws MethodError convert(Some, 1) +@test_throws MethodError convert(Union{Some, Void}, 1) +@test_throws MethodError convert(Some{Int}, 1) +@test_throws MethodError convert(Union{Some{Int}, Void}, 1) + +@test convert(Some, Some(1)) === convert(Union{Some, Void}, Some(1)) === Some(1) +@test convert(Some{Int}, Some(1)) === convert(Union{Some{Int}, Void}, Some(1)) === Some(1) +@test convert(Some{Int}, Some(1.0)) === Some(1) +@test convert(Union{Some{Int}, Void}, Some(1.0)) === Some(1) + +@test_throws MethodError convert(Some, nothing) +@test_throws MethodError convert(Some{Int}, nothing) + +@test convert(Some, Some(nothing)) === Some(nothing) +@test convert(Some{Void}, Some(nothing)) === Some(nothing) +@test convert(Some, Some(nothing)) === Some(nothing) +@test convert(Some{Void}, Some(nothing)) === Some(nothing) + +@test convert(Union{Some, Void}, nothing) === nothing +@test convert(Union{Some, Void}, nothing) === nothing +@test convert(Union{Some{Int}, Void}, nothing) === nothing + +@test convert(Union{Int, Void}, nothing) === nothing +@test convert(Union{Int, Void}, 1) === 1 +@test convert(Union{Int, Void}, 1.0) === 1 +@test convert(Void, nothing) === nothing +@test_throws MethodError convert(Void, 1) + +## show() + +@test sprint(show, Some(1)) == "Some(1)" +@test sprint(showcompact, Some(1)) == "1" +@test sprint(show, Some(Some(1))) == "Some(Some(1))" +@test sprint(showcompact, Some(Some(1))) == "1" + +## == and isequal nothing + +@test Some(1) != nothing +@test Some(nothing) != nothing +@test !isequal(Some(1), nothing) +@test !isequal(Some(nothing), nothing) + +## get() +@test get(Some(1)) === 1 +@test get(Some(nothing)) === nothing +@test_throws MethodError get(nothing) + +@test get(Some(1), 0) === 1 +@test get(Some(nothing), 0) === nothing +@test get(nothing, 0) === 0 diff --git a/test/spawn.jl b/test/spawn.jl index 93703cef90c44..08d85e362beba 100644 --- a/test/spawn.jl +++ b/test/spawn.jl @@ -458,7 +458,7 @@ if Sys.isunix() Base.link_pipe(p) push!(ps, p) end - if isnull(ulimit_n) + if ulimit_n === nothing @warn "`ulimit -n` is set to unlimited, fd exhaustion cannot be tested" @test_broken false else diff --git a/test/specificity.jl b/test/specificity.jl index ba58adb53bf7c..bc36a14553709 100644 --- a/test/specificity.jl +++ b/test/specificity.jl @@ -127,8 +127,8 @@ f17016(f, t1::Tuple) = 1 @test !args_morespecific(Tuple{Real, Real, Vararg{Real}}, Tuple{T, T, T} where T <: Real) @test args_morespecific(Tuple{Real, Real, Vararg{Int}}, Tuple{T, T, T} where T <: Real) -@test args_morespecific(Tuple{Type{Base.Nullable{T}}} where T, Tuple{Type{T}, Any} where T) -@test !args_morespecific(Tuple{Type{Base.Nullable{T}}, T} where T, Tuple{Type{Base.Nullable{T}}} where T) +@test args_morespecific(Tuple{Type{Base.Some{T}}} where T, Tuple{Type{T}, Any} where T) +@test !args_morespecific(Tuple{Type{Base.Some{T}}, T} where T, Tuple{Type{Base.Some{T}}} where T) @test args_morespecific(Tuple{Union{Base.StepRange{T, S} where S, Base.StepRangeLen{T, T, S} where S}, Union{Base.StepRange{T, S} where S, Base.StepRangeLen{T, T, S} where S}} where T, diff --git a/test/strings/basic.jl b/test/strings/basic.jl index 1203272b8a780..4d0abe8a6010b 100644 --- a/test/strings/basic.jl +++ b/test/strings/basic.jl @@ -254,7 +254,7 @@ end for T in [Int8, Int16, Int32, Int64, Int128] for i in [typemax(T), typemin(T)] f = "$(i)0" - @test isnull(tryparse(T, f)) + @test tryparse(T, f) === nothing end end end @@ -272,12 +272,12 @@ end @test typeof(unsafe_string(sp)) == String @test get(tryparse(BigInt, "1234567890")) == BigInt(1234567890) - @test isnull(tryparse(BigInt, "1234567890-")) + @test tryparse(BigInt, "1234567890-") === nothing @test get(tryparse(Float64, "64")) == 64.0 - @test isnull(tryparse(Float64, "64o")) + @test tryparse(Float64, "64o") === nothing @test get(tryparse(Float32, "32")) == 32.0f0 - @test isnull(tryparse(Float32, "32o")) + @test tryparse(Float32, "32o") === nothing end @testset "issue #10994: handle embedded NUL chars for string parsing" begin @@ -285,7 +285,7 @@ end @test_throws ArgumentError parse(T, "1\0") end for T in [BigInt, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, Float64, Float32] - @test isnull(tryparse(T, "1\0")) + @test tryparse(T, "1\0") === nothing end let s = Base.Unicode.normalize("tést",:NFKC) @test unsafe_string(Base.unsafe_convert(Cstring, Base.cconvert(Cstring, s))) == s From 605f01aff9669978a5a8dfcf8b4dcca41dc89cc2 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Thu, 9 Nov 2017 23:07:18 +0100 Subject: [PATCH 02/16] Use Union{T, Void} rather than Union{Some{T}, Void} where possible --- base/channels.jl | 10 +- base/deprecated.jl | 13 +- base/docs/Docs.jl | 12 +- base/int.jl | 6 +- base/libgit2/callbacks.jl | 37 +++--- base/libgit2/config.jl | 6 +- base/libgit2/index.jl | 4 +- base/libgit2/libgit2.jl | 36 +++--- base/libgit2/rebase.jl | 4 +- base/libgit2/reference.jl | 19 ++- base/libgit2/remote.jl | 9 +- base/libgit2/repository.jl | 10 +- base/libgit2/status.jl | 4 +- base/libgit2/types.jl | 70 +++++------ base/lock.jl | 10 +- base/methodshow.jl | 12 +- base/pkg/entry.jl | 8 +- base/pkg/pkg.jl | 4 +- base/process.jl | 26 ++-- base/repl/REPLCompletions.jl | 2 +- base/socket.jl | 2 +- base/stream.jl | 12 +- base/threadcall.jl | 8 +- base/util.jl | 8 +- doc/src/manual/parallel-computing.md | 24 ++-- doc/src/manual/stacktraces.md | 4 +- examples/clustermanager/0mq/ZMQCM.jl | 18 +-- .../clustermanager/simple/UnixDomainCM.jl | 14 +-- stdlib/Dates/src/types.jl | 16 +-- stdlib/Distributed/src/cluster.jl | 114 +++++++++--------- stdlib/Distributed/src/managers.jl | 65 +++++----- stdlib/Distributed/src/messages.jl | 2 +- stdlib/Distributed/src/process_messages.jl | 12 +- stdlib/Distributed/src/remotecall.jl | 9 +- stdlib/Distributed/src/workerpool.jl | 8 +- stdlib/Distributed/test/distributed_exec.jl | 16 ++- stdlib/Distributed/test/topology.jl | 12 +- test/libgit2-helpers.jl | 13 +- test/libgit2.jl | 36 +++--- test/reflection.jl | 2 +- 40 files changed, 342 insertions(+), 355 deletions(-) diff --git a/base/channels.jl b/base/channels.jl index cb445b0b67348..4e40177cf1c82 100644 --- a/base/channels.jl +++ b/base/channels.jl @@ -21,7 +21,7 @@ mutable struct Channel{T} <: AbstractChannel cond_take::Condition # waiting for data to become available cond_put::Condition # waiting for a writeable slot state::Symbol - excp::Union{Some{<:Exception}, Void} # Exception to be thrown when state != :open + excp::Union{Exception, Void} # exception to be thrown when state != :open data::Vector{T} sz_max::Int # maximum size of channel @@ -129,7 +129,7 @@ isbuffered(c::Channel) = c.sz_max==0 ? false : true function check_channel_state(c::Channel) if !isopen(c) - c.excp !== nothing && throw(get(c.excp)) + c.excp !== nothing && throw(c.excp) throw(closed_exception()) end end @@ -143,7 +143,7 @@ Close a channel. An exception is thrown by: """ function close(c::Channel) c.state = :closed - c.excp = Some(closed_exception()) + c.excp = closed_exception() notify_error(c) nothing end @@ -237,7 +237,7 @@ function close_chnl_on_taskdone(t::Task, ref::WeakRef) !isopen(c) && return if istaskfailed(t) c.state = :closed - c.excp = Some(task_result(t)) + c.excp = task_result(t) notify_error(c) else close(c) @@ -387,7 +387,7 @@ function notify_error(c::Channel, err) foreach(t->schedule(t, err; error=true), waiters) end end -notify_error(c::Channel) = notify_error(c, get(c.excp)) +notify_error(c::Channel) = notify_error(c, c.excp) eltype(::Type{Channel{T}}) where {T} = T diff --git a/base/deprecated.jl b/base/deprecated.jl index 28d009bece659..c9639b3206ba0 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -1512,8 +1512,9 @@ end function prompt(msg::AbstractString; default::AbstractString="", password::Bool=false) Base.depwarn(string( "`LibGit2.prompt(msg::AbstractString; default::AbstractString=\"\", password::Bool=false)` is deprecated, use ", - "`get(Base.prompt(msg, default=default, password=password), \"\")` instead."), :prompt) - Base.get(Base.prompt(msg, default=default, password=password), "") + "`result = Base.prompt(msg, default=default, password=password); result === nothing ? \"\" : result` instead."), :prompt) + result = Base.prompt(msg, default=default, password=password) + result === nothing ? "" : result end end @@ -1658,10 +1659,10 @@ import .Iterators.enumerate # PR #23640 # when this deprecation is deleted, remove all calls to it, and replace all keywords of: -# `payload::Union{CredentialPayload, Union{Some{<:Union{AbstractCredential, CachedCredentials}}, Void}}` +# `payload::Union{CredentialPayload, AbstractCredential, CachedCredentials, Void}` # with `payload::CredentialPayload` from base/libgit2/libgit2.jl @eval LibGit2 function deprecate_nullable_creds(f, sig, payload) - if isa(payload, Union{Some{<:Union{AbstractCredential, CachedCredentials}}, Void}) + if isa(payload, Union{AbstractCredential, CachedCredentials, Void}) # Note: Be careful not to show the contents of the credentials as it could reveal a # password. if payload === nothing @@ -1669,9 +1670,9 @@ import .Iterators.enumerate msg *= "LibGit2.$f($sig; payload=LibGit2.CredentialPayload()) instead." p = CredentialPayload() else - cred = get(payload) + cred = payload C = typeof(cred) - msg = "LibGit2.$f($sig; payload=Some($C(...))) is deprecated, use " + msg = "LibGit2.$f($sig; payload=$C(...)) is deprecated, use " msg *= "LibGit2.$f($sig; payload=LibGit2.CredentialPayload($C(...))) instead." p = CredentialPayload(cred) end diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl index 410bb7a79fcb0..835fb858704cc 100644 --- a/base/docs/Docs.jl +++ b/base/docs/Docs.jl @@ -142,7 +142,7 @@ linenumber, source code, and fielddocs. """ mutable struct DocStr text :: Core.SimpleVector - object :: Union{Some{<:Any}, Void} + object :: Any data :: Dict{Symbol, Any} end @@ -160,9 +160,9 @@ function docstr(binding::Binding, @nospecialize typesig = Union{}) end docstr(object, data = Dict()) = _docstr(object, data) -_docstr(vec::Core.SimpleVector, data) = DocStr(vec, nothing, data) -_docstr(str::AbstractString, data) = DocStr(Core.svec(str), nothing, data) -_docstr(object, data) = DocStr(Core.svec(), Some(object), data) +_docstr(vec::Core.SimpleVector, data) = DocStr(vec, nothing, data) +_docstr(str::AbstractString, data) = DocStr(Core.svec(str), nothing, data) +_docstr(object, data) = DocStr(Core.svec(), object, data) _docstr(doc::DocStr, data) = (doc.data = merge(data, doc.data); doc) @@ -188,9 +188,9 @@ function parsedoc(d::DocStr) md = formatdoc(d) md.meta[:module] = d.data[:module] md.meta[:path] = d.data[:path] - d.object = Some(md) + d.object = md end - get(d.object) + d.object end """ diff --git a/base/int.jl b/base/int.jl index 83053f64a5fb0..eacfa07acd486 100644 --- a/base/int.jl +++ b/base/int.jl @@ -603,12 +603,12 @@ macro big_str(s) print(bf, s[end]) seekstart(bf) n = tryparse(BigInt, String(take!(bf))) - n !== nothing && return get(n) + n === nothing || return get(n) else n = tryparse(BigInt, s) - n !== nothing && return get(n) + n === nothing || return get(n) n = tryparse(BigFloat, s) - n !== nothing && return get(n) + n === nothing || return get(n) end message = "invalid number format $s for BigInt or BigFloat" return :(throw(ArgumentError($message))) diff --git a/base/libgit2/callbacks.jl b/base/libgit2/callbacks.jl index 09fc529b58306..9c540822ff43e 100644 --- a/base/libgit2/callbacks.jl +++ b/base/libgit2/callbacks.jl @@ -62,7 +62,7 @@ function exhausted_abort() end function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, username_ptr) - cred = Base.get(p.credential)::SSHCredential + cred = p.credential::SSHCredential revised = false # Use a filled credential as-is on the first pass. Reset password on sucessive calls. @@ -115,7 +115,7 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, url = git_url(scheme=p.scheme, host=p.host) response = Base.prompt("Username for '$url'", default=cred.user) response === nothing && return user_abort() - cred.user = Base.get(response) + cred.user = response end url = git_url(scheme=p.scheme, host=p.host, username=cred.user) @@ -125,7 +125,7 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, if !isfile(cred.prvkey) || !revised || !haskey(ENV, "SSH_KEY_PATH") response = Base.prompt("Private key location for '$url'", default=cred.prvkey) response === nothing && return user_abort() - cred.prvkey = expanduser(Base.get(response)) + cred.prvkey = expanduser(response) # Only update the public key if the private key changed if cred.prvkey != last_private_key @@ -139,7 +139,7 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, if isfile(cred.prvkey) && (stale || !isfile(cred.pubkey)) response = Base.prompt("Public key location for '$url'", default=cred.pubkey) response === nothing && return user_abort() - cred.pubkey = expanduser(Base.get(response)) + cred.pubkey = expanduser(response) end # Ask for a passphrase when the private key exists and requires a passphrase @@ -149,11 +149,11 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, "Your SSH Key requires a password, please enter it now:", "Passphrase required", cred.prvkey; prompt_username=false) response === nothing && return user_abort() - cred.pass = Base.get(response)[2] + cred.pass = response[2] else response = Base.prompt("Passphrase for $(cred.prvkey)", password=true) response === nothing && return user_abort() - cred.pass = Base.get(response) + cred.pass = response isempty(cred.pass) && return user_abort() # Ambiguous if EOF or newline end end @@ -174,7 +174,7 @@ function authenticate_ssh(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload, end function authenticate_userpass(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayload) - cred = Base.get(p.credential)::UserPasswordCredential + cred = p.credential::UserPasswordCredential revised = false # Use a filled credential as-is on the first pass. Reset password on sucessive calls. @@ -204,16 +204,16 @@ function authenticate_userpass(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayl "Please enter your credentials for '$url'", "Credentials required", username; prompt_username=true) response === nothing && return user_abort() - cred.user, cred.pass = Base.get(response) + cred.user, cred.pass = response else response = Base.prompt("Username for '$url'", default=username) response === nothing && return user_abort() - cred.user = Base.get(response) + cred.user = response url = git_url(scheme=p.scheme, host=p.host, username=cred.user) response = Base.prompt("Password for '$url'", password=true) response === nothing && return user_abort() - cred.pass = Base.get(response) + cred.pass = response isempty(cred.pass) && return user_abort() # Ambiguous if EOF or newline end @@ -283,10 +283,10 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, # modification only is in effect for the first callback since `allowed_types` cannot # be mutated. if p.explicit !== nothing - cred = Base.get(p.explicit) + cred = p.explicit # Copy explicit credentials to avoid mutating approved credentials. - p.credential = Some(deepcopy(cred)) + p.credential = deepcopy(cred) if isa(cred, SSHCredential) allowed_types &= Cuint(Consts.CREDTYPE_SSH_KEY) @@ -296,12 +296,11 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, allowed_types &= Cuint(0) # Unhandled credential type end elseif p.cache !== nothing - cache = Base.get(p.cache) cred_id = credential_identifier(p.scheme, p.host) # Perform a deepcopy as we do not want to mutate approved cached credentials - if haskey(cache, cred_id) - p.credential = Some(deepcopy(cache[cred_id])) + if haskey(p.cache, cred_id) + p.credential = deepcopy(p.cache[cred_id]) end end @@ -312,16 +311,16 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, # use ssh key or ssh-agent if isset(allowed_types, Cuint(Consts.CREDTYPE_SSH_KEY)) - if p.credential === nothing || !isa(Base.get(p.credential), SSHCredential) - p.credential = Some(SSHCredential(p.username)) + if p.credential === nothing || !isa(p.credential, SSHCredential) + p.credential = SSHCredential(p.username) end err = authenticate_ssh(libgit2credptr, p, username_ptr) err == 0 && return err end if isset(allowed_types, Cuint(Consts.CREDTYPE_USERPASS_PLAINTEXT)) - if p.credential === nothing || !isa(Base.get(p.credential), UserPasswordCredential) - p.credential = Some(UserPasswordCredential(p.username)) + if p.credential === nothing || !isa(p.credential, UserPasswordCredential) + p.credential = UserPasswordCredential(p.username) end err = authenticate_userpass(libgit2credptr, p) err == 0 && return err diff --git a/base/libgit2/config.jl b/base/libgit2/config.jl index 1e515eac44104..867890bb4655c 100644 --- a/base/libgit2/config.jl +++ b/base/libgit2/config.jl @@ -197,7 +197,7 @@ function Base.start(ci::GitConfigIter) err = ccall((:git_config_next, :libgit2), Cint, (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr) if err == Cint(Error.GIT_OK) - state = Some(unsafe_load(entry_ptr_ptr[])) + state = unsafe_load(entry_ptr_ptr[]) elseif err == Cint(Error.ITEROVER) state = nothing else @@ -209,12 +209,12 @@ end Base.done(ci::GitConfigIter, state) = state === nothing function Base.next(ci::GitConfigIter, state) - entry = Base.get(state) + entry = state entry_ptr_ptr = Ref{Ptr{ConfigEntry}}(C_NULL) err = ccall((:git_config_next, :libgit2), Cint, (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr) if err == Cint(Error.GIT_OK) - state = Some(unsafe_load(entry_ptr_ptr[])) + state = unsafe_load(entry_ptr_ptr[]) elseif err == Cint(Error.ITEROVER) state = nothing else diff --git a/base/libgit2/index.jl b/base/libgit2/index.jl index e4982e7024535..378e8ceae3897 100644 --- a/base/libgit2/index.jl +++ b/base/libgit2/index.jl @@ -56,7 +56,7 @@ function repository(idx::GitIndex) if idx.owner === nothing throw(GitError(Error.Index, Error.ENOTFOUND, "Index does not have an owning repository.")) else - return Base.get(idx.owner) + return idx.owner end end @@ -183,7 +183,7 @@ function Base.find(path::String, idx::GitIndex) ret = ccall((:git_index_find, :libgit2), Cint, (Ref{Csize_t}, Ptr{Void}, Cstring), pos_ref, idx.ptr, path) ret == Cint(Error.ENOTFOUND) && return nothing - return Some(pos_ref[]+1) + return pos_ref[]+1 end """ diff --git a/base/libgit2/libgit2.jl b/base/libgit2/libgit2.jl index b8c60983c3582..617dc3e128dda 100644 --- a/base/libgit2/libgit2.jl +++ b/base/libgit2/libgit2.jl @@ -262,7 +262,7 @@ Equivalent to `git fetch [|] []`. function fetch(repo::GitRepo; remote::AbstractString="origin", remoteurl::AbstractString="", refspecs::Vector{<:AbstractString}=AbstractString[], - payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) + payload::Union{CredentialPayload, AbstractCredential, CachedCredentials, Void}=CredentialPayload()) p = reset!(deprecate_nullable_creds(:fetch, "repo", payload), GitConfig(repo)) rmt = if isempty(remoteurl) get(GitRemote, repo, remote) @@ -304,7 +304,7 @@ function push(repo::GitRepo; remote::AbstractString="origin", remoteurl::AbstractString="", refspecs::Vector{<:AbstractString}=AbstractString[], force::Bool=false, - payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) + payload::Union{CredentialPayload, AbstractCredential, CachedCredentials, Void}=CredentialPayload()) p = reset!(deprecate_nullable_creds(:push, "repo", payload), GitConfig(repo)) rmt = if isempty(remoteurl) get(GitRemote, repo, remote) @@ -384,10 +384,10 @@ function branch!(repo::GitRepo, branch_name::AbstractString, end end else - tmpcmt = with(peel(GitCommit, Base.get(branch_rmt_ref))) do hrc + tmpcmt = with(peel(GitCommit, branch_rmt_ref)) do hrc GitHash(hrc) end - close(Base.get(branch_rmt_ref)) + close(branch_rmt_ref) tmpcmt end else @@ -397,7 +397,7 @@ function branch!(repo::GitRepo, branch_name::AbstractString, cmt = GitCommit(repo, commit_id) new_branch_ref = nothing try - new_branch_ref = Some(create_branch(repo, branch_name, cmt, force=force)) + new_branch_ref = create_branch(repo, branch_name, cmt, force=force) finally close(cmt) new_branch_ref === nothing && throw(GitError(Error.Object, Error.ERROR, "cannot create branch `$branch_name` with `$commit_id`")) @@ -410,7 +410,7 @@ function branch!(repo::GitRepo, branch_name::AbstractString, try with(GitConfig, repo) do cfg set!(cfg, "branch.$branch_name.remote", Consts.REMOTE_ORIGIN) - set!(cfg, "branch.$branch_name.merge", name(Base.get(branch_ref))) + set!(cfg, "branch.$branch_name.merge", name(branch_ref)) end catch @warn "Please provide remote tracking for branch '$branch_name' in '$(path(repo))'" @@ -419,15 +419,15 @@ function branch!(repo::GitRepo, branch_name::AbstractString, if set_head # checkout selected branch - with(peel(GitTree, Base.get(branch_ref))) do btree + with(peel(GitTree, branch_ref)) do btree checkout_tree(repo, btree) end # switch head to the branch - head!(repo, Base.get(branch_ref)) + head!(repo, branch_ref) end finally - close(Base.get(branch_ref)) + close(branch_ref) end return end @@ -520,7 +520,7 @@ function clone(repo_url::AbstractString, repo_path::AbstractString; branch::AbstractString="", isbare::Bool = false, remote_cb::Ptr{Void} = C_NULL, - payload::Union{CredentialPayload, Some{<:Union{AbstractCredential, CachedCredentials}}, Void}=CredentialPayload()) + payload::Union{CredentialPayload, AbstractCredential, CachedCredentials, Void}=CredentialPayload()) # setup clone options lbranch = Base.cconvert(Cstring, branch) @Base.gc_preserve lbranch begin @@ -549,7 +549,7 @@ end function reset!(repo::GitRepo, committish::AbstractString, pathspecs::AbstractString...) obj = GitObject(repo, isempty(committish) ? Consts.HEAD_FILE : committish) # do not remove entries in the index matching the provided pathspecs with empty target commit tree - reset!(repo, Some(obj), pathspecs...) + reset!(repo, obj, pathspecs...) end """ @@ -726,9 +726,9 @@ function merge!(repo::GitRepo; "There is no tracking information for the current branch.")) end try - [GitAnnotated(repo, Base.get(tr_brn_ref))] + [GitAnnotated(repo, tr_brn_ref)] finally - close(Base.get(tr_brn_ref)) + close(tr_brn_ref) end end end @@ -770,14 +770,14 @@ function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractSt "There is no tracking information for the current branch.")) end try - GitAnnotated(repo, Base.get(brn_ref)) + GitAnnotated(repo, brn_ref) finally close(brn_ref) end else GitAnnotated(repo, upstream) end - onto_ann = isempty(newbase) ? nothing : Some(GitAnnotated(repo, newbase)) + onto_ann = isempty(newbase) ? nothing : GitAnnotated(repo, newbase) try sig = default_signature(repo) try @@ -794,12 +794,12 @@ function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractSt close(rbs) end finally - #onto_ann !== nothing && close(get(onto_ann)) + #onto_ann !== nothing && close(onto_ann) close(sig) end finally if !isempty(newbase) - close(Base.get(onto_ann)) + close(onto_ann) end close(upst_ann) close(head_ann) @@ -885,7 +885,7 @@ function restore(s::State, repo::GitRepo) opts = CheckoutOptions( checkout_strategy = Consts.CHECKOUT_FORCE | # check the index out to work Consts.CHECKOUT_REMOVE_UNTRACKED) # remove everything else - checkout_index(repo, Some(idx), options = opts) + checkout_index(repo, idx, options = opts) read_tree!(idx, s.index) # restore index end diff --git a/base/libgit2/rebase.jl b/base/libgit2/rebase.jl index 3a262fcaa6dfd..030db04fef6d0 100644 --- a/base/libgit2/rebase.jl +++ b/base/libgit2/rebase.jl @@ -1,14 +1,14 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license function GitRebase(repo::GitRepo, branch::GitAnnotated, upstream::GitAnnotated; - onto::Union{Some{GitAnnotated}, Void}=nothing, + onto::Union{GitAnnotated, Void}=nothing, opts::RebaseOptions = RebaseOptions()) rebase_ptr_ptr = Ref{Ptr{Void}}(C_NULL) @check ccall((:git_rebase_init, :libgit2), Cint, (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{RebaseOptions}), rebase_ptr_ptr, repo.ptr, branch.ptr, upstream.ptr, - onto === nothing ? C_NULL : Base.get(onto).ptr, Ref(opts)) + onto === nothing ? C_NULL : onto.ptr, Ref(opts)) return GitRebase(repo, rebase_ptr_ptr[]) end diff --git a/base/libgit2/reference.jl b/base/libgit2/reference.jl index da3da75272f05..af59f722fdaee 100644 --- a/base/libgit2/reference.jl +++ b/base/libgit2/reference.jl @@ -247,15 +247,14 @@ function head!(repo::GitRepo, ref::GitReference) end """ - lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{Some{GitReference}, Void} + lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{GitReference, Void} Determine if the branch specified by `branch_name` exists in the repository `repo`. If `remote` is `true`, `repo` is assumed to be a remote git repository. Otherwise, it is part of the local filesystem. -Return either a [`Some`](@ref) object, or [`nothing`](@ref) if -the requested branch does not exist yet. If the branch does exist, the `Some` wrapper -contains a `GitReference` to the branch. +Return either a `GitReference` to the requested branch +if it exists, or [`nothing`](@ref) if not. """ function lookup_branch(repo::GitRepo, branch_name::AbstractString, @@ -274,18 +273,16 @@ function lookup_branch(repo::GitRepo, end throw(Error.GitError(err)) end - return Some(GitReference(repo, ref_ptr_ptr[])) + return GitReference(repo, ref_ptr_ptr[]) end """ - upstream(ref::GitReference) -> Union{Some{GitReference}, Void} + upstream(ref::GitReference) -> Union{GitReference, Void} Determine if the branch containing `ref` has a specified upstream branch. -Return either a [`Some`](@ref) object, or [`nothing`](@ref) if -the requested branch does not have an upstream counterpart. If -the upstream branch does exist, the `Some` wrapper -contains a `GitReference` to the upstream branch. +Return either a `GitReference` to the upstream branch if it exists, +or [`nothing`](@ref) if the requested branch does not have an upstream counterpart. """ function upstream(ref::GitReference) isempty(ref) && return nothing @@ -301,7 +298,7 @@ function upstream(ref::GitReference) end throw(Error.GitError(err)) end - return Some(GitReference(ref.owner, ref_ptr_ptr[])) + return GitReference(ref.owner, ref_ptr_ptr[]) end repository(ref::GitReference) = ref.owner diff --git a/base/libgit2/remote.jl b/base/libgit2/remote.jl index 717aa70360d17..a03a5a0eb1799 100644 --- a/base/libgit2/remote.jl +++ b/base/libgit2/remote.jl @@ -61,12 +61,11 @@ function GitRemoteAnon(repo::GitRepo, url::AbstractString) end """ - lookup_remote(repo::GitRepo, remote_name::AbstractString) -> Union{Some{GitRemote}, Void} + lookup_remote(repo::GitRepo, remote_name::AbstractString) -> Union{GitRemote, Void} Determine if the `remote_name` specified exists within the `repo`. Return -either a [`Some`](@ref) object, or [`nothing`](@ref) if the requested remote -does not exist. If the remote does exist, the `Some` wrapper -contains a [`GitRemote`](@ref) to the remote name. +either a [`GitRemote`](@ref) to the remote name if it exists, or [`nothing`](@ref) +if not. # Examples ```julia @@ -81,7 +80,7 @@ function lookup_remote(repo::GitRepo, remote_name::AbstractString) (Ptr{Ptr{Void}}, Ptr{Void}, Cstring), rmt_ptr_ptr, repo.ptr, remote_name) if err == Int(Error.GIT_OK) - return Some(GitRemote(repo, rmt_ptr_ptr[])) + return GitRemote(repo, rmt_ptr_ptr[]) elseif err == Int(Error.ENOTFOUND) return nothing else diff --git a/base/libgit2/repository.jl b/base/libgit2/repository.jl index 5c6491f5caac1..6a00beb80ec43 100644 --- a/base/libgit2/repository.jl +++ b/base/libgit2/repository.jl @@ -336,18 +336,18 @@ function checkout_tree(repo::GitRepo, obj::GitObject; end """ - checkout_index(repo::GitRepo, idx::Union{Some{GitIndex}, Void} = nothing; options::CheckoutOptions = CheckoutOptions()) + checkout_index(repo::GitRepo, idx::Union{GitIndex, Void} = nothing; options::CheckoutOptions = CheckoutOptions()) Update the working tree of `repo` to match the index `idx`. If `idx` is `nothing`, the index of `repo` will be used. `options` controls how the checkout will be performed. See [`CheckoutOptions`](@ref) for more information. """ -function checkout_index(repo::GitRepo, idx::Union{Some{GitIndex}, Void} = nothing; +function checkout_index(repo::GitRepo, idx::Union{GitIndex, Void} = nothing; options::CheckoutOptions = CheckoutOptions()) @check ccall((:git_checkout_index, :libgit2), Cint, (Ptr{Void}, Ptr{Void}, Ptr{CheckoutOptions}), repo.ptr, - idx === nothing ? C_NULL : Base.get(idx).ptr, + idx === nothing ? C_NULL : idx.ptr, Ref(options)) end @@ -385,11 +385,11 @@ function cherrypick(repo::GitRepo, commit::GitCommit; options::CherrypickOptions end """Updates some entries, determined by the `pathspecs`, in the index from the target commit tree.""" -function reset!(repo::GitRepo, obj::Union{Some{<:GitObject}, Void}, pathspecs::AbstractString...) +function reset!(repo::GitRepo, obj::Union{GitObject, Void}, pathspecs::AbstractString...) @check ccall((:git_reset_default, :libgit2), Cint, (Ptr{Void}, Ptr{Void}, Ptr{StrArrayStruct}), repo.ptr, - obj === nothing ? C_NULL : Base.get(obj).ptr, + obj === nothing ? C_NULL : obj.ptr, collect(pathspecs)) return head_oid(repo) end diff --git a/base/libgit2/status.jl b/base/libgit2/status.jl index 4b70aacd439ae..f31b643139ca6 100644 --- a/base/libgit2/status.jl +++ b/base/libgit2/status.jl @@ -36,7 +36,7 @@ function Base.getindex(status::GitStatus, i::Integer) end """ - LibGit2.status(repo::GitRepo, path::String) + LibGit2.status(repo::GitRepo, path::String) -> Union{Cuint, Void} Lookup the status of the file at `path` in the git repository `repo`. For instance, this can be used @@ -49,5 +49,5 @@ function status(repo::GitRepo, path::String) (Ref{Cuint}, Ptr{Void}, Cstring), status_ptr, repo.ptr, path) (ret == Cint(Error.ENOTFOUND) || ret == Cint(Error.EAMBIGUOUS)) && return nothing - return Some(status_ptr[]) + return status_ptr[] end diff --git a/base/libgit2/types.jl b/base/libgit2/types.jl index 8df04c4f19af4..91d6d293e80d0 100644 --- a/base/libgit2/types.jl +++ b/base/libgit2/types.jl @@ -911,27 +911,27 @@ Base.isempty(obj::AbstractGitObject) = (obj.ptr == C_NULL) abstract type GitObject <: AbstractGitObject end for (typ, owntyp, sup, cname) in [ - (:GitRepo, nothing, :AbstractGitObject, :git_repository), - (:GitConfig, :(Union{Some{GitRepo}, Void}), :AbstractGitObject, :git_config), - (:GitIndex, :(Union{Some{GitRepo}, Void}), :AbstractGitObject, :git_index), - (:GitRemote, :GitRepo, :AbstractGitObject, :git_remote), - (:GitRevWalker, :GitRepo, :AbstractGitObject, :git_revwalk), - (:GitReference, :GitRepo, :AbstractGitObject, :git_reference), - (:GitDescribeResult, :GitRepo, :AbstractGitObject, :git_describe_result), - (:GitDiff, :GitRepo, :AbstractGitObject, :git_diff), - (:GitDiffStats, :GitRepo, :AbstractGitObject, :git_diff_stats), - (:GitAnnotated, :GitRepo, :AbstractGitObject, :git_annotated_commit), - (:GitRebase, :GitRepo, :AbstractGitObject, :git_rebase), - (:GitBlame, :GitRepo, :AbstractGitObject, :git_blame), - (:GitStatus, :GitRepo, :AbstractGitObject, :git_status_list), - (:GitBranchIter, :GitRepo, :AbstractGitObject, :git_branch_iterator), - (:GitConfigIter, nothing, :AbstractGitObject, :git_config_iterator), - (:GitUnknownObject, :GitRepo, :GitObject, :git_object), - (:GitCommit, :GitRepo, :GitObject, :git_commit), - (:GitBlob, :GitRepo, :GitObject, :git_blob), - (:GitTree, :GitRepo, :GitObject, :git_tree), - (:GitTag, :GitRepo, :GitObject, :git_tag), - (:GitTreeEntry, :GitTree, :AbstractGitObject, :git_tree_entry), + (:GitRepo, nothing, :AbstractGitObject, :git_repository), + (:GitConfig, :(Union{GitRepo, Void}), :AbstractGitObject, :git_config), + (:GitIndex, :(Union{GitRepo, Void}), :AbstractGitObject, :git_index), + (:GitRemote, :GitRepo, :AbstractGitObject, :git_remote), + (:GitRevWalker, :GitRepo, :AbstractGitObject, :git_revwalk), + (:GitReference, :GitRepo, :AbstractGitObject, :git_reference), + (:GitDescribeResult, :GitRepo, :AbstractGitObject, :git_describe_result), + (:GitDiff, :GitRepo, :AbstractGitObject, :git_diff), + (:GitDiffStats, :GitRepo, :AbstractGitObject, :git_diff_stats), + (:GitAnnotated, :GitRepo, :AbstractGitObject, :git_annotated_commit), + (:GitRebase, :GitRepo, :AbstractGitObject, :git_rebase), + (:GitBlame, :GitRepo, :AbstractGitObject, :git_blame), + (:GitStatus, :GitRepo, :AbstractGitObject, :git_status_list), + (:GitBranchIter, :GitRepo, :AbstractGitObject, :git_branch_iterator), + (:GitConfigIter, nothing, :AbstractGitObject, :git_config_iterator), + (:GitUnknownObject, :GitRepo, :GitObject, :git_object), + (:GitCommit, :GitRepo, :GitObject, :git_commit), + (:GitBlob, :GitRepo, :GitObject, :git_blob), + (:GitTree, :GitRepo, :GitObject, :git_tree), + (:GitTag, :GitRepo, :GitObject, :git_tag), + (:GitTreeEntry, :GitTree, :AbstractGitObject, :git_tree_entry), ] if owntyp === nothing @@ -963,11 +963,9 @@ for (typ, owntyp, sup, cname) in [ return obj end end - if isa(owntyp, Expr) && owntyp.args[1] == :Union && owntyp.args[2].args[1] == :Some + if isa(owntyp, Expr) && owntyp.args[1] == :Union && owntyp.args[3] == :Void @eval begin $typ(ptr::Ptr{Void}, fin::Bool=true) = $typ(nothing, ptr, fin) - $typ(owner::$(owntyp.args[2].args[2]), ptr::Ptr{Void}, fin::Bool=true) = - $typ(Some(owner), ptr, fin) end end end @@ -1251,8 +1249,8 @@ A `CredentialPayload` instance is expected to be `reset!` whenever it will be us different URL. """ mutable struct CredentialPayload <: Payload - explicit::Union{Some{<:AbstractCredential}, Void} - cache::Union{Some{CachedCredentials}, Void} + explicit::Union{AbstractCredential, Void} + cache::Union{CachedCredentials, Void} allow_ssh_agent::Bool # Allow the use of the SSH agent to get credentials allow_git_helpers::Bool # Allow the use of git credential helpers allow_prompt::Bool # Allow prompting the user for credentials @@ -1260,7 +1258,7 @@ mutable struct CredentialPayload <: Payload config::GitConfig # Ephemeral state fields - credential::Union{Some{<:AbstractCredential}, Void} + credential::Union{AbstractCredential, Void} first_pass::Bool use_ssh_agent::Bool use_env::Bool @@ -1273,8 +1271,8 @@ mutable struct CredentialPayload <: Payload host::String function CredentialPayload( - credential::Union{Some{<:AbstractCredential}, Void}=nothing, - cache::Union{Some{CachedCredentials}, Void}=nothing, + credential::Union{AbstractCredential, Void}=nothing, + cache::Union{CachedCredentials, Void}=nothing, config::GitConfig=GitConfig(); allow_ssh_agent::Bool=true, allow_git_helpers::Bool=true, @@ -1286,11 +1284,11 @@ mutable struct CredentialPayload <: Payload end function CredentialPayload(credential::AbstractCredential; kwargs...) - CredentialPayload(Some(credential), nothing; kwargs...) + CredentialPayload(credential, nothing; kwargs...) end function CredentialPayload(cache::CachedCredentials; kwargs...) - CredentialPayload(nothing, Some(cache); kwargs...) + CredentialPayload(nothing, cache; kwargs...) end """ @@ -1326,14 +1324,13 @@ should be destroyed. Should only be set to `false` during testing. """ function approve(p::CredentialPayload; shred::Bool=true) p.credential === nothing && return # No credentials were used - cred = Base.get(p.credential) if p.cache !== nothing - approve(Base.get(p.cache), cred, p.url) + approve(p.cache, cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers - approve(p.config, cred, p.url) + approve(p.config, p.credential, p.url) end shred && securezero!(cred) @@ -1351,14 +1348,13 @@ should be destroyed. Should only be set to `false` during testing. """ function reject(p::CredentialPayload; shred::Bool=true) p.credential === nothing && return # No credentials were used - cred = Base.get(p.credential) if p.cache !== nothing - reject(Base.get(p.cache), cred, p.url) + reject(p.cache, cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers - reject(p.config, cred, p.url) + reject(p.config, p.credential, p.url) end shred && securezero!(cred) diff --git a/base/lock.jl b/base/lock.jl index 55bc2f669040d..94e49797c1976 100644 --- a/base/lock.jl +++ b/base/lock.jl @@ -11,7 +11,7 @@ Each `lock` must be matched with an `unlock`. This lock is NOT threadsafe. See `Threads.Mutex` for a threadsafe lock. """ mutable struct ReentrantLock - locked_by::Union{Some{Task}, Void} + locked_by::Union{Task, Void} cond_wait::Condition reentrancy_cnt::Int @@ -41,10 +41,10 @@ Each successful `trylock` must be matched by an `unlock`. function trylock(rl::ReentrantLock) t = current_task() if rl.reentrancy_cnt == 0 - rl.locked_by = Some(t) + rl.locked_by = t rl.reentrancy_cnt = 1 return true - elseif t == get(rl.locked_by) + elseif t == rl.locked_by rl.reentrancy_cnt += 1 return true end @@ -64,10 +64,10 @@ function lock(rl::ReentrantLock) t = current_task() while true if rl.reentrancy_cnt == 0 - rl.locked_by = Some(t) + rl.locked_by = t rl.reentrancy_cnt = 1 return - elseif t == get(rl.locked_by) + elseif t == rl.locked_by rl.reentrancy_cnt += 1 return end diff --git a/base/methodshow.jl b/base/methodshow.jl index ca56c439dfd5c..35bae1f1671a0 100644 --- a/base/methodshow.jl +++ b/base/methodshow.jl @@ -102,7 +102,7 @@ function show_method_params(io::IO, tv) end end -function show(io::IO, m::Method; kwtype::Union{Some{DataType}, Void}=nothing) +function show(io::IO, m::Method; kwtype::Union{DataType, Void}=nothing) tv, decls, file, line = arg_decl_parts(m) sig = unwrap_unionall(m.sig) ft0 = sig.parameters[1] @@ -130,7 +130,7 @@ function show(io::IO, m::Method; kwtype::Union{Some{DataType}, Void}=nothing) join(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2] for d in decls[2:end]], ", ", ", ") if kwtype !== nothing - kwargs = kwarg_decl(m, get(kwtype)) + kwargs = kwarg_decl(m, kwtype) if !isempty(kwargs) print(io, "; ") join(io, kwargs, ", ", ", ") @@ -157,7 +157,7 @@ function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=tru what = startswith(ns, '@') ? "macro" : "generic function" print(io, "# $n $m for ", what, " \"", ns, "\":") end - kwtype = isdefined(mt, :kwsorter) ? Some(typeof(mt.kwsorter)) : nothing + kwtype = isdefined(mt, :kwsorter) ? typeof(mt.kwsorter) : nothing n = rest = 0 local last @@ -233,7 +233,7 @@ function url(m::Method) end end -function show(io::IO, ::MIME"text/html", m::Method; kwtype::Union{Some{DataType}, Void}=nothing) +function show(io::IO, ::MIME"text/html", m::Method; kwtype::Union{DataType, Void}=nothing) tv, decls, file, line = arg_decl_parts(m) sig = unwrap_unionall(m.sig) ft0 = sig.parameters[1] @@ -262,7 +262,7 @@ function show(io::IO, ::MIME"text/html", m::Method; kwtype::Union{Some{DataType} join(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2]*"" for d in decls[2:end]], ", ", ", ") if kwtype !== nothing - kwargs = kwarg_decl(m, get(kwtype)) + kwargs = kwarg_decl(m, kwtype) if !isempty(kwargs) print(io, "; ") join(io, kwargs, ", ", ", ") @@ -290,7 +290,7 @@ function show(io::IO, mime::MIME"text/html", ms::MethodList) ns = string(name) what = startswith(ns, '@') ? "macro" : "generic function" print(io, "$n $meths for ", what, " $ns:
      ") - kwtype = isdefined(mt, :kwsorter) ? Some(typeof(mt.kwsorter)) : nothing + kwtype = isdefined(mt, :kwsorter) ? typeof(mt.kwsorter) : nothing for meth in ms print(io, "
    • ") show(io, mime, meth; kwtype=kwtype) diff --git a/base/pkg/entry.jl b/base/pkg/entry.jl index c81676307aa0a..bbaaeaa334ed5 100644 --- a/base/pkg/entry.jl +++ b/base/pkg/entry.jl @@ -320,17 +320,17 @@ function pin(pkg::AbstractString, head::AbstractString) @info "Package $pkg: checking out existing branch $branch" else @info "Creating $pkg branch $branch" - ref = Some(LibGit2.create_branch(repo, branch, commit)) + ref = LibGit2.create_branch(repo, branch, commit) end # checkout selected branch - with(LibGit2.peel(LibGit2.GitTree, get(ref))) do btree + with(LibGit2.peel(LibGit2.GitTree, ref)) do btree LibGit2.checkout_tree(repo, btree) end # switch head to the branch - LibGit2.head!(repo, get(ref)) + LibGit2.head!(repo, ref) finally - close(get(ref)) + close(ref) end finally close(commit) diff --git a/base/pkg/pkg.jl b/base/pkg/pkg.jl index c09e58d07ba11..cbf1230de71b1 100644 --- a/base/pkg/pkg.jl +++ b/base/pkg/pkg.jl @@ -22,13 +22,13 @@ const META_BRANCH = "metadata-v2" struct PkgError <: Exception msg::AbstractString - ex::Union{Some{<:Exception}, Void} + ex::Union{Exception, Void} end PkgError(msg::AbstractString) = PkgError(msg, nothing) function Base.showerror(io::IO, pkgerr::PkgError) print(io, pkgerr.msg) if pkgerr.ex !== nothing - pkgex = get(pkgerr.ex) + pkgex = pkgerr.ex if isa(pkgex, CompositeException) for cex in pkgex print(io, "\n=> ") diff --git a/base/process.jl b/base/process.jl index b412a40477565..2534b6d2e923d 100644 --- a/base/process.jl +++ b/base/process.jl @@ -391,7 +391,7 @@ function _uv_hook_close(proc::Process) notify(proc.closenotify) end -function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) +function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Union{ProcessChain, Void}=nothing) spawn(redirect.cmd, (redirect.stream_no == STDIN_NO ? redirect.handle : stdios[1], redirect.stream_no == STDOUT_NO ? redirect.handle : stdios[2], @@ -399,12 +399,12 @@ function spawn(redirect::CmdRedirect, stdios::StdIOSet; chain::Union{Some{Proces chain=chain) end -function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) +function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Union{ProcessChain, Void}=nothing) out_pipe = Libc.malloc(_sizeof_uv_named_pipe) in_pipe = Libc.malloc(_sizeof_uv_named_pipe) link_pipe(in_pipe, false, out_pipe, false) if chain === nothing - chain = Some(ProcessChain(stdios)) + chain = ProcessChain(stdios) end try spawn(cmds.a, (stdios[1], out_pipe, stdios[3]), chain=chain) @@ -415,15 +415,15 @@ function spawn(cmds::OrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Libc.free(out_pipe) Libc.free(in_pipe) end - get(chain) + chain end -function spawn(cmds::ErrOrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) +function spawn(cmds::ErrOrCmds, stdios::StdIOSet; chain::Union{ProcessChain, Void}=nothing) out_pipe = Libc.malloc(_sizeof_uv_named_pipe) in_pipe = Libc.malloc(_sizeof_uv_named_pipe) link_pipe(in_pipe, false, out_pipe, false) if chain === nothing - chain = Some(ProcessChain(stdios)) + chain = ProcessChain(stdios) end try spawn(cmds.a, (stdios[1], stdios[2], out_pipe), chain=chain) @@ -434,7 +434,7 @@ function spawn(cmds::ErrOrCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain Libc.free(out_pipe) Libc.free(in_pipe) end - get(chain) + chain end function setup_stdio(stdio::PipeEndpoint, readable::Bool) @@ -505,7 +505,7 @@ function setup_stdio(anon::Function, stdio::StdIOSet) close_err && close_stdio(err) end -function spawn(cmd::Cmd, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) +function spawn(cmd::Cmd, stdios::StdIOSet; chain::Union{ProcessChain, Void}=nothing) if isempty(cmd.exec) throw(ArgumentError("cannot spawn empty command")) end @@ -516,20 +516,20 @@ function spawn(cmd::Cmd, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void in, out, err) end if chain !== nothing - push!(get(chain).processes, pp) + push!(chain.processes, pp) end pp end -function spawn(cmds::AndCmds, stdios::StdIOSet; chain::Union{Some{ProcessChain}, Void}=nothing) +function spawn(cmds::AndCmds, stdios::StdIOSet; chain::Union{ProcessChain, Void}=nothing) if chain === nothing - chain = Some(ProcessChain(stdios)) + chain = ProcessChain(stdios) end setup_stdio(stdios) do in, out, err spawn(cmds.a, (in,out,err), chain=chain) spawn(cmds.b, (in,out,err), chain=chain) end - get(chain) + chain end # INTERNAL @@ -555,7 +555,7 @@ spawn_opts_inherit(in::Redirectable=RawFD(0), out::Redirectable=RawFD(1), err::R Run a command object asynchronously, returning the resulting `Process` object. """ -spawn(cmds::AbstractCmd, args...; chain::Union{Some{ProcessChain}, Void}=nothing) = +spawn(cmds::AbstractCmd, args...; chain::Union{ProcessChain, Void}=nothing) = spawn(cmds, spawn_opts_swallow(args...)...; chain=chain) function eachline(cmd::AbstractCmd; chomp::Bool=true) diff --git a/base/repl/REPLCompletions.jl b/base/repl/REPLCompletions.jl index 0fe3e6597e417..345c5a9a8c582 100644 --- a/base/repl/REPLCompletions.jl +++ b/base/repl/REPLCompletions.jl @@ -372,7 +372,7 @@ function complete_methods(ex_org::Expr) t_in = Tuple{Core.Typeof(func), args_ex...} # Input types na = length(args_ex)+1 ml = methods(func) - kwtype = isdefined(ml.mt, :kwsorter) ? Some(typeof(ml.mt.kwsorter)) : nothing + kwtype = isdefined(ml.mt, :kwsorter) ? typeof(ml.mt.kwsorter) : nothing io = IOBuffer() for method in ml ms = method.sig diff --git a/base/socket.jl b/base/socket.jl index 6d7b90853b2d4..7c1053944a07b 100644 --- a/base/socket.jl +++ b/base/socket.jl @@ -262,7 +262,7 @@ mutable struct TCPSocket <: LibuvStream readnotify::Condition connectnotify::Condition closenotify::Condition - sendbuf::Union{Some{IOBuffer}, Void} + sendbuf::Union{IOBuffer, Void} lock::ReentrantLock throttle::Int diff --git a/base/stream.jl b/base/stream.jl index 8542ab4edb491..36316e0688027 100644 --- a/base/stream.jl +++ b/base/stream.jl @@ -104,7 +104,7 @@ mutable struct PipeEndpoint <: LibuvStream readnotify::Condition connectnotify::Condition closenotify::Condition - sendbuf::Union{Some{IOBuffer}, Void} + sendbuf::Union{IOBuffer, Void} lock::ReentrantLock throttle::Int @@ -154,7 +154,7 @@ mutable struct TTY <: LibuvStream buffer::IOBuffer readnotify::Condition closenotify::Condition - sendbuf::Union{Some{IOBuffer}, Void} + sendbuf::Union{IOBuffer, Void} lock::ReentrantLock throttle::Int @static if Sys.iswindows(); ispty::Bool; end @@ -852,7 +852,7 @@ function unsafe_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt) return uv_write(s, p, UInt(n)) end - buf = get(s.sendbuf) + buf = s.sendbuf totb = nb_available(buf) + n if totb < buf.maxsize nb = unsafe_write(buf, p, n) @@ -871,7 +871,7 @@ function flush(s::LibuvStream) if s.sendbuf === nothing return end - buf = get(s.sendbuf) + buf = s.sendbuf if nb_available(buf) > 0 arr = take!(buf) # Array of UInt8s uv_write(s, arr) @@ -879,13 +879,13 @@ function flush(s::LibuvStream) return end -buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=Some(PipeBuffer(bufsize)); s) +buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=PipeBuffer(bufsize); s) ## low-level calls to libuv ## function write(s::LibuvStream, b::UInt8) if s.sendbuf !== nothing - buf = get(s.sendbuf) + buf = s.sendbuf if nb_available(buf) + 1 < buf.maxsize return write(buf, b) end diff --git a/base/threadcall.jl b/base/threadcall.jl index a1efb0a32d77d..17280270a6212 100644 --- a/base/threadcall.jl +++ b/base/threadcall.jl @@ -1,12 +1,12 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license const max_ccall_threads = parse(Int, get(ENV, "UV_THREADPOOL_SIZE", "4")) -const thread_notifiers = Union{Some{Condition}, Void}[nothing for i in 1:max_ccall_threads] +const thread_notifiers = Union{Condition, Void}[nothing for i in 1:max_ccall_threads] const threadcall_restrictor = Semaphore(max_ccall_threads) function notify_fun(idx) global thread_notifiers - notify(get(thread_notifiers[idx])) + notify(thread_notifiers[idx]) return end @@ -84,7 +84,7 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva # wait for a worker thread to be available acquire(threadcall_restrictor) idx = findfirst(x -> x === nothing, thread_notifiers) - thread_notifiers[idx] = Some(Condition()) + thread_notifiers[idx] = Condition() # queue up the work to be done ccall(:jl_queue_work, Void, @@ -92,7 +92,7 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva fun_ptr, args_arr, ret_arr, c_notify_fun, idx) # wait for a result & return it - wait(get(thread_notifiers[idx])) + wait(thread_notifiers[idx]) thread_notifiers[idx] = nothing release(threadcall_restrictor) diff --git a/base/util.jl b/base/util.jl index 21efffd492692..a57683cde5eeb 100644 --- a/base/util.jl +++ b/base/util.jl @@ -426,7 +426,7 @@ getpass(prompt::AbstractString) = unsafe_string(ccall(:getpass, Cstring, (Cstrin end """ - prompt(message; default="", password=false) -> Union{Some{String}, Void} + prompt(message; default="", password=false) -> Union{String, Void} Displays the `message` then waits for user input. Input is terminated when a newline (\\n) is encountered or EOF (^D) character is entered on a blank line. If a `default` is provided @@ -448,7 +448,7 @@ function prompt(message::AbstractString; default::AbstractString="", password::B isempty(uinput) && return nothing # Encountered an EOF uinput = chomp(uinput) end - Some(isempty(uinput) ? default : uinput) + isempty(uinput) ? default : uinput end # Windows authentication prompt @@ -529,8 +529,8 @@ if Sys.iswindows() # Done. passbuf_ = passbuf[1:passlen[]-1] - result = Some((String(transcode(UInt8, usernamebuf[1:usernamelen[]-1])), - String(transcode(UInt8, passbuf_)))) + result = (String(transcode(UInt8, usernamebuf[1:usernamelen[]-1])), + String(transcode(UInt8, passbuf_))) securezero!(passbuf_) securezero!(passbuf) diff --git a/doc/src/manual/parallel-computing.md b/doc/src/manual/parallel-computing.md index afb9a6a7fdf15..f27289350f34e 100644 --- a/doc/src/manual/parallel-computing.md +++ b/doc/src/manual/parallel-computing.md @@ -1164,27 +1164,27 @@ appropriate fields initialized) to `launched` ```julia mutable struct WorkerConfig # Common fields relevant to all cluster managers - io::Union{Some{<:IO}, Void} - host::Union{Some{<:AbstractString}, Void} - port::Union{Some{<:Integer}, Void} + io::Union{IO, Void} + host::Union{AbstractString, Void} + port::Union{Integer, Void} # Used when launching additional workers at a host - count::Union{Some{Union{Int, Symbol}}, Void} - exename::Union{Some{<:Union{AbstractString, Cmd}}, Void} - exeflags::Union{Some{Cmd}, Void} + count::Union{Int, Symbol, Void} + exename::Union{AbstractString, Cmd, Void} + exeflags::Union{Cmd, Void} # External cluster managers can use this to store information at a per-worker level # Can be a dict if multiple fields need to be stored. - userdata::Union{Some{<:Any}, Void} + userdata::Any # SSHManager / SSH tunnel connections to workers - tunnel::Union{Some{Bool}, Void} - bind_addr::Union{Some{<:AbstractString}, Void} - sshflags::Union{Some{Cmd}, Void} - max_parallel::Union{Some{<:Integer}, Void} + tunnel::Union{Bool, Void} + bind_addr::Union{AbstractString, Void} + sshflags::Union{Cmd, Void} + max_parallel::Union{Integer, Void} # Used by Local/SSH managers - connect_at::Union{Some{<:Any}, Void} + connect_at::Any [...] end diff --git a/doc/src/manual/stacktraces.md b/doc/src/manual/stacktraces.md index d58ae3a9dbd35..bffbfdc20e6c6 100644 --- a/doc/src/manual/stacktraces.md +++ b/doc/src/manual/stacktraces.md @@ -73,7 +73,7 @@ returned by [`backtrace`](@ref): ```julia-repl julia> top_frame = stacktrace()[1] -eval(::Module, ::Any) at boot.jl:236 +eval(::Module, ::Expr) at REPL.jl:3 julia> top_frame.func :eval @@ -85,7 +85,7 @@ julia> top_frame.line 236 julia> top_frame.linfo -Some(MethodInstance for eval(::Module, ::Any)) +MethodInstance for eval(::Module, ::Expr) julia> top_frame.inlined false diff --git a/examples/clustermanager/0mq/ZMQCM.jl b/examples/clustermanager/0mq/ZMQCM.jl index 31ddcc1176523..69ceb5e0d462a 100644 --- a/examples/clustermanager/0mq/ZMQCM.jl +++ b/examples/clustermanager/0mq/ZMQCM.jl @@ -205,7 +205,7 @@ function launch(manager::ZMQCMan, params::Dict, launched::Array, c::Condition) io, pobj = open(`$(params[:exename]) worker.jl $i $(cluster_cookie())`, "r") wconfig = WorkerConfig() - wconfig.userdata = Some(Dict(:zid=>i, :io=>io)) + wconfig.userdata = Dict(:zid=>i, :io=>io) push!(launched, wconfig) notify(c) end @@ -214,19 +214,19 @@ end function connect(manager::ZMQCMan, pid::Int, config::WorkerConfig) #println("connect_m2w") if myid() == 1 - zid = get(config.userdata)[:zid] + zid = config.userdata[:zid] config.connect_at = zid # This will be useful in the worker-to-worker connection setup. - print_worker_stdout(get(config.userdata)[:io], pid) + print_worker_stdout(config.userdata[:io], pid) else #println("connect_w2w") - zid = get(config.connect_at) - config.userdata = Some(Dict{Symbol, Any}(:zid=>zid)) + zid = config.connect_at + config.userdata = Dict{Symbol, Any}(:zid=>zid) end streams = setup_connection(zid, SELF_INITIATED) - udata = get(config.userdata) + udata = config.userdata udata[:streams] = streams streams @@ -261,13 +261,13 @@ function manage(manager::ZMQCMan, id::Int, config::WorkerConfig, op) end function kill(manager::ZMQCMan, pid::Int, config::WorkerConfig) - send_data(get(config.userdata)[:zid], CONTROL_MSG, KILL_MSG) - (r_s, w_s) = get(config.userdata)[:streams] + send_data(config.userdata[:zid], CONTROL_MSG, KILL_MSG) + (r_s, w_s) = config.userdata[:streams] close(r_s) close(w_s) # remove from our map - delete!(manager.map_zmq_julia, get(config.userdata)[:zid]) + delete!(manager.map_zmq_julia, config.userdata[:zid]) nothing end diff --git a/examples/clustermanager/simple/UnixDomainCM.jl b/examples/clustermanager/simple/UnixDomainCM.jl index 2bc9dba5eed89..4e96e69b63ef2 100644 --- a/examples/clustermanager/simple/UnixDomainCM.jl +++ b/examples/clustermanager/simple/UnixDomainCM.jl @@ -17,7 +17,7 @@ function launch(manager::UnixDomainCM, params::Dict, launched::Array, c::Conditi pobj = open(cmd) wconfig = WorkerConfig() - wconfig.userdata = Some(Dict(:sockname=>sockname, :io=>pobj.out, :process=>pobj)) + wconfig.userdata = Dict(:sockname=>sockname, :io=>pobj.out, :process=>pobj) push!(launched, wconfig) notify(c) catch e @@ -30,19 +30,19 @@ function connect(manager::UnixDomainCM, pid::Int, config::WorkerConfig) if myid() == 1 # println("connect_m2w") # This will be useful in the worker-to-worker connection setup. - config.connect_at = Some(get(config.userdata)[:sockname]) + config.connect_at = config.userdata[:sockname] - print_worker_stdout(get(config.userdata)[:io], pid) + print_worker_stdout(config.userdata[:io], pid) else # println("connect_w2w") - sockname = get(config.connect_at) - config.userdata = Some(Dict{Symbol, Any}(:sockname=>sockname)) + sockname = config.connect_at + config.userdata = Dict{Symbol, Any}(:sockname=>sockname) end t = time() while true try - address = get(config.userdata)[:sockname] + address = config.userdata[:sockname] if isa(address, Tuple) sock = connect(address...) else @@ -75,7 +75,7 @@ function manage(manager::UnixDomainCM, id::Int, config::WorkerConfig, op) # Does not seem to be required, filesystem entry cleanup is happening automatically on process exit # if op == :deregister # try -# rm(get(config.userdata)[:sockname]) +# rm(config.userdata[:sockname]) # end # end nothing diff --git a/stdlib/Dates/src/types.jl b/stdlib/Dates/src/types.jl index 9e6696bddebe1..008d6e37afe9e 100644 --- a/stdlib/Dates/src/types.jl +++ b/stdlib/Dates/src/types.jl @@ -152,20 +152,20 @@ daysinmonth(y,m) = DAYSINMONTH[m] + (m == 2 && isleapyear(y)) # we can validate arguments in tryparse. """ - validargs(::Type{<:TimeType}, args...) -> Union{Some{ArgumentError}, Void} + validargs(::Type{<:TimeType}, args...) -> Union{ArgumentError, Void} Determine whether the given arguments consitute valid inputs for the given type. -Returns either a `Some{ArgumentError}` object, or [`nothing`](@ref) in case of success. +Returns either an `ArgumentError`, or [`nothing`](@ref) in case of success. """ function validargs end """ - argerror([msg]) -> Union{Some{ArgumentError}, Void} + argerror([msg]) -> Union{ArgumentError, Void} -Construct a `Some{ArgumentError}` object wrapping the given message, +Return an `ArgumentError` object with the given message, or [`nothing`](@ref) if no message is provided. For use by `validargs`. """ -argerror(msg::String) = Some(ArgumentError(msg)) +argerror(msg::String) = ArgumentError(msg) argerror() = nothing ### CONSTRUCTORS ### @@ -178,7 +178,7 @@ Construct a `DateTime` type by parts. Arguments must be convertible to [`Int64`] function DateTime(y::Int64, m::Int64=1, d::Int64=1, h::Int64=0, mi::Int64=0, s::Int64=0, ms::Int64=0) err = validargs(DateTime, y, m, d, h, mi, s, ms) - err === nothing || throw(get(err)) + err === nothing || throw(err) rata = ms + 1000 * (s + 60mi + 3600h + 86400 * totaldays(y, m, d)) return DateTime(UTM(rata)) end @@ -201,7 +201,7 @@ Construct a `Date` type by parts. Arguments must be convertible to [`Int64`](@re """ function Date(y::Int64, m::Int64=1, d::Int64=1) err = validargs(Date, y, m, d) - err === nothing || throw(get(err)) + err === nothing || throw(err) return Date(UTD(totaldays(y, m, d))) end @@ -218,7 +218,7 @@ Construct a `Time` type by parts. Arguments must be convertible to [`Int64`](@re """ function Time(h::Int64, mi::Int64=0, s::Int64=0, ms::Int64=0, us::Int64=0, ns::Int64=0) err = validargs(Time, h, mi, s, ms, us, ns) - err === nothing || throw(get(err)) + err === nothing || throw(err) return Time(Nanosecond(ns + 1000us + 1000000ms + 1000000000s + 60000000000mi + 3600000000000h)) end diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index 8d11a16269a66..9b8179ef31654 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -4,41 +4,41 @@ abstract type ClusterManager end mutable struct WorkerConfig # Common fields relevant to all cluster managers - io::Union{Some{<:IO}, Void} - host::Union{Some{<:AbstractString}, Void} - port::Union{Some{<:Integer}, Void} + io::Union{IO, Void} + host::Union{AbstractString, Void} + port::Union{Integer, Void} # Used when launching additional workers at a host - count::Union{Some{Union{Int, Symbol}}, Void} - exename::Union{Some{<:Union{AbstractString, Cmd}}, Void} - exeflags::Union{Some{Cmd}, Void} + count::Union{Int, Symbol, Void} + exename::Union{AbstractString, Cmd, Void} + exeflags::Union{Cmd, Void} # External cluster managers can use this to store information at a per-worker level # Can be a dict if multiple fields need to be stored. - userdata::Union{Some{<:Any}, Void} + userdata::Any # SSHManager / SSH tunnel connections to workers - tunnel::Union{Some{Bool}, Void} - bind_addr::Union{Some{<:AbstractString}, Void} - sshflags::Union{Some{Cmd}, Void} - max_parallel::Union{Some{<:Integer}, Void} + tunnel::Union{Bool, Void} + bind_addr::Union{AbstractString, Void} + sshflags::Union{Cmd, Void} + max_parallel::Union{Integer, Void} # Used by Local/SSH managers - connect_at::Union{Some{<:Any}, Void} + connect_at::Any - process::Union{Some{<:Process}, Void} - ospid::Union{Some{<:Integer}, Void} + process::Union{Process, Void} + ospid::Union{Integer, Void} # Private dictionary used to store temporary information by Local/SSH managers. - environ::Union{Some{<:Dict}, Void} + environ::Union{Dict, Void} # Connections to be setup depending on the network topology requested - ident::Union{Some{<:Any}, Void} # Worker as identified by the Cluster Manager. + ident::Any # Worker as identified by the Cluster Manager. # List of other worker idents this worker must connect with. Used with topology T_CUSTOM. - connect_idents::Union{Some{<:Array}, Void} + connect_idents::Union{Array, Void} # Run multithreaded blas on worker - enable_threaded_blas::Union{Some{Bool}, Void} + enable_threaded_blas::Union{Bool, Void} function WorkerConfig() wc = new() @@ -57,9 +57,9 @@ mutable struct Worker add_msgs::Array{Any,1} gcflag::Bool state::WorkerState - c_state::Condition # wait for state changes - ct_time::Float64 # creation time - conn_func::Union{Some{<:Function}, Void} # Used to setup connections lazily + c_state::Condition # wait for state changes + ct_time::Float64 # creation time + conn_func::Any # used to setup connections lazily r_stream::IO w_stream::IO @@ -67,10 +67,10 @@ mutable struct Worker # serializer as part of the Worker object manager::ClusterManager config::WorkerConfig - version::Union{Some{VersionNumber}, Void} # Julia version of the remote process + version::Union{VersionNumber, Void} # Julia version of the remote process function Worker(id::Int, r_stream::IO, w_stream::IO, manager::ClusterManager; - version::Union{Some{VersionNumber}, Void}=nothing, + version::Union{VersionNumber, Void}=nothing, config::WorkerConfig=WorkerConfig()) w = Worker(id) w.r_stream = r_stream @@ -128,16 +128,13 @@ end exec_conn_func(id::Int) = exec_conn_func(worker_from_id(id)) function exec_conn_func(w::Worker) - if w.conn_func === nothing - return wait_for_conn(w) # Some other task may be trying to connect at the same time. - end - try - f = get(w.conn_func) - w.conn_func = nothing + f = w.conn_func + # Will be called if some other task tries to connect at the same time. + w.conn_func = () -> wait_for_conn(w) f() catch e - w.conn_func = Some(() -> throw(e)) + w.conn_func = () -> throw(e) rethrow(e) end nothing @@ -175,15 +172,13 @@ worker_timeout() = parse(Float64, get(ENV, "JULIA_WORKER_TIMEOUT", "60.0")) ## worker creation and setup ## """ - start_worker(out::IO=STDOUT) - start_worker(cookie::AbstractString) - start_worker(out::IO, cookie::AbstractString) + start_worker([out::IO=STDOUT], cookie::Union{AbstractString, Void}) `start_worker` is an internal function which is the default entry point for worker processes connecting via TCP/IP. It sets up the process as a Julia cluster worker. -If the cookie is unspecified, the worker tries to read it from its STDIN. +If the cookie is `nothing`, the worker tries to read it from its STDIN. host:port information is written to stream `out` (defaults to STDOUT). @@ -193,15 +188,9 @@ line option) and schedules tasks to process incoming TCP connections and request It does not return. """ -start_worker(out::IO=STDOUT) = start_worker(out, nothing) -start_worker(cookie::AbstractString) = start_worker(STDOUT, Some(cookie)) -start_worker(out::IO, cookie::AbstractString) = start_worker(out, Some(cookie)) -function start_worker(out::IO, cookie_in::Union{Some{<:AbstractString}, Void}) - if cookie_in === nothing - cookie = readline(STDIN) - else - cookie = get(cookie_in) - end +start_worker(out::IO=STDOUT, cookie::Void=nothing) = start_worker(out, readline(STDIN)) +start_worker(cookie::Union{AbstractString, Void}) = start_worker(STDOUT, cookie) +function start_worker(out::IO, cookie::AbstractString) close(STDIN) # workers will not use it redirect_stderr(STDOUT) @@ -390,7 +379,7 @@ function addprocs_locked(manager::ClusterManager; kwargs...) end if PGRP.lazy === nothing || nprocs() == 1 - PGRP.lazy = Some(params[:lazy]) + PGRP.lazy = params[:lazy] elseif isclusterlazy() != params[:lazy] throw(ArgumentError(string("Active workers with lazy=", isclusterlazy(), ". Cannot set lazy=", params[:lazy]))) @@ -463,9 +452,9 @@ function setup_launched_worker(manager, wconfig, launched_q) # When starting workers on remote multi-core hosts, `launch` can (optionally) start only one # process on the remote machine, with a request to start additional workers of the # same type. This is done by setting an appropriate value to `WorkerConfig.cnt`. - cnt = get(wconfig.count, 1) + cnt = wconfig.count === nothing ? 1 : wconfig.count if cnt === :auto - cnt = get(wconfig.environ)[:cpu_cores] + cnt = wconfig.environ[:cpu_cores] end cnt = cnt - 1 # Removing self from the requested number @@ -477,8 +466,8 @@ end function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launched_q) @sync begin - exename = get(fromconfig.exename) - exeflags = get(fromconfig.exeflags, ``) + exename = fromconfig.exename + exeflags = fromconfig.exeflags === nothing ? `` : fromconfig.exeflags cmd = `$exename $exeflags` new_addresses = remotecall_fetch(launch_additional, frompid, cnt, cmd) @@ -489,8 +478,8 @@ function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launch for x in [:host, :tunnel, :sshflags, :exeflags, :exename, :enable_threaded_blas] setfield!(wconfig, x, getfield(fromconfig, x)) end - wconfig.bind_addr = Some(bind_addr) - wconfig.port = Some(port) + wconfig.bind_addr = bind_addr + wconfig.port = port let wconfig=wconfig @async begin @@ -562,10 +551,13 @@ function create_worker(manager, wconfig) elseif PGRP.topology == :custom # wait for requested workers to be up before connecting to them. - filterfunc(x) = (x.id != 1) && isdefined(x, :config) && (get(x.config.ident) in get(wconfig.connect_idents, [])) + filterfunc(x) = (x.id != 1) && isdefined(x, :config) && + (x.config.ident !== nothing) && (wconfig.connect_idents !== nothing) && + (x.config.ident in wconfig.connect_idents) wlist = filter(filterfunc, PGRP.workers) - while length(wlist) < length(get(wconfig.connect_idents, [])) + while wconfig.connect_idents !== nothing && + length(wlist) < length(wconfig.connect_idents) sleep(1.0) wlist = filter(filterfunc, PGRP.workers) end @@ -576,9 +568,13 @@ function create_worker(manager, wconfig) end end - all_locs = map(x -> isa(x, Worker) ? (get(x.config.connect_at, ()), x.id) : ((), x.id, true), join_list) + all_locs = map(x -> isa(x, Worker) ? + ((x.config.connect_at === nothing ? () : x.config.connect_at), x.id) : + ((), x.id, true), + join_list) send_connection_hdr(w, true) - join_message = JoinPGRPMsg(w.id, all_locs, PGRP.topology, get(wconfig.enable_threaded_blas, false), isclusterlazy()) + enable_threaded_blas = wconfig.enable_threaded_blas === nothing ? false : wconfig.enable_threaded_blas + join_message = JoinPGRPMsg(w.id, all_locs, PGRP.topology, enable_threaded_blas, isclusterlazy()) send_msg_now(w, MsgHeader(RRID(0,0), ntfy_oid), join_message) @schedule manage(w.manager, w.id, w.config, :register) @@ -680,7 +676,7 @@ mutable struct ProcessGroup workers::Array{Any,1} refs::Dict # global references topology::Symbol - lazy::Union{Some{Bool}, Void} + lazy::Union{Bool, Void} ProcessGroup(w::Array{Any,1}) = new("pg-default", w, Dict(), :all_to_all, nothing) end @@ -696,7 +692,7 @@ function topology(t) t end -isclusterlazy() = get(PGRP.lazy, false) +isclusterlazy() = PGRP.lazy === nothing ? false : PGRP.lazy get_bind_addr(pid::Integer) = get_bind_addr(worker_from_id(pid)) get_bind_addr(w::LocalProcess) = LPROC.bind_addr @@ -706,7 +702,7 @@ function get_bind_addr(w::Worker) w.config.bind_addr = remotecall_fetch(get_bind_addr, w.id, w.id) end end - get(w.config.bind_addr) + w.config.bind_addr end # globals @@ -1058,8 +1054,8 @@ function check_same_host(pids) if all(p -> (p==1) || (isa(map_pid_wrkr[p].manager, LocalManager)), pids) return true else - first_bind_addr = get(map_pid_wrkr[pids[1]].config.bind_addr) - return all(p -> (p != 1) && (get(map_pid_wrkr[p].config.bind_addr) == first_bind_addr), pids[2:end]) + first_bind_addr = map_pid_wrkr[pids[1]].config.bind_addr + return all(p -> (p != 1) && (map_pid_wrkr[p].config.bind_addr == first_bind_addr), pids[2:end]) end end end diff --git a/stdlib/Distributed/src/managers.jl b/stdlib/Distributed/src/managers.jl index 91c5321fbb45a..b7e25d3e0be19 100644 --- a/stdlib/Distributed/src/managers.jl +++ b/stdlib/Distributed/src/managers.jl @@ -209,15 +209,15 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched, write_cookie(io) wconfig = WorkerConfig() - wconfig.io = Some(io.out) - wconfig.host = Some(host) - wconfig.tunnel = Some(params[:tunnel]) - wconfig.sshflags = Some(sshflags) - wconfig.exeflags = Some(exeflags) - wconfig.exename = Some(exename) - wconfig.count = Some(cnt) - wconfig.max_parallel = Some(params[:max_parallel]) - wconfig.enable_threaded_blas = Some(params[:enable_threaded_blas]) + wconfig.io = io.out + wconfig.host = host + wconfig.tunnel = params[:tunnel] + wconfig.sshflags = sshflags + wconfig.exeflags = exeflags + wconfig.exename = exename + wconfig.count = cnt + wconfig.max_parallel = params[:max_parallel] + wconfig.enable_threaded_blas = params[:enable_threaded_blas] push!(launched, wconfig) @@ -227,10 +227,10 @@ end function manage(manager::SSHManager, id::Integer, config::WorkerConfig, op::Symbol) if op == :interrupt - ospid = get(config.ospid, 0) + ospid = config.ospid === nothing ? 0 : config.ospid if ospid > 0 - host = get(config.host) - sshflags = get(config.sshflags) + host = config.host + sshflags = config.sshflags if !success(`ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host "kill -2 $ospid"`) @error "Error sending a Ctrl-C to julia worker $id on $host" end @@ -330,9 +330,9 @@ function launch(manager::LocalManager, params::Dict, launched::Array, c::Conditi write_cookie(io) wconfig = WorkerConfig() - wconfig.process = Some(io) - wconfig.io = Some(io.out) - wconfig.enable_threaded_blas = Some(params[:enable_threaded_blas]) + wconfig.process = io + wconfig.io = io.out + wconfig.enable_threaded_blas = params[:enable_threaded_blas] push!(launched, wconfig) end @@ -341,7 +341,7 @@ end function manage(manager::LocalManager, id::Integer, config::WorkerConfig, op::Symbol) if op == :interrupt - kill(get(config.process), 2) + kill(config.process, 2) end end @@ -394,17 +394,17 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) # master connecting to workers if config.io !== nothing - (bind_addr, port) = read_worker_host_port(get(config.io)) - pubhost = get(config.host, bind_addr) - config.host = Some(pubhost) - config.port = Some(port) + (bind_addr, port) = read_worker_host_port(config.io) + pubhost = config.host === nothing ? bind_addr : config.host + config.host = pubhost + config.port = port else - pubhost = get(config.host) - port = get(config.port) - bind_addr = get(config.bind_addr, pubhost) + pubhost = config.host + port = config.port + bind_addr = config.bind_addr === nothing ? pubhost : config.bind_addr end - tunnel = get(config.tunnel, false) + tunnel = config.tunnel === nothing ? false : config.tunnel s = split(pubhost,'@') user = "" @@ -422,11 +422,12 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) if tunnel if !haskey(tunnel_hosts_map, pubhost) - tunnel_hosts_map[pubhost] = Semaphore(get(config.max_parallel, typemax(Int))) + tunnel_hosts_map[pubhost] = Semaphore(config.max_parallel === nothing ? + typemax(Int) : config.max_parallel) end sem = tunnel_hosts_map[pubhost] - sshflags = get(config.sshflags) + sshflags = config.sshflags acquire(sem) try (s, bind_addr) = connect_to_worker(pubhost, bind_addr, port, user, sshflags) @@ -437,14 +438,14 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) (s, bind_addr) = connect_to_worker(bind_addr, port) end - config.bind_addr = Some(bind_addr) + config.bind_addr = bind_addr # write out a subset of the connect_at required for further worker-worker connection setups - config.connect_at = Some((bind_addr, port)) + config.connect_at = (bind_addr, port) if config.io !== nothing let pid = pid - redirect_worker_output(pid, get(config.io)) + redirect_worker_output(pid, config.io) end end @@ -452,9 +453,9 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) end function connect_w2w(pid::Int, config::WorkerConfig) - (rhost, rport) = get(config.connect_at) - config.host = Some(rhost) - config.port = Some(rport) + (rhost, rport) = config.connect_at + config.host = rhost + config.port = rport (s, bind_addr) = connect_to_worker(rhost, rport) (s,s) end diff --git a/stdlib/Distributed/src/messages.jl b/stdlib/Distributed/src/messages.jl index 5a3c02a608eae..aec20d1f4bb2b 100644 --- a/stdlib/Distributed/src/messages.jl +++ b/stdlib/Distributed/src/messages.jl @@ -32,7 +32,7 @@ struct MsgHeader end # Special oid (0,0) uses to indicate a null ID. -# Used instead of Union{Some, Void} to decrease wire size of header. +# Used instead of Union{Int, Void} to decrease wire size of header. null_id(id) = id == RRID(0, 0) struct CallMsg{Mode} <: AbstractMsg diff --git a/stdlib/Distributed/src/process_messages.jl b/stdlib/Distributed/src/process_messages.jl index 2f1aae32e0cce..dddbe72507ede 100644 --- a/stdlib/Distributed/src/process_messages.jl +++ b/stdlib/Distributed/src/process_messages.jl @@ -139,7 +139,7 @@ function message_handler_loop(r_stream::IO, w_stream::IO, incoming::Bool) wpid=0 # the worker r_stream is connected to. boundary = similar(MSG_BOUNDARY) try - version = Some(process_hdr(r_stream, incoming)) + version = process_hdr(r_stream, incoming) serializer = ClusterSerializer(r_stream) # The first message will associate wpid with r_stream @@ -309,17 +309,17 @@ function handle_msg(msg::JoinPGRPMsg, header, r_stream, w_stream, version) end lazy = msg.lazy - PGRP.lazy = Some(lazy) + PGRP.lazy = lazy wait_tasks = Task[] for (connect_at, rpid) in msg.other_workers wconfig = WorkerConfig() - wconfig.connect_at = Some(connect_at) + wconfig.connect_at = connect_at let rpid=rpid, wconfig=wconfig if lazy # The constructor registers the object with a global registry. - Worker(rpid, Some(()->connect_to_peer(cluster_manager, rpid, wconfig))) + Worker(rpid, ()->connect_to_peer(cluster_manager, rpid, wconfig)) else t = @async connect_to_peer(cluster_manager, rpid, wconfig) push!(wait_tasks, t) @@ -350,8 +350,8 @@ function handle_msg(msg::JoinCompleteMsg, header, r_stream, w_stream, version) w = map_sock_wrkr[r_stream] environ = get(w.config.environ, Dict()) environ[:cpu_cores] = msg.cpu_cores - w.config.environ = Some(environ) - w.config.ospid = Some(msg.ospid) + w.config.environ = environ + w.config.ospid = msg.ospid w.version = version ntfy_channel = lookup_ref(header.notify_oid) diff --git a/stdlib/Distributed/src/remotecall.jl b/stdlib/Distributed/src/remotecall.jl index 56cd35f13b53f..e5e7f62437f5f 100644 --- a/stdlib/Distributed/src/remotecall.jl +++ b/stdlib/Distributed/src/remotecall.jl @@ -22,13 +22,12 @@ mutable struct Future <: AbstractRemoteRef where::Int whence::Int id::Int - v::Union{Some{<:Any}, Void} + v::Union{Some{Any}, Void} - Future(w::Int, rrid::RRID) = Future(w, rrid, nothing) - Future(w::Int, rrid::RRID, v::Union{Some{<:Any}, Void}) = + Future(w::Int, rrid::RRID, v::Union{Some{<:Any}, Void}=nothing) = (r = new(w,rrid.whence,rrid.id,v); return test_existing_ref(r)) - Future(t::Tuple) = new(t[1],t[2],t[3],t[4]) # Useful for creating dummy, zeroed-out instances + Future(t::NTuple{4, Any}) = new(t[1],t[2],t[3],t[4]) # Useful for creating dummy, zeroed-out instances end """ @@ -183,7 +182,7 @@ or to use a local [`Channel`](@ref) as a proxy: isready(c) # will not block """ function isready(rr::Future) - rr.v !== nothing && return true + rr.v === nothing || return true rid = remoteref_id(rr) return if rr.where == myid() diff --git a/stdlib/Distributed/src/workerpool.jl b/stdlib/Distributed/src/workerpool.jl index 47cf59550c7de..a5fba93f2623e 100644 --- a/stdlib/Distributed/src/workerpool.jl +++ b/stdlib/Distributed/src/workerpool.jl @@ -185,7 +185,7 @@ performs a `remote_do` on it. """ remote_do(f, pool::AbstractWorkerPool, args...; kwargs...) = remotecall_pool(remote_do, f, pool, args...; kwargs...) -const _default_worker_pool = Ref{Union{Some{WorkerPool}, Void}}(nothing) +const _default_worker_pool = Ref{Union{WorkerPool, Void}}(nothing) """ default_worker_pool() @@ -197,12 +197,12 @@ function default_worker_pool() # for the first time if _default_worker_pool[] === nothing if myid() == 1 - _default_worker_pool[] = Some(WorkerPool()) + _default_worker_pool[] = WorkerPool() else - _default_worker_pool[] = Some(remotecall_fetch(()->default_worker_pool(), 1)) + _default_worker_pool[] = remotecall_fetch(()->default_worker_pool(), 1) end end - return get(_default_worker_pool[]) + return _default_worker_pool[] end """ diff --git a/stdlib/Distributed/test/distributed_exec.jl b/stdlib/Distributed/test/distributed_exec.jl index ab7e03457c950..82a4e9621e3fb 100644 --- a/stdlib/Distributed/test/distributed_exec.jl +++ b/stdlib/Distributed/test/distributed_exec.jl @@ -260,9 +260,7 @@ function test_regular_io_ser(ref::Distributed.AbstractRemoteRef) v = getfield(ref2, fld) if isa(v, Number) @test v === zero(typeof(v)) - elseif isa(v, Union{Some, Void}) - @test v === nothing - else + elseif v !== nothing error(string("Add test for field ", fld)) end end @@ -604,7 +602,7 @@ if DoFullTest # error message but should not terminate. for w in Distributed.PGRP.workers if isa(w, Distributed.Worker) - local s = connect(get(w.config.host), get(w.config.port)) + local s = connect(w.config.host, w.config.port) write(s, randstring(32)) end end @@ -943,7 +941,7 @@ end function test_blas_config(pid, expected) for worker in Distributed.PGRP.workers if worker.id == pid - @test get(worker.config.enable_threaded_blas) == expected + @test worker.config.enable_threaded_blas == expected return end end @@ -1060,8 +1058,8 @@ function launch(manager::ErrorSimulator, params::Dict, launched::Array, c::Condi io = open(detach(setenv(cmd, dir=dir))) wconfig = WorkerConfig() - wconfig.process = Some(io) - wconfig.io = Some(io.out) + wconfig.process = io + wconfig.io = io.out push!(launched, wconfig) notify(c) end @@ -1421,8 +1419,8 @@ function launch(manager::WorkerArgTester, params::Dict, launched::Array, c::Cond manager.write_cookie && Distributed.write_cookie(io) wconfig = WorkerConfig() - wconfig.process = Some(io) - wconfig.io = Some(io.out) + wconfig.process = io + wconfig.io = io.out push!(launched, wconfig) notify(c) diff --git a/stdlib/Distributed/test/topology.jl b/stdlib/Distributed/test/topology.jl index 4a0872dbedf28..7769e3bd1587f 100644 --- a/stdlib/Distributed/test/topology.jl +++ b/stdlib/Distributed/test/topology.jl @@ -48,10 +48,10 @@ function launch(manager::TopoTestManager, params::Dict, launched::Array, c::Cond Distributed.write_cookie(io) wconfig = WorkerConfig() - wconfig.process = Some(io) - wconfig.io = Some(io.out) - wconfig.ident = Some(i) - wconfig.connect_idents = Some(collect(i+2:2:manager.np)) + wconfig.process = io + wconfig.io = io.out + wconfig.ident = i + wconfig.connect_idents = collect(i+2:2:manager.np) push!(launched, wconfig) end @@ -61,9 +61,9 @@ end const map_pid_ident=Dict() function manage(manager::TopoTestManager, id::Integer, config::WorkerConfig, op::Symbol) if op == :register - map_pid_ident[id] = get(config.ident) + map_pid_ident[id] = config.ident elseif op == :interrupt - kill(get(config.process), 2) + kill(config.process, 2) end end diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl index 2ca3d2d062355..0539b8699c6f0 100644 --- a/test/libgit2-helpers.jl +++ b/test/libgit2-helpers.jl @@ -12,7 +12,7 @@ without having to authenticate against a real server. function credential_loop( valid_credential::AbstractCredential, url::AbstractString, - user::Union{Some{<:AbstractString}, Void}, + user::Union{AbstractString, Void}, allowed_types::UInt32, payload::CredentialPayload; shred::Bool=true) @@ -28,11 +28,12 @@ function credential_loop( err = Cint(0) while err == 0 err = ccall(cb, Cint, (Ptr{Ptr{Void}}, Cstring, Cstring, Cuint, Any), - libgitcred_ptr_ptr, url, get(user, C_NULL), allowed_types, payload) + libgitcred_ptr_ptr, url, user === nothing ? C_NULL : user, + allowed_types, payload) num_authentications += 1 # Check if the callback provided us with valid credentials - if payload.credential !== nothing && get(payload.credential) == valid_credential + if payload.credential !== nothing && payload.credential == valid_credential LibGit2.approve(payload, shred=shred) break end @@ -60,7 +61,7 @@ end function credential_loop( valid_credential::UserPasswordCredential, url::AbstractString, - user::Union{Some{<:AbstractString}, Void}=nothing, + user::Union{AbstractString, Void}=nothing, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) credential_loop(valid_credential, url, user, 0x000001, payload, shred=shred) @@ -69,7 +70,7 @@ end function credential_loop( valid_credential::SSHCredential, url::AbstractString, - user::Union{Some{<:AbstractString}, Void}=nothing, + user::Union{AbstractString, Void}=nothing, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) credential_loop(valid_credential, url, user, 0x000046, payload, shred=shred) @@ -81,5 +82,5 @@ function credential_loop( user::AbstractString, payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) - credential_loop(valid_credential, url, Some(user), payload, shred=shred) + credential_loop(valid_credential, url, user, payload, shred=shred) end diff --git a/test/libgit2.jl b/test/libgit2.jl index 86898fd7846bd..fff1be8753fba 100644 --- a/test/libgit2.jl +++ b/test/libgit2.jl @@ -768,14 +768,14 @@ mktempdir() do dir # null because we are looking for a REMOTE branch @test LibGit2.lookup_branch(repo, test_branch, true) === nothing # not nothing because we are now looking for a LOCAL branch - LibGit2.with(Base.get(LibGit2.lookup_branch(repo, test_branch, false))) do tbref + LibGit2.with(LibGit2.lookup_branch(repo, test_branch, false)) do tbref @test LibGit2.shortname(tbref) == test_branch @test LibGit2.upstream(tbref) === nothing end @test LibGit2.lookup_branch(repo, test_branch2, true) === nothing # test deleting the branch LibGit2.branch!(repo, test_branch2; set_head=false) - LibGit2.with(Base.get(LibGit2.lookup_branch(repo, test_branch2, false))) do tbref + LibGit2.with(LibGit2.lookup_branch(repo, test_branch2, false)) do tbref @test LibGit2.shortname(tbref) == test_branch2 LibGit2.delete_branch(tbref) @test LibGit2.lookup_branch(repo, test_branch2, true) === nothing @@ -1279,7 +1279,7 @@ mktempdir() do dir LibGit2.with(LibGit2.GitIndex(repo)) do idx i = find(test_file, idx) @test i !== nothing - idx_entry = idx[get(i)] + idx_entry = idx[i] @test idx_entry !== nothing idx_entry_str = sprint(show, idx_entry) @test idx_entry_str == "IndexEntry($(string(idx_entry.id)))" @@ -1305,7 +1305,7 @@ mktempdir() do dir # check file status st = LibGit2.status(repo, test_file) @test st !== nothing - @test LibGit2.isset(get(st), LibGit2.Consts.STATUS_CURRENT) + @test LibGit2.isset(st, LibGit2.Consts.STATUS_CURRENT) # modify file open(joinpath(test_repo, test_file), "a") do io @@ -1314,28 +1314,28 @@ mktempdir() do dir # file modified but not staged st_mod = LibGit2.status(repo, test_file) - @test !LibGit2.isset(get(st_mod), LibGit2.Consts.STATUS_INDEX_MODIFIED) - @test LibGit2.isset(get(st_mod), LibGit2.Consts.STATUS_WT_MODIFIED) + @test !LibGit2.isset(st_mod, LibGit2.Consts.STATUS_INDEX_MODIFIED) + @test LibGit2.isset(st_mod, LibGit2.Consts.STATUS_WT_MODIFIED) # stage file LibGit2.add!(repo, test_file) # modified file staged st_stg = LibGit2.status(repo, test_file) - @test LibGit2.isset(get(st_stg), LibGit2.Consts.STATUS_INDEX_MODIFIED) - @test !LibGit2.isset(get(st_stg), LibGit2.Consts.STATUS_WT_MODIFIED) + @test LibGit2.isset(st_stg, LibGit2.Consts.STATUS_INDEX_MODIFIED) + @test !LibGit2.isset(st_stg, LibGit2.Consts.STATUS_WT_MODIFIED) # try to unstage to unknown commit @test_throws LibGit2.Error.GitError LibGit2.reset!(repo, "XYZ", test_file) # status should not change st_new = LibGit2.status(repo, test_file) - @test get(st_new) == get(st_stg) + @test st_new == st_stg # try to unstage to HEAD new_head = LibGit2.reset!(repo, LibGit2.Consts.HEAD_FILE, test_file) st_uns = LibGit2.status(repo, test_file) - @test get(st_uns) == get(st_mod) + @test st_uns == st_mod # reset repo @test_throws LibGit2.Error.GitError LibGit2.reset!(repo, LibGit2.GitHash(), LibGit2.Consts.RESET_HARD) @@ -1358,7 +1358,7 @@ mktempdir() do dir for r in (repo, path) # Set just the fetch URL LibGit2.set_remote_fetch_url(r, remote_name, url) - remote = get(LibGit2.lookup_remote(repo, remote_name)) + remote = LibGit2.lookup_remote(repo, remote_name) @test LibGit2.name(remote) == remote_name @test LibGit2.url(remote) == url @test LibGit2.push_url(remote) == "" @@ -1368,7 +1368,7 @@ mktempdir() do dir # Set just the push URL LibGit2.set_remote_push_url(r, remote_name, url) - remote = get(LibGit2.lookup_remote(repo, remote_name)) + remote = LibGit2.lookup_remote(repo, remote_name) @test LibGit2.name(remote) == remote_name @test LibGit2.url(remote) == "" @test LibGit2.push_url(remote) == url @@ -1378,7 +1378,7 @@ mktempdir() do dir # Set the fetch and push URL LibGit2.set_remote_url(r, remote_name, url) - remote = get(LibGit2.lookup_remote(repo, remote_name)) + remote = LibGit2.lookup_remote(repo, remote_name) @test LibGit2.name(remote) == remote_name @test LibGit2.url(remote) == url @test LibGit2.push_url(remote) == url @@ -2225,7 +2225,7 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(ssh_ex, challenges) @test err == git_ok @test auth_attempts == 1 - @test get(p.credential).prvkey == abspath(valid_key) + @test p.credential.prvkey == abspath(valid_key) end withenv("SSH_KEY_PATH" => valid_key, @@ -2241,7 +2241,7 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(ssh_ex, challenges) @test err == git_ok @test auth_attempts == 2 - @test get(p.credential).pubkey == abspath(valid_key * ".pub") + @test p.credential.pubkey == abspath(valid_key * ".pub") end end @@ -2443,7 +2443,7 @@ mktempdir() do dir include($LIBGIT2_HELPER_PATH) payload = CredentialPayload($valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop($valid_cred, "ssh://github.com/repo", Some(""), + credential_loop($valid_cred, "ssh://github.com/repo", "", Cuint(LibGit2.Consts.CREDTYPE_SSH_KEY), payload) end @@ -2460,7 +2460,7 @@ mktempdir() do dir include($LIBGIT2_HELPER_PATH) payload = CredentialPayload($valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop($valid_cred, "https://github.com/repo", Some(""), + credential_loop($valid_cred, "https://github.com/repo", "", Cuint(LibGit2.Consts.CREDTYPE_USERPASS_PLAINTEXT), payload) end @@ -2483,7 +2483,7 @@ mktempdir() do dir valid_cred = LibGit2.UserPasswordCredential("foo", "bar") payload = CredentialPayload(valid_cred, allow_ssh_agent=false, allow_git_helpers=false) - credential_loop(valid_cred, "foo://github.com/repo", Some(""), + credential_loop(valid_cred, "foo://github.com/repo", "", $allowed_types, payload) end diff --git a/test/reflection.jl b/test/reflection.jl index 24e3a781562df..e68790abe21c6 100644 --- a/test/reflection.jl +++ b/test/reflection.jl @@ -593,7 +593,7 @@ function has_backslashes(f::Function) end function has_backslashes(meth::Method) if '\\' in string(meth.file) - return Some(meth) + return meth else return nothing end From 5c04391ef1c0e21aa3feaa87792c9295b2942a84 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Sun, 12 Nov 2017 12:45:31 +0100 Subject: [PATCH 03/16] Update precompile.jl Remove all uses of Some, except for Union{Some{Any}, Void}. --- base/parse.jl | 6 +-- base/precompile.jl | 94 +++++++++++++++++++++++----------------------- 2 files changed, 50 insertions(+), 50 deletions(-) diff --git a/base/parse.jl b/base/parse.jl index 1e0aa7c28af8f..c264aa52a69de 100644 --- a/base/parse.jl +++ b/base/parse.jl @@ -302,8 +302,8 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String} if i₊ == 0 # purely real or imaginary value if iᵢ > 0 # purely imaginary x_ = tryparse_internal(T, s, i, iᵢ-1, raise) - isnull(x_) && return nothing - x = unsafe_get(x_) + x_ === nothing && return nothing + x = get(x_) return Some(Complex{T}(zero(x),x)) else # purely real return Some(tryparse_internal(T, s, i, e, raise)) @@ -344,4 +344,4 @@ tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, rais tryparse_internal(T, s, startpos, endpos, 10, raise) parse(::Type{T}, s::AbstractString) where T<:Union{Real,Complex} = - unsafe_get(tryparse_internal(T, s, start(s), endof(s), true)) + get(tryparse_internal(T, s, start(s), endof(s), true)) diff --git a/base/precompile.jl b/base/precompile.jl index 7c4399ab36825..1be887564e958 100644 --- a/base/precompile.jl +++ b/base/precompile.jl @@ -1068,28 +1068,28 @@ precompile(Tuple{typeof(Base._jl_spawn), String, Array{String, 1}, Ptr{Void}, Ba precompile(Tuple{Type{Base.Timer}, Int64, Float64}) precompile(Tuple{typeof(Base.sleep), Int64}) precompile(Tuple{typeof(Base._uv_hook_close), Base.PipeEndpoint}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{IO}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{IO}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{AbstractString}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{AbstractString}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Integer}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Integer}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Cmd}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Base.Cmd}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{IO, Void}}}) +precompile(Tuple{Type{Base.Union{IO, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{AbstractString, Void}}}) +precompile(Tuple{Type{Base.Union{AbstractString, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Integer, Void}}}) +precompile(Tuple{Type{Base.Union{Integer, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Int64, Symbol, Void}}}) +precompile(Tuple{Type{Base.Union{Int64, Symbol, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Cmd, Void}}}) +precompile(Tuple{Type{Base.Union{Base.Cmd, Void}}}) precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Any}, Void}}}) precompile(Tuple{Type{Base.Union{Some{Any}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Bool}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Bool}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Process}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Base.Process}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) -precompile(Tuple{Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) -precompile(Tuple{Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.Process}, Void}}, Base.Process}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Bool}, Void}}, Bool}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Bool, Void}}}) +precompile(Tuple{Type{Base.Union{Bool, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Process, Void}}}) +precompile(Tuple{Type{Base.Union{Base.Process, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Dict{K, V}, Void} where V where K}}) +precompile(Tuple{Type{Base.Union{Base.Dict{K, V}, Void} where V where K}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Array{T, N}, Void} where N where T}}) +precompile(Tuple{Type{Base.Union{Array{T, N}, Void} where N where T}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Base.Process, Void}}, Base.Process}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Bool, Void}}, Bool}) precompile(Tuple{typeof(Base.task_done_hook), Task}) precompile(Tuple{typeof(Base.getindex), Tuple{Array{Any, 1}, Tuple{}}, Int64}) precompile(Tuple{Type{Base.TCPSocket}}) @@ -1175,7 +1175,7 @@ precompile(Tuple{typeof(Base._uv_hook_close), Base.Timer}) precompile(Tuple{typeof(Base.notify), Base.Condition, Base.EOFError, Bool, Bool}) precompile(Tuple{typeof(Base.unpreserve_handle), Base.Timer}) precompile(Tuple{typeof(Base.disassociate_julia_struct), Base.Timer}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{AbstractString}, Void}}, Base.SubString{String}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{AbstractString, Void}}, Base.SubString{String}}) precompile(Tuple{typeof(Base.connect!), Base.TCPSocket, Base.SubString{String}, UInt16}) precompile(Tuple{typeof(Base.notify), Base.Condition, Base.IPv4, Bool, Bool}) precompile(Tuple{typeof(Base.schedule), Task, Base.IPv4}) @@ -1184,7 +1184,7 @@ precompile(Tuple{typeof(Base.uv_status_string), Base.TCPSocket}) precompile(Tuple{typeof(Base._fd), Base.TCPSocket}) precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TCPSocket}) precompile(Tuple{typeof(Base.isopen), Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{AbstractString}, Void}}, String}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{AbstractString, Void}}, String}) precompile(Tuple{typeof(Base.unpreserve_handle), Base.TCPSocket}) precompile(Tuple{typeof(Base.check_open), Base.TCPSocket}) precompile(Tuple{typeof(Base.stream_wait), Base.TCPSocket, Base.Condition}) @@ -1201,7 +1201,7 @@ precompile(Tuple{typeof(Base.unsafe_read), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.read!), Base.TCPSocket, Array{Int64, 1}}) precompile(Tuple{typeof(Base.read), Base.TCPSocket, Type{UInt8}}) precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.Union{Some{Base.VersionNumber}, Void}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Base.VersionNumber, Void}}, Base.Union{Base.VersionNumber, Void}}) precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{Int64}, Char}) precompile(Tuple{typeof(Base.close), Base.TCPSocket}) precompile(Tuple{typeof(Base.convert), Type{Base.AbstractChannel}, Base.Channel{Any}}) @@ -1270,28 +1270,28 @@ precompile(Tuple{typeof(Base.setindex!), Base.Dict{Int64, Void}, Void, Int64}) precompile(Tuple{Type{Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}}, Tuple{Int64}}) precompile(Tuple{typeof(Base.eachindex), Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}}) precompile(Tuple{typeof(Base.LinAlg.BLAS.set_num_threads), Int64}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{IO}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{IO}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{AbstractString}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{AbstractString}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Integer}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Integer}, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{IO, Void}}}) +precompile(Tuple{Type{Base.Union{IO, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{AbstractString, Void}}}) +precompile(Tuple{Type{Base.Union{AbstractString, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Integer, Void}}}) +precompile(Tuple{Type{Base.Union{Integer, Void}}}) precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Union{Int64, Symbol}}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Cmd}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Base.Cmd}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Any}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Any}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Bool}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Bool}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Process}, Void}}}) -precompile(Tuple{Type{Base.Union{Some{Base.Process}, Void}}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) -precompile(Tuple{Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}}) -precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) -precompile(Tuple{Type{Base.Union{Some{Array{T, N}}, Void} where N where T}}) +precompile(Tuple{Type{Base.Union{Int64, Symbol, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Cmd, Void}}}) +precompile(Tuple{Type{Base.Union{Base.Cmd, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Any}}) +precompile(Tuple{Type{Any}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Bool, Void}}}) +precompile(Tuple{Type{Base.Union{Bool, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Process, Void}}}) +precompile(Tuple{Type{Base.Union{Base.Process, Void}}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Base.Dict{K, V}, Void} where V where K}}) +precompile(Tuple{Type{Base.Union{Base.Dict{K, V}, Void} where V where K}}) +precompile(Tuple{typeof(Base.eltype), Type{Base.Union{Array{T, N}, Void} where N where T}}) +precompile(Tuple{Type{Base.Union{Array{T, N}, Void} where N where T}}) precompile(Tuple{typeof(Base.convert), Type{IO}, Base.TCPSocket}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.VersionNumber}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Base.VersionNumber, Void}}, Base.VersionNumber}) precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.uv_write), Base.TCPSocket, Ptr{UInt8}, UInt64}) precompile(Tuple{typeof(Base.flush), Base.TCPSocket}) @@ -1313,12 +1313,12 @@ precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{WeakRef, Void}, WeakRef}) precompile(Tuple{typeof(Base._setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef, Int64}) precompile(Tuple{typeof(Base.setindex!), Base.Dict{WeakRef, Void}, Void, WeakRef}) precompile(Tuple{Type{Base.Channel{Int64}}, Int64}) -precompile(Tuple{typeof(Base.get), Base.Union{Some{Base.Dict{K, V}}, Void} where V where K, Base.Dict{Any, Any}}) +precompile(Tuple{typeof(Base.get), Base.Union{Base.Dict{K, V}, Void} where V where K, Base.Dict{Any, Any}}) precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Int64, Symbol}) precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Int64, Symbol, Int64}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.Dict{K, V}}, Void} where V where K}, Base.Dict{Any, Any}}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Integer}, Void}}, Int64}) -precompile(Tuple{typeof(Base.convert), Type{Base.Union{Some{Base.VersionNumber}, Void}}, Base.VersionNumber}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Base.Dict{K, V}, Void} where V where K}, Base.Dict{Any, Any}}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Integer, Void}}, Int64}) +precompile(Tuple{typeof(Base.convert), Type{Base.Union{Base.VersionNumber, Void}}, Base.VersionNumber}) precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Int64}) precompile(Tuple{typeof(Base.put_buffered), Base.Channel{Any}, Int64}) precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Any}, Int64}) From b7cb5603397f847c636f6188e314d31f1c61875d Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Sat, 25 Nov 2017 17:49:47 +0100 Subject: [PATCH 04/16] Review fixes --- base/client.jl | 2 +- base/some.jl | 8 +------- base/threadcall.jl | 2 +- stdlib/Distributed/src/cluster.jl | 8 +++----- stdlib/Distributed/src/remotecall.jl | 2 +- test/some.jl | 7 ------- 6 files changed, 7 insertions(+), 22 deletions(-) diff --git a/base/client.jl b/base/client.jl index 8ce6ff086f1aa..c97bb39ba9f4d 100644 --- a/base/client.jl +++ b/base/client.jl @@ -76,7 +76,7 @@ color_normal = text_colors[:normal] function repl_color(key, default) env_str = get(ENV, key, "") c = tryparse(Int, env_str) - c_conv = c === nothing ? Symbol(env_str) : get(c) + c_conv = get(c, Symbol(env_str)) haskey(text_colors, c_conv) ? c_conv : default end diff --git a/base/some.jl b/base/some.jl index 8c05c22b72bb1..49833b7cb9418 100644 --- a/base/some.jl +++ b/base/some.jl @@ -3,19 +3,13 @@ """ Some{T} -A wrapper type used with `Union{Some{T}, Void}` to distinguish between the absence +A wrapper type used in `Union{Some{T}, Void}` to distinguish between the absence of a value ([`nothing`](@ref)) and the presence of a `nothing` value (i.e. `Some(nothing)`). -It can also be used to force users of a function argument or of an object field -to explicitly handle the possibility of a field or argument being `nothing`, -either manually or by calling [`get`](@ref) before actually using the wrapped -value. """ struct Some{T} value::T end -eltype(::Type{Some{T}}) where {T} = T - promote_rule(::Type{Some{S}}, ::Type{Some{T}}) where {S,T} = Some{promote_type(S, T)} promote_rule(::Type{Some{T}}, ::Type{Void}) where {T} = Union{Some{T}, Void} diff --git a/base/threadcall.jl b/base/threadcall.jl index 17280270a6212..fcf258df0f4e9 100644 --- a/base/threadcall.jl +++ b/base/threadcall.jl @@ -83,7 +83,7 @@ function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argva # wait for a worker thread to be available acquire(threadcall_restrictor) - idx = findfirst(x -> x === nothing, thread_notifiers) + idx = findfirst(equalto(nothing), thread_notifiers) thread_notifiers[idx] = Condition() # queue up the work to be done diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index 9b8179ef31654..892dcd99634e0 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -172,14 +172,12 @@ worker_timeout() = parse(Float64, get(ENV, "JULIA_WORKER_TIMEOUT", "60.0")) ## worker creation and setup ## """ - start_worker([out::IO=STDOUT], cookie::Union{AbstractString, Void}) + start_worker([out::IO=STDOUT], cookie::AbstractString=readline(STDIN)) `start_worker` is an internal function which is the default entry point for worker processes connecting via TCP/IP. It sets up the process as a Julia cluster worker. -If the cookie is `nothing`, the worker tries to read it from its STDIN. - host:port information is written to stream `out` (defaults to STDOUT). The function closes STDIN (after reading the cookie if required), redirects STDERR to STDOUT, @@ -188,8 +186,8 @@ line option) and schedules tasks to process incoming TCP connections and request It does not return. """ -start_worker(out::IO=STDOUT, cookie::Void=nothing) = start_worker(out, readline(STDIN)) -start_worker(cookie::Union{AbstractString, Void}) = start_worker(STDOUT, cookie) +start_worker(out::IO=STDOUT, cookie::Void=readline(STDIN)) = start_worker(out, cookie) +start_worker(cookie::AbstractString=readline(STDIN)) = start_worker(STDOUT, cookie) function start_worker(out::IO, cookie::AbstractString) close(STDIN) # workers will not use it redirect_stderr(STDOUT) diff --git a/stdlib/Distributed/src/remotecall.jl b/stdlib/Distributed/src/remotecall.jl index e5e7f62437f5f..ca2e4f25b4ffc 100644 --- a/stdlib/Distributed/src/remotecall.jl +++ b/stdlib/Distributed/src/remotecall.jl @@ -24,7 +24,7 @@ mutable struct Future <: AbstractRemoteRef id::Int v::Union{Some{Any}, Void} - Future(w::Int, rrid::RRID, v::Union{Some{<:Any}, Void}=nothing) = + Future(w::Int, rrid::RRID, v::Union{Some, Void}=nothing) = (r = new(w,rrid.whence,rrid.id,v); return test_existing_ref(r)) Future(t::NTuple{4, Any}) = new(t[1],t[2],t[3],t[4]) # Useful for creating dummy, zeroed-out instances diff --git a/test/some.jl b/test/some.jl index ced400855e8bd..ef7d425722627 100644 --- a/test/some.jl +++ b/test/some.jl @@ -1,9 +1,5 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license -## eltype() - -@test eltype(Some(1)) === Int - ## promote() @test promote_type(Some{Int}, Some{Float64}) === Some{Float64} @@ -25,12 +21,9 @@ @test_throws MethodError convert(Some, nothing) @test_throws MethodError convert(Some{Int}, nothing) -@test convert(Some, Some(nothing)) === Some(nothing) -@test convert(Some{Void}, Some(nothing)) === Some(nothing) @test convert(Some, Some(nothing)) === Some(nothing) @test convert(Some{Void}, Some(nothing)) === Some(nothing) -@test convert(Union{Some, Void}, nothing) === nothing @test convert(Union{Some, Void}, nothing) === nothing @test convert(Union{Some{Int}, Void}, nothing) === nothing From 5db20e31b5efab6a52992e7caf1ec006129e6aff Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Wed, 29 Nov 2017 22:01:09 +0100 Subject: [PATCH 05/16] Add coalesce() and use it --- base/deprecated.jl | 3 +-- base/libgit2/callbacks.jl | 8 ++++---- base/libgit2/gitcredential.jl | 8 ++++---- base/libgit2/utils.jl | 2 +- base/some.jl | 27 +++++++++++++++++++++++++++ base/statistics.jl | 4 ++-- stdlib/Distributed/src/cluster.jl | 10 +++++----- stdlib/Distributed/src/managers.jl | 17 ++++++++--------- test/libgit2-helpers.jl | 2 +- test/some.jl | 12 ++++++++++++ 10 files changed, 65 insertions(+), 28 deletions(-) diff --git a/base/deprecated.jl b/base/deprecated.jl index c9639b3206ba0..00ae37bf5cda6 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -1513,8 +1513,7 @@ end Base.depwarn(string( "`LibGit2.prompt(msg::AbstractString; default::AbstractString=\"\", password::Bool=false)` is deprecated, use ", "`result = Base.prompt(msg, default=default, password=password); result === nothing ? \"\" : result` instead."), :prompt) - result = Base.prompt(msg, default=default, password=password) - result === nothing ? "" : result + coalesce(Base.prompt(msg, default=default, password=password), "") end end diff --git a/base/libgit2/callbacks.jl b/base/libgit2/callbacks.jl index 9c540822ff43e..2be0e07d9aab2 100644 --- a/base/libgit2/callbacks.jl +++ b/base/libgit2/callbacks.jl @@ -188,8 +188,8 @@ function authenticate_userpass(libgit2credptr::Ptr{Ptr{Void}}, p::CredentialPayl git_cred = GitCredential(p.config, p.url) # Use `deepcopy` to ensure zeroing the `git_cred` doesn't also zero the `cred`s copy - cred.user = deepcopy(git_cred.username === nothing ? "" : git_cred.username) - cred.pass = deepcopy(git_cred.password === nothing ? "" : git_cred.password) + cred.user = deepcopy(coalesce(git_cred.username, "")) + cred.pass = deepcopy(coalesce(git_cred.password, "")) securezero!(git_cred) revised = true @@ -274,8 +274,8 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Void}}, url_ptr::Cstring, p.url = unsafe_string(url_ptr) m = match(URL_REGEX, p.url) - p.scheme = m[:scheme] === nothing ? "" : m[:scheme] - p.username = m[:user] === nothing ? "" : m[:user] + p.scheme = coalesce(m[:scheme], "") + p.username = coalesce(m[:user], "") p.host = m[:host] # When an explicit credential is supplied we will make sure to use the given diff --git a/base/libgit2/gitcredential.jl b/base/libgit2/gitcredential.jl index da9668d4994a6..2eb1b69471371 100644 --- a/base/libgit2/gitcredential.jl +++ b/base/libgit2/gitcredential.jl @@ -65,10 +65,10 @@ function ismatch(url::AbstractString, git_cred::GitCredential) m === nothing && error("Unable to parse URL") # Note: missing URL groups match anything - (m[:scheme] === nothing ? true : isequal(m[:scheme], git_cred.protocol)) && - (m[:host] === nothing ? true : isequal(m[:host], git_cred.host)) && - (m[:path] === nothing ? true : isequal(m[:path], git_cred.path)) && - (m[:user] === nothing ? true : isequal(m[:user], git_cred.username)) + (m[:scheme] === nothing ? true : m[:scheme] == git_cred.protocol) && + (m[:host] === nothing ? true : m[:host] == git_cred.host) && + (m[:path] === nothing ? true : m[:path] == git_cred.path) && + (m[:user] === nothing ? true : m[:user] == git_cred.username) end function isfilled(cred::GitCredential) diff --git a/base/libgit2/utils.jl b/base/libgit2/utils.jl index ed455035b30d3..1eacbd5e7d180 100644 --- a/base/libgit2/utils.jl +++ b/base/libgit2/utils.jl @@ -163,7 +163,7 @@ end function credential_identifier(url::AbstractString) m = match(URL_REGEX, url) - scheme = m[:scheme] === nothing ? "" : m[:scheme] + scheme = coalesce(m[:scheme], "") host = m[:host] credential_identifier(scheme, host) end diff --git a/base/some.jl b/base/some.jl index 49833b7cb9418..b9211e1bd8f76 100644 --- a/base/some.jl +++ b/base/some.jl @@ -60,3 +60,30 @@ function get end get(x::Some) = x.value get(x::Some, y) = x.value get(x::Void, y) = y + +""" + coalesce(x, y...) + +Return the first value in the arguments which is not equal to `nothing`, +or `nothing` if all arguments are `nothing`. + +# Examples + +```jldoctest +julia> coalesce(nothing, 1) +1 + +julia> coalesce(1, nothing) +1 + +julia> coalesce(nothing, nothing) +nothing + +``` +""" +function coalesce end + +coalesce(x::Any) = x +coalesce(x::Void) = nothing +coalesce(x::Any, y...) = x +coalesce(x::Void, y...) = coalesce(y...) \ No newline at end of file diff --git a/base/statistics.jl b/base/statistics.jl index 91a9660b451e2..593f7c3743053 100644 --- a/base/statistics.jl +++ b/base/statistics.jl @@ -198,7 +198,7 @@ varm(A::AbstractArray{T}, m::AbstractArray, region; corrected::Bool=true) where var(A::AbstractArray{T}; corrected::Bool=true, mean=nothing) where {T} = - real(varm(A, mean === nothing ? Base.mean(A) : mean; corrected=corrected)) + real(varm(A, coalesce(mean, Base.mean(A)); corrected=corrected)) """ var(v[, region]; corrected::Bool=true, mean=nothing) @@ -217,7 +217,7 @@ The mean `mean` over the region may be provided. `DataArrays.jl` package is recommended. """ var(A::AbstractArray, region; corrected::Bool=true, mean=nothing) = - varm(A, mean === nothing ? Base.mean(A, region) : mean, region; corrected=corrected) + varm(A, coalesce(mean, Base.mean(A, region)), region; corrected=corrected) varm(iterable, m; corrected::Bool=true) = var(iterable, corrected=corrected, mean=m) diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index 892dcd99634e0..6bb786dafc1ef 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -450,7 +450,7 @@ function setup_launched_worker(manager, wconfig, launched_q) # When starting workers on remote multi-core hosts, `launch` can (optionally) start only one # process on the remote machine, with a request to start additional workers of the # same type. This is done by setting an appropriate value to `WorkerConfig.cnt`. - cnt = wconfig.count === nothing ? 1 : wconfig.count + cnt = coalesce(wconfig.count, 1) if cnt === :auto cnt = wconfig.environ[:cpu_cores] end @@ -465,7 +465,7 @@ end function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launched_q) @sync begin exename = fromconfig.exename - exeflags = fromconfig.exeflags === nothing ? `` : fromconfig.exeflags + exeflags = coalesce(fromconfig.exeflags, ``) cmd = `$exename $exeflags` new_addresses = remotecall_fetch(launch_additional, frompid, cnt, cmd) @@ -567,11 +567,11 @@ function create_worker(manager, wconfig) end all_locs = map(x -> isa(x, Worker) ? - ((x.config.connect_at === nothing ? () : x.config.connect_at), x.id) : + (coalesce(x.config.connect_at, ()), x.id) : ((), x.id, true), join_list) send_connection_hdr(w, true) - enable_threaded_blas = wconfig.enable_threaded_blas === nothing ? false : wconfig.enable_threaded_blas + enable_threaded_blas = coalesce(wconfig.enable_threaded_blas, false) join_message = JoinPGRPMsg(w.id, all_locs, PGRP.topology, enable_threaded_blas, isclusterlazy()) send_msg_now(w, MsgHeader(RRID(0,0), ntfy_oid), join_message) @@ -690,7 +690,7 @@ function topology(t) t end -isclusterlazy() = PGRP.lazy === nothing ? false : PGRP.lazy +isclusterlazy() = coalesce(PGRP.lazy, false) get_bind_addr(pid::Integer) = get_bind_addr(worker_from_id(pid)) get_bind_addr(w::LocalProcess) = LPROC.bind_addr diff --git a/stdlib/Distributed/src/managers.jl b/stdlib/Distributed/src/managers.jl index b7e25d3e0be19..a727387969350 100644 --- a/stdlib/Distributed/src/managers.jl +++ b/stdlib/Distributed/src/managers.jl @@ -227,8 +227,8 @@ end function manage(manager::SSHManager, id::Integer, config::WorkerConfig, op::Symbol) if op == :interrupt - ospid = config.ospid === nothing ? 0 : config.ospid - if ospid > 0 + ospid = config.ospid + if ospid !== nothing host = config.host sshflags = config.sshflags if !success(`ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host "kill -2 $ospid"`) @@ -395,16 +395,16 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) # master connecting to workers if config.io !== nothing (bind_addr, port) = read_worker_host_port(config.io) - pubhost = config.host === nothing ? bind_addr : config.host + pubhost = coalesce(config.host, bind_addr) config.host = pubhost config.port = port else - pubhost = config.host - port = config.port - bind_addr = config.bind_addr === nothing ? pubhost : config.bind_addr + pubhost = notnothing(config.host) + port = notnothing(config.port) + bind_addr = coalesce(config.bind_addr, pubhost) end - tunnel = config.tunnel === nothing ? false : config.tunnel + tunnel = coalesce(config.tunnel, false) s = split(pubhost,'@') user = "" @@ -422,8 +422,7 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) if tunnel if !haskey(tunnel_hosts_map, pubhost) - tunnel_hosts_map[pubhost] = Semaphore(config.max_parallel === nothing ? - typemax(Int) : config.max_parallel) + tunnel_hosts_map[pubhost] = Semaphore(coalesce(config.max_parallel, typemax(Int))) end sem = tunnel_hosts_map[pubhost] diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl index 0539b8699c6f0..c562699131f1e 100644 --- a/test/libgit2-helpers.jl +++ b/test/libgit2-helpers.jl @@ -28,7 +28,7 @@ function credential_loop( err = Cint(0) while err == 0 err = ccall(cb, Cint, (Ptr{Ptr{Void}}, Cstring, Cstring, Cuint, Any), - libgitcred_ptr_ptr, url, user === nothing ? C_NULL : user, + libgitcred_ptr_ptr, url, coalesce(user, C_NULL), allowed_types, payload) num_authentications += 1 diff --git a/test/some.jl b/test/some.jl index ef7d425722627..d4f57f9e3aedc 100644 --- a/test/some.jl +++ b/test/some.jl @@ -55,3 +55,15 @@ @test get(Some(1), 0) === 1 @test get(Some(nothing), 0) === nothing @test get(nothing, 0) === 0 + +# coalesce() +using Base.coalesce +@test coalesce(1) === 1 +@test coalesce(nothing) === nothing +@test coalesce(nothing, 1) === 1 +@test coalesce(1, nothing) === 1 +@test coalesce(nothing, nothing) === nothing +@test coalesce(nothing, 1, 2) === 1 +@test coalesce(1, nothing, 2) === 1 +@test coalesce(nothing, nothing, 2) === 2 +@test coalesce(nothing, nothing, nothing) === nothing \ No newline at end of file From a2f17993ec722add00c4904d030390a69ca73c15 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Wed, 29 Nov 2017 22:52:52 +0100 Subject: [PATCH 06/16] Fix start_worker() method definition --- stdlib/Distributed/src/cluster.jl | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index 6bb786dafc1ef..723be351324ee 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -186,9 +186,8 @@ line option) and schedules tasks to process incoming TCP connections and request It does not return. """ -start_worker(out::IO=STDOUT, cookie::Void=readline(STDIN)) = start_worker(out, cookie) start_worker(cookie::AbstractString=readline(STDIN)) = start_worker(STDOUT, cookie) -function start_worker(out::IO, cookie::AbstractString) +function start_worker(out::IO, cookie::AbstractString=readline(STDIN)) close(STDIN) # workers will not use it redirect_stderr(STDOUT) From c0053f03c7ded941eaffbd904fe00aaa66a8db26 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Wed, 29 Nov 2017 22:56:19 +0100 Subject: [PATCH 07/16] Add notnothing(x) to assert that x !== nothing Use it everywhere get() was called and nothing would not trigger an error immediately. --- base/libgit2/config.jl | 2 +- base/libgit2/libgit2.jl | 1 + base/lock.jl | 4 ++-- base/some.jl | 10 +++++++++- stdlib/Distributed/src/Distributed.jl | 2 +- stdlib/Distributed/src/cluster.jl | 11 +++++------ stdlib/Distributed/src/managers.jl | 10 +++++----- test/libgit2-helpers.jl | 1 + test/some.jl | 7 ++++++- 9 files changed, 31 insertions(+), 17 deletions(-) diff --git a/base/libgit2/config.jl b/base/libgit2/config.jl index 867890bb4655c..02c86fcdb8bcf 100644 --- a/base/libgit2/config.jl +++ b/base/libgit2/config.jl @@ -209,7 +209,7 @@ end Base.done(ci::GitConfigIter, state) = state === nothing function Base.next(ci::GitConfigIter, state) - entry = state + entry = notnothing(state) entry_ptr_ptr = Ref{Ptr{ConfigEntry}}(C_NULL) err = ccall((:git_config_next, :libgit2), Cint, (Ptr{Ptr{ConfigEntry}}, Ptr{Void}), entry_ptr_ptr, ci.ptr) diff --git a/base/libgit2/libgit2.jl b/base/libgit2/libgit2.jl index 617dc3e128dda..2eaefcdb88c38 100644 --- a/base/libgit2/libgit2.jl +++ b/base/libgit2/libgit2.jl @@ -6,6 +6,7 @@ Interface to [libgit2](https://libgit2.github.com/). module LibGit2 import Base: == +using Base: coalesce, notnothing export with, GitRepo, GitConfig diff --git a/base/lock.jl b/base/lock.jl index 94e49797c1976..2b427e84a6398 100644 --- a/base/lock.jl +++ b/base/lock.jl @@ -44,7 +44,7 @@ function trylock(rl::ReentrantLock) rl.locked_by = t rl.reentrancy_cnt = 1 return true - elseif t == rl.locked_by + elseif t == notnothing(rl.locked_by) rl.reentrancy_cnt += 1 return true end @@ -67,7 +67,7 @@ function lock(rl::ReentrantLock) rl.locked_by = t rl.reentrancy_cnt = 1 return - elseif t == rl.locked_by + elseif t == notnothing(rl.locked_by) rl.reentrancy_cnt += 1 return end diff --git a/base/some.jl b/base/some.jl index b9211e1bd8f76..5792b2ab1075e 100644 --- a/base/some.jl +++ b/base/some.jl @@ -86,4 +86,12 @@ function coalesce end coalesce(x::Any) = x coalesce(x::Void) = nothing coalesce(x::Any, y...) = x -coalesce(x::Void, y...) = coalesce(y...) \ No newline at end of file +coalesce(x::Void, y...) = coalesce(y...) + +""" + notnothing(x) + +Throw an error if `x == nothing`, and return `x` if not. +""" +notnothing(x::Any) = x +notnothing(::Void) = throw(ArgumentError("nothing passed to notnothing")) \ No newline at end of file diff --git a/stdlib/Distributed/src/Distributed.jl b/stdlib/Distributed/src/Distributed.jl index 7a243bfb94f45..d36705747138b 100644 --- a/stdlib/Distributed/src/Distributed.jl +++ b/stdlib/Distributed/src/Distributed.jl @@ -16,7 +16,7 @@ using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connecte VERSION_STRING, sync_begin, sync_add, sync_end, async_run_thunk, binding_module, notify_error, atexit, julia_exename, julia_cmd, AsyncGenerator, acquire, release, invokelatest, - shell_escape_posixly, uv_error + shell_escape_posixly, uv_error, coalesce, notnothing using Base.Unicode: isascii, isdigit, isnumeric # NOTE: clusterserialize.jl imports additional symbols from Base.Serializer for use diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl index 723be351324ee..2f21b6e7809f1 100644 --- a/stdlib/Distributed/src/cluster.jl +++ b/stdlib/Distributed/src/cluster.jl @@ -129,7 +129,7 @@ end exec_conn_func(id::Int) = exec_conn_func(worker_from_id(id)) function exec_conn_func(w::Worker) try - f = w.conn_func + f = notnothing(w.conn_func) # Will be called if some other task tries to connect at the same time. w.conn_func = () -> wait_for_conn(w) f() @@ -463,7 +463,7 @@ end function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launched_q) @sync begin - exename = fromconfig.exename + exename = notnothing(fromconfig.exename) exeflags = coalesce(fromconfig.exeflags, ``) cmd = `$exename $exeflags` @@ -549,8 +549,7 @@ function create_worker(manager, wconfig) elseif PGRP.topology == :custom # wait for requested workers to be up before connecting to them. filterfunc(x) = (x.id != 1) && isdefined(x, :config) && - (x.config.ident !== nothing) && (wconfig.connect_idents !== nothing) && - (x.config.ident in wconfig.connect_idents) + (notnothing(x.config.ident) in coalesce(wconfig.connect_idents, [])) wlist = filter(filterfunc, PGRP.workers) while wconfig.connect_idents !== nothing && @@ -1051,8 +1050,8 @@ function check_same_host(pids) if all(p -> (p==1) || (isa(map_pid_wrkr[p].manager, LocalManager)), pids) return true else - first_bind_addr = map_pid_wrkr[pids[1]].config.bind_addr - return all(p -> (p != 1) && (map_pid_wrkr[p].config.bind_addr == first_bind_addr), pids[2:end]) + first_bind_addr = notnothing(map_pid_wrkr[pids[1]].config.bind_addr) + return all(p -> (p != 1) && (notnothing(map_pid_wrkr[p].config.bind_addr) == first_bind_addr), pids[2:end]) end end end diff --git a/stdlib/Distributed/src/managers.jl b/stdlib/Distributed/src/managers.jl index a727387969350..ad5c4318766cc 100644 --- a/stdlib/Distributed/src/managers.jl +++ b/stdlib/Distributed/src/managers.jl @@ -229,8 +229,8 @@ function manage(manager::SSHManager, id::Integer, config::WorkerConfig, op::Symb if op == :interrupt ospid = config.ospid if ospid !== nothing - host = config.host - sshflags = config.sshflags + host = notnothing(config.host) + sshflags = notnothing(config.sshflags) if !success(`ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host "kill -2 $ospid"`) @error "Error sending a Ctrl-C to julia worker $id on $host" end @@ -426,7 +426,7 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) end sem = tunnel_hosts_map[pubhost] - sshflags = config.sshflags + sshflags = notnothing(config.sshflags) acquire(sem) try (s, bind_addr) = connect_to_worker(pubhost, bind_addr, port, user, sshflags) @@ -444,7 +444,7 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) if config.io !== nothing let pid = pid - redirect_worker_output(pid, config.io) + redirect_worker_output(pid, notnothing(config.io)) end end @@ -452,7 +452,7 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig) end function connect_w2w(pid::Int, config::WorkerConfig) - (rhost, rport) = config.connect_at + (rhost, rport) = notnothing(config.connect_at) config.host = rhost config.port = rport (s, bind_addr) = connect_to_worker(rhost, rport) diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl index c562699131f1e..c8c3f657ca3b1 100644 --- a/test/libgit2-helpers.jl +++ b/test/libgit2-helpers.jl @@ -2,6 +2,7 @@ import Base.LibGit2: AbstractCredential, UserPasswordCredential, SSHCredential, CachedCredentials, CredentialPayload, Payload +using Base: coalesce const DEFAULT_PAYLOAD = CredentialPayload(allow_ssh_agent=false, allow_git_helpers=false) diff --git a/test/some.jl b/test/some.jl index d4f57f9e3aedc..4eae24f409a9b 100644 --- a/test/some.jl +++ b/test/some.jl @@ -66,4 +66,9 @@ using Base.coalesce @test coalesce(nothing, 1, 2) === 1 @test coalesce(1, nothing, 2) === 1 @test coalesce(nothing, nothing, 2) === 2 -@test coalesce(nothing, nothing, nothing) === nothing \ No newline at end of file +@test coalesce(nothing, nothing, nothing) === nothing + +# notnothing() +using Base: notnothing +@test notnothing(1) === 1 +@test_throws ArgumentError notnothing(nothing) \ No newline at end of file From ec91f63b18045956db907c0c3c8dbfab6de286ea Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Tue, 5 Dec 2017 14:42:22 +0100 Subject: [PATCH 08/16] Fix ProductIterator regression by using custom MaybeValue wrapper MaybeValue is just a simplified version of Nullable reserved for internal use which wraps a value or no value in a type-stable way. Information about whether a value is present or not is carried separately. --- base/iterators.jl | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/base/iterators.jl b/base/iterators.jl index e8a2e06b7c2e9..ce2517bb29c0f 100644 --- a/base/iterators.jl +++ b/base/iterators.jl @@ -5,7 +5,7 @@ Methods for working with Iterators. """ module Iterators -import Base: start, done, next, isempty, length, size, eltype, iteratorsize, iteratoreltype, axes, ndims, pairs, last, first +import Base: start, done, next, isempty, length, size, eltype, iteratorsize, iteratoreltype, axes, ndims, pairs, last, first, get using Base: tail, tuple_type_head, tuple_type_tail, tuple_type_cons, SizeUnknown, HasLength, HasShape, IsInfinite, EltypeUnknown, HasEltype, OneTo, @propagate_inbounds, Generator, AbstractRange @@ -746,6 +746,14 @@ function next(P::ProductIterator, state) end done(P::ProductIterator, state) = state[1] +struct MaybeValue{T} + x::T + MaybeValue{T}() where {T} = new{T}() + MaybeValue{T}(x::T) where {T} = new{T}(x) +end + +get(v::MaybeValue) = v.x + _prod_start(iterators::Tuple{}) = false, (), () function _prod_start(iterators) iter1 = first(iterators) @@ -753,10 +761,10 @@ function _prod_start(iterators) d, tailstates, tailnvalues = _prod_start(tail(iterators)) if done(iter1, state1) d = true - nvalue1 = nothing + nvalue1 = MaybeValue{eltype(iter1)}() else value1, state1 = next(iter1, state1) - nvalue1 = Some{eltype(iter1)}(value1) + nvalue1 = MaybeValue{eltype(iter1)}(value1) end return (d, (state1, tailstates...), (nvalue1, tailnvalues...)) end @@ -767,15 +775,15 @@ function _prod_next(iterators, states, nvalues) state1 = first(states) if !done(iter1, state1) value1, state1 = next(iter1, state1) - nvalue1 = Some{eltype(iter1)}(value1) + nvalue1 = MaybeValue{eltype(iter1)}(value1) return false, (state1, tail(states)...), (nvalue1, tail(nvalues)...) else d, tailstates, tailnvalues = _prod_next(tail(iterators), tail(states), tail(nvalues)) if d # all iterators are done - nvalue1 = nothing + nvalue1 = MaybeValue{eltype(iter1)}() else value1, state1 = next(iter1, start(iter1)) # iter cannot be done immediately - nvalue1 = Some{eltype(iter1)}(value1) + nvalue1 = MaybeValue{eltype(iter1)}(value1) end return d, (state1, tailstates...), (nvalue1, tailnvalues...) end From c8b6193931aa41898a1a3247eb3c82685dd0a8ac Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Tue, 5 Dec 2017 14:54:37 +0100 Subject: [PATCH 09/16] Improve NEWS --- NEWS.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/NEWS.md b/NEWS.md index 398ef04a38aeb..abb505486678a 100644 --- a/NEWS.md +++ b/NEWS.md @@ -770,10 +770,10 @@ Deprecated or removed * `Associative` has been deprecated in favor of `AbstractDict` ([#25012]). - * `Nullable{T}` has been deprecated and moved to the Nullables package: - use `Union{T, Void}` or `Union{Some{T}, Void}` instead. `isnull(x)` can be replaced - with `x === nothing` and `unsafe_get(x)` with `get(x)`. - `NullException` has been removed ([#23642]). + * `Nullable{T}` has been deprecated and moved to the Nullables package ([#23642]). + Use `Union{T, Void}` instead, or `Union{Some{T}, Void}` if `nothing` is a possible value + (i.e. `Void <: T`). `isnull(x)` can be replaced with `x === nothing` + and `unsafe_get(x)` with `get(x)`. `NullException` has been removed. Command-line option changes --------------------------- From bfb40cf52b56fe468abc895f82891885274cb361 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Thu, 14 Dec 2017 22:42:44 +0100 Subject: [PATCH 10/16] Make tryparse() return Union{T, Void} --- base/client.jl | 2 +- base/gmp.jl | 2 +- base/int.jl | 6 +-- base/mpfr.jl | 2 +- base/parse.jl | 51 ++++++++++----------- base/repl/REPL.jl | 1 - stdlib/Dates/src/io.jl | 15 +++--- stdlib/Dates/src/parse.jl | 44 +++++++++--------- stdlib/DelimitedFiles/src/DelimitedFiles.jl | 12 ++--- test/parse.jl | 10 ++-- test/spawn.jl | 2 +- test/strings/basic.jl | 8 ++-- 12 files changed, 75 insertions(+), 80 deletions(-) diff --git a/base/client.jl b/base/client.jl index c97bb39ba9f4d..c4f29777c5149 100644 --- a/base/client.jl +++ b/base/client.jl @@ -76,7 +76,7 @@ color_normal = text_colors[:normal] function repl_color(key, default) env_str = get(ENV, key, "") c = tryparse(Int, env_str) - c_conv = get(c, Symbol(env_str)) + c_conv = coalesce(c, Symbol(env_str)) haskey(text_colors, c_conv) ? c_conv : default end diff --git a/base/gmp.jl b/base/gmp.jl index 4bde7223cb29c..ffbc4731fb517 100644 --- a/base/gmp.jl +++ b/base/gmp.jl @@ -256,7 +256,7 @@ function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, end raise && throw(ArgumentError("invalid BigInt: $(repr(bstr))")) return nothing end - Some(flipsign!(z, sgn)) + flipsign!(z, sgn) end convert(::Type{BigInt}, x::Union{Clong,Int32}) = MPZ.set_si(x) diff --git a/base/int.jl b/base/int.jl index eacfa07acd486..4620784e3c3a8 100644 --- a/base/int.jl +++ b/base/int.jl @@ -603,12 +603,12 @@ macro big_str(s) print(bf, s[end]) seekstart(bf) n = tryparse(BigInt, String(take!(bf))) - n === nothing || return get(n) + n === nothing || return n else n = tryparse(BigInt, s) - n === nothing || return get(n) + n === nothing || return n n = tryparse(BigFloat, s) - n === nothing || return get(n) + n === nothing || return n end message = "invalid number format $s for BigInt or BigFloat" return :(throw(ArgumentError($message))) diff --git a/base/mpfr.jl b/base/mpfr.jl index 1e20bcad0a9c3..c3208e53c5d34 100644 --- a/base/mpfr.jl +++ b/base/mpfr.jl @@ -125,7 +125,7 @@ function tryparse(::Type{BigFloat}, s::AbstractString, base::Int=0) !isempty(s) && Base.Unicode.isspace(s[end]) && return tryparse(BigFloat, rstrip(s), base) z = BigFloat() err = ccall((:mpfr_set_str, :libmpfr), Int32, (Ref{BigFloat}, Cstring, Int32, Int32), z, s, base, ROUNDING_MODE[]) - err == 0 ? Some(z) : nothing + err == 0 ? z : nothing end convert(::Type{Rational}, x::BigFloat) = convert(Rational{BigInt}, x) diff --git a/base/parse.jl b/base/parse.jl index c264aa52a69de..9ecf359f7452b 100644 --- a/base/parse.jl +++ b/base/parse.jl @@ -121,7 +121,7 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: n += d if i > endpos n *= sgn - return Some(n) + return n end c, i = next(s,i) Unicode.isspace(c) && break @@ -143,7 +143,7 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: raise && throw(OverflowError("overflow parsing $(repr(SubString(s,startpos,endpos)))")) return nothing end - (i > endpos) && return Some(n) + (i > endpos) && return n c, i = next(s,i) end while i <= endpos @@ -153,7 +153,7 @@ function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos:: return nothing end end - return Some(n) + return n end function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString{String}}, @@ -178,9 +178,9 @@ function tryparse_internal(::Type{Bool}, sbuff::Union{String,SubString{String}}, p = pointer(sbuff) + startpos - 1 @gc_preserve sbuff begin (len == 4) && (0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), - p, "true", 4)) && (return Some(true)) + p, "true", 4)) && (return true) (len == 5) && (0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), - p, "false", 5)) && (return Some(false)) + p, "false", 5)) && (return false) end if raise @@ -204,8 +204,8 @@ end """ tryparse(type, str, [base]) -Like [`parse`](@ref), but returns either a [`Some`](@ref) object wrapping a value -of the requested type, or [`nothing`](@ref) if the string does not contain a valid number. +Like [`parse`](@ref), but returns either a value of the requested type, +or [`nothing`](@ref) if the string does not contain a valid number. """ tryparse(::Type{T}, s::AbstractString, base::Integer) where {T<:Integer} = tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), false) @@ -213,11 +213,11 @@ tryparse(::Type{T}, s::AbstractString) where {T<:Integer} = tryparse_internal(T, s, start(s), endof(s), 0, false) function parse(::Type{T}, s::AbstractString, base::Integer) where T<:Integer - get(tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), true)) + tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), true) end function parse(::Type{T}, s::AbstractString) where T<:Integer - get(tryparse_internal(T, s, start(s), endof(s), 0, true)) # Zero means, "figure it out" + tryparse_internal(T, s, start(s), endof(s), 0, true) # Zero means, "figure it out" end ## string to float functions ## @@ -225,48 +225,48 @@ end function tryparse(::Type{Float64}, s::String) hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse(::Type{Float64}, s::SubString{String}) hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse_internal(::Type{Float64}, s::String, startpos::Int, endpos::Int) hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse_internal(::Type{Float64}, s::SubString{String}, startpos::Int, endpos::Int) hasvalue, val = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse(::Type{Float32}, s::String) hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s)) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse(::Type{Float32}, s::SubString{String}) hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.ncodeunits) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse_internal(::Type{Float32}, s::String, startpos::Int, endpos::Int) hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, startpos-1, endpos-startpos+1) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end function tryparse_internal(::Type{Float32}, s::SubString{String}, startpos::Int, endpos::Int) hasvalue, val = ccall(:jl_try_substrtof, Tuple{Bool, Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset+startpos-1, endpos-startpos+1) - hasvalue ? Some(val) : nothing + hasvalue ? val : nothing end tryparse(::Type{T}, s::AbstractString) where {T<:Union{Float32,Float64}} = tryparse(T, String(s)) tryparse(::Type{Float16}, s::AbstractString) = - convert(Union{Some{Float16}, Void}, tryparse(Float32, s)) + convert(Union{Float16, Void}, tryparse(Float32, s)) tryparse_internal(::Type{Float16}, s::AbstractString, startpos::Int, endpos::Int) = - convert(Union{Some{Float16}, Void}, tryparse_internal(Float32, s, startpos, endpos)) + convert(Union{Float16, Void}, tryparse_internal(Float32, s, startpos, endpos)) ## string to complex functions ## @@ -301,12 +301,11 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String} if i₊ == 0 # purely real or imaginary value if iᵢ > 0 # purely imaginary - x_ = tryparse_internal(T, s, i, iᵢ-1, raise) - x_ === nothing && return nothing - x = get(x_) - return Some(Complex{T}(zero(x),x)) + x = tryparse_internal(T, s, i, iᵢ-1, raise) + x === nothing && return nothing + return Complex{T}(zero(x),x) else # purely real - return Some(tryparse_internal(T, s, i, e, raise)) + return Complex{T}(tryparse_internal(T, s, i, e, raise)) end end @@ -323,7 +322,7 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String} im = tryparse_internal(T, s, i₊+1, iᵢ-1, raise) im === nothing && return nothing - return Some(Complex{T}(get(re), s[i₊]=='-' ? -get(im) : get(im))) + return Complex{T}(re, s[i₊]=='-' ? -im : im) end # the ±1 indexing above for ascii chars is specific to String, so convert: @@ -344,4 +343,4 @@ tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, rais tryparse_internal(T, s, startpos, endpos, 10, raise) parse(::Type{T}, s::AbstractString) where T<:Union{Real,Complex} = - get(tryparse_internal(T, s, start(s), endof(s), true)) + tryparse_internal(T, s, start(s), endof(s), true) diff --git a/base/repl/REPL.jl b/base/repl/REPL.jl index 94460b0371151..a3175eb35d901 100644 --- a/base/repl/REPL.jl +++ b/base/repl/REPL.jl @@ -981,7 +981,6 @@ function setup_interface( str = String(take!(LineEdit.buffer(s))) n = tryparse(Int, str) n === nothing && @goto writeback - n = get(n) if n <= 0 || n > length(linfos) || startswith(linfos[n][1], "./REPL") @goto writeback end diff --git a/stdlib/Dates/src/io.jl b/stdlib/Dates/src/io.jl index 504c8787d5ef2..3a35feb29584a 100644 --- a/stdlib/Dates/src/io.jl +++ b/stdlib/Dates/src/io.jl @@ -19,8 +19,7 @@ the argument out in the method definition. Return a tuple of 2 elements `(res, idx)`, where: -* `res` is either a [`Some`](@ref) object holding the result of the parsing, - or `nothing` if parsing failed. +* `res` is either the result of the parsing, or `nothing` if parsing failed. * `idx` is an `Int` - if parsing failed, the index at which it failed; if parsing succeeded, `idx` is the index _after_ the index at which parsing ended. """ @@ -100,11 +99,11 @@ end for (tok, fn) in zip("uUeE", [monthabbr_to_value, monthname_to_value, dayabbr_to_value, dayname_to_value]) @eval @inline function tryparsenext(d::DatePart{$tok}, str, i, len, locale) word, i = tryparsenext_word(str, i, len, locale, max_width(d)) - val = word === nothing ? 0 : $fn(get(word), locale) + val = word === nothing ? 0 : $fn(word, locale) if val == 0 return nothing, i else - return Some(val), i + return val, i end end end @@ -115,7 +114,7 @@ struct Decimal3 end @inline function tryparsenext(d::DatePart{'s'}, str, i, len) ms, ii = tryparsenext_base10(str, i, len, min_width(d), max_width(d)) if ms !== nothing - val0 = val = get(ms) + val0 = val = ms len = ii - i if len > 3 val, r = divrem(val, Int64(10) ^ (len - 3)) @@ -123,7 +122,7 @@ struct Decimal3 end else val *= Int64(10) ^ (3 - len) end - ms = Some(val) + ms = val end return ms, ii end @@ -192,7 +191,7 @@ Delim(d::String) = Delim{String, length(d)}(d) c, i = next(str, i) c != d.d && return (nothing, i) end - return Some(true), i + return true, i end @inline function tryparsenext(d::Delim{String, N}, str, i::Int, len) where N @@ -208,7 +207,7 @@ end return nothing, i1 end end - return Some(true), i1 + return true, i1 end @inline function format(io, d::Delim, dt, locale) diff --git a/stdlib/Dates/src/parse.jl b/stdlib/Dates/src/parse.jl index 6dcce55ef37ce..8c59189b5687c 100644 --- a/stdlib/Dates/src/parse.jl +++ b/stdlib/Dates/src/parse.jl @@ -27,8 +27,8 @@ the end of the string, `len`. When a directive cannot be parsed the returned val will be `nothing` if `raise` is false otherwise an exception will be thrown. Return a 3-element tuple `(values, pos, num_parsed)`: -* `values::Union{Some{Tuple}, Void}`: Either `nothing`, or a `Some` object wrapping a tuple - which contains a value for each `DatePart` within the `DateFormat` in the order +* `values::Union{Tuple, Void}`: Either `nothing`, or a tuple which contains a value + for each `DatePart` within the `DateFormat` in the order in which they occur. If the string ends before we finish parsing all the directives the missing values will be filled in with default values. * `pos::Int`: The character index at which parsing stopped. @@ -43,7 +43,6 @@ Return a 3-element tuple `(values, pos, num_parsed)`: tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters] value_names = Symbol[genvar(t) for t in tokens] value_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in tokens) - R = typeof(value_defaults) # Pre-assign variables to defaults. Allows us to use `@goto done` without worrying about # unassigned variables. @@ -65,7 +64,7 @@ Return a 3-element tuple `(values, pos, num_parsed)`: pos > len && @goto done $val, next_pos = tryparsenext(directives[$i], str, pos, len, locale) $val === nothing && @goto error - $name = get($val) + $name = $val pos = next_pos num_parsed += 1 directive_index += 1 @@ -96,7 +95,7 @@ Return a 3-element tuple `(values, pos, num_parsed)`: pos > len || @goto error @label done - return Some{$R}($(Expr(:tuple, value_names...))), pos, num_parsed + return $(Expr(:tuple, value_names...)), pos, num_parsed @label error if raise @@ -121,8 +120,8 @@ parsed the returned value tuple will be `nothing` if `raise` is false otherwise be thrown. Return a 2-element tuple `(values, pos)`: -* `values::Union{Some{Tuple}, Void}`: Either `nothing`, or a `Some` object wrapping a tuple - which contains a value for each token as specified by the passed in type. +* `values::Union{Tuple, Void}`: Either `nothing`, or a tuple which contains a value + for each token as specified by the passed in type. * `pos::Int`: The character index at which parsing stopped. """ @generated function tryparsenext_internal(::Type{T}, str::AbstractString, pos::Int, len::Int, @@ -135,7 +134,6 @@ Return a 2-element tuple `(values, pos)`: output_tokens = CONVERSION_TRANSLATIONS[T] output_names = Symbol[genvar(t) for t in output_tokens] output_defaults = Tuple(CONVERSION_DEFAULTS[t] for t in output_tokens) - R = typeof(output_defaults) # Pre-assign output variables to defaults. Ensures that all output variables are # assigned as the value tuple returned from `tryparsenext_core` may not include all @@ -154,8 +152,8 @@ Return a 2-element tuple `(values, pos)`: values, pos, num_parsed = tryparsenext_core(str, pos, len, df, raise) values === nothing && return nothing, pos $(assign_defaults...) - $value_tuple = get(values) - return Some{$R}($(Expr(:tuple, output_names...))), pos + $value_tuple = values + return $(Expr(:tuple, output_names...)), pos end end @@ -176,7 +174,7 @@ end if i <= min_pos return nothing, i else - return Some(d), i + return d, i end end @@ -195,7 +193,7 @@ end if word_end == 0 return nothing, i else - return Some(SubString(str, word_start, word_end)), i + return SubString(str, word_start, word_end), i end end @@ -206,7 +204,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF th = tm = ts = tms = Int64(0) val, i = tryparsenext_base10(s, i, end_pos, 1) - dy = val === nothing ? (@goto error) : get(val) + dy = val === nothing ? (@goto error) : val i > end_pos && @goto error c, i = next(s, i) @@ -214,7 +212,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, i = tryparsenext_base10(s, i, end_pos, 1, 2) - dm = val === nothing ? (@goto error) : get(val) + dm = val === nothing ? (@goto error) : val i > end_pos && @goto done c, i = next(s, i) @@ -222,7 +220,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, i = tryparsenext_base10(s, i, end_pos, 1, 2) - dd = val === nothing ? (@goto error) : get(val) + dd = val === nothing ? (@goto error) : val i > end_pos && @goto done c, i = next(s, i) @@ -230,7 +228,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, i = tryparsenext_base10(s, i, end_pos, 1, 2) - th = val === nothing ? (@goto error) : get(val) + th = val === nothing ? (@goto error) : val i > end_pos && @goto done c, i = next(s, i) @@ -238,7 +236,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, i = tryparsenext_base10(s, i, end_pos, 1, 2) - tm = val === nothing ? (@goto error) : get(val) + tm = val === nothing ? (@goto error) : val i > end_pos && @goto done c, i = next(s, i) @@ -246,7 +244,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, i = tryparsenext_base10(s, i, end_pos, 1, 2) - ts = val === nothing ? (@goto error) : get(val) + ts = val === nothing ? (@goto error) : val i > end_pos && @goto done c, i = next(s, i) @@ -254,7 +252,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF i > end_pos && @goto done val, j = tryparsenext_base10(s, i, end_pos, 1, 3) - tms = val === nothing ? (@goto error) : get(val) + tms = val === nothing ? (@goto error) : val tms *= 10 ^ (3 - (j - i)) j > end_pos || @goto error @@ -269,7 +267,7 @@ end function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType pos, len = start(str), endof(str) values, pos = tryparsenext_internal(T, str, pos, len, df, true) - T(get(values)...) + T(values...) end function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType @@ -277,9 +275,9 @@ function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_fo values, pos = tryparsenext_internal(T, str, pos, len, df, false) if values === nothing nothing - elseif validargs(T, get(values)...) === nothing + elseif validargs(T, values...) === nothing # TODO: validargs gets called twice, since it's called again in the T constructor - Some(T(get(values)...)) + T(values...) else nothing end @@ -300,7 +298,7 @@ number of components may be less than the total number of `DatePart`. quote pos, len = start(str), endof(str) values, pos, num_parsed = tryparsenext_core(str, pos, len, df, true) - t = get(values) + t = values types = $(Expr(:tuple, tokens...)) result = Vector{Any}(uninitialized, num_parsed) for (i, typ) in enumerate(types) diff --git a/stdlib/DelimitedFiles/src/DelimitedFiles.jl b/stdlib/DelimitedFiles/src/DelimitedFiles.jl index 7ff6dfa3c2832..02337e6d7a9bf 100644 --- a/stdlib/DelimitedFiles/src/DelimitedFiles.jl +++ b/stdlib/DelimitedFiles/src/DelimitedFiles.jl @@ -523,17 +523,17 @@ end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Bool,2}, row::Int, col::Int) n = tryparse_internal(Bool, sbuff, startpos, endpos, 0, false) - n === nothing || (cells[row, col] = get(n)) + n === nothing || (cells[row, col] = n) n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) where T<:Integer n = tryparse_internal(T, sbuff, startpos, endpos, 0, false) - n === nothing || (cells[row, col] = get(n)) + n === nothing || (cells[row, col] = n) n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) where T<:Union{Real,Complex} n = tryparse_internal(T, sbuff, startpos, endpos, false) - n === nothing || (cells[row, col] = get(n)) + n === nothing || (cells[row, col] = n) n === nothing end function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{<:AbstractString,2}, row::Int, col::Int) @@ -546,12 +546,12 @@ function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Any,2}, if len > 0 # check Inteter ni64 = tryparse_internal(Int, sbuff, startpos, endpos, 0, false) - ni64 === nothing || (cells[row, col] = get(ni64); return false) + ni64 === nothing || (cells[row, col] = ni64; return false) # check Bool nb = tryparse_internal(Bool, sbuff, startpos, endpos, 0, false) - nb === nothing || (cells[row, col] = get(nb); return false) - + nb === nothing || (cells[row, col] = nb; return false) + # check float64 hasvalue, valf64 = ccall(:jl_try_substrtod, Tuple{Bool, Float64}, (Ptr{UInt8}, Csize_t, Csize_t), sbuff, startpos-1, endpos-startpos+1) diff --git a/test/parse.jl b/test/parse.jl index 9911f92a71c6b..0c17bdc59a474 100644 --- a/test/parse.jl +++ b/test/parse.jl @@ -212,8 +212,8 @@ end @test parse(Int, "2") === 2 @test parse(Bool, "true") === true @test parse(Bool, "false") === false -@test tryparse(Bool, "true") === Some(true) -@test tryparse(Bool, "false") === Some(false) +@test tryparse(Bool, "true") === true +@test tryparse(Bool, "false") === false @test_throws ArgumentError parse(Int, "2", 1) @test_throws ArgumentError parse(Int, "2", 63) @@ -225,9 +225,9 @@ end # error throwing branch from #10560 @test_throws ArgumentError Base.tryparse_internal(Bool, "foo", 1, 2, 10, true) -@test tryparse(Float64, "1.23") === Some(1.23) -@test tryparse(Float32, "1.23") === Some(1.23f0) -@test tryparse(Float16, "1.23") === Some(Float16(1.23)) +@test tryparse(Float64, "1.23") === 1.23 +@test tryparse(Float32, "1.23") === 1.23f0 +@test tryparse(Float16, "1.23") === Float16(1.23) # parsing complex numbers (#22250) @testset "complex parsing" begin diff --git a/test/spawn.jl b/test/spawn.jl index 08d85e362beba..48ee76874296d 100644 --- a/test/spawn.jl +++ b/test/spawn.jl @@ -453,7 +453,7 @@ if Sys.isunix() let ps = Pipe[] ulimit_n = tryparse(Int, readchomp(`sh -c 'ulimit -n'`)) try - for i = 1 : 100 * get(ulimit_n, 1000) + for i = 1 : 100 * coalesce(ulimit_n, 1000) p = Pipe() Base.link_pipe(p) push!(ps, p) diff --git a/test/strings/basic.jl b/test/strings/basic.jl index 4d0abe8a6010b..e881ec16dafbc 100644 --- a/test/strings/basic.jl +++ b/test/strings/basic.jl @@ -247,7 +247,7 @@ end for T in [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128] for i in [typemax(T), typemin(T)] s = "$i" - @test get(tryparse(T, s)) == i + @test tryparse(T, s) == i end end @@ -271,12 +271,12 @@ end @test unsafe_string(sp,5) == "abcde" @test typeof(unsafe_string(sp)) == String - @test get(tryparse(BigInt, "1234567890")) == BigInt(1234567890) + @test tryparse(BigInt, "1234567890") == BigInt(1234567890) @test tryparse(BigInt, "1234567890-") === nothing - @test get(tryparse(Float64, "64")) == 64.0 + @test tryparse(Float64, "64") == 64.0 @test tryparse(Float64, "64o") === nothing - @test get(tryparse(Float32, "32")) == 32.0f0 + @test tryparse(Float32, "32") == 32.0f0 @test tryparse(Float32, "32o") === nothing end From 833c9ea28a8371fff08d97174f7dfe402a6a9cda Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Thu, 14 Dec 2017 23:16:38 +0100 Subject: [PATCH 11/16] Improve Some, remove get(::Some[, x]) method in favor of coalesce (now exported) --- NEWS.md | 3 +- base/exports.jl | 1 + base/some.jl | 45 ++++++++-------------------- doc/src/manual/faq.md | 2 +- doc/src/stdlib/base.md | 1 + stdlib/Distributed/src/remotecall.jl | 2 +- test/some.jl | 27 +++++++++-------- 7 files changed, 33 insertions(+), 48 deletions(-) diff --git a/NEWS.md b/NEWS.md index abb505486678a..5e4940762d331 100644 --- a/NEWS.md +++ b/NEWS.md @@ -773,7 +773,8 @@ Deprecated or removed * `Nullable{T}` has been deprecated and moved to the Nullables package ([#23642]). Use `Union{T, Void}` instead, or `Union{Some{T}, Void}` if `nothing` is a possible value (i.e. `Void <: T`). `isnull(x)` can be replaced with `x === nothing` - and `unsafe_get(x)` with `get(x)`. `NullException` has been removed. + and `unsafe_get`/`get` can be dropped or replaced with `coalesce`. + `NullException` has been removed. Command-line option changes --------------------------- diff --git a/base/exports.jl b/base/exports.jl index 19c8499477c2f..0681197fa74dd 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -862,6 +862,7 @@ export fetch, # missing values + coalesce, ismissing, missing, skipmissing, diff --git a/base/some.jl b/base/some.jl index 5792b2ab1075e..7c35d54d0e955 100644 --- a/base/some.jl +++ b/base/some.jl @@ -5,6 +5,8 @@ A wrapper type used in `Union{Some{T}, Void}` to distinguish between the absence of a value ([`nothing`](@ref)) and the presence of a `nothing` value (i.e. `Some(nothing)`). + +Use [`coalesce`](@ref) to access the value wrapped by a `Some` object. """ struct Some{T} value::T @@ -21,7 +23,7 @@ convert(::Type{Void}, x::Any) = throw(MethodError(convert, (Void, x))) convert(::Type{Void}, x::Void) = nothing function show(io::IO, x::Some) - if get(io, :compact, false) + if get(io, :typeinfo, Any) == typeof(x) show(io, x.value) else print(io, "Some(") @@ -30,42 +32,12 @@ function show(io::IO, x::Some) end end -""" - get(x::Some[, y]) - get(x::Void[, y]) - -Attempt to access the value wrapped in `x`. Return the value if -`x` is not [`nothing`](@ref) (i.e. it is a [`Some`](@ref) object). -If `x` is `nothing`, return `y` if provided, or throw a `MethodError` if not. - -# Examples -```jldoctest -julia> get(Some(5)) -5 - -julia> get(nothing) -ERROR: MethodError() -[...] - -julia> get(Some(1), 0) -1 - -julia> get(nothing, 0) -0 - -``` -""" -function get end - -get(x::Some) = x.value -get(x::Some, y) = x.value -get(x::Void, y) = y - """ coalesce(x, y...) Return the first value in the arguments which is not equal to `nothing`, -or `nothing` if all arguments are `nothing`. +or `nothing` if all arguments are `nothing`. Unwrap arguments of type +[`Some`](@ref). # Examples @@ -79,13 +51,20 @@ julia> coalesce(1, nothing) julia> coalesce(nothing, nothing) nothing +julia> coalesce(Some(1)) +1 + +julia> coalesce(nothing, Some(1)) +1 ``` """ function coalesce end coalesce(x::Any) = x +coalesce(x::Some) = x.value coalesce(x::Void) = nothing coalesce(x::Any, y...) = x +coalesce(x::Some, y...) = x.value coalesce(x::Void, y...) = coalesce(y...) """ diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md index fa4ca2a17a91f..937d037cd450c 100644 --- a/doc/src/manual/faq.md +++ b/doc/src/manual/faq.md @@ -629,7 +629,7 @@ would not otherwise have a value also yield `nothing`, for example `if false; en For situations where a value `x` of type `T` exists only sometimes, the `Union{T, Void}` type can be used. If the value itself can be `nothing` (notably, when `T` is `Any`), the `Union{Some{T}, Void}` type is more appropriate since `x == nothing` then indicates -the absence of a value, and `get(x) == nothing` indicates the presence of a value equal +the absence of a value, and `x == Some(nothing)` indicates the presence of a value equal to `nothing`. To represent missing data in the statistical sense (`NA` in R or `NULL` in SQL), use the diff --git a/doc/src/stdlib/base.md b/doc/src/stdlib/base.md index 3ab80f4372cc6..2d8c3c2d632c2 100644 --- a/doc/src/stdlib/base.md +++ b/doc/src/stdlib/base.md @@ -214,6 +214,7 @@ Base.@polly ```@docs Base.Missing Base.missing +Base.coalesce Base.ismissing Base.skipmissing ``` diff --git a/stdlib/Distributed/src/remotecall.jl b/stdlib/Distributed/src/remotecall.jl index ca2e4f25b4ffc..522fecdd57862 100644 --- a/stdlib/Distributed/src/remotecall.jl +++ b/stdlib/Distributed/src/remotecall.jl @@ -488,7 +488,7 @@ Wait for a value to become available on the specified remote channel. wait(r::RemoteChannel, args...) = (call_on_owner(wait_ref, r, myid(), args...); r) function fetch(r::Future) - r.v !== nothing && return get(r.v) + r.v !== nothing && return coalesce(r.v) v = call_on_owner(fetch_ref, r) r.v = Some(v) send_del_client(r) diff --git a/test/some.jl b/test/some.jl index 4eae24f409a9b..c4010ce8227a5 100644 --- a/test/some.jl +++ b/test/some.jl @@ -36,9 +36,9 @@ ## show() @test sprint(show, Some(1)) == "Some(1)" -@test sprint(showcompact, Some(1)) == "1" @test sprint(show, Some(Some(1))) == "Some(Some(1))" -@test sprint(showcompact, Some(Some(1))) == "1" +@test repr([Some(1)]) == "Some{$Int}[1]" +@test repr([Some(Some(1))]) == "Some{Some{$Int}}[Some(1)]" ## == and isequal nothing @@ -47,17 +47,8 @@ @test !isequal(Some(1), nothing) @test !isequal(Some(nothing), nothing) -## get() -@test get(Some(1)) === 1 -@test get(Some(nothing)) === nothing -@test_throws MethodError get(nothing) - -@test get(Some(1), 0) === 1 -@test get(Some(nothing), 0) === nothing -@test get(nothing, 0) === 0 - # coalesce() -using Base.coalesce + @test coalesce(1) === 1 @test coalesce(nothing) === nothing @test coalesce(nothing, 1) === 1 @@ -68,7 +59,19 @@ using Base.coalesce @test coalesce(nothing, nothing, 2) === 2 @test coalesce(nothing, nothing, nothing) === nothing +@test coalesce(Some(1)) === 1 +@test coalesce(Some(nothing)) === nothing +@test coalesce(Some(1), 0) === 1 +@test coalesce(Some(nothing), 0) === nothing +@test coalesce(nothing, Some(nothing)) === nothing +@test coalesce(Some(1), nothing) === 1 +@test coalesce(nothing, Some(1)) === 1 +@test coalesce(nothing, Some(1), nothing) === 1 +@test coalesce(nothing, Some(1), Some(2)) === 1 +@test coalesce(Some(1), nothing, Some(2)) === 1 + # notnothing() + using Base: notnothing @test notnothing(1) === 1 @test_throws ArgumentError notnothing(nothing) \ No newline at end of file From c8ba97ae99efcbb000d57487c83bcb5bd08372bd Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Fri, 15 Dec 2017 00:05:00 +0100 Subject: [PATCH 12/16] LibGit2 rebase fixes --- base/libgit2/types.jl | 10 +++-- stdlib/Distributed/src/process_messages.jl | 2 +- test/libgit2-helpers.jl | 11 +----- test/libgit2.jl | 46 +++++++++++----------- 4 files changed, 31 insertions(+), 38 deletions(-) diff --git a/base/libgit2/types.jl b/base/libgit2/types.jl index 91d6d293e80d0..f8b552af32f5e 100644 --- a/base/libgit2/types.jl +++ b/base/libgit2/types.jl @@ -1323,14 +1323,15 @@ The `shred` keyword controls whether sensitive information in the payload creden should be destroyed. Should only be set to `false` during testing. """ function approve(p::CredentialPayload; shred::Bool=true) - p.credential === nothing && return # No credentials were used + cred = p.credential + cred === nothing && return # No credentials were used if p.cache !== nothing approve(p.cache, cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers - approve(p.config, p.credential, p.url) + approve(p.config, cred, p.url) end shred && securezero!(cred) @@ -1347,14 +1348,15 @@ The `shred` keyword controls whether sensitive information in the payload creden should be destroyed. Should only be set to `false` during testing. """ function reject(p::CredentialPayload; shred::Bool=true) - p.credential === nothing && return # No credentials were used + cred = p.credential + cred === nothing && return # No credentials were used if p.cache !== nothing reject(p.cache, cred, p.url) shred = false # Avoid wiping `cred` as this would also wipe the cached copy end if p.allow_git_helpers - reject(p.config, p.credential, p.url) + reject(p.config, cred, p.url) end shred && securezero!(cred) diff --git a/stdlib/Distributed/src/process_messages.jl b/stdlib/Distributed/src/process_messages.jl index dddbe72507ede..7fa8b0adb3684 100644 --- a/stdlib/Distributed/src/process_messages.jl +++ b/stdlib/Distributed/src/process_messages.jl @@ -348,7 +348,7 @@ end function handle_msg(msg::JoinCompleteMsg, header, r_stream, w_stream, version) w = map_sock_wrkr[r_stream] - environ = get(w.config.environ, Dict()) + environ = coalesce(w.config.environ, Dict()) environ[:cpu_cores] = msg.cpu_cores w.config.environ = environ w.config.ospid = msg.ospid diff --git a/test/libgit2-helpers.jl b/test/libgit2-helpers.jl index c8c3f657ca3b1..ff43d5524aeca 100644 --- a/test/libgit2-helpers.jl +++ b/test/libgit2-helpers.jl @@ -75,13 +75,4 @@ function credential_loop( payload::CredentialPayload=DEFAULT_PAYLOAD; shred::Bool=true) credential_loop(valid_credential, url, user, 0x000046, payload, shred=shred) -end - -function credential_loop( - valid_credential::AbstractCredential, - url::AbstractString, - user::AbstractString, - payload::CredentialPayload=DEFAULT_PAYLOAD; - shred::Bool=true) - credential_loop(valid_credential, url, user, payload, shred=shred) -end +end \ No newline at end of file diff --git a/test/libgit2.jl b/test/libgit2.jl index fff1be8753fba..1235cb6d4c88f 100644 --- a/test/libgit2.jl +++ b/test/libgit2.jl @@ -2182,8 +2182,8 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(ex, []) @test err == git_ok @test auth_attempts == 1 - @test get(p.credential).prvkey == default_key - @test get(p.credential).pubkey == default_key * ".pub" + @test p.credential.prvkey == default_key + @test p.credential.pubkey == default_key * ".pub" # Confirm the private key if any other prompting is required ex = gen_ex(valid_p_cred) @@ -2272,16 +2272,16 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(ex, []) @test err == git_ok @test auth_attempts == 1 - @test get(p.explicit) == valid_cred - @test get(p.credential) != valid_cred + @test p.explicit == valid_cred + @test p.credential != valid_cred # Explicitly provided credential is incorrect ex = gen_ex(invalid_cred, allow_prompt=false, allow_ssh_agent=false) err, auth_attempts, p = challenge_prompt(ex, []) @test err == exhausted_error @test auth_attempts == 3 - @test get(p.explicit) == invalid_cred - @test get(p.credential) != invalid_cred + @test p.explicit == invalid_cred + @test p.credential != invalid_cred end @testset "HTTPS explicit credentials" begin @@ -2304,16 +2304,16 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(ex, []) @test err == git_ok @test auth_attempts == 1 - @test get(p.explicit) == valid_cred - @test get(p.credential) != valid_cred + @test p.explicit == valid_cred + @test p.credential != valid_cred # Explicitly provided credential is incorrect ex = gen_ex(invalid_cred, allow_prompt=false) err, auth_attempts, p = challenge_prompt(ex, []) @test err == exhausted_error @test auth_attempts == 2 - @test get(p.explicit) == invalid_cred - @test get(p.credential) != invalid_cred + @test p.explicit == invalid_cred + @test p.credential != invalid_cred end @testset "Cached credentials" begin @@ -2353,12 +2353,12 @@ mktempdir() do dir "Password for 'https://$valid_username@github.com':" => "$valid_password\n", ] err, auth_attempts, p = challenge_prompt(ex, challenges) - cache = get(p.cache) + cache = p.cache @test err == git_ok @test auth_attempts == 1 @test typeof(cache) == LibGit2.CachedCredentials @test cache.cred == Dict(cred_id => valid_cred) - @test get(p.credential) == valid_cred + @test p.credential == valid_cred # Replace a credential in the cache ex = gen_ex(cached_cred=invalid_cred) @@ -2367,12 +2367,12 @@ mktempdir() do dir "Password for 'https://$valid_username@github.com':" => "$valid_password\n", ] err, auth_attempts, p = challenge_prompt(ex, challenges) - cache = get(p.cache) + cache = p.cache @test err == git_ok @test auth_attempts == 2 @test typeof(cache) == LibGit2.CachedCredentials @test cache.cred == Dict(cred_id => valid_cred) - @test get(p.credential) == valid_cred + @test p.credential == valid_cred # Canceling a credential request should leave the cache unmodified ex = gen_ex(cached_cred=invalid_cred) @@ -2382,22 +2382,22 @@ mktempdir() do dir "Username for 'https://github.com' [foo]:" => "\x04", ] err, auth_attempts, p = challenge_prompt(ex, challenges) - cache = get(p.cache) + cache = p.cache @test err == abort_prompt @test auth_attempts == 3 @test typeof(cache) == LibGit2.CachedCredentials @test cache.cred == Dict(cred_id => invalid_cred) - @test get(p.credential) != invalid_cred + @test p.credential != invalid_cred # An EAUTH error should remove credentials from the cache ex = gen_ex(cached_cred=invalid_cred, allow_prompt=false) err, auth_attempts, p = challenge_prompt(ex, []) - cache = get(p.cache) + cache = p.cache @test err == exhausted_error @test auth_attempts == 2 @test typeof(cache) == LibGit2.CachedCredentials @test cache.cred == Dict() - @test get(p.credential) != invalid_cred + @test p.credential != invalid_cred end @testset "HTTPS git helper username" begin @@ -2433,7 +2433,7 @@ mktempdir() do dir @test auth_attempts == 1 # Verify credential wasn't accidentally zeroed (#24731) - @test get(p.credential) == valid_cred + @test p.credential == valid_cred end @testset "Incompatible explicit credentials" begin @@ -2450,8 +2450,8 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(expect_ssh_ex, []) @test err == incompatible_error @test auth_attempts == 1 - @test get(p.explicit) == valid_cred - @test get(p.credential) != valid_cred + @test p.explicit == valid_cred + @test p.credential != valid_cred # User provides a SSH credential where a user/password credential is required. @@ -2467,8 +2467,8 @@ mktempdir() do dir err, auth_attempts, p = challenge_prompt(expect_https_ex, []) @test err == incompatible_error @test auth_attempts == 1 - @test get(p.explicit) == valid_cred - @test get(p.credential) != valid_cred + @test p.explicit == valid_cred + @test p.credential != valid_cred end # A hypothetical scenario where the the allowed authentication can either be From e44a7dfef8e14c876dd0c570459a19bbed0f0fdd Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Fri, 15 Dec 2017 08:17:55 +0100 Subject: [PATCH 13/16] Test fixes --- base/missing.jl | 7 ++++++- test/missing.jl | 4 ++++ test/strings/basic.jl | 2 +- 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/base/missing.jl b/base/missing.jl index f721edf51ef5a..5c56e27216cc3 100644 --- a/base/missing.jl +++ b/base/missing.jl @@ -31,9 +31,14 @@ promote_rule(::Type{Missing}, ::Type{Any}) = Any promote_rule(::Type{Missing}, ::Type{Missing}) = Missing convert(::Type{Union{T, Missing}}, x) where {T} = convert(T, x) +# To fix ambiguities +convert(::Type{Missing}, ::Missing) = missing +convert(::Type{Void}, ::Void) = nothing +convert(::Type{Union{Void, Missing}}, x::Union{Void, Missing}) = x +convert(::Type{Union{Void, Missing}}, x) = + throw(MethodError(convert, (Union{Void, Missing}, x))) # To print more appropriate message than "T not defined" convert(::Type{Missing}, x) = throw(MethodError(convert, (Missing, x))) -convert(::Type{Missing}, ::Missing) = missing # Comparison operators ==(::Missing, ::Missing) = missing diff --git a/test/missing.jl b/test/missing.jl index dcf2d37daf821..35a0e385758e9 100644 --- a/test/missing.jl +++ b/test/missing.jl @@ -13,7 +13,11 @@ end @testset "convert" begin @test convert(Union{Int, Missing}, 1) === 1 @test convert(Union{Int, Missing}, 1.0) === 1 + @test convert(Union{Void, Missing}, missing) === missing + @test convert(Union{Void, Missing}, nothing) === nothing + @test_throws MethodError convert(Missing, 1) + @test_throws MethodError convert(Union{Void, Missing}, 1) @test_throws MethodError convert(Union{Int, Missing}, "a") end diff --git a/test/strings/basic.jl b/test/strings/basic.jl index e881ec16dafbc..19886bc08da26 100644 --- a/test/strings/basic.jl +++ b/test/strings/basic.jl @@ -242,7 +242,7 @@ end end @testset "issue #10307" begin - @test typeof(map(x -> parse(Int16, x), AbstractString[])) == Vector{Int16} + @test typeof(map(x -> parse(Int16, x), AbstractString[])) == Vector{Union{Int16, Void}} for T in [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128] for i in [typemax(T), typemin(T)] From 1605c9dda96aa55fec6cb25f49a8ab664aff4823 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Fri, 15 Dec 2017 08:18:32 +0100 Subject: [PATCH 14/16] Remove test/nullable.jl --- test/nullable.jl | 520 ----------------------------------------------- 1 file changed, 520 deletions(-) delete mode 100644 test/nullable.jl diff --git a/test/nullable.jl b/test/nullable.jl deleted file mode 100644 index 2edc67cdc3cae..0000000000000 --- a/test/nullable.jl +++ /dev/null @@ -1,520 +0,0 @@ -# This file is a part of Julia. License is MIT: https://julialang.org/license - -# "is a null with type T", curried on 2nd argument -isnull_oftype(x::Nullable, T::Type) = eltype(x) == T && isnull(x) -isnull_oftype(T::Type) = x -> isnull_oftype(x, T) - -# return true if nullables (or arrays of nullables) have the same type, -# nullity, and value (if they are non-null) -istypeequal(x::Nullable, y::Nullable) = - typeof(x) == typeof(y) && isnull(filter(!, x .== y)) -istypeequal(x::AbstractArray, y::AbstractArray) = - length(x) == length(y) && all(xy -> istypeequal(xy...), zip(x, y)) - -types = [ - Bool, - Float16, - Float32, - Float64, - Int128, - Int16, - Int32, - Int64, - Int8, - UInt16, - UInt32, - UInt64, - UInt8, -] - -# Nullable{T}() = new(true) -for T in types - x = Nullable{T}() - @test x.hasvalue === false - @test isa(x.value, T) - @test eltype(Nullable{T}) === T - @test eltype(x) === T -end - -# Nullable{T}(value::T) = new(false, value) -for T in types - x = Nullable{T}(zero(T)) - @test x.hasvalue === true - @test isa(x.value, T) - @test x.value === zero(T) - @test eltype(x) === T - - x = Nullable{T}(one(T)) - @test x.hasvalue === true - @test isa(x.value, T) - @test x.value === one(T) - @test eltype(x) === T -end - -# Nullable{T}(value::T, hasvalue::Bool) = new(hasvalue, value) -for T in types - x = Nullable{T}(zero(T), true) - @test x.hasvalue === true - @test isa(x.value, T) - @test x.value === zero(T) - @test eltype(x) === T - - x = Nullable{T}(zero(T), false) - @test x.hasvalue === false - @test isa(x.value, T) - @test eltype(Nullable{T}) === T - @test eltype(x) === T -end - - -# struct NullException <: Exception -@test isa(NullException(), NullException) -@test_throws NullException throw(NullException()) - -# Nullable{T}(value::T) = Nullable{T}(value) -for T in types - v = zero(T) - x = Nullable(v) - @test x.hasvalue === true - @test isa(x.value, T) - @test x.value === v - - v = one(T) - x = Nullable(v) - @test x.hasvalue === true - @test isa(x.value, T) - @test x.value === v -end - -# show{T}(io::IO, x::Nullable{T}) -io1 = IOBuffer() -io2 = IOBuffer() -for (i, T) in enumerate(types) - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - show(io1, x1) - @test String(take!(io1)) == @sprintf("Nullable{%s}()", T) - show(io1, x2) - showcompact(io2, get(x2)) - @test String(take!(io1)) == @sprintf("Nullable{%s}(%s)", T, String(take!(io2))) - show(io1, x3) - showcompact(io2, get(x3)) - @test String(take!(io1)) == @sprintf("Nullable{%s}(%s)", T, String(take!(io2))) -end - -module NullableTestEnum -import Test -# For curmod_* -include("testenv.jl") -io = IOBuffer() -@enum TestEnum a b -show(io, Nullable(a)) -Test.@test String(take!(io)) == "Nullable{$(curmod_prefix)TestEnum}(a)" -end - -# showcompact(io::IO, x::Nullable) -io1 = IOBuffer() -io2 = IOBuffer() -for (i, T) in enumerate(types) - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - showcompact(io1, x1) - @test String(take!(io1)) == "#NULL" - showcompact(io1, x2) - showcompact(io2, get(x2)) - @test String(take!(io1)) == String(take!(io2)) - showcompact(io1, x3) - showcompact(io2, get(x3)) - @test String(take!(io1)) == String(take!(io2)) - - a1 = [x2] - showcompact(io1, a1) - showcompact(io2, x2) - @test String(take!(io1)) == - @sprintf("Nullable{%s}[%s]", string(T), String(take!(io2))) -end - -# get(x::Nullable) -for T in types - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - - @test_throws NullException get(x1) - @test get(x2) === zero(T) - @test get(x3) === one(T) -end - -@test_throws NullException get(Nullable()) - -# get{S, T}(x::Nullable{S}, y::T) -for T in types - x0 = Nullable() - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - - @test get(x0, zero(T)) === zero(T) - @test get(x0, one(T)) === one(T) - @test get(x1, zero(T)) === zero(T) - @test get(x1, one(T)) === one(T) - @test get(x2, one(T)) === zero(T) - @test get(x3, zero(T)) === one(T) -end - -for T in types - # unsafe_get(x::Nullable) - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - a = rand(T) - x4 = Nullable(a) - - @test isa(unsafe_get(x1), T) - @test unsafe_get(x2) === zero(T) - @test unsafe_get(x3) === one(T) - @test unsafe_get(x4) === a - - # unsafe_get(x) - x2 = zero(T) - x3 = one(T) - x4 = rand(T) - - @test unsafe_get(x2) === zero(T) - @test unsafe_get(x3) === one(T) - @test unsafe_get(x4) === x4 -end - -@test_throws UndefRefError unsafe_get(Nullable()) -@test_throws UndefRefError unsafe_get(Nullable{String}()) -@test_throws UndefRefError unsafe_get(Nullable{Array}()) - -for T in types - # isnull(x::Nullable) - x1 = Nullable{T}() - x2 = Nullable(zero(T)) - x3 = Nullable(one(T)) - - @test isnull(x1) === true - @test isnull(x2) === false - @test isnull(x3) === false - - # isnull(x) - x1 = zero(T) - x2 = one(T) - x3 = rand(T) - - @test isnull(x1) === false - @test isnull(x2) === false - @test isnull(x3) === false -end - -@test isnull(Nullable()) - -# function =={S, T}(x::Nullable{S}, y::Nullable{T}) -for T in types - x0 = Nullable() - x1 = Nullable{T}() - x2 = Nullable{T}() - x3 = Nullable(zero(T)) - x4 = Nullable(one(T)) - - @test_throws NullException (x0 == x1) - @test_throws NullException (x0 == x2) - @test_throws NullException (x0 == x3) - @test_throws NullException (x0 == x4) - - @test_throws NullException (x1 == x1) - @test_throws NullException (x1 == x2) - @test_throws NullException (x1 == x3) - @test_throws NullException (x1 == x4) - - @test_throws NullException (x2 == x1) - @test_throws NullException (x2 == x2) - @test_throws NullException (x2 == x3) - @test_throws NullException (x2 == x4) - - @test_throws NullException (x3 == x1) - @test_throws NullException (x3 == x2) - @test_throws NullException (x3 == x3) - @test_throws NullException (x3 == x4) - - @test_throws NullException (x4 == x1) - @test_throws NullException (x4 == x2) - @test_throws NullException (x4 == x3) - @test_throws NullException (x4 == x4) -end - -# function hash(x::Nullable, h::UInt) -for T in types - x0 = Nullable() - x1 = Nullable{T}() - x2 = Nullable{T}() - x3 = Nullable(zero(T)) - x4 = Nullable(one(T)) - - @test isa(hash(x0), UInt) - @test isa(hash(x1), UInt) - @test isa(hash(x2), UInt) - @test isa(hash(x3), UInt) - @test isa(hash(x4), UInt) - - @test hash(x0) == hash(x2) - @test hash(x0) != hash(x3) - @test hash(x0) != hash(x4) - @test hash(x1) == hash(x2) - @test hash(x1) != hash(x3) - @test hash(x1) != hash(x4) - @test hash(x2) != hash(x3) - @test hash(x2) != hash(x4) - @test hash(x3) != hash(x4) -end - -mutable struct TestNType{T} - v::Nullable{T} -end - -for T in types - x1 = TestNType{T}(Nullable{T}()) - @test isnull(x1.v) - x1.v = one(T) - @test !isnull(x1.v) - @test get(x1.v, one(T)) === one(T) -end - -# Operators -TestTypes = [[T.parameters[1] for T in Base.uniontypes(Base.NullSafeTypes)]; - [BigInt, BigFloat, - Complex{Int}, Complex{Float64}, Complex{BigFloat}, - Rational{Int}, Rational{BigInt}]] -for S in TestTypes, T in TestTypes - u0 = zero(S) - u1 = one(S) - if S <: AbstractFloat - u2 = S(NaN) - elseif S <: Complex && S.parameters[1] <: AbstractFloat - u2 = S(NaN, NaN) - else - u2 = u1 - end - - v0 = zero(T) - v1 = one(T) - if T <: AbstractFloat - v2 = T(NaN) - elseif T <: Complex && T.parameters[1] <: AbstractFloat - v2 = T(NaN, NaN) - else - v2 = v1 - end - - for u in (u0, u1, u2), v in (v0, v1, v2) - # function isequal(x::Nullable, y::Nullable) - @test isequal(Nullable(u), Nullable(v)) === isequal(u, v) - @test isequal(Nullable(u), Nullable(u)) === true - @test isequal(Nullable(v), Nullable(v)) === true - - @test isequal(Nullable(u), Nullable(v, false)) === false - @test isequal(Nullable(u, false), Nullable(v)) === false - @test isequal(Nullable(u, false), Nullable(v, false)) === true - - @test isequal(Nullable(u), Nullable{T}()) === false - @test isequal(Nullable{S}(), Nullable(v)) === false - @test isequal(Nullable{S}(), Nullable{T}()) === true - - @test isequal(Nullable(u), Nullable()) === false - @test isequal(Nullable(), Nullable(v)) === false - @test isequal(Nullable{S}(), Nullable()) === true - @test isequal(Nullable(), Nullable{T}()) === true - @test isequal(Nullable(), Nullable()) === true - - # function isless(x::Nullable, y::Nullable) - if S <: Real && T <: Real - @test isless(Nullable(u), Nullable(v)) === isless(u, v) - @test isless(Nullable(u), Nullable(u)) === false - @test isless(Nullable(v), Nullable(v)) === false - - @test isless(Nullable(u), Nullable(v, false)) === true - @test isless(Nullable(u, false), Nullable(v)) === false - @test isless(Nullable(u, false), Nullable(v, false)) === false - - @test isless(Nullable(u), Nullable{T}()) === true - @test isless(Nullable{S}(), Nullable(v)) === false - @test isless(Nullable{S}(), Nullable{T}()) === false - - @test isless(Nullable(u), Nullable()) === true - @test isless(Nullable(), Nullable(v)) === false - @test isless(Nullable{S}(), Nullable()) === false - @test isless(Nullable(), Nullable{T}()) === false - @test isless(Nullable(), Nullable()) === false - end - end -end - -# issue #9462 -for T in types - @test isa(convert(Nullable{Number}, Nullable(one(T))), Nullable{Number}) - @test isa(convert(Nullable{Number}, one(T)), Nullable{Number}) - @test isa(convert(Nullable{T}, one(T)), Nullable{T}) - @test isa(convert(Nullable{Any}, Nullable(one(T))), Nullable{Any}) - @test isa(convert(Nullable{Any}, one(T)), Nullable{Any}) - - # one(T) is convertible to every type in types - # let's test that with Nullables - for S in types - @test isa(convert(Nullable{T}, one(S)), Nullable{T}) - end -end - -@test isnull(convert(Nullable, nothing)) -@test isnull(convert(Nullable{Int}, nothing)) -@test isa(convert(Nullable{Int}, nothing), Nullable{Int}) - -@test convert(Nullable, 1) === Nullable(1) -@test convert(Nullable, Nullable(1)) === Nullable(1) -@test isequal(convert(Nullable, "a"), Nullable("a")) -@test isequal(convert(Nullable, Nullable("a")), Nullable("a")) - -using Dates -@test promote_type(Nullable{Int}, Int) === Nullable{Int} -@test promote_type(Nullable{Union{}}, Int) === Nullable{Int} -@test promote_type(Nullable{Float64}, Nullable{Int}) === Nullable{Float64} -@test promote_type(Nullable{Union{}}, Nullable{Int}) === Nullable{Int} -@test promote_type(Nullable{Date}, Nullable{DateTime}) === Nullable{DateTime} - -@test Base.promote_op(+, Nullable{Int}, Nullable{Int}) == Nullable{Int} -@test Base.promote_op(-, Nullable{Int}, Nullable{Int}) == Nullable{Int} -@test Base.promote_op(+, Nullable{Float64}, Nullable{Int}) == Nullable{Float64} -@test Base.promote_op(-, Nullable{Float64}, Nullable{Int}) == Nullable{Float64} -@test Base.promote_op(-, Nullable{DateTime}, Nullable{DateTime}) == Nullable{Dates.Millisecond} - -# tests for istypeequal (which uses filter, broadcast) -@test istypeequal(Nullable(0), Nullable(0)) -@test !istypeequal(Nullable(0), Nullable(0.0)) -@test !istypeequal(Nullable(0), Nullable(1)) -@test !istypeequal(Nullable(0), Nullable(1.0)) -@test istypeequal([Nullable(0), Nullable(1)], [Nullable(0), Nullable(1)]) -@test istypeequal([Nullable(0), Nullable(1)], Any[Nullable(0), Nullable(1)]) -@test !istypeequal([Nullable(0), Nullable(1)], Any[Nullable(0.0), Nullable(1)]) -@test !istypeequal([Nullable(0), Nullable(1)], [Nullable(0), Nullable(2)]) -@test !istypeequal([Nullable(0), Nullable(1)], - [Nullable(0), Nullable(1), Nullable(2)]) - -# filter -for p in (_ -> true, _ -> false) - @test @inferred(filter(p, Nullable())) |> isnull_oftype(Union{}) - @test @inferred(filter(p, Nullable{Int}())) |> isnull_oftype(Int) -end -@test @inferred(filter(_ -> true, Nullable(85))) === Nullable(85) -@test @inferred(filter(_ -> false, Nullable(85))) |> isnull_oftype(Int) -@test @inferred(filter(x -> x > 0, Nullable(85))) === Nullable(85) -@test @inferred(filter(x -> x < 0, Nullable(85))) |> isnull_oftype(Int) -@test get(@inferred(filter(x -> length(x) > 2, Nullable("test")))) == "test" -@test @inferred(filter(x -> length(x) > 5, Nullable("test"))) |> - isnull_oftype(String) - -# map -sqr(x) = x^2 -@test @inferred(map(sqr, Nullable())) |> isnull_oftype(Union{}) -@test @inferred(map(sqr, Nullable{Int}())) |> isnull_oftype(Int) -@test @inferred(map(sqr, Nullable(2))) === Nullable(4) -@test @inferred(map(+, Nullable(0.0))) === Nullable(0.0) -@test @inferred(map(+, Nullable(3.0, false)))=== Nullable(3.0, false) -@test @inferred(map(-, Nullable(1.0))) === Nullable(-1.0) -@test @inferred(map(-, Nullable{Float64}())) |> isnull_oftype(Float64) -@test @inferred(map(sin, Nullable(1))) === Nullable(sin(1)) -@test @inferred(map(sin, Nullable{Int}())) |> isnull_oftype(Float64) - -# should not throw if function wouldn't be called -@test map(x -> x ? 0 : 0.0, Nullable()) |> isnull_oftype(Union{}) -@test map(x -> x ? 0 : 0.0, Nullable(true)) === Nullable(0) -@test map(x -> x ? 0 : 0.0, Nullable(false)) === Nullable(0.0) -@test map(x -> x ? 0 : 0.0, Nullable{Bool}()) |> isnull_oftype(Union{}) - -# broadcast and elementwise -@test sin.(Nullable(0.0)) === Nullable(0.0) -@test sin.(Nullable{Float64}()) |> isnull_oftype(Float64) -@test @inferred(broadcast(sin, Nullable(0.0))) === Nullable(0.0) -@test @inferred(broadcast(sin, Nullable{Float64}())) |> isnull_oftype(Float64) - -@test Nullable(8) .+ Nullable(10) === Nullable(18) -@test Nullable(8) .- Nullable(10) === Nullable(-2) -@test Nullable(8) .+ Nullable{Int}() |> isnull_oftype(Int) -@test Nullable{Int}() .- Nullable(10) |> isnull_oftype(Int) - -@test @inferred(broadcast(log, 10, Nullable(1.0))) === - Nullable(0.0) -@test @inferred(broadcast(log, 10, Nullable{Float64}())) |> - isnull_oftype(Float64) -@test @inferred(broadcast(log, Nullable(10), Nullable(1.0))) === - Nullable(0.0) -@test @inferred(broadcast(log, Nullable(10), Nullable{Float64}())) |> - isnull_oftype(Float64) - -@test Nullable(2) .^ Nullable(4) === Nullable(16) -@test Nullable(2) .^ Nullable{Int}() |> isnull_oftype(Int) - -# multi-arg broadcast -@test (Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ - Nullable(1) === Nullable(6)) -@test (Nullable(1) .+ Nullable(1) .+ Nullable(1) .+ Nullable{Int}() .+ - Nullable(1) .+ Nullable(1) |> isnull_oftype(Int)) - -# these are not inferrable because there are too many arguments -us = map(Nullable, 1:20) -@test broadcast(max, us...) === Nullable(20) -@test isnull(broadcast(max, us..., Nullable{Int}())) - -# test all elementwise operations -# note that elementwise operations are the same as broadcast -for op in (+, -, *, /, \, //, ==, <, !=, <=, ÷, %, <<, >>, ^) - # op(1, 1) chosen because it works for all operations - res = op(1, 1) - @test @inferred(broadcast(op, Nullable(1), Nullable(1))) === - Nullable(res) - @test @inferred(broadcast(op, Nullable{Int}(), Nullable(1))) |> - isnull_oftype(typeof(res)) - @test @inferred(broadcast(op, Nullable(1), Nullable{Int}())) |> - isnull_oftype(typeof(res)) - @test @inferred(broadcast(op, Nullable{Int}(), Nullable{Int}())) |> - isnull_oftype(typeof(res)) - @test @inferred(broadcast(op, Nullable(1), 1)) === - Nullable(res) - @test @inferred(broadcast(op, 1, Nullable(1))) === - Nullable(res) -end - -# test reasonable results for Union{} -# the exact types of these is finnicky and depends on implementation details -# but is guaranteed to be at worst concrete and possibly Union{} on a good day -@test isnull(@inferred(Nullable() .+ Nullable())) -@test isnull(@inferred(Nullable() .+ 1)) -@test isnull(@inferred(Nullable() .+ Nullable(1))) - -# test that things don't pessimize because of non-homogenous types -@test Nullable(10.5) === - @inferred(broadcast(+, 1, 2, Nullable(3), Nullable(4.0), Nullable(1//2))) - -# test fast path taken -for op in (+, *, -) - for b1 in (false, true) - for b2 in (false, true) - @test Nullable{Int}(op(1, 2), b1 & b2) === - @inferred(broadcast(op, Nullable{Int}(1, b1), - Nullable{Int}(2, b2))) - end - end -end - -# issue #11675 -@test repr(Nullable()) == "Nullable{Union{}}()" - -# issue #19270 -let f19270(x::S, y::T) where {S,T} = Base.promote_op(^, S, T) - @test f19270(Nullable(0.0f0), Nullable(BigInt(0))) == Nullable{Float32} -end - -# issue #21397 -@test Nullable(Tuple) === Nullable{DataType}(Tuple) From e0770e512fb6dbae3085d87952172a130c4eb67f Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Fri, 15 Dec 2017 15:22:02 +0100 Subject: [PATCH 15/16] Fix remaining call to get() on Windows --- test/reflection.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/reflection.jl b/test/reflection.jl index e68790abe21c6..e79374018f4a5 100644 --- a/test/reflection.jl +++ b/test/reflection.jl @@ -605,7 +605,7 @@ if Sys.iswindows() @warn """No methods found in Base with backslashes in file name, skipping test for `Base.url`""" else - @test !('\\' in Base.url(get(h16850))) + @test !('\\' in Base.url(h16850)) end else @test h16850 === nothing From 55b03b17b614121a1ef313ae1a48d868c171e698 Mon Sep 17 00:00:00 2001 From: Milan Bouchet-Valat Date: Fri, 15 Dec 2017 15:33:32 +0100 Subject: [PATCH 16/16] Support missing in coalesce() --- base/missing.jl | 1 - base/some.jl | 12 ++++++++---- test/some.jl | 47 +++++++++++++++++++++++++++-------------------- 3 files changed, 35 insertions(+), 25 deletions(-) diff --git a/base/missing.jl b/base/missing.jl index 5c56e27216cc3..f7e04f096d489 100644 --- a/base/missing.jl +++ b/base/missing.jl @@ -33,7 +33,6 @@ promote_rule(::Type{Missing}, ::Type{Missing}) = Missing convert(::Type{Union{T, Missing}}, x) where {T} = convert(T, x) # To fix ambiguities convert(::Type{Missing}, ::Missing) = missing -convert(::Type{Void}, ::Void) = nothing convert(::Type{Union{Void, Missing}}, x::Union{Void, Missing}) = x convert(::Type{Union{Void, Missing}}, x) = throw(MethodError(convert, (Union{Void, Missing}, x))) diff --git a/base/some.jl b/base/some.jl index 7c35d54d0e955..3229283e66e18 100644 --- a/base/some.jl +++ b/base/some.jl @@ -35,9 +35,9 @@ end """ coalesce(x, y...) -Return the first value in the arguments which is not equal to `nothing`, -or `nothing` if all arguments are `nothing`. Unwrap arguments of type -[`Some`](@ref). +Return the first value in the arguments which is not equal to +either [`nothing`](@ref) or [`missing`](@ref), or the last argument. +Unwrap arguments of type [`Some`](@ref). # Examples @@ -45,6 +45,9 @@ or `nothing` if all arguments are `nothing`. Unwrap arguments of type julia> coalesce(nothing, 1) 1 +julia> coalesce(missing, 1) +1 + julia> coalesce(1, nothing) 1 @@ -63,9 +66,10 @@ function coalesce end coalesce(x::Any) = x coalesce(x::Some) = x.value coalesce(x::Void) = nothing +coalesce(x::Missing) = missing coalesce(x::Any, y...) = x coalesce(x::Some, y...) = x.value -coalesce(x::Void, y...) = coalesce(y...) +coalesce(x::Union{Void, Missing}, y...) = coalesce(y...) """ notnothing(x) diff --git a/test/some.jl b/test/some.jl index c4010ce8227a5..4816f791513d4 100644 --- a/test/some.jl +++ b/test/some.jl @@ -49,26 +49,33 @@ # coalesce() -@test coalesce(1) === 1 -@test coalesce(nothing) === nothing -@test coalesce(nothing, 1) === 1 -@test coalesce(1, nothing) === 1 -@test coalesce(nothing, nothing) === nothing -@test coalesce(nothing, 1, 2) === 1 -@test coalesce(1, nothing, 2) === 1 -@test coalesce(nothing, nothing, 2) === 2 -@test coalesce(nothing, nothing, nothing) === nothing - -@test coalesce(Some(1)) === 1 -@test coalesce(Some(nothing)) === nothing -@test coalesce(Some(1), 0) === 1 -@test coalesce(Some(nothing), 0) === nothing -@test coalesce(nothing, Some(nothing)) === nothing -@test coalesce(Some(1), nothing) === 1 -@test coalesce(nothing, Some(1)) === 1 -@test coalesce(nothing, Some(1), nothing) === 1 -@test coalesce(nothing, Some(1), Some(2)) === 1 -@test coalesce(Some(1), nothing, Some(2)) === 1 +for v in (nothing, missing) + @test coalesce(1) === 1 + @test coalesce(v) === v + @test coalesce(v, 1) === 1 + @test coalesce(1, v) === 1 + @test coalesce(v, v) === v + @test coalesce(v, 1, 2) === 1 + @test coalesce(1, v, 2) === 1 + @test coalesce(v, v, 2) === 2 + @test coalesce(v, v, v) === v + + @test coalesce(Some(1)) === 1 + @test coalesce(Some(v)) === v + @test coalesce(Some(1), 0) === 1 + @test coalesce(Some(v), 0) === v + @test coalesce(v, Some(v)) === v + @test coalesce(Some(1), v) === 1 + @test coalesce(v, Some(1)) === 1 + @test coalesce(v, Some(1), v) === 1 + @test coalesce(v, Some(1), Some(2)) === 1 + @test coalesce(Some(1), v, Some(2)) === 1 + + @test coalesce(v, missing) === missing + @test coalesce(v, nothing) === nothing + @test coalesce(v, missing, v) === v + @test coalesce(v, nothing, v) === v +end # notnothing()