Wrapping a type alias in julia

I am trying to see if validate_convert is defined for the type specified. Problem is I defined my type as an alias instead of wrapping it. Now I have a lot of code that uses this type and it seems to me like wrapping it would require a lot of changes to use something like value(U::UserID) = U.value.

Do you see anyway of making this work but not match when type=String only when type=UserID or is there another solution?

UserID = String

function validate_convert(::Type{UserID}, input)::UserID
    parse(UserID, input)
end

type = UserID
hasmethod(validate_convert, Tuple{typeof(type),typeof(value)})

> it seems to me like wrapping it would require a lot of changes to use something like value(U::UserID) = U.value.

TypedDelegation.jl:

> Easily apply functions onto fields.
> Use a struct's fields as operands for operations on values of that type.

You can make your type a wrapper type, and then use @delegate_onefield and @delegate_onefield_astype to forward calls on your UserID type to be calls on the wrapped String. @delegate_onefield will return what the call on the String returns as is, @delegate_onefield_astype is useful for methods that return a String but you want them to return a UserID.

Your type alias UserID is completely equivalent to String:

julia> UserID = String;

julia> UserID === String
true

So, no, there is no way to write a method that matches UserID but not String. Your options are to make UserID a struct that wraps a string (or an integer or whatever you need), or to just use plain old String for your user IDs. If you don't need to dispatch on the user ID, then it might make sense to just use strings for the IDs.

Wrapper types are a bit of a problem. If you want Wrapper{T} to behave just like T, then you need to reimplement all the methods defined for T, which is unfortunate.

This may not be applicable for you, but if you're mainly interested in using these wrapper types inside structs you can hide some logic to wrap/unwrap the data transparently when it's accessed. As an example:

struct ValidatedField{Tag, T}
    val::T

    function ValidatedField{Tag, T}(val) where {Tag, T}
        vf = new{Tag, T}(val::T)
        (validate(vf) || throw(ArgumentError("Invalid: $val"))) && vf
    end
end

value(vf::ValidatedField) = vf.val
validate(vf::ValidatedField) = false

abstract type ValidatedRecord end

function Base.getproperty(vr::V, field::Symbol) where V <: ValidatedRecord
    f = getfield(vr, field)
    return f isa ValidatedField ? value(f) : f
end

function Base.setproperty!(vr::V, field::Symbol, val) where V <: ValidatedRecord
    T = fieldtype(V, field) 
    setfield!(vr, field, T <: ValidatedField ? T(val) : val)
end

UserID = ValidatedField{:UserId, String}
validate(u::UserID) = all(islowercase, value(u))

mutable struct User <: ValidatedRecord
    id::UserID # appears as a String but must be a valid UserID
    name::String # just a normal String

    function User(id, name)
        u = new()
        u.id, u.name = id, name
        return u
    end
end

user = User("foo", "Bob")
user.id # => "foo"
user.id = "Bar" # invalid
user.id = "bar" # valid