start adjusting at-layer for auto-functor

Author: mcabbott

Project.toml

@@ -47,7 +47,7 @@ CUDA = "4, 5"
 ChainRulesCore = "1.12"
 Compat = "4.10.0"
 Enzyme = "0.12, 0.13"
-Functors = "0.4"
+Functors = "0.5"
 MLDataDevices = "1.4.2"
 MLUtils = "0.4"
 MPI = "0.20.19"

src/deprecations.jl

@@ -158,3 +158,26 @@ end
 #   where `loss_mxy` accepts the model as its first argument.
 #   """
 # ))
+
+"""
+    @functor MyLayer
+
+Flux used to require the use of `Functors.@functor` to mark any new layer-like struct.
+This allowed it to explore inside the struct, and update any trainable parameters within.
+
+[email protected] removes this requirement. This is because [email protected] changed ist behaviour
+to be opt-out instead of opt-in. Arbitrary structs will now be explored without special marking.
+Hence calling `@functor` is no longer required.
+
+Calling `Flux.@layer MyLayer` is, however, still recommended. This adds various convenience methods
+for your layer type, such as pretty printing.
+"""
+macro functor(ex)
+  Base.depwarn("""The macro `@functor` is deprecated.
+      Most likely, you should write `Flux.@layer MyLayer` which will add various convenience methods for your type,
+      such as pretty-printing, and use with Adapt.jl.
+      However, this is not required. Flux.jl v0.15 uses Functors.jl v0.5, which makes exploration of most nested `struct`s
+      opt-out instead of opt-in... so Flux will automatically see inside any custom struct definitions.
+      """, Symbol("@functor")
+  _layer_macro(ex)
+end

src/layers/macro.jl

@@ -4,6 +4,8 @@
     @layer :expand Chain
     @layer BatchNorm trainable=(β,γ)
 
+NEEDS NEW DOCS!
+
 This macro replaces most uses of `@functor`. Its basic purpose is the same:
 When you define a new layer, this tells Flux to explore inside it
 to see the parameters it trains, and also to move them to the GPU, change precision, etc.
@@ -48,11 +50,15 @@ Trio(
 
 """
 macro layer(exs...)
+  _layer_macro(exs...)
+end
+
+function _layer_macro(exs...)
   out = quote end
 
   # These functions are defined in show.jl, and each return an expression overloading Base.show
   type, rest... = if exs[1] == QuoteNode(:expand)
-    push!(out.args, _macro_big_show(esc(exs[2])))  
+    push!(out.args, _macro_big_show(esc(exs[2])))
     exs[2:end]
   elseif exs[1] == QuoteNode(:ignore)
     exs[2:end]
@@ -63,9 +69,6 @@ macro layer(exs...)
     exs
   end
 
-  # This function exists only for depwarns when you use @functor directly
-  push!(out.args, :(Flux._check_new_macro(::$(esc(type))) = nothing))
-  
   push!(out.args, _macro_functor(esc(type)))
 
   for j in 1:length(rest)
@@ -85,23 +88,12 @@ macro layer(exs...)
   out
 end
 
-# Temporary depwarn function, called within `params`, is also called by `show`.
-
-function _check_new_macro(x::T) where T
-  Functors.isleaf(x) && return
-  Base.depwarn(LazyString("This type should probably now use `Flux.@layer` instead of `@functor`: ", T), Symbol("@functor"))
-end
-_check_new_macro(::Tuple) = nothing  # defined by Functors.jl, not by users
-_check_new_macro(::NamedTuple) = nothing
-_check_new_macro(::AbstractArray) = nothing
-_check_new_macro(::Ref) = nothing
-
 # @layer's code for Functors & Adapt
 # Unlike @functor, _default_functor doesn't need to eval anything
 
 function _macro_functor(type)
   quote
-    Functors.functor(::Type{T}, x) where {T<:$type} = $_default_functor(T, x)
+    # Functors.functor(::Type{T}, x) where {T<:$type} = $_default_functor(T, x)
     Adapt.adapt_structure(to, layer::$type) = $fmap($adapt(to), layer)
   end
 end
@@ -110,28 +102,28 @@ function _macro_functor(type, fields)
   Meta.isexpr(fields, :tuple) || error("expected a tuple of field names")
   symbols = Tuple(map(_noquotenode, fields.args))
   quote
-    Functors.functor(::Type{T}, x) where {T<:$type} = $_custom_functor(T, x, Val($symbols))
+    # Functors.functor(::Type{T}, x) where {T<:$type} = $_custom_functor(T, x, Val($symbols))
     Adapt.adapt_structure(to, layer::$type) = $fmap($adapt(to), layer)
   end
 end
 _macro_functor(type, field::Union{Symbol,QuoteNode}) = _macro_functor(type, :(($field,)))  # lets you forget a comma
 
-function _default_functor(::Type{T}, x) where {T}
-   if @generated
-     F = fieldnames(T)
-     args = map(sy -> :(getfield(x, $(QuoteNode(sy)))), F)
-     C = Base.typename(T).wrapper  # constructor
-     # recon = VERSION > v"1.9-" ? :(Splat($C)) : :(Base.splat($C))
-     recon = :(Base.splat($C))
-     :((NamedTuple{$F}(($(args...),)), $recon))
-   else
-     # Getting this parameterless type takes about 2μs, every time:
-     # spl = VERSION > v"1.9-" ? Splat : Base.splat
-     spl = Base.splat
-     namedtuple(x), spl(Base.typename(T).wrapper)
-   end
-end
- 
+# function _default_functor(::Type{T}, x) where {T}
+#    if @generated
+#      F = fieldnames(T)
+#      args = map(sy -> :(getfield(x, $(QuoteNode(sy)))), F)
+#      C = Base.typename(T).wrapper  # constructor
+#      # recon = VERSION > v"1.9-" ? :(Splat($C)) : :(Base.splat($C))
+#      recon = :(Base.splat($C))
+#      :((NamedTuple{$F}(($(args...),)), $recon))
+#    else
+#      # Getting this parameterless type takes about 2μs, every time:
+#      # spl = VERSION > v"1.9-" ? Splat : Base.splat
+#      spl = Base.splat
+#      namedtuple(x), spl(Base.typename(T).wrapper)
+#    end
+# end
+
 function namedtuple(x::T) where T
   F = fieldnames(T)
   NamedTuple{F}(map(sy -> getfield(x, sy), F))