Add with_type_parameters function for configurable type changes

Author: MilesCranmer

src/arrays.jl

@@ -31,7 +31,7 @@ struct QuantityArray{T,N,D<:AbstractDimensions,Q<:AbstractUnionQuantity{T,D},V<:
     dimensions::D
 
     function QuantityArray(v::_V, d::_D, ::Type{_Q}) where {_T,_N,_D<:AbstractDimensions,_Q<:AbstractUnionQuantity,_V<:AbstractArray{_T,_N}}
-        Q_out = constructorof(_Q){_T,_D}
+        Q_out = with_type_parameters(_Q, _T, _D)
         return new{_T,_N,_D,Q_out,_V}(v, d)
     end
 end

src/symbolic_dimensions.jl

@@ -55,7 +55,9 @@ function Base.getproperty(d::SymbolicDimensions{R}, s::Symbol) where {R}
 end
 Base.propertynames(::SymbolicDimensions) = ALL_SYMBOLS
 Base.getindex(d::SymbolicDimensions, k::Symbol) = getproperty(d, k)
+
 constructorof(::Type{<:SymbolicDimensions}) = SymbolicDimensions
+with_type_parameters(::Type{<:SymbolicDimensions}, ::Type{R}) where {R} = SymbolicDimensions{R}
 
 SymbolicDimensions{R}(d::SymbolicDimensions) where {R} = SymbolicDimensions{R}(getfield(d, :nzdims), convert(Vector{R}, getfield(d, :nzvals)))
 SymbolicDimensions(; kws...) = SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}(; kws...)
@@ -73,7 +75,7 @@ end
 for (type, _) in ABSTRACT_QUANTITY_TYPES
     @eval begin
         function Base.convert(::Type{Q}, q::AbstractUnionQuantity{<:Any,<:Dimensions}) where {T,Q<:$type{T,SymbolicDimensions}}
-            return convert(constructorof(Q){T,SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}}, q)
+            return convert(with_type_parameters(Q, T,SymbolicDimensions{DEFAULT_DIM_BASE_TYPE}), q)
         end
         function Base.convert(::Type{Q}, q::AbstractUnionQuantity{<:Any,<:Dimensions}) where {T,R,Q<:$type{T,SymbolicDimensions{R}}}
             syms = (:m, :kg, :s, :A, :K, :cd, :mol)
@@ -91,7 +93,7 @@ for (type, _) in ABSTRACT_QUANTITY_TYPES
             d = dimension(q)
             for (idx, value) in zip(getfield(d, :nzdims), getfield(d, :nzvals))
                 if !iszero(value)
-                    result = result * convert(constructorof(Q){T,D}, ALL_VALUES[idx]) ^ value
+                    result = result * convert(with_type_parameters(Q, T, D), ALL_VALUES[idx]) ^ value
                 end
             end
             return result
@@ -110,7 +112,7 @@ for converting to specific symbolic units, or `convert(Quantity{<:Any,<:Symbolic
 for assuming SI units as the output symbols.
 """
 function uexpand(q::Q) where {T,R,D<:SymbolicDimensions{R},Q<:AbstractQuantity{T,D}}
-    return convert(constructorof(Q){T,Dimensions{R}}, q)
+    return convert(with_type_parameters(Q, T, Dimensions{R}), q)
 end
 uexpand(q::QuantityArray) = uexpand.(q)
 # TODO: Make the array-based one more efficient

src/types.jl

@@ -87,7 +87,7 @@ struct Dimensions{R<:Real} <: AbstractDimensions{R}
     amount::R
 end
 
-(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = constructorof(D){R}((tryrationalize(R, get(kws, k, zero(R))) for k in static_fieldnames(D))...)
+(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = with_type_parameters(D, R)((tryrationalize(R, get(kws, k, zero(R))) for k in static_fieldnames(D))...)
 (::Type{D})(; kws...) where {R,D<:AbstractDimensions{R}} = constructorof(D)(R; kws...)
 (::Type{D})(; kws...) where {D<:AbstractDimensions} = D(DEFAULT_DIM_BASE_TYPE; kws...)
 function (::Type{D})(d::D2) where {R,D<:AbstractDimensions{R},D2<:AbstractDimensions}
@@ -177,10 +177,26 @@ constructorof(::Type{<:Dimensions}) = Dimensions
 constructorof(::Type{<:Quantity}) = Quantity
 constructorof(::Type{<:GenericQuantity}) = GenericQuantity
 
+function with_type_parameters(::Type{<:Dimensions}, ::Type{R}) where {R}
+    return Dimensions{R}
+end
+function with_type_parameters(::Type{<:Quantity}, ::Type{T}, ::Type{D}) where {T,D}
+    return Quantity{T,D}
+end
+function with_type_parameters(::Type{<:GenericQuantity}, ::Type{T}, ::Type{D}) where {T,D}
+    return GenericQuantity{T,D}
+end
+
 # The following functions should be overloaded for special types
 function constructorof(::Type{T}) where {T}
     return Base.typename(T).wrapper
 end
+function with_type_parameters(::Type{D}, ::Type{R}) where {D<:AbstractDimensions,R}
+    return constructorof(D){R}
+end
+function with_type_parameters(::Type{Q}, ::Type{T}, ::Type{D}) where {Q<:AbstractUnionQuantity,T,D}
+    return constructorof(Q){T,D}
+end
 
 struct DimensionError{Q1,Q2} <: Exception
     q1::Q1

src/utils.jl

@@ -116,8 +116,8 @@ end
 for f in (:one, :typemin, :typemax)
     @eval begin
         Base.$f(::Type{Q}) where {T,D,Q<:AbstractUnionQuantity{T,D}} = new_quantity(Q, $f(T), D)
-        Base.$f(::Type{Q}) where {T,Q<:AbstractUnionQuantity{T}} = $f(constructorof(Q){T, DEFAULT_DIM_TYPE})
-        Base.$f(::Type{Q}) where {Q<:AbstractUnionQuantity} = $f(constructorof(Q){DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE})
+        Base.$f(::Type{Q}) where {T,Q<:AbstractUnionQuantity{T}} = $f(with_type_parameters(Q, T, DEFAULT_DIM_TYPE))
+        Base.$f(::Type{Q}) where {Q<:AbstractUnionQuantity} = $f(with_type_parameters(Q, DEFAULT_VALUE_TYPE, DEFAULT_DIM_TYPE))
     end
     if f == :one  # Return empty dimensions, as should be multiplicative identity.
         @eval Base.$f(q::Q) where {Q<:AbstractUnionQuantity} = new_quantity(Q, $f(ustrip(q)), one(dimension(q)))