[WIP][SetParameters] Generalize to work for any type, rename to TypeParameterAccessors

NDTensors/src/lib/TypeParameterAccessors/src/Base/abstractarray.jl

@@ -5,8 +5,8 @@ position(::Type{<:AbstractArray}, ::typeof(eltype)) = Position(1)
 position(::Type{<:AbstractArray}, ::typeof(ndims)) = Position(2)
 
 ## TODO I don't think this is the right place for this but define it here for now
-default_parameter(::Type{<:AbstractArray}, ::typeof(eltype)) = Float64
-default_parameter(::Type{<:AbstractArray}, ::typeof(ndims)) = 1
+default_parameter(::Type{<:AbstractArray}, ::Position{1}) = Float64
+default_parameter(::Type{<:AbstractArray}, ::Position{2}) = 1
 
 parameter_name(::Type{<:AbstractArray}, ::Position{1}) = eltype
 parameter_name(::Type{<:AbstractArray}, ::Position{2}) = ndims

NDTensors/src/lib/TypeParameterAccessors/src/Base/internals.jl

@@ -0,0 +1,14 @@
+# Relies on Julia internals
+@generated to_datatype(::Type{type}) where {type} = Base.unwrap_unionall(type)
+#to_datatype(type::DataType) = type
+
+"""
+    parameters(type::DataType)
+
+Gets all the type parameters of the DataType `type`.
+"""
+parameters(type::DataType) = Tuple(type.parameters)
+
+@generated to_unionall(type::Type, ::Type{ref_type}) where {ref_type} =
+  Base.rewrap_unionall(parameter(type), ref_type)
+@generated unspecify_parameters(::Type{type}) where {type} = Base.typename(type).wrapper

NDTensors/src/lib/TypeParameterAccessors/src/TypeParameterAccessors.jl

@@ -1,5 +1,6 @@
 module TypeParameterAccessors
 include("undefinedposition.jl")
+include("Base/internals.jl")
 include("parameters.jl")
 include("unspecify_parameters.jl")
 

NDTensors/src/lib/TypeParameterAccessors/src/default_parameter.jl

@@ -4,6 +4,8 @@ Get the default parameter of an object which is associated with a specific funct
 """
 default_parameter(object, fun::Function) = default_parameter(typeof(object), fun)
 
+default_parameter(type::Type, fun::Function) = default_parameter(type, position(type, fun))
+
 Compat.@assume_effects :foldable function default_parameters(type::Type)
   return map(name -> default_parameter(type, name), parameter_names(type))
 end

NDTensors/src/lib/TypeParameterAccessors/src/interface.jl

@@ -5,8 +5,8 @@
 # Required overloads, generic fallback
 position(::Type, ::Function) = UndefinedPosition()
 
-function default_parameter(type::Type, fun::Function)
-  return error("The default parameter of function $(fun) is not defined for type $(type)")
+function default_parameter(type::Type, name)
+  return error("The default parameter of $(name) is not defined for type $(type)")
 end
 
 UnspecifiedFunction() = nothing

NDTensors/src/lib/TypeParameterAccessors/src/parameters.jl

@@ -1,14 +1,3 @@
-# Relies on Julia internals
-@generated to_datatype(::Type{type}) where {type} = Base.unwrap_unionall(type)
-to_datatype(type::DataType) = type
-
-"""
-    parameters(type::DataType)
-
-Gets all the type parameters of the DataType `type`.
-"""
-parameters(type::DataType) = Tuple(type.parameters)
-
 """
     parameters(type::UnionAll, position::Int)
 
@@ -23,6 +12,13 @@ Gets all the type parameters of the object `object`.
 """
 parameters(object) = parameters(typeof(object))
 
+struct SpecifiedParameter{N} end
+SpecifiedParameter(val) = SpecifiedParameter{is_specified_parameter(val)}()
+
+is_specified_parameter(param)::Bool = true
+is_specified_parameter(param::TypeVar)::Bool = false
+is_parameter_specified(type::Type, pos) = is_specified_parameter(parameter(type, pos))
+
 """
     parameter(type::Type, position::Int)
 
@@ -63,3 +59,16 @@ parameter(x) = parameter(typeof(x))
 Gets the number of parameters for the Type `type`.
 """
 nparameters(type::Type) = length(parameters(type))
+
+function get_parameter(type::Type, pos)
+  param = parameter(type, pos)
+  return _get_parameter(SpecifiedParameter(param), param)
+end
+
+function _get_parameter(::SpecifiedParameter{true}, parameter)
+  return parameter
+end
+
+function _get_parameter(::SpecifiedParameter{false}, parameter)
+  return error("The requested type parameter isn't specified.")
+end

NDTensors/src/lib/TypeParameterAccessors/src/position.jl

@@ -9,12 +9,12 @@ Position(x) = Position{x}()
 
 Get a type parameter of the type `type` at the position `position`.
 """
-parameter(type::Type, position::Position) = parameter(type, int(position))
+parameter(type::Type, position::Position) = parameter(type, Int(position))
 
 struct TypeParameter{P} end
 TypeParameter(x) = TypeParameter{x}()
 
-int(p::Position) = parameter(p)
+Base.Int(p::Position) = parameter(p)
 
 eachposition(type::Type) = ntuple(Position, nparameters(type))
 

NDTensors/src/lib/TypeParameterAccessors/src/set_parameters.jl

@@ -4,7 +4,7 @@ using Compat: Compat
 
 Set the parameters of DataType `type` to the tuple `paramters`.
 """
-function set_parameters(type::DataType, parameters::Tuple)
+Compat.@assume_effects :foldable function set_parameters(type::DataType, parameters::Tuple)
   return unspecify_parameters(type){parameters...}
 end
 

NDTensors/src/lib/TypeParameterAccessors/src/specify_parameters.jl

@@ -1,25 +1,23 @@
 using Compat: Compat
 
 Compat.@assume_effects :foldable function specify_parameter(type::Type, pos::Int, param)
-  return _specify_parameter(parameter(type, pos), type, Position(pos), param)
+  return _specify_parameter(
+    SpecifiedParameter(parameter(type, pos)), type, Position(pos), param
+  )
 end
 
 Compat.@assume_effects :foldable function specify_parameter(
   type::Type, pos::Position, param
 )
-  return _specify_parameter(parameter(type, pos), type, pos, param)
+  return _specify_parameter(SpecifiedParameter(parameter(type, pos)), type, pos, param)
 end
 
-function _specify_parameter(::TypeVar, type::Type, pos::Position, param)
-  return set_parameter(type, pos, TypeParameter(param))
-end
-
-function _specify_parameter(::TypeVar, type::Type, pos::Position, param::Type)
+function _specify_parameter(::SpecifiedParameter{false}, type::Type, pos::Position, param)
   return set_parameter(type, pos, param)
 end
 
 @generated function _specify_parameter(
-  ::Union{<:Int,<:DataType}, ::Type{Typ}, pos, param
+  ::SpecifiedParameter{true}, ::Type{Typ}, pos, param
 ) where {Typ}
   return Typ
 end
@@ -28,7 +26,7 @@ Compat.@assume_effects :foldable function specify_parameter(
   type::Type, fun::Function, param
 )
   pos = position(type, fun)
-  return _specify_parameter(parameter(type, pos), type, pos, param)
+  return _specify_parameter(SpecifiedParameter(parameter(type, pos)), type, pos, param)
 end
 
 ## TODO document this. You are able to put any type of position,