How to distinguish different objects in the same struct using Symbol in Julia?

Question

As mentioned in the title, I want to use multiple-dispatch to assign different behaviors of the same struct, distinguished by Symbol. The struct can be constructed as follows:

struct AbstractAlgorithm
    algorithmName::String
    algorithmSymbol::Symbol

    function AbstractAlgorithm(algorithmName::String)
        if algorithmName ∉ ("Value Iteration", "Policy Iteration")
            error("Given algorithm $algorithmName not defined yet.")
        elseif algorithmName=="Value Iteration"
            new(algorithmName, Symbol("vIter"))
        elseif algorithmName=="Policy Iteration"
            new(algorithmName, Symbol("pIter"))
        end
    end  
end

And I wanted to distinguish the same struct using different symbols in a function, such as:

function A(a::AbstractAlgorithm with Symbol vIter) = do A1
function A(a::AbstractAlgorithm with Symbol pIter) = do A2

How should I design function A using multiple-dispatch?

Answer 1

I am adding as an answer a small comment to what @Giovanni proposed since it is too long (+ some minor changes to your code).

If you want to use a parametric type (and not, as @DNF proposed a type hierarchy) you can just write:

struct Algorithm{T}
    algorithmName::String

    function Algorithm(algorithmName::AbstractString)
        algorithmName == "Value Iteration" && return new{:vIter}(algorithmName)
        algorithmName == "Policy Iteration" && return new{:pIter}(algorithmName)
        error("Given algorithm $algorithmName not defined yet.")
    end
end

function A(a::Algorithm{:pIter})
    # ...
end

function A(a::Algorithm{:vIter})
    # ...
end

The point is that Symbol can be used as type parameter, so you do not have to wrap it in Val.

Answer 2

This seems like a highly unusual and un-idiomatic approach, since Julia natively supports multiple dispatch. Also, AbstractNN is a naming convention for abstract types, while you are using it for a concrete type.

Why not instead use dispatch:

abstract type AbstractAlgorithm end

struct ValueIteration <: AbstractAlgorithm end

struct PolicyIteration <: AbstractAlgorithm end

and then implement your wanted behaviors based on the types of your algorithm objects:

A(::ValueIteration) = A1() 
A(::PolicyIteration) = A2() 

Answer 3

One solution could be using Val

struct AbstractAlgorithm{T}
    algorithmName::String

    function AbstractAlgorithm(algorithmName::String)
        if algorithmName ∉ ("Value Iteration", "Policy Iteration")
            error("Given algorithm $algorithmName not defined yet.")
        elseif algorithmName=="Value Iteration"
            new{Val{:vIter}}(algorithmName)
        elseif algorithmName=="Policy Iteration"
            new{Val{:pIter}}(algorithmName)
        end
    end
end

function A(a::AbstractAlgorithm{Val{:pIter}})
    A1
end

function A(a::AbstractAlgorithm{Val{:vIter}})
    A2
end