reduce Meta.parse calls (#158)

Author: jishnub

src/Operators/Operator.jl

@@ -371,7 +371,7 @@ end
 
 
 for OP in (:colstart,:colstop,:rowstart,:rowstop)
-    defOP = Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval begin
         $OP(A::Operator, i::Integer) = $defOP(A,i)
         $OP(A::Operator, i::PosInfinity) = ℵ₀

src/Operators/banded/CalculusOperator.jl

@@ -7,9 +7,9 @@ abstract type CalculusOperator{S,OT,T}<:Operator{T} end
 ## Note that all functions called in calculus_operator must be exported
 
 macro calculus_operator(Op)
-    ConcOp=Meta.parse("Concrete"*string(Op))
-    WrappOp=Meta.parse(string(Op)*"Wrapper")
-    DefaultOp=Meta.parse("Default"*string(Op))
+    ConcOp = Symbol(:Concrete, Op)
+    WrappOp = Symbol(Op, :Wrapper)
+    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

src/Operators/banded/Reverse.jl

@@ -1,7 +1,7 @@
 
 
 for TYP in (:ReverseOrientation,:Reverse)
-    WRAP = Meta.parse(string(TYP)*"Wrapper")
+    WRAP = Symbol(TYP, :Wrapper)
     @eval begin
         abstract type $TYP{T} <: Operator{T} end
 

src/Operators/functionals/CalculusFunctional.jl

@@ -7,8 +7,8 @@ abstract type CalculusFunctional{S,T} <: Operator{T} end
 ##TODO: Add ConcreteOp
 
 macro calculus_functional(Op)
-    ConcOp=Meta.parse("Concrete"*string(Op))
-    WrappOp=Meta.parse(string(Op)*"Wrapper")
+    ConcOp = Symbol(:Concrete, Op)
+    WrappOp = Symbol(Op, :Wrapper)
     return esc(quote
         abstract type $Op{SSS,TTT} <: CalculusFunctional{SSS,TTT} end
         struct $ConcOp{S,T} <: $Op{S,T}

src/Operators/general/algebra.jl

@@ -30,7 +30,7 @@ bandwidths(P::PlusOperator) = P.bandwidths
 israggedbelow(P::PlusOperator) = isbandedbelow(P) || all(israggedbelow,P.ops)
 
 for (OP,mn) in ((:colstart,:min),(:colstop,:max),(:rowstart,:min),(:rowstop,:max))
-    defOP = Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::PlusOperator,k::Integer)
         if isbanded(P)
             $defOP(P,k)
@@ -310,7 +310,7 @@ israggedbelow(P::TimesOperator) = isbandedbelow(P) || all(israggedbelow,P.ops)
 Base.stride(P::TimesOperator) = mapreduce(stride,gcd,P.ops)
 
 for OP in (:rowstart,:rowstop)
-    defOP=Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::TimesOperator,k::Integer)
         if isbanded(P)
             return $defOP(P,k)
@@ -323,7 +323,7 @@ for OP in (:rowstart,:rowstop)
 end
 
 for OP in (:colstart,:colstop)
-    defOP=Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::TimesOperator, k::Integer)
         if isbanded(P)
             return $defOP(P, k)

src/constructors.jl

@@ -38,14 +38,14 @@ end
 
 # default_Fun is the default constructor, based on evaluation and transforms
 # last argument is whether to splat or not
-default_Fun(::Type{T},f,d::Space{ReComp},pts::AbstractArray,::Type{Val{true}}) where {T,ReComp} =
+default_Fun(T::Type,f,d::Space,pts::AbstractArray,::Type{Val{true}}) =
     Fun(d,transform(d,T[f(x...) for x in pts]))
 
-default_Fun(::Type{T},f,d::Space{ReComp},pts::AbstractArray,::Type{Val{false}}) where {T,ReComp} =
+default_Fun(T::Type,f,d::Space,pts::AbstractArray,::Type{Val{false}}) =
     Fun(d,transform(d,broadcast!(f, similar(pts, T), pts)))
 
 
-function default_Fun(f,d::Space{ReComp},n::Integer,::Type{Val{false}}) where ReComp
+function default_Fun(f,d::Space,n::Integer,::Type{Val{false}})
     pts=points(d, n)
     f1=f(pts[1])
     if isa(f1,AbstractArray) && size(d) ≠ size(f1)
@@ -57,7 +57,7 @@ function default_Fun(f,d::Space{ReComp},n::Integer,::Type{Val{false}}) where ReC
     default_Fun(Tprom,f,d,pts,Val{false})
 end
 
-function default_Fun(f,d::Space{ReComp},n::Integer,::Type{Val{true}}) where ReComp
+function default_Fun(f,d::Space,n::Integer,::Type{Val{true}})
     pts=points(d, n)
     f1=f(pts[1]...)
     if isa(f1,AbstractArray) && size(d) ≠ size(f1)
@@ -69,9 +69,9 @@ function default_Fun(f,d::Space{ReComp},n::Integer,::Type{Val{true}}) where ReCo
     default_Fun(Tprom,f,d,pts,Val{true})
 end
 
-default_Fun(f,d::Space{ReComp},n::Integer) where {ReComp} = default_Fun(f,d,n,Val{!hasnumargs(f,1)})
+default_Fun(f,d::Space,n::Integer) = default_Fun(f,d,n,Val{!hasnumargs(f,1)})
 
-Fun(f,d::Space{ReComp},n::Integer) where {ReComp} = default_Fun(dynamic(f),d,n)
+Fun(f,d::Space,n::Integer) = default_Fun(dynamic(f),d,n)
 
 # the following is to avoid ambiguity
 # Fun(f::Fun,d) should be equivalent to Fun(x->f(x),d)
@@ -144,12 +144,12 @@ Fun(f::Type, d::Space) = error("Not implemented")
 
 
 # special case constructors
-zeros(S::Space) = Fun(S,zeros(1))
-zeros(::Type{T}, S::Space) where {T<:Number} = Fun(S,zeros(T,1))
+zeros(S::Space) = zeros(Float64, S)
+zeros(T::Type, S::Space) = Fun(S,zeros(T,1))
 
 # catch all
-ones(S::Space) = Fun(x->1.0,S)
-ones(::Type{T}, S::Space) where {T<:Number} = Fun(x->one(T),S)
+ones(S::Space) = ones(Float64, S)
+ones(T::Type, S::Space) = Fun(x->one(T),S)
 
 function Fun(::typeof(identity), d::Domain)
     cd=canonicaldomain(d)
@@ -169,7 +169,7 @@ Fun(::typeof(identity), S::Space) = Fun(identity,domain(S))
 Fun(f::typeof(zero), d::Space) = zeros(eltype(domain(d)),d)
 Fun(f::typeof(one), d::Space) = ones(eltype(domain(d)),d)
 
-Fun(f::Type, d::Domain) = Fun(f,Space(d))
+# Fun(f::Type, d::Domain) = Fun(f,Space(d))
 Fun(f, d::Domain) = Fun(f,Space(d))