Combining SimpleTraits.jl traits on one type

General Usage
1

I recently got a little into SimpleTraits - and I like it quite well. But I have a question considering the combination of traits.

Consider the following MWE (just noticed, maybe AbstractA is not necessary in general)

using SimpleTraits
abstract type AbstractA end
abstract type DecoA <: AbstractA end
# A few concrete types
struct A <: AbstractA end
struct A1 <: DecoA end
struct A2 <: DecoA end
struct A3 <: DecoA end

# just some function
f(::AbstractA, x) = x+2
g(::DecoA, x, y) = x+y

Now I want to do two decorators, for example

@traitdef IsNice{T}
@traitimpl IsNice{T} <- is_nice(T)
is_nice(::Type{<:A1}) = true
is_nice(::Type{<:A2}) = false
is_nice(::Type{<:DecoA}) = false

@traitdef IsCool{T}
@traitimpl IsCool{T} <- is_cool(T)
is_cool(::Type{<:A1}) = false
is_cool(T::Type{<:A2}) = true
is_cool(T::Type{<:DecoA}) = false

@traitfn f(a::TA, x) where {TA <: DecoA; IsNice{TA}} = g(a,x,3) #(a)
@traitfn f(a::TA, x) where {TA <: DecoA; IsCool{TA}} = g(a,x,5) #(b)
  1. what is a good way to write the case !IsNice and !IsCool ?
  2. what is a good way to write the case !IsNice or !IsCool ?

More generically, if I have a set of traits is there a way to define the fallback, that none of them is active?

I want it to fallback to just using f i.e. I want A3 act similar to A.

print("normal:$(f(A(),0))") # prints: normal:2
println("cool $(f(A2(),0))") #prints: cool: 5
println("neither nice nor cool $(f(A3(),0))") # does not work, since there is no !IsCool cases should behave like A (see Q1)
println("nice $(f(A1(),0))") # does not work since it first „checks“ Cool (defined last; see Q2)

This brings up the idea of preceedence - i.e.

  1. If I have A4 the is nice and cool, which one is called first, (a) or (b) and how could I steer that?
1 Like
2

From the README on SimpleTraits.jl it appears dispatching on multiple traits is not yet possible.

However WhereTraits.jl could possibly support it!

using WhereTraits

abstract type AbstractA end
abstract type DecoA <: AbstractA end

# A few concrete types
struct A <: AbstractA end
struct A1 <: DecoA end
struct A2 <: DecoA end
struct A3 <: DecoA end

# just some function
f(::AbstractA, x) = x+2
g(::DecoA, x, y) = x+y

is_nice(::Type{<:A1}) = true
is_nice(::Type{<:DecoA}) = false

is_cool(::Type{<:A2}) = true
is_cool(::Type{<:DecoA}) = false

@traits f(a::TA, x) where {TA <: DecoA, is_nice(TA)} = g(a,x,3)
@traits f(a::TA, x) where {TA <: DecoA, is_cool(TA)} = g(a,x,5)
@traits f(a::TA, x) where {TA <: DecoA, !is_cool(TA), !is_nice(TA)} = "without this the multiple dispatch is ill-defined for `A3`"

@show f(A(),0)
@show f(A1(),0)
@show f(A2(),0)
@show f(A3(),0)
2 Likes
3

Thanks for this nice solution,
actually @mateuszbaran proposed a solution without WhereTraits, since that comes with a lot of dependencies and we want to use it in a lightweight interface. His solution is here

https://github.com/JuliaManifolds/ManifoldsBase.jl/pull/91#issuecomment-1001498928

Just out of curiosity: Your approach would (in the current form) still error on both set to true (my A4) so I would have to give precedence for either cool or nice in a fourth function definition, right?

1 Like
4

You could just set a function with proper type signature

@traits f(a::TA, x) where {TA <: DecoA, is_cool(TA), is_nice(TA)} = "dispatch for `A4`"

It’s a shame WhereTraits.jl is such a heavy weight, I would also think twice before using it as a major dependency in a package. The solution by @mateuszbaran seems like a nice way around the problem!

2 Likes
5

Oh, I actually exactly had such a line in mind with my question. One disadvantage of that approach (which Mateusz avoids) is that for 3 one would need 8 cases, for 4 traits 16 and so on, it does not scale well; but thanks for your input, I will report, when we managed to have a solution.

6

Just to finish this thread, we just released our solution to the question asked, in principle using a list of traits (ordered) here Decorating/Extending a Manifold · ManifoldsBase.jl

2 Likes