Use the inverse function instead of the Base.inv function (#4)

* Use the 'inverse' function (from InverseFunctions.jl) instead of 'inv' function (from Base)

* Define the 'inverse' function

* Fix code

* Update docstring

* Update src/interface.jl

---------

Co-authored-by: Júlio Hoffimann <[email protected]>

Author: eliascarv

src/identity.jl

@@ -13,7 +13,7 @@ isrevertible(::Type{Identity}) = true
 
 isinvertible(::Type{Identity}) = true
 
-Base.inv(::Identity) = Identity()
+inverse(::Identity) = Identity()
 
 apply(::Identity, object) = object, nothing
 

src/interface.jl

@@ -32,16 +32,26 @@ function isrevertible end
 """
     isinvertible(transform)
 
-Tells whether or not the `transform` is invertible, i.e. supports a
-`inv` function. Defaults to `false` for new transform types.
+Tells whether or not the `transform` is invertible, i.e. whether it
+implements the `inverse` function. Defaults to `false` for new transform
+types.
 
 Transforms can be invertible in the mathematical sense, i.e., there
 exists a one-to-one mapping between input and output spaces.
 
-See also [`isrevertible`](@ref).
+See also [`inverse`](@ref), [`isrevertible`](@ref).
 """
 function isinvertible end
 
+"""
+    inverse(transform)
+
+Returns the inverse transform of the `transform`.
+
+See also [`isinvertible`](@ref).
+"""
+function inverse end
+
 """
     assertions(transform)
 
@@ -90,23 +100,19 @@ function reapply end
 # TRANSFORM FALLBACKS
 # --------------------
 
-isrevertible(transform::Transform) =
-  isrevertible(typeof(transform))
+isrevertible(transform::Transform) = isrevertible(typeof(transform))
 isrevertible(::Type{<:Transform}) = false
 
-isinvertible(transform::Transform) =
-  isinvertible(typeof(transform))
+isinvertible(transform::Transform) = isinvertible(typeof(transform))
 isinvertible(::Type{<:Transform}) = false
 
 assertions(transform::Transform) = []
 
 preprocess(transform::Transform, object) = nothing
 
-reapply(transform::Transform, object, cache) =
-  apply(transform, object) |> first
+reapply(transform::Transform, object, cache) = apply(transform, object) |> first
 
-(transform::Transform)(object) =
-  apply(transform, object) |> first
+(transform::Transform)(object) = apply(transform, object) |> first
 
 function Base.show(io::IO, transform::Transform)
   T = typeof(transform)

src/sequential.jl

@@ -15,7 +15,7 @@ isrevertible(s::SequentialTransform) = all(isrevertible, s.transforms)
 
 isinvertible(s::SequentialTransform) = all(isinvertible, s.transforms)
 
-Base.inv(s::SequentialTransform) = SequentialTransform([inv(t) for t in reverse(s.transforms)])
+inverse(s::SequentialTransform) = SequentialTransform([inverse(t) for t in reverse(s.transforms)])
 
 function apply(s::SequentialTransform, table)
   allcache = []
@@ -59,21 +59,16 @@ end
 Create a [`SequentialTransform`](@ref) transform with
 `[transform₁, transform₂, …, transformₙ]`.
 """
-→(t1::Transform, t2::Transform) =
-  SequentialTransform([t1, t2])
-→(t1::Transform, t2::SequentialTransform) =
-  SequentialTransform([t1; t2.transforms])
-→(t1::SequentialTransform, t2::Transform) =
-  SequentialTransform([t1.transforms; t2])
-→(t1::SequentialTransform, t2::SequentialTransform) =
-  SequentialTransform([t1.transforms; t2.transforms])
+→(t1::Transform, t2::Transform) = SequentialTransform([t1, t2])
+→(t1::Transform, t2::SequentialTransform) = SequentialTransform([t1; t2.transforms])
+→(t1::SequentialTransform, t2::Transform) = SequentialTransform([t1.transforms; t2])
+→(t1::SequentialTransform, t2::SequentialTransform) = SequentialTransform([t1.transforms; t2.transforms])
 
 # AbstractTrees interface
 AbstractTrees.nodevalue(::SequentialTransform) = SequentialTransform
 AbstractTrees.children(s::SequentialTransform) = s.transforms
 
-Base.show(io::IO, s::SequentialTransform) =
-  print(io, join(s.transforms, " → "))
+Base.show(io::IO, s::SequentialTransform) = print(io, join(s.transforms, " → "))
 
 function Base.show(io::IO, ::MIME"text/plain", s::SequentialTransform)
   tree = AbstractTrees.repr_tree(s, context=io)

test/runtests.jl

@@ -4,8 +4,8 @@ using Test
 @testset "TransformsBase.jl" begin
   @test TransformsBase.isrevertible(Identity())
   @test TransformsBase.isinvertible(Identity())
-  @test inv(Identity()) == Identity()
-  @test inv(Identity() → Identity()) == Identity()
+  @test TransformsBase.inverse(Identity()) == Identity()
+  @test TransformsBase.inverse(Identity() → Identity()) == Identity()
   @test (Identity() → Identity()) == Identity()
 
   # test fallbacks
@@ -14,6 +14,8 @@ using Test
   T = TestTransform()
   @test !TransformsBase.isrevertible(T)
   @test !TransformsBase.isinvertible(T)
+  @test !TransformsBase.isrevertible(T → T)
+  @test !TransformsBase.isinvertible(T → T)
   @test TransformsBase.assertions(T) |> isempty
   @test TransformsBase.preprocess(T, nothing) |> isnothing
   @test TransformsBase.reapply(T, 1, nothing) == 1