Updating / adding functions together

I am working on a problem where I have a continuous real valued function, e.g. a solution to an ODE, and I want to be able to update it multiple times by adding other continuous functions, which are calculated by code running elsewhere (i.e. not user defined).

For example, the workflow looks something like: solve an ODE and save the solution as a function of time, f(t), do some calculations to find the “update” function, g(t), and then update f by f(t) += g(t).

I’ve put together a minimal working example to try and illustrate what I’ve tried. The idea I’ve had is to define a SolutionObject type which contains an at_time field, which is the function I want to update. The tspan field defines the range over which this function is defined but is not directly relevant to the problem. I saw this answer on StackOverflow which shows how to add together anonymous functions using the let keyword:

julia> mutable struct SolutionObject{T<:AbstractFloat}
             at_time # Function (1-d continuous)
             tspan::Tuple{T, T}

julia> sol_object = SolutionObject(t -> t^2, (0., 10.))
julia> update_function = t -> 2t

# add together the outputs of the two functions and save it
# back in the original function (not type stable)
julia> sol_object.at_time = let old_function = sol_object.at_time
              t -> old_function(t) + update_function(t)

# this gives the expected result
julia> println(sol_object.at_time(3.0)) # 15.0 (= 9.0 + 6.0)

julia> using BenchmarkTools

# but is slow compared to the direct definition
julia> @btime sol_object.at_time(3.0) # 71.368 ns (4 allocations: 64 bytes)

julia> added = t -> t^2 + 2t
julia> @btime added(3.0) # 16.139 ns (1 allocation: 16 bytes)

This is pretty slow, and also not type stable. If I make a different constructor where the type of at_time is defined then the above code gives an error, which is the expected behaviour:

julia> mutable struct TypedSolutionObject{F<:Function, T<:AbstractFloat}

julia> typed_sol_object = TypedSolutionObject(t -> t^2, (0., 10.))

julia> typed_sol_object.at_time = let old_function = typed_sol_object.at_time
              t -> old_function(t) + update_function(t)
ERROR: MethodError: Cannot `convert` an object of type var"#15#16"{var"#13#14"} to an object of type var"#13#14"
Closest candidates are:
  convert(::Type{T}, ::T) where T at Base.jl:61
 [1] setproperty!(x::TypedSolutionObject{var"#13#14", Float64}, f::Symbol, v::Function)
   @ Base ./Base.jl:39
 [2] top-level scope
   @ ~/projects/mwe/anon_function_types.jl:31

One workaround here is to define a new TypedSolutionObject with the updated_f, but this gives the same performance as the original code (perhaps unsurprisingly?):

julia> updated_f = let old_function = typed_sol_object.at_time
              t -> old_function(t) + update_function(t)

julia> updated_typed_solution_object = TypedSolutionObject(updated_f, typed_sol_object.tspan)
julia> @btime updated_typed_solution_object.at_time(3.0) # 74.553 ns (4 allocations: 64 bytes)

In my code I have currently implemented the workaround and it is way too slow and still not type stable, and this approach somehow seems wrong / overly complicated. Does anyone have suggestions of how I could solve this problem, perhaps with a different approach than what I have already tried? I’m happy to provide more info if needed.