Remove @compact(name=...) and replace with NoShow

src/Fluxperimental.jl

@@ -13,6 +13,9 @@ include("chain.jl")
 
 include("compact.jl")
 
+include("noshow.jl")
+export NoShow
+
 include("new_recur.jl")
 
 end # module Fluxperimental

src/compact.jl

@@ -68,20 +68,6 @@ for epoch in 1:1000
   Flux.train!((m,x,y) -> (m(x) - y)^2, model, data, optim)
 end
 ```
-
-You may also specify a `name` for the model, which will
-be used instead of the default printout, which gives a verbatim
-representation of the code used to construct the model:
-
-```
-model = @compact(w=rand(3), name="Linear(3 => 1)") do x
-  sum(w .* x)
-end
-println(model)  # "Linear(3 => 1)"
-```
-
-This can be useful when using `@compact` to hierarchically construct
-complex models to be used inside a `Chain`.
 """
 macro compact(_exs...)
   # check inputs, extracting function expression fex and unprocessed keyword arguments _kwexs
@@ -108,16 +94,6 @@ macro compact(_exs...)
   kwexs2 = map(ex -> Expr(:kw, ex.args...), _kwexs) # handle keyword arguments provided before semicolon
   kwexs = (kwexs1..., kwexs2...)
 
-  # check if user has named layer:
-  name = findfirst(ex -> ex.args[1] == :name, kwexs)
-  if name !== nothing && kwexs[name].args[2] !== nothing
-    length(kwexs) == 1 && error("expects keyword arguments")
-    name_str = kwexs[name].args[2]
-    # remove name from kwexs (a tuple)
-    kwexs = (kwexs[1:name-1]..., kwexs[name+1:end]...)
-    name = name_str
-  end
-
   # make strings
   layer = "@compact"
   setup = NamedTuple(map(ex -> Symbol(string(ex.args[1])) => string(ex.args[2]), kwexs))
@@ -136,7 +112,7 @@ macro compact(_exs...)
   fex = supportself(fex, vars)
 
   # assemble
-  return esc(:($CompactLayer($fex, $name, ($layer, $input, $block), $setup; $(kwexs...))))
+  return esc(:($CompactLayer($fex, ($layer, $input, $block), $setup; $(kwexs...))))
 end
 
 function supportself(fex::Expr, vars)
@@ -155,12 +131,11 @@ end
 
 struct CompactLayer{F,NT1<:NamedTuple,NT2<:NamedTuple}
   fun::F
-  name::Union{String,Nothing}
   strings::NTuple{3,String}
   setup_strings::NT1
   variables::NT2
 end
-CompactLayer(f::Function, name::Union{String,Nothing}, str::Tuple, setup_str::NamedTuple; kw...) = CompactLayer(f, name, str, setup_str, NamedTuple(kw))
+CompactLayer(f::Function, str::Tuple, setup_str::NamedTuple; kw...) = CompactLayer(f, str, setup_str, NamedTuple(kw))
 (m::CompactLayer)(x...) = m.fun(m.variables, x...)
 CompactLayer(args...) = error("CompactLayer is meant to be constructed by the macro")
 Flux.@functor CompactLayer
@@ -179,16 +154,6 @@ end
 
 function Flux._big_show(io::IO, obj::CompactLayer, indent::Int=0, name=nothing)
   setup_strings = obj.setup_strings
-  local_name = obj.name
-  has_explicit_name = local_name !== nothing
-  if has_explicit_name
-    if indent != 0 || length(Flux.params(obj)) <= 2
-      _just_show_params(io, local_name, obj, indent)
-    else  # indent == 0
-      print(io, local_name)
-      Flux._big_finale(io, obj)
-    end
-  else  # no name, so print normally
     layer, input, block = obj.strings
     pre, post = ("(", ")")
     println(io, " "^indent, isnothing(name) ? "" : "$name = ", layer, pre)
@@ -220,7 +185,6 @@ function Flux._big_show(io::IO, obj::CompactLayer, indent::Int=0, name=nothing)
     else
       println(io, ",")
     end
-  end
 end
 
 # Modified from src/layers/show.jl

src/noshow.jl

@@ -0,0 +1,60 @@
+
+"""
+    NoShow(layer)
+    NoShow(string, layer)
+
+This alters printing (for instance at the REPL prompt) to let you hide the complexity
+of some part of a Flux model. It has no effect on the actual running of the model.
+
+By default it prints `NoShow(...)` instead of the given layer.
+If you provide a string, it prints that instead -- it can be anything,
+but it may make sense to print the name of a function which will
+re-create the same structure.
+
+# Examples
+
+```jldoctest
+julia> Chain(Dense(2 => 3), NoShow(Parallel(vcat, Dense(3 => 4), Dense(3 => 5))), Dense(9 => 10))
+Chain(
+  Dense(2 => 3),                        # 9 parameters
+  NoShow(...),                          # 36 parameters
+  Dense(9 => 10),                       # 100 parameters
+)                   # Total: 8 arrays, 145 parameters, 1.191 KiB.
+
+julia> PseudoLayer((i,o)::Pair) = Parallel(+, Dense(i => o, relu), Dense(i => o, tanh));
+
+julia> mid = PseudoLayer(3 => 10);
+
+julia> Chain(Dense(2 => 3), NoShow("PseudoLayer(3 => 10)", mid), Dense(9 => 10))
+Chain(
+  Dense(2 => 3),                        # 9 parameters
+  PseudoLayer(3 => 10),                 # 80 parameters
+  Dense(9 => 10),                       # 100 parameters
+)                   # Total: 8 arrays, 189 parameters, 1.379 KiB.
+```
+"""
+struct NoShow{T}
+    str::String
+    layer::T
+end
+
+NoShow(layer) = NoShow("", layer)
+
+Flux.@functor NoShow
+
+(no::NoShow)(x...) = no.layer(x...)
+
+Base.show(io::IO, no::NoShow) = print(io, isempty(no.str) ? "NoShow(...)" : no.str)
+
+Flux._show_leaflike(::NoShow) = true  # I think this is right
+Flux._show_children(::NoShow) = (;)   # Seems to be needed?
+
+function Base.show(io::IO, ::MIME"text/plain", m::NoShow)
+  if get(io, :typeinfo, nothing) === nothing  # e.g., top level of REPL
+    Flux._big_show(io, m)
+  elseif !get(io, :compact, false)  # e.g., printed inside a Vector, but not a matrix
+    Flux._layer_show(io, m)
+  else
+    show(io, m)
+  end
+end

test/compact.jl

@@ -118,15 +118,6 @@ end
     @test similar_strings(get_model_string(model), expected_string)
   end
 
-  @testset "Custom naming" begin
-    model = @compact(w=Dense(32, 32), name="Linear(...)") do x, y
-      tmp = sum(w(x))
-      return tmp + y
-    end
-    expected_string = "Linear(...)         # 1_056 parameters"
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
   @testset "Hierarchical models" begin
     model1 = @compact(w1=Dense(32=>32, relu), w2=Dense(32=>32, relu)) do x
       w2(w1(x))
@@ -148,6 +139,28 @@ end
     @test similar_strings(get_model_string(model2), expected_string)
   end
 
+#=  # This test is broken:
+
+julia> model1 = @compact(w1=Dense(32=>32, relu), w2=Dense(32=>32, relu)) do x
+             w2(w1(x));
+
+julia> model2 = @compact(w1=model1, w2=Dense(32=>32, relu)) do x
+             w2(w1(x))
+           end
+@compact(
+  @compact(
+    w1 = Dense(32 => 32, relu),         # 1_056 parameters
+    w2 = Dense(32 => 32, relu),         # 1_056 parameters
+  ) do x 
+      w2(w1(x))
+  end,
+  w2 = Dense(32 => 32, relu),           # 1_056 parameters
+) do x 
+    w2(w1(x))
+end                  # Total: 6 arrays, 3_168 parameters, 13.239 KiB.
+
+=#
+
   @testset "Array parameters" begin
     model = @compact(x=randn(32), w=Dense(32=>32)) do s
       w(x .* s)
@@ -161,41 +174,6 @@ end
     @test similar_strings(get_model_string(model), expected_string)
   end
 
-  @testset "Hierarchy with inner model named" begin
-    model = @compact(
-      w1=@compact(w1=randn(32, 32), name="Model(32)") do x
-        w1 * x
-      end,
-      w2=randn(32, 32),
-      w3=randn(32),
-    ) do x
-      w2 * w1(x)
-    end
-    expected_string = """@compact(
-      Model(32),                            # 1_024 parameters
-      w2 = randn(32, 32),                   # 1_024 parameters
-      w3 = randn(32),                       # 32 parameters
-    ) do x 
-        w2 * w1(x)
-    end                  # Total: 3 arrays, 2_080 parameters, 17.089 KiB."""
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
-  @testset "Hierarchy with outer model named" begin
-    model = @compact(
-      w1=@compact(w1=randn(32, 32)) do x
-        w1 * x
-      end,
-      w2=randn(32, 32),
-      w3=randn(32),
-      name="Model(32)"
-    ) do x
-      w2 * w1(x)
-    end
-    expected_string = """Model(32)                  # Total: 3 arrays, 2_080 parameters, 17.057KiB."""
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
   @testset "Dependent initializations" begin
     # Test that initialization lines cannot depend on each other
     @test_throws UndefVarError @compact(y = 3, z = y^2) do x