Use dimension_names instead of static_fieldnames

Author: MilesCranmer

docs/src/types.md

@@ -44,9 +44,14 @@ UnionAbstractQuantity
 DynamicQuantities.ABSTRACT_QUANTITY_TYPES
 ```
 
-## Constructors
+## Custom behavior in abstract quantities
+
+There are a few functions you may need to overload
+when subtyping `AbstractDimensions`, `AbstractQuantity`,
+or `AbstractGenericQuantity`.
 
 ```@docs
 constructorof
 with_type_parameters
-```
+dimension_names
+```

src/internal_utils.jl

@@ -3,11 +3,6 @@ This file contains utility functions that are not specific to the
 library, but are used throughout.
 """
 
-@generated function fieldnames_equal(::Type{T1}, ::Type{T2}) where {T1,T2}
-    # Needs to be a generated function to ensure hardcoded
-    return Base.propertynames(T1) == Base.propertynames(T2)
-end
-
 const SUPERSCRIPT_MAPPING = ('⁰', '¹', '²', '³', '⁴', '⁵', '⁶', '⁷', '⁸', '⁹')
 const INTCHARS = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')
 

src/symbolic_dimensions.jl

@@ -1,5 +1,3 @@
-import Tricks: static_fieldnames
-
 import .Units: UNIT_SYMBOLS, UNIT_MAPPING, UNIT_VALUES
 import .Constants: CONSTANT_SYMBOLS, CONSTANT_MAPPING, CONSTANT_VALUES
 
@@ -41,7 +39,7 @@ struct SymbolicDimensions{R} <: AbstractDimensions{R}
     nzvals::Vector{R}
 end
 
-static_fieldnames(::Type{<:SymbolicDimensions}) = ALL_SYMBOLS
+@inline dimension_names(::Type{<:SymbolicDimensions}) = ALL_SYMBOLS
 function Base.getproperty(d::SymbolicDimensions{R}, s::Symbol) where {R}
     nzdims = getfield(d, :nzdims)
     i = get(ALL_MAPPING, s, INDEX_TYPE(0))

src/types.jl

@@ -1,4 +1,4 @@
-import Tricks: static_fieldnames, static_fieldtypes
+using Tricks: static_fieldnames
 
 const DEFAULT_DIM_BASE_TYPE = FixedRational{DEFAULT_NUMERATOR_TYPE,DEFAULT_DENOM}
 const DEFAULT_VALUE_TYPE = Float64
@@ -103,13 +103,13 @@ struct Dimensions{R<:Real} <: AbstractDimensions{R}
     amount::R
 end
 
-(::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})(::Type{R}; kws...) where {R,D<:AbstractDimensions} = with_type_parameters(D, R)((tryrationalize(R, get(kws, k, zero(R))) for k in dimension_names(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}
-    fieldnames_equal(D, D2) ||
+    dimension_names_equal(D, D2) ||
         error("Cannot create a dimensions of `$(D)` from `$(D2)`. Please write a custom method for construction.")
-    D((getproperty(d, k) for k in static_fieldnames(D))...)
+    D((getproperty(d, k) for k in dimension_names(D))...)
 end
 
 const DEFAULT_DIM_TYPE = Dimensions{DEFAULT_DIM_BASE_TYPE}
@@ -238,6 +238,17 @@ function with_type_parameters(::Type{Q}, ::Type{T}, ::Type{D}) where {Q<:UnionAb
     return constructorof(Q){T,D}
 end
 
+"""
+    dimension_names(::Type{<:AbstractDimensions})
+
+Return a tuple of symbols with the names of the dimensions of the given type.
+This should be static so that it can be hardcoded during compilation.
+The default is to use `fieldnames`, but you can overload this for custom behavior.
+"""
+@inline function dimension_names(::Type{D}) where {D<:AbstractDimensions}
+    return static_fieldnames(D)
+end
+
 struct DimensionError{Q1,Q2} <: Exception
     q1::Q1
     q2::Q2

src/utils.jl

@@ -1,14 +1,13 @@
 import Compat: allequal
-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)
+    dim_names = dimension_names(dimension_type)
     return new_dimensions(
         dimension_type,
         (
             f((getproperty(arg, dim) for arg in args)...)
-            for dim in dimension_names
+            for dim in dim_names
         )...
     )
 end
@@ -48,9 +47,14 @@ function Base.promote_rule(::Type{<:AbstractQuantity}, ::Type{<:Number})
     return Number
 end
 
-Base.keys(d::AbstractDimensions) = static_fieldnames(typeof(d))
+Base.keys(d::AbstractDimensions) = dimension_names(typeof(d))
 Base.getindex(d::AbstractDimensions, k::Symbol) = getfield(d, k)
 
+@generated function dimension_names_equal(::Type{T1}, ::Type{T2}) where {T1,T2}
+    # Needs to be a generated function to ensure hardcoded
+    return dimension_names(T1) == dimension_names(T2)
+end
+
 # Compatibility with `.*`
 Base.size(q::UnionAbstractQuantity) = size(ustrip(q))
 Base.length(q::UnionAbstractQuantity) = length(ustrip(q))