Only allocate when asked

Author: joschmitt

src/MPoly.jl

@@ -501,8 +501,11 @@ Return an iterator for the coefficients of the given polynomial. To retrieve
 an array of the coefficients, use `collect(coefficients(a))`.
 """
 function coefficients(a::MPolyRingElem{T}; inplace::Bool = false) where T <: RingElement
-   t = zero(coefficient_ring(parent(a)))
-   return Generic.MPolyCoeffs(a, inplace, t)
+   if inplace
+      t = zero(coefficient_ring(parent(a)))
+      return Generic.MPolyCoeffs(a, inplace, t)
+   end
+   return Generic.MPolyCoeffs(a)
 end
 
 @doc raw"""
@@ -517,9 +520,12 @@ function exponent_vectors(a::MPolyRingElem{T}; inplace::Bool = false) where T <:
 end
 
 function exponent_vectors(::Type{Vector{S}}, a::MPolyRingElem{T}; inplace::Bool = false) where {T <: RingElement, S}
-   # Don't use `zeros`: If S === ZZRingElem, then all the entries would be identical
-   t = [zero(S) for _ in 1:nvars(parent(a))]
-   return Generic.MPolyExponentVectors(a, inplace, t)
+   if inplace
+      # Don't use `zeros`: If S === ZZRingElem, then all the entries would be identical
+      t = [zero(S) for _ in 1:nvars(parent(a))]
+      return Generic.MPolyExponentVectors(a, inplace, t)
+   end
+   return Generic.MPolyExponentVectors(Vector{S}, a)
 end
 
 @doc raw"""
@@ -529,8 +535,11 @@ Return an iterator for the monomials of the given polynomial. To retrieve
 an array of the monomials, use `collect(monomials(a))`.
 """
 function monomials(a::MPolyRingElem{T}; inplace::Bool = false) where T <: RingElement
-   t = zero(parent(a))
-   return Generic.MPolyMonomials(a, inplace, t)
+   if inplace
+      t = zero(parent(a))
+      return Generic.MPolyMonomials(a, inplace, t)
+   end
+   return Generic.MPolyMonomials(a)
 end
 
 @doc raw"""
@@ -540,8 +549,11 @@ Return an iterator for the terms of the given polynomial. To retrieve
 an array of the terms, use `collect(terms(a))`.
 """
 function terms(a::MPolyRingElem{T}; inplace::Bool = false) where T <: RingElement
-   t = zero(parent(a))
-   return Generic.MPolyTerms(a, inplace, t)
+   if inplace
+      t = zero(parent(a))
+      return Generic.MPolyTerms(a, inplace, t)
+   end
+   return Generic.MPolyTerms(a)
 end
 
 ###############################################################################

src/generic/GenericTypes.jl

@@ -385,46 +385,74 @@ end
 
 # Iterators
 
-struct MPolyCoeffs{T <: AbstractAlgebra.NCRingElem, S <: AbstractAlgebra.RingElement}
+mutable struct MPolyCoeffs{T <: AbstractAlgebra.NCRingElem, S <: AbstractAlgebra.RingElement}
    poly::T
    inplace::Bool
    temp::S # only used if inplace == true
-end
 
-function MPolyCoeffs(f::AbstractAlgebra.NCRingElem)
-   return MPolyCoeffs(f, false, zero(coefficient_ring(parent(f))))
+   function MPolyCoeffs(f::AbstractAlgebra.NCRingElem)
+     I = new{typeof(f), elem_type(coefficient_ring_type(f))}()
+      I.poly = f
+      I.inplace = false
+      return I
+   end
+
+   function MPolyCoeffs(f::AbstractAlgebra.NCRingElem, inplace::Bool, temp::AbstractAlgebra.RingElement)
+      return new{typeof(f), typeof(temp)}(f, inplace, temp)
+   end
 end
 
 # S may be the type of anything that can store an exponent vector, for example
 # Vector{Int}, ZZMatrix, ...
-struct MPolyExponentVectors{T <: AbstractAlgebra.RingElem, S}
+mutable struct MPolyExponentVectors{T <: AbstractAlgebra.RingElem, S}
    poly::T
    inplace::Bool
    temp::S # only used if inplace == true
-end
 
-function MPolyExponentVectors(f::AbstractAlgebra.RingElem)
-   return MPolyExponentVectors(f, false, Vector{Int}())
+   function MPolyExponentVectors(::Type{S}, f::AbstractAlgebra.NCRingElem) where S
+      I = new{typeof(f), S}()
+      I.poly = f
+      I.inplace = false
+      return I
+   end
+
+   function MPolyExponentVectors(f::AbstractAlgebra.NCRingElem, inplace::Bool, temp::S) where S
+      return new{typeof(f), S}(f, inplace, temp)
+   end
 end
 
-struct MPolyTerms{T <: AbstractAlgebra.NCRingElem}
+mutable struct MPolyTerms{T <: AbstractAlgebra.NCRingElem}
    poly::T
    inplace::Bool
    temp::T # only used if inplace == true
-end
 
-function MPolyTerms(f::AbstractAlgebra.NCRingElem)
-   return MPolyTerms(f, false, zero(parent(f)))
+   function MPolyTerms(f::AbstractAlgebra.NCRingElem)
+      I = new{typeof(f)}()
+      I.poly = f
+      I.inplace = false
+      return I
+   end
+
+   function MPolyTerms(f::T, inplace::Bool, temp::T) where {T <: AbstractAlgebra.NCRingElem}
+      return new{T}(f, inplace, temp)
+   end
 end
 
-struct MPolyMonomials{T <: AbstractAlgebra.NCRingElem}
+mutable struct MPolyMonomials{T <: AbstractAlgebra.NCRingElem}
    poly::T
    inplace::Bool
    temp::T # only used if inplace == true
-end
 
-function MPolyMonomials(f::NCRingElem)
-   return MPolyMonomials(f, false, zero(parent(f)))
+   function MPolyMonomials(f::AbstractAlgebra.NCRingElem)
+      I = new{typeof(f)}()
+      I.poly = f
+      I.inplace = false
+      return I
+   end
+
+   function MPolyMonomials(f::T, inplace::Bool, temp::T) where {T <: AbstractAlgebra.NCRingElem}
+      return new{T}(f, inplace, temp)
+   end
 end
 
 mutable struct MPolyBuildCtx{T, S}