Saving arguments or wrap function?

Currently I have a structure where I save functions into something of the sort

struct fooS

    A::Dict{Symbol, Function}
    fooS(x) = new(consfoo(x)...)

function consfoo(x)

    return x, Dict{Symbol, Function}()

function fillDictionary(X, y, key)

    p1 = y*X.x + 1
    p2 = y*X.x^2 + 2
    X.A[key] = u -> p1*u + p2 


X = fooS(0.1)

fillDictionary(X, 0.2, :a)

function foo(X, x)

    return X.A[:a](x)

@code_warntype foo(X, 0.1)

However this code is type unstable.

Would it be better to save the parameters generated in fillDictionary or wrap the function in something like function wrapper?

It’s hard to say what is “better” without knowing what your end application is. Why are you saving a dictionary of functions in the first place?

1 Like

The long story is that I have a struct, name Curve
Sometimes for a Curve I’m gonna need interpolators that I can compute from this data. There are 5 interpolators that I need to do this.

Since not every curve will need the interpolator, when I construct the struct I do not fill the array. But later when I have decided if I want to compute the interpolators I have to fill this dictionary.

So I use a dictionary because its mutable and its more clear which interpolator I’m calling this way

The short story is, it’s hard to store different functions in a single object and have it be type stable, because each function f has its own specific type typeof(f). The two easiest solutions I see are

1 Like

Why not store the raw curve and the interpolator in different types, then?

e.g. have Curve for the raw data with no interpolator. Then if you want to interpolate, wrap it in an InterpolatedCurve(curve) that augments it with the interpolation data. If you have several different interpolation algorithms, you can have several InterpolatedCurve types corresponding to different algorithms, or you can have a single type InterpolatedCurve{algorithm} parameterized on the algorithm.

Basically, if your Curve type may or may not contain other data, and that other data is not even type-stable, that’s a strong indication that you probably want to refactor your data structures.