Rely on isrevertible fallback whenever possible

Author: juliohm

src/transforms/closure.jl

@@ -13,8 +13,6 @@ See also [`Remainder`](@ref).
 """
 struct Closure <: StatelessFeatureTransform end
 
-isrevertible(::Type{Closure}) = false
-
 assertions(::Closure) = [scitypeassert(Continuous)]
 
 function applyfeat(::Closure, feat, prep)

src/transforms/coalesce.jl

@@ -44,8 +44,6 @@ Coalesce(cols::C...; value) where {C<:Column} = Coalesce(selector(cols), value)
 
 parameters(transform::Coalesce) = (; value=transform.value)
 
-isrevertible(::Type{<:Coalesce}) = false
-
 colcache(::Coalesce, x) = nothing
 
 colapply(transform::Coalesce, x, c) = coalesce.(x, transform.value)

src/transforms/dropextrema.jl

@@ -52,8 +52,6 @@ DropExtrema(cols::C...; low=0.25, high=0.75) where {C<:Column} = DropExtrema(sel
 
 parameters(transform::DropExtrema) = (low=transform.low, high=transform.high)
 
-isrevertible(::Type{<:DropExtrema}) = false
-
 function preprocess(transform::DropExtrema, feat)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)

src/transforms/dropmissing.jl

@@ -41,8 +41,6 @@ DropMissing() = DropMissing(AllSelector())
 DropMissing(cols) = DropMissing(selector(cols))
 DropMissing(cols::C...) where {C<:Column} = DropMissing(selector(cols))
 
-isrevertible(::Type{<:DropMissing}) = false
-
 function preprocess(transform::DropMissing, feat)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)

src/transforms/dropnan.jl

@@ -35,8 +35,6 @@ DropNaN() = DropNaN(AllSelector())
 DropNaN(cols) = DropNaN(selector(cols))
 DropNaN(cols::C...) where {C<:Column} = DropNaN(selector(cols))
 
-isrevertible(::Type{<:DropNaN}) = false
-
 _isnan(_) = false
 _isnan(x::Number) = isnan(x)
 

src/transforms/filter.jl

@@ -27,8 +27,6 @@ struct Filter{F} <: StatelessFeatureTransform
   pred::F
 end
 
-isrevertible(::Type{<:Filter}) = false
-
 function preprocess(transform::Filter, feat)
   # lazy row iterator
   rows = tablerows(feat)

src/transforms/map.jl

@@ -62,8 +62,6 @@ function Map(pairs::MapPair...)
   Map(selectors, funs, targets)
 end
 
-isrevertible(::Type{Map}) = false
-
 _funname(fun::Base.Fix1) = "fix1_" * _funname(fun.f)
 _funname(fun::Base.Fix2) = "fix2_" * _funname(fun.f)
 _funname(fun::ComposedFunction) = _funname(fun.outer) * "_" * _funname(fun.inner)

src/transforms/replace.jl

@@ -58,8 +58,6 @@ function Replace(pairs::Pair...)
   Replace(selectors, preds, news)
 end
 
-isrevertible(::Type{<:Replace}) = false
-
 function applyfeat(transform::Replace, feat, prep)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)

src/transforms/sample.jl

@@ -40,8 +40,6 @@ Sample(size::Int, weights::AbstractWeights; replace=false, ordered=false, rng=Ra
 
 Sample(size::Int, weights; kwargs...) = Sample(size, Weights(collect(weights)); kwargs...)
 
-isrevertible(::Type{<:Sample}) = false
-
 function preprocess(transform::Sample, feat)
   # retrieve valid indices
   inds = 1:_nrows(feat)

src/transforms/satisfies.jl

@@ -19,8 +19,6 @@ struct Satisfies{F} <: StatelessFeatureTransform
   pred::F
 end
 
-isrevertible(::Type{<:Satisfies}) = false
-
 function applyfeat(transform::Satisfies, feat, prep)
   pred = transform.pred
   cols = Tables.columns(feat)

src/transforms/select.jl

@@ -45,8 +45,6 @@ Select(pairs::Pair{C,S}...) where {C<:Column,S<:AbstractString} =
 
 Select() = throw(ArgumentError("cannot create Select transform without arguments"))
 
-isrevertible(::Type{<:Select}) = false
-
 # utils
 _newnames(::Nothing, select) = select
 _newnames(names::Vector{Symbol}, select) = names
@@ -91,8 +89,6 @@ Reject(cols::C...) where {C<:Column} = Reject(selector(cols))
 Reject() = throw(ArgumentError("cannot create Reject transform without arguments"))
 Reject(::AllSelector) = throw(ArgumentError("cannot reject all columns"))
 
-isrevertible(::Type{<:Reject}) = false
-
 function applyfeat(transform::Reject, feat, prep)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)

src/transforms/sort.jl

@@ -34,8 +34,6 @@ Sort(cols::C...; kwargs...) where {C<:Column} = Sort(selector(cols), values(kwar
 
 Sort(; kwargs...) = throw(ArgumentError("cannot create Sort transform without arguments"))
 
-isrevertible(::Type{<:Sort}) = false
-
 function preprocess(transform::Sort, feat)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)