remove the AbstractMap type

Author: daanhb

src/generic/composite.jl

@@ -87,7 +87,7 @@ function composedmap2(m1, m2::ComposedMap)
 end
 
 # Arguments to ∘ should be reversed before passing on to mapcompose
-Base.:∘(map1::AbstractMap, map2::AbstractMap) = composedmap(map2, map1)
+Base.:∘(map1::Map, map2::Map) = composedmap(map2, map1)
 
 
 isequalmap(m1::ComposedMap, m2::ComposedMap) =

src/generic/inverse.jl

@@ -24,7 +24,7 @@ inverse(m) = LazyInverse(m)
 inverse(m::LazyInverse) = supermap(m)
 # Concrete maps should implement inverse(m, x)
 
-Base.:\(m::AbstractMap, x) = inverse(m, x)
+Base.:\(m::Map, x) = inverse(m, x)
 
 implements_inverse(m) = !(inverse(m) isa LazyInverse)
 

src/generic/map.jl

@@ -1,14 +1,16 @@
 
-"An `AbstractMap` represents a function `y=f(x)` of a single variable."
-abstract type AbstractMap end
-
-"A `Map{T}` is a map of a single variable of type `T`."
-abstract type Map{T} <: AbstractMap end
+"""
+A `Map{T}` is a map of a single variable of type `T`.
+"""
+abstract type Map{T} end
 
 Map(m) = convert(Map, m)
 Map{T}(m) where {T} = convert(Map{T}, m)
 
-"A `TypedMap{T,U}` maps a variable of type `T` to a variable of type `U`."
+"""
+Any instance of `TypedMap{T,U}` maps a variable of type `T` to a variable
+of type `U`.
+"""
 abstract type TypedMap{T,U} <: Map{T} end
 
 const EuclideanMap{N,T} = Map{<:StaticVector{N,T}}
@@ -43,7 +45,6 @@ numtype(::Type{<:Map{T}}) where T = numtype(T)
 isrealmap(m) = isrealtype(domaintype(m)) && isrealtype(codomaintype(m))
 isrealmap(::UniformScaling{T}) where {T} = isrealtype(T)
 
-convert(::Type{AbstractMap}, m::AbstractMap) = m
 convert(::Type{Map{T}}, m::Map{T}) where {T} = m
 convert(::Type{Map{T}}, m::Map{S}) where {S,T} = similarmap(m, T)
 convert(::Type{TypedMap{T,U}}, m::TypedMap{T,U}) where {T,U} = m
@@ -83,10 +84,10 @@ convert_codomaintype(::Type{Any}, map) = map
 
 
 # Users may call a map, concrete subtypes specialize the `applymap` function
-(m::AbstractMap)(x) = applymap(m, x)
-
-# For Map{T}, we allow invocation with multiple arguments by conversion to T
+# Some effort is spent at this generic level to convert the argument to something
+# of type `T`.
 (m::Map{T})(x) where {T} = promote_and_apply(m, x)
+# For convenience we allow invocation with multiple arguments by conversion to T
 (m::Map{T})(x...) where {T} = promote_and_apply(m, convert(T, x))
 
 "Promote map and point to compatible types."
@@ -115,9 +116,8 @@ promote_and_apply(m::Map, x) = applymap(promote_map_point_pair(m,x)...)
 
 applymap!(y, m, x) = y .= m(x)
 
-# Fallback for functions that are not of type AbstractMap
+# Fallback for functions that are not of type Map
 applymap(m, x) = m(x)
-applymap(m::AbstractMap, x) = error("Please implement applymap for map $(m)")
 
 
 "Can the maps be promoted to a common domain type without throwing an error?"

src/generic/product.jl

@@ -194,7 +194,7 @@ end
 
 TupleProductMap{T}(maps::Vector) where {T<:Tuple} = TupleProductMap{T}(maps...)
 TupleProductMap{T}(maps...) where {T<:Tuple} = TupleProductMap{T}(maps)
-function TupleProductMap{T}(maps::NTuple{N,<:AbstractMap}) where {N,T <: Tuple}
+function TupleProductMap{T}(maps::NTuple{N,<:Map}) where {N,T <: Tuple}
 	Tmaps = map((t,d) -> convert(Map{t},d), tuple(T.parameters...), maps)
 	TupleProductMap{T,typeof(Tmaps)}(Tmaps)
 end

src/types/affine.jl

@@ -48,7 +48,7 @@ function diffvolume(m::AbstractAffineMap{T}) where T
     ConstantMap{T}(c)
 end
 
-islinearmap(m::AbstractMap) = false
+islinearmap(m::Map) = false
 islinearmap(m::AbstractAffineMap) = _affine_islinearmap(m, unsafe_vector(m))
 _affine_islinearmap(m, b) = all(b .== 0)
 

src/types/basic.jl

@@ -91,7 +91,7 @@ abstract type ConstantMap{T,U} <: TypedMap{T,U} end
 
 applymap(m::ConstantMap, x) = mapconstant(m)
 
-isconstantmap(m::AbstractMap) = false
+isconstantmap(m::Map) = false
 isconstantmap(m::ConstantMap) = true
 
 isrealmap(m::ConstantMap{T,U}) where {T,U} =