Namespace in Calculus operator macro (#267)

* Namespace in Calculus operator macro

* bump version to v0.7.34

* more namespaces in macros

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.7.33"
+version = "0.7.34"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Operators/Operator.jl

@@ -75,7 +75,7 @@ hasconstblocks(A::Operator) = hasconstblocks(domainspace(A)) && hasconstblocks(r
 macro functional(FF)
     quote
         Base.size(A::$FF,k::Integer) = k==1 ? 1 : dimension(domainspace(A))
-        ApproxFunBase.rangespace(F::$FF) = ConstantSpace(eltype(F))
+        ApproxFunBase.rangespace(F::$FF) = ApproxFunBase.ConstantSpace(eltype(F))
         ApproxFunBase.isafunctional(::$FF) = true
         ApproxFunBase.blockbandwidths(A::$FF) = 0,hastrivialblocks(domainspace(A)) ? bandwidth(A,2) : ℵ₀
         function ApproxFunBase.defaultgetindex(f::$FF,k::Integer,j::Integer)
@@ -494,7 +494,7 @@ haswrapperstructure(_) = false
 #  Ex: c*op or real(op)
 macro wrapperstructure(Wrap)
     ret = quote
-        haswrapperstructure(::$Wrap) = true
+        ApproxFunBase.haswrapperstructure(::$Wrap) = true
     end
 
     for func in (:(ApproxFunBase.bandwidths),:(LinearAlgebra.stride),

src/Operators/banded/CalculusOperator.jl

@@ -12,7 +12,7 @@ macro calculus_operator(Op)
     DefaultOp = Symbol(:Default, Op)
     return esc(quote
         # The SSS, TTT are to work around #9312
-        abstract type $Op{SSS,OT,TTT} <: CalculusOperator{SSS,OT,TTT} end
+        abstract type $Op{SSS,OT,TTT} <: ApproxFunBase.CalculusOperator{SSS,OT,TTT} end
 
         struct $ConcOp{S<:Space,OT,T} <: $Op{S,OT,T}
             space::S        # the domain space
@@ -23,22 +23,22 @@ macro calculus_operator(Op)
             order::OT
         end
 
-        @wrapper $WrappOp
+        ApproxFunBase.@wrapper $WrappOp
 
 
         ## Constructors
-        $ConcOp(sp::Space,k) = $ConcOp{typeof(sp),typeof(k),prectype(sp)}(sp,k)
+        $ConcOp(sp::Space,k) = $ConcOp{typeof(sp),typeof(k),ApproxFunBase.prectype(sp)}(sp,k)
 
-        $Op(sp::UnsetSpace,k) = $ConcOp(sp,k)
-        $Op(sp::UnsetSpace,k::Real) = $ConcOp(sp,k)
-        $Op(sp::UnsetSpace,k::Integer) = $ConcOp(sp,k)
+        $Op(sp::ApproxFunBase.UnsetSpace,k) = $ConcOp(sp,k)
+        $Op(sp::ApproxFunBase.UnsetSpace,k::Real) = $ConcOp(sp,k)
+        $Op(sp::ApproxFunBase.UnsetSpace,k::Integer) = $ConcOp(sp,k)
 
         function $DefaultOp(sp::Space,k)
-            csp=canonicalspace(sp)
-            if conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
+            csp=ApproxFunBase.canonicalspace(sp)
+            if ApproxFunBase.conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
                error("Implement $(string($Op))($(string(sp)),$k)")
             end
-            $WrappOp(TimesOperator([$Op(csp,k),Conversion(sp,csp)]),k)
+            $WrappOp(ApproxFunBase.TimesOperator([$Op(csp,k),Conversion(sp,csp)]),k)
         end
 
         $DefaultOp(d,k) = $Op(Space(d),k)

src/Operators/functionals/CalculusFunctional.jl

@@ -10,19 +10,19 @@ macro calculus_functional(Op)
     ConcOp = Symbol(:Concrete, Op)
     WrappOp = Symbol(Op, :Wrapper)
     return esc(quote
-        abstract type $Op{SSS,TTT} <: CalculusFunctional{SSS,TTT} end
+        abstract type $Op{SSS,TTT} <: ApproxFunBase.CalculusFunctional{SSS,TTT} end
         struct $ConcOp{S,T} <: $Op{S,T}
             domainspace::S
         end
         struct $WrappOp{BT<:Operator,S<:Space,T} <: $Op{S,T}
             op::BT
         end
 
-        @wrapper $WrappOp
+        ApproxFunBase.@wrapper $WrappOp
 
 
         # We expect the operator to be real/complex if the basis is real/complex
-        $ConcOp(dsp::Space) = $ConcOp{typeof(dsp),prectype(dsp)}(dsp)
+        $ConcOp(dsp::Space) = $ConcOp{typeof(dsp),ApproxFunBase.prectype(dsp)}(dsp)
 
         $Op() = $Op(UnsetSpace())
         $Op(dsp) = $ConcOp(dsp)
@@ -37,7 +37,7 @@ macro calculus_functional(Op)
         ApproxFunBase.domain(Σ::$ConcOp) = domain(Σ.domainspace)
         ApproxFunBase.domainspace(Σ::$ConcOp) = Σ.domainspace
 
-        Base.getindex(::$ConcOp{UnsetSpace},kr::AbstractRange) =
+        Base.getindex(::$ConcOp{ApproxFunBase.UnsetSpace},kr::AbstractRange) =
             error("Spaces cannot be inferred for operator")
 
         $WrappOp(op::Operator) =