Check is_transformable via duck typing

[glennmoy]

The transform API is currently checked by calling is_transformable on a type, which just checks for types that are expected to have an apply method defined for it. This is just duck typing but with extra steps.
This way of checking the interface is brittle and unnecessary: if users define an apply method for their type downstream but forget to extend is_transformable for it it defeats the purpose, similarly one can easily get around the check by extending is_transformable without actually extending apply.
Rather, is_transformable(my_type) should just verify that an apply method for my_type exists and cut out this middle step.

[bencottier]

I thought

is_transformable(::T) where T = hasmethod(apply, Tuple{T, Transform})

But that allows anything for T because of the table method. How do we deal with that?

[glennmoy]

I thought

is_transformable(::T) where T = hasmethod(apply, Tuple{T, Transform})

But that allows anything for T because of the table method. How do we deal with that?

We can probably work around it, for example methodswith can restrict to not checking against the supertypes including Any.

help?> methodswith
search: methodswith

  methodswith(typ[, module or function]; supertypes::Bool=false])

  Return an array of methods with an argument of type typ.

  The optional second argument restricts the search to a particular module or function (the default is all top-level
  modules).

  If keyword supertypes is true, also return arguments with a parent type of typ, excluding type Any.

So in this case something like this would work:

function is_transformable(T::Type) 
    Tables.istable(T) && return true  # cannot check against the method with no type annotation
    return !isempty(methodswith(T, FeatureTransforms.apply; supertypes=true))
end

julia> trans = [[1, 2, 3], [[1 2], [3 4]], (a=[1, 2], b=[3, 4]), DataFrame(:a=>[1, 2], :b=>[3, 4])];

julia> all(is_transformable(t) for t in trans)
true

julia> all(is_transformable(typeof(t)) for t in trans)
true

# extend it for a new type
julia> FeatureTransforms.apply(x::Integer, ::Transform) = x

julia> transformable(1)
true

But I'm not sure how effective it is to rely on the method table for these things.