suboptimal design of `Fix`, `ComposedFunction`, `Returns`, `Splat`, `Broadcast.Broadcasted`: `sizeof(Base.Fix1(convert, Float32)) > 0`

[nsajko]

Fix fails to be a zero-cost abstraction when either the callable or the fixed positional argument (or both) are types:

julia> sizeof(Base.Fix1(convert, Float32))  # would expect `0`
8

Fixing this would be arguably breaking, so I'm registering a new package providing a stand-in replacement to Base.Fix, Base.Fix1, Base.Fix2:

• https://github.com/JuliaFunctional/FixFunctionArgument.jl

However perhaps this is something to reconsider for v2, or it could pass as a "minor change".

[PatrickHaecker]

Good finding and great solution!

Which functionality do you see as breaking?

• the change in sizeof?
• the change in the second and third type parameter?
• the change in the upper bounds in the second and third type parameter?

FixFunctionArgument.jl depends on ZeroDimensionalArrays.jl. Could you provide a fix without depending on ZeroDimensionalArrays.jl and without copying most of it into Base?

[nsajko]

The changes to the interpretation of the type parameters F and T would be breaking. In fact even some method definitions in Base would start throwing because they dispatch on subtypes of Fix2. Functions findall, findnext, findprev, to be specific.

That gets me thinking, though, given that reliably dispatching on subtypes is one of the main things that Fix is used for, I might need to give this issue more thought; both to see if there's a way at a minimally-invasive fix for Base, and to make my package more compatible with Base.Fix.

[nsajko]

I think a mostly backwards-compatible fix would be possible, however it would be quite ugly. We could have the constructors for Fix, Fix1 and Fix2 work fine, and have the type parameters the same as before, in case neither the callable (f) nor the fixed positional argument (x) are types. However, when either f isa Type or x isa Type, we would lack the property Fix{N}(f, x) isa Fix. I don't think it's worth it to do this.

Regarding my package, I'll introduce some additional type aliases to make dispatching on subtypes of Fix a nicer experience.

[nsajko]

Ah, I realize the exact same issue as with Fix is present with ComposedFunction:

julia> sizeof(Bool ∘ +)
8

julia> sizeof(Bool ∘ Int)
16

Probably that will be another package.

[nsajko]

Scratch that, here's the solution, and it's already in Base:

• julia/base/operators.jl

  Lines 1110 to 1113 in 573db77

  	struct Constructor{F} <: Function end
  	(::Constructor{F})(args...; kw...) where {F} = (@inline; F(args...; kw...))
  	maybeconstructor(::Type{F}) where {F} = Constructor{F}()
  	maybeconstructor(f) = f

I think if we applied maybeconstructor to both arguments of both Fix and of ∘ during construction, that could perhaps pass as a minor change. Even if it that can't pass as a minor change, I think it would simplify the design in my package.

Working on a PR.

[nsajko]

the exact same issue as with Fix is present with ComposedFunction

Also Returns:

julia> sizeof(Returns(Vector))
8

[nsajko]

Also splat/Base.Splat:

julia> sizeof(splat(Vector))
8