Revise type_param delegation

For elements, use type plus parent.

For rings, default to just the type.

Author: fingolfin

experimental/LieAlgebras/src/serialization.jl

@@ -127,8 +127,6 @@ end
 @register_serialization_type LinearLieAlgebraElem
 @register_serialization_type DirectSumLieAlgebraElem
 
-type_params(x::T) where {T<:LieAlgebraElem} = TypeParams(T, parent(x))
-
 function save_object(s::SerializerState, x::LieAlgebraElem)
   save_object(s, coefficients(x))
 end
@@ -222,8 +220,6 @@ end
 
 @register_serialization_type LieAlgebraModuleElem
 
-type_params(x::T) where {T<:LieAlgebraModuleElem} = TypeParams(T, parent(x))
-
 function save_object(s::SerializerState, x::LieAlgebraModuleElem)
   save_object(s, coefficients(x))
 end

src/Serialization/Algebras.jl

@@ -4,6 +4,8 @@
 # Free associative algebra serialization
 @register_serialization_type FreeAssociativeAlgebra uses_id
 
+type_params(R::T) where T <: FreeAssociativeAlgebra = TypeParams(T, coefficient_ring(R))
+
 function save_object(s::SerializerState, A::FreeAssociativeAlgebra)
   save_data_dict(s) do
     save_object(s, symbols(A), :symbols)

src/Serialization/Fields.jl

@@ -5,13 +5,6 @@
 ################################################################################
 # field of rationals (singleton type)
 @register_serialization_type QQField
-# exclude from ring union definition
-type_params(::QQField) = TypeParams(QQField, nothing)
-type_params(::QQFieldElem) = TypeParams(QQFieldElem, nothing)
-type_params(::fpField) = TypeParams(fpField, nothing)
-type_params(::FpField) = TypeParams(FpField, nothing)
-type_params(::QQBarField) = TypeParams(QQBarField, nothing)
-type_params(::PadicField) = TypeParams(PadicField, nothing)
 
 ################################################################################
 # type_params for field extension types
@@ -244,6 +237,8 @@ end
 
 @register_serialization_type FracField uses_id
 
+type_params(R::T) where T <: FracField = TypeParams(T, base_ring(R))
+
 const FracUnionTypes = Union{MPolyRingElem, PolyRingElem, UniversalPolyRingElem}
 # we use the union to prevent QQField from using these save methods
 
@@ -282,6 +277,8 @@ end
 
 @register_serialization_type AbstractAlgebra.Generic.RationalFunctionField "RationalFunctionField" uses_id
 
+type_params(R::T) where T <: AbstractAlgebra.Generic.RationalFunctionField = TypeParams(T, base_ring(R))
+
 function save_object(s::SerializerState,
                      RF::AbstractAlgebra.Generic.RationalFunctionField{<: FieldElem, <: MPolyRingElem})
   save_data_dict(s) do

src/Serialization/Groups.jl

@@ -90,8 +90,6 @@ using Oscar: GAPGroup, _coeff
 # `GAPGroupElem` objects get serialized together with their parents.
 const GrpElemUnionType = Union{GAPGroupElem, FinGenAbGroupElem}
 
-type_params(p::T) where T <: GrpElemUnionType = TypeParams(T, parent(p))
-
 #############################################################################
 # attributes handling
 const GAPGroup_attributes = [

src/Serialization/LieTheory.jl

@@ -74,8 +74,6 @@ end
 
 @register_serialization_type WeightLatticeElem
 
-type_params(w::WeightLatticeElem) = TypeParams(WeightLatticeElem, parent(w))
-
 function save_object(s::SerializerState, w::WeightLatticeElem)
   save_object(s, _vec(coefficients(w)))
 end
@@ -107,8 +105,6 @@ end
 
 @register_serialization_type WeylGroupElem
 
-type_params(w::WeylGroupElem) = TypeParams(WeylGroupElem, parent(w))
-
 function save_object(s::SerializerState, x::WeylGroupElem)
   save_object(s, word(x))
 end

src/Serialization/Rings.jl

@@ -1,8 +1,6 @@
 ################################################################################
 # Common union types
 
-const RingMatElemUnion = Union{NCRingElem, MatElem, SMat}
-const RingMatSpaceUnion = Union{NCRing, MatSpace, SMatSpace}
 const ModRingUnion = Union{zzModRing, ZZModRing}
 const ModRingElemUnion = Union{zzModRingElem, ZZModRingElem}
 
@@ -31,14 +29,18 @@ const LaurentUnionType = Union{Generic.LaurentSeriesRing,
 ################################################################################
 # type_params functions
 
-type_params(x::T) where T <: RingMatElemUnion = TypeParams(T, parent(x))
-type_params(R::T) where T <: RingMatSpaceUnion = TypeParams(T, base_ring(R))
+# element types by default use their parent as reference object
+type_params(x::T) where T <: SetElem = TypeParams(T, parent(x))
+type_params(x::T) where T <: SMat = TypeParams(T, parent(x))
+
+# rings, groups etc. default have no reference object
+type_params(R::T) where T <: AbstractAlgebra.Set = TypeParams(T, nothing)
+
+# ideals and matrix spaces have their base ring as reference object
 type_params(x::T) where T <: Ideal = TypeParams(T, base_ring(x))
-# exclude from ring union
-type_params(::ZZRing) = TypeParams(ZZRing, nothing)
-type_params(::ZZRingElem) = TypeParams(ZZRingElem, nothing)
-type_params(R::T) where T <: PolyRingUnionType = TypeParams(T, coefficient_ring(R))
-type_params(R::T) where T <: ModRingUnion = TypeParams(T, nothing)
+type_params(x::T) where T <: MatSpace = TypeParams(T, base_ring(x))
+type_params(x::T) where T <: SMatSpace = TypeParams(T, base_ring(x))
+
 
 ################################################################################
 # ring of integers (singleton type)
@@ -85,6 +87,9 @@ end
 @register_serialization_type MPolyDecRing uses_id
 @register_serialization_type AbstractAlgebra.Generic.LaurentMPolyWrapRing uses_id
 
+# polynomial-like rings use their coefficient ring as reference object
+type_params(R::T) where T <: PolyRingUnionType = TypeParams(T, coefficient_ring(R))
+
 function save_object(s::SerializerState, R::PolyRingUnionType)
   save_data_dict(s) do
     save_object(s, symbols(R), :symbols)
@@ -378,6 +383,7 @@ end
 # Power Series
 @register_serialization_type SeriesRing uses_id
 
+type_params(R::T) where T <: SeriesRing = TypeParams(T, base_ring(R))
 
 function save_object(s::SerializerState, R::RelPowerSeriesUnionType)
   save_data_dict(s) do
@@ -497,6 +503,8 @@ end
 @register_serialization_type Generic.LaurentSeriesField "LaurentSeriesField" uses_id
 @register_serialization_type ZZLaurentSeriesRing uses_id
 
+type_params(R::T) where T <: LaurentUnionType = TypeParams(T, base_ring(R))
+
 function save_object(s::SerializerState, R::LaurentUnionType)
   save_data_dict(s) do
     save_object(s, var(R), :var)
@@ -702,8 +710,6 @@ end
 
 @register_serialization_type MPolyLocRingElem
 
-type_params(a::MPolyLocRingElem) = TypeParams(MPolyLocRingElem, parent(a))
-
 function save_object(s::SerializerState, a::MPolyLocRingElem)
   # `save_type_params` will store the output of type_params
   # in this case the parent ring
@@ -742,8 +748,6 @@ end
 
 @register_serialization_type MPolyQuoLocRingElem
 
-type_params(a::T) where {T<:MPolyQuoLocRingElem} = TypeParams(T, parent(a))
-
 function save_object(s::SerializerState, a::MPolyQuoLocRingElem)
  save_object(s, [lifted_numerator(a), lifted_denominator(a)])
 end