What is the best way to distingish between two structures with the same form in Julia?

So I am from OOP background, so the following problem seems very easy.

class Hermitian:
  def __init__(self, mat::np.ndarray):  
    self.mat::np.ndarray = mat

class Hamiltonian(Hermitian):
  ...

class Correlation(Hermitian):
  ...

So for people who knows a bit Physics Hamiltonian and Correlation function can both be expressed in matrix form, but since they really are just a matrix in my context, so they can be a subclass of a Hermitian.

The reason I want to partition them is because they are some subroutines that have to handle differently for each of these objects.

Such as the operation to compute the eigenvalues, they can share the operation defined for Hermitian, but for something else like resolving for entanglement entropy which is specific only for Correlation, then in Python I can write def ee(corr::Correlation) to label that this is for Correlation only, or explicitly assert with the isinstance method.

Yet in Julia, there are no such thing as inheriting from a abstract struct, I have to define the two structures explicitly.

struct Hamiltonian
  mat::Matrix{Complex}
end

struct Correlation
  mat::Matrix{Complex}
end

Which is true that now I can define functions only for a specific type, but the shared methods are now impossible or to overload the method for each of these types.

Can someone suggest a defacto way to structure this kind of problem?

*I don't want to put a specifier::Symbol within a general struct Hermitian to label the type of the object like:

struct Hermitian
  specifier::Symbol
  mat::Matrix
end

hamiltonian::Hermitian = Hermitian(:hamiltonian, ...)

This could be handled in several different ways, but the one that is probably closest to what you want is:

julia> abstract type Hermitian end

julia> struct Hamiltonian{T} <: Hermitian
           mat::Matrix{Complex{T}}
       end

julia> struct Correlation{T} <: Hermitian
           mat::Matrix{Complex{T}}
       end

julia> getmat(::Hermitian) = error("getmat must be defined by concrete subtypes")
getmat (generic function with 1 method)

julia> getmat(x::Hamiltonian) = x.mat
getmat (generic function with 2 methods)

julia> getmat(x::Correlation) = x.mat
getmat (generic function with 3 methods)

julia> matsum(x::Hermitian) = sum(getmat(x)) # function common for all subtypes
matsum (generic function with 1 method)

julia> ee(corr::Correlation) = "defined only for Correlation"
ee (generic function with 1 method)

Things to note:

1. Abstract type does not have fields. They can be only defined for concrete types.
2. However, you can dispatch on abstract type, as in matsum definition.
3. The way I typically want to handle such things is to define a getter for a field, like getmat in our case. Note that this has an additional benefit that in general Hamiltonian and Correlation do not have to share mat as their field. This matrix e.g. could be computed on the flight in one case, and stored in a struct in other case. Defining such getter allows for a level of abstraction that might be handy (i.e. not all subtypes of Hermitian might want to store mat matrix in general)
4. A small thing is that Matrix{Complex} is not a concrete type as Complex can be complex of e.g. floats, or integers. Therefore, if you want performance it is usually better to make the type parametric. I used T as a parameter. In this way your code will be type stable.
5. When you use the pattern I described above, what is crucial is that you define the interface methods required to be defined by Hermitian abstract type subtypes (and make sure that such subtypes define this interface; in my example the interface requires that the getmat function is defined).

If something is not clear please comment and I can expand on this.