Some unknown functions

I am trying to understand a function of a code that i have, and there are some functions that i cannot explain , this is the function:

function op_mat(op)
    op = op[:as_poly](domain="C")
    op_a = op.x[:gens]
    nab = op[:length]()
    op_ab = ones(SymPy.Sym, nab)
    coef = zeros(Complex, nab)
    mat = zeros(Int64, length(op_a), nab)
    for (i, (ps, c)) in enumerate(op[:as_dict]())
        for (j, p) in enumerate(ps)
            mat[j, i] = p
            op_ab[i] = op_a[j]^p * op_ab[i]
        coef[i] = c
    return op_a, op_ab, mat, coef

what i’m having problem with is that [:as_poly](domain="C")and op_a = op.x[:gens]also (op[:as_dict]()now for this one it could be converting op to a dictionary but i’m not sure.

My understanding is that all a[b] really does is call getindex(a, b) and return the result. So it would appear that the module defined getindex for the type of op. Something like (my return functions are totally made up, and I’m guessing at op’s type):

function Base.getIndex(x::Op, i::Symbol)::Function
    if i == :as_poly
        return (;domain::String = "") -> Poly(x, domain)
    elseif i == :gens
        return () -> Gens(x.y, x.z)
    elseif i == :length
        return  () -> length(x.f)
    return () -> nothing

An alternative would be if op had a map of symbols to functions it could be returning.

So really (at a guess) it’s just using getindex to create functions that can pull data from that op instance object when those functions are called, which makes me think they are going for sort of “object oriented” feel. It might also be returning functions rather than the values themselves to avoid the whole returns of different type overhead…