Change functions user needs to define

Author: MilesCranmer

Project.toml

@@ -5,6 +5,7 @@ version = "0.4.0"
 
 [deps]
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+Tricks = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775"
 
 [weakdeps]
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
@@ -19,8 +20,8 @@ julia = "1.6"
 
 [extras]
 Ratios = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
-SaferIntegers = "88634af6-177f-5301-88b8-7819386cfa38"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
+SaferIntegers = "88634af6-177f-5301-88b8-7819386cfa38"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 

src/types.jl

@@ -1,15 +1,11 @@
+import Tricks: static_fieldnames
+
 const DEFAULT_DIM_TYPE = FixedRational{Int32, 2^4 * 3^2 * 5^2 * 7}
 const DEFAULT_VALUE_TYPE = Float64
 
 abstract type AbstractQuantity{T,R} end
 abstract type AbstractDimensions{R} end
 
-constructor_of(::Type{D}) where {D<:AbstractDimensions} = D
-constructor_of(::Type{D}) where {R,D<:AbstractDimensions{R}} = D.name.wrapper
-constructor_of(::Type{Q}) where {Q<:AbstractQuantity} = Q
-constructor_of(::Type{Q}) where {T,Q<:AbstractQuantity{T}} = Q.body.name.wrapper
-constructor_of(::Type{Q}) where {T,R,Q<:AbstractQuantity{T,R}} = Q.name.wrapper
-
 """
     Dimensions{R}
 
@@ -36,7 +32,6 @@ which is by default a rational number.
 - `Dimensions(::Type{R}; kws...)` or `Dimensions{R}(; kws...)`: Pass a subset of dimensions as keyword arguments, with the output type set to `Dimensions{R}`.
 - `Dimensions{R}(args...)`: Pass all the dimensions as arguments, with the output type set to `Dimensions{R}`.
 - `Dimensions{R}(d::Dimensions)`: Copy the dimensions from another `Dimensions` object, with the output type set to `Dimensions{R}`.
-
 """
 struct Dimensions{R<:Real} <: AbstractDimensions{R}
     length::R
@@ -48,12 +43,14 @@ struct Dimensions{R<:Real} <: AbstractDimensions{R}
     amount::R
 end
 
-(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = D{R}((tryrationalize(R, get(kws, k, zero(R))) for k in fieldnames(D))...)
+(::Type{D})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = D{R}((tryrationalize(R, get(kws, k, zero(R))) for k in static_fieldnames(D))...)
 (::Type{D})(; kws...) where {D<:AbstractDimensions} = D(DEFAULT_DIM_TYPE; kws...)
 
-(::Type{D})(args...) where {R,D<:AbstractDimensions{R}} = constructor_of(D)(Base.Fix1(convert, R).(args)...)
-(::Type{D})(; kws...) where {R,D<:AbstractDimensions{R}} = constructor_of(D)(R; kws...)
-(::Type{D})(d::AbstractDimensions) where {R,D<:AbstractDimensions{R}} = D((getfield(d, k) for k in fieldnames(D))...)
+(::Type{D})(args...) where {R,D<:AbstractDimensions{R}} = dimension_constructor(D)(Base.Fix1(convert, R).(args)...)
+(::Type{D})(; kws...) where {R,D<:AbstractDimensions{R}} = dimension_constructor(D)(R; kws...)
+(::Type{D})(d::AbstractDimensions) where {R,D<:AbstractDimensions{R}} = D((getfield(d, k) for k in static_fieldnames(D))...)
+
+new_dimensions(::Type{D}, dims...) where {D<:AbstractDimensions} = dimension_constructor(D)(dims...)
 
 
 """
@@ -94,10 +91,12 @@ struct Quantity{T,R} <: AbstractQuantity{T,R}
     Quantity{T,R}(q::Quantity) where {T,R} = Quantity(convert(T, q.value), Dimensions{R}(dimension(q)))
 end
 
+new_quantity(::Type{QD}, l, r) where {QD<:Union{AbstractQuantity,AbstractDimensions}} = quantity_constructor(QD)(l, r)
+
 # All that is needed to make an `AbstractQuantity` work:
 dimension_name(::Dimensions, k::Symbol) = (length="m", mass="kg", time="s", current="A", temperature="K", luminosity="cd", amount="mol")[k]
-new_dimensions(::Type{<:Dimensions}, dims...) = Dimensions(dims...)
-new_quantity(::Type{<:Union{<:Quantity,<:Dimensions}}, l, r) = Quantity(l, r)
+quantity_constructor(::Type{<:Union{Quantity,Dimensions}}) = Quantity
+dimension_constructor(::Type{<:Union{Quantity,Dimensions}}) = Dimensions
 
 struct DimensionError{Q1,Q2} <: Exception
     q1::Q1

src/utils.jl

@@ -1,28 +1,23 @@
-@generated function map_dimensions(f::F, args::AbstractDimensions...) where {F<:Function}
-    dimension_type = first(args)
-    dimension_names = Base.fieldnames(dimension_type)
-    output = :(new_dimensions($dimension_type))
-    for dim in dimension_names
-        f_expr = :(f())
-        for i=1:length(args)
-            push!(f_expr.args, :(args[$i].$dim))
-        end
-        push!(output.args, f_expr)
-    end
-    return output
+import Tricks: static_fieldnames
+
+function map_dimensions(f::F, args::AbstractDimensions...) where {F<:Function}
+    dimension_type = promote_type(typeof(args).parameters...)
+    dimension_names = static_fieldnames(dimension_type)
+    return new_dimensions(
+        dimension_type,
+        (
+            f((getfield(arg, dim) for arg in args)...)
+            for dim in dimension_names
+        )...
+    )
 end
-@generated function all_dimensions(f::F, args::AbstractDimensions...) where {F<:Function}
-    dimension_type = first(args)
-    dimension_names = Base.fieldnames(dimension_type)
-    output = Expr(:&&)
+function all_dimensions(f::F, args::AbstractDimensions...) where {F<:Function}
+    dimension_type = promote_type(typeof(args).parameters...)
+    dimension_names = static_fieldnames(dimension_type)
     for dim in dimension_names
-        f_expr = :(f())
-        for i=1:length(args)
-            push!(f_expr.args, :(args[$i].$dim))
-        end
-        push!(output.args, f_expr)
+        f((getfield(arg, dim) for arg in args)...) || return false
     end
-    return output
+    return true
 end
 
 Base.float(q::AbstractQuantity{T}) where {T<:AbstractFloat} = convert(T, q)
@@ -33,7 +28,7 @@ Base.convert(::Type{T}, q::AbstractQuantity) where {T<:Real} =
     end
 
 Base.isfinite(q::AbstractQuantity) = isfinite(ustrip(q))
-Base.keys(d::AbstractDimensions) = Base.fieldnames(typeof(d))
+Base.keys(d::AbstractDimensions) = static_fieldnames(typeof(d))
 # TODO: Make this more generic.
 Base.iszero(d::AbstractDimensions) = all_dimensions(iszero, d)
 Base.iszero(q::AbstractQuantity) = iszero(ustrip(q))