Hi all, I am developing some simulation code that can be used either to do a quick calculation or a more complete and slower algorithm. I implemented two functions that either produce a “simple” or “complex” structure; for the sake of simplicity, let’s assume that the calculations are very trivial:
abstract type Results{T <: Number} end
struct SimpleResults{T} <: Results{T}
val1::T
val2::T
end
simple(input) = SimpleResults(input, input * 2)
struct ComplexResults{T} <: Results{T}
val1::T
val2::T
val3::T
end
complex(input) = ComplexResults(input, input * 2, input * 3)
Both return types are derived from the abstract type Results.
In a typical case, these calculations should be performed many times in a row, producing a long vector of results. For these, I implemented a ListOfResults type that basically wraps a AbstractVector{<: Results} and keeps some ancillary information too (in info):
struct ListOfResults{R <: Results, V <: AbstractVector{R}}
vec::V
info::String
end
I am now a bit puzzled in thinking how to create a proper API for the function that creates a ListOfResults object. I would like to let the user decide whether simple or complex should be called and which vector-like use for ListOfResults.vec (Vector, CuArray, …).
Since the exact eltype of vec is decided only after a call to simple or complex is done, my strategy would be something like this:
function fill_list_of_results(list_of_inputs, array_type, fn_to_call)
# Query the first result
first_result = fn_to_call(list_of_inputs[begin])
# Allocate the array
R = typeof(first_result)
V = array_type{R}
vec = V(undef, length(list_of_inputs))
# Build the object to be returned
result = ListOfResults(vec, "some useful information")
# Fill the array
result.vec[begin] = first_result
for (cur_idx, cur_input) in enumerate(list_of_inputs)
(cur_idx == firstindex(list_of_inputs)) && continue
result.vec[cur_idx] = fn_to_call(cur_input)
end
return result
end
This implementation works as expected:
# Works!
fill_list_of_results([1, 2, 3], Vector, simple)
# Works too!
fill_list_of_results([1.0, 2.0, 3.0], Vector, complex)
However, I am not entirely satisfied with it. I don’t find the implementation of fill_list_of_results too elegant nor “Julia”-like: it calls the function once, saves the result back and uses the type to build an array, then does a for loop skipping the first element… It’s more complicated than I would have expected, but I am at loss to find a smarter way to do the same. Perhaps I should completely revise the way I’m tackling the problem?
I would like to hear your opinion: is there a cleaner way to do what I need? Thank you!