fixed new disambiguation errors

Author: schlichtanders

Changelog.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - `Option(3)` works now
 - The constructors `Const{ElementType}(value)` and `Identity{ElementType}(value)` had been removed already, however were still used. Maybe this now gave errors because of newer julia version, don't know, but now everything uses `Const(value)` and `Identity(value)` instead.
+- fixed a couple of disambiguation errors which magically appeared after switching to Julia 1.6
 
 ### Removed
 - `Option{T}(value::T)` didn't work and is removed now, as it does not provide any benefit anylonger, which is a breaking change

src/ContextManager.jl

@@ -75,7 +75,9 @@ end
 # ContextManager is just a wrapper
 # pass through function call syntax
 (c::ContextManager)(cont) = c.f(cont)
-Base.run(cont, c::ContextManager) = c(cont)
+# in principle `cont` could be anything, as anything could be a function, however we have an ambiguity with Base AbstractCmd, and as this is mainly used for do-syntax
+# it should be fine to restrict to `Function` 
+Base.run(cont::Function, c::ContextManager) = c(cont)
 Base.run(c::ContextManager) = c(identity)
 
 

src/Identity.jl

@@ -36,7 +36,7 @@ Base.eltype(::Type{<:Identity{T}}) where T = T
 Base.eltype(::Type{<:Identity}) = Any
 
 Base.iterate(a::Identity) = a.value, nothing
-Base.iterate(a::Identity, state) = state
+Base.iterate(a::Identity, state::Nothing) = state
 Base.foreach(f, a::Identity) = begin f(a.value); nothing; end
 Base.map(f, a::Identity) = Identity(f(a.value))
 # for convenience, Identity does not use convert, whatever monad is returned is valid, providing maximum flexibility.

src/Try.jl

@@ -86,11 +86,9 @@ function Base.showerror(io::IO, ::MIME"text/plain", exc::MultipleExceptions)
   Base.show(io, MIME"text/plain"(), exc)
 end
 
-Base.merge(f1::Thrown, f2::Thrown) = MultipleExceptions((f1, f2))
-Base.merge(f::Thrown, e::Exception) = MultipleExceptions((f, e))
-Base.merge(e::Exception, f::Thrown) = MultipleExceptions((e, f))
+Base.merge(e1::Exception, e2::Exception) = MultipleExceptions((e1, e2))
 Base.merge(es::MultipleExceptions, e::Exception) = MultipleExceptions(tuple(es.exceptions..., e))
-Base.merge(e::Exception, fs::MultipleExceptions) = MultipleExceptions(tuple(e, fs.exceptions...))
+Base.merge(e::Exception, es::MultipleExceptions) = MultipleExceptions(tuple(e, es.exceptions...))
 Base.merge(es1::MultipleExceptions, es2::MultipleExceptions) = MultipleExceptions(tuple(es1.exceptions..., es2.exceptions...))
 
 

src/promote_type.jl

@@ -101,13 +101,14 @@ end
 # we need to be cautious here, as we cannot dispatch on Type{<:Either{<:Any, R}} or similar, because R might not be defined
 Base.promote_rule(::Type{Either{L, R}}, ::Type{Either{L, R}}) where {L, R} = Either{L, R}
 Base.promote_rule(::Type{Either{L1, R}}, ::Type{Either{L2, R}}) where {L1, R, L2 <: L1} = Either{L1, R}
+Base.promote_rule(::Type{Either{L2, R}}, ::Type{Either{L1, R}}) where {L1, R, L2 <: L1} = Either{L1, R}  # we needed to add this because rule A and B are ambiguous otherwise 
 Base.promote_rule(::Type{Either{L, R1}}, ::Type{Either{L, R2}}) where {L, R1, R2 <: R1} = Either{L, R1}
 Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2 <: L1, R2} = Either{L1, <:Any}
-Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2, R2 <: R1} = Either{<:Any, R1}
+Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2, R2 <: R1} = Either{<:Any, R1}
 Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
-Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
+Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}  # rule A
 
-Base.promote_rule(::Type{Either{L1, R}}, ::Type{Either{L2, R}}) where {L1, R, L2} = Either{<:Any, R}
+Base.promote_rule(::Type{Either{L1, R}}, ::Type{Either{L2, R}}) where {L1, R, L2} = Either{<:Any, R}  # rule B
 Base.promote_rule(::Type{Either{L, R1}}, ::Type{Either{L, R2}}) where {L, R1, R2} = Either{L, <:Any}
 Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2, R2} = Either