Make CallableTransform and CallableInverse aliases of Base.Fix1

ext/ChangesOfVariablesExt.jl

@@ -4,10 +4,10 @@ import TransformVariables
 import ChangesOfVariables
 
 function ChangesOfVariables.with_logabsdet_jacobian(f::TransformVariables.CallableTransform, x)
-    return TransformVariables.transform_and_logjac(f.t, x)
+    return TransformVariables.transform_and_logjac(f.x, x)
 end
 function ChangesOfVariables.with_logabsdet_jacobian(f::TransformVariables.CallableInverse, x)
-    return TransformVariables.inverse_and_logjac(f.t, x)
+    return TransformVariables.inverse_and_logjac(f.x, x)
 end
 
 end # module

src/generic.jl

@@ -125,41 +125,21 @@ transform(t, x) == transform(t)(x)
 """
 function transform end
 
+transform(t::AbstractTransform) = Base.Fix1(transform, t)
+
 """
 $(TYPEDEF)
 
 Partial application of `transform(t, x)`, callable with `x`. Use `transform(t)` to
 construct.
 """
-struct CallableTransform{T}
-    t::T
-end
-
-(f::CallableTransform)(x) = transform(f.t, x)
+const CallableTransform{T} = Base.Fix1{typeof(transform),T} where {T<:AbstractTransform}
 
 function Base.show(io::IO, f::CallableTransform)
-    print(io, "callable for the transformation $(f.t)")
-end
-
-transform(t) = CallableTransform(t)
-
-"""
-$(TYPEDEF)
-
-Partial application of `inverse(t, y)`, callable with `y`. Use `inverse(t)` to
-construct.
-"""
-struct CallableInverse{T}
-    t::T
-end
-
-function Base.show(io::IO, f::CallableInverse)
-    print(io, "callable inverse for the transformation $(f.t)")
+    print(io, "callable for the transformation ", f.x)
 end
 
-inverse(f::CallableInverse) = CallableTransform(f.t)
-
-inverse(f::CallableTransform) = CallableInverse(f.t)
+inverse(f::CallableTransform) = Base.Fix1(inverse, f.x)
 
 """
 `$(FUNCTIONNAME)(t, y)`
@@ -174,9 +154,21 @@ with transform, so the following holds:
 inverse(t)(y) == inverse(t, y) == inverse(transform(t))(y)
 ```
 """
-inverse(t::AbstractTransform) = CallableInverse(t)
+inverse(t::AbstractTransform) = Base.Fix1(inverse, t)
+
+"""
+$(TYPEDEF)
+
+Partial application of `inverse(t, y)`, callable with `y`. Use `inverse(t)` to
+construct.
+"""
+const CallableInverse{T} = Base.Fix1{typeof(inverse),T} where {T<:AbstractTransform}
+
+function Base.show(io::IO, f::CallableInverse)
+    print(io, "callable inverse for the transformation ", f.x)
+end
 
-(f::CallableInverse)(y) = inverse(f.t, y)
+inverse(f::CallableInverse) = Base.Fix1(transform, f.x)
 
 """
 `$(FUNCTIONNAME)(t::AbstractTransform, y)`

test/runtests.jl

@@ -583,17 +583,17 @@ end
 
 @testset "ChangesOfVariables" begin
     t = as(Real, 1.0, 3.0)
-    f = TransformVariables.CallableTransform(t)
-    inv_f = TransformVariables.CallableInverse(t)
+    f = transform(t)
+    inv_f = inverse(t)
     ChangesOfVariables.test_with_logabsdet_jacobian(f, -4.2, ForwardDiff.derivative)
     ChangesOfVariables.test_with_logabsdet_jacobian(inv_f, 1.7, ForwardDiff.derivative)
 end
 
 
 @testset "InverseFunctions" begin
     t = as(Real, 1.0, 3.0)
-    f = TransformVariables.CallableTransform(t)
-    inv_f = TransformVariables.CallableInverse(t)
+    f = transform(t)
+    inv_f = inverse(t)
     InverseFunctions.test_inverse(f, -4.2)
     InverseFunctions.test_inverse(inv_f, 1.7)
 end