AnyDuck : A Value Type Erased Type
A Constrained Duck Typed Value Type
For yak shaving reasons, I need a type able to hold any type conforming to a particular interface. I'd like this to act as a (Semi)Regular value type. That is, I'd like it to be copyable, assignable, and so forth, and not be sliced or otherwise mangeled in the process. I want it to be reasonably efficient, not significantly worse than traditional virtual function overhead. I also don't want to be terribly creative in implementing, using existing std library types.
The overall pattern I've settled on for now is to hold the type in a
Ducks are defined as things that quack, and quack is a const function. I want to be able to put any type that models Duck into an AnyDuck, and pass AnyDuck into any generic function expecting a Duck. I also want to be able to extend AnyDuck to unrelated types, as long as they model Duck. Mallard, for example:
The core of the idea, is to capture the Duck type in a templated constructor where I know the exact type, and create the appropriate lambda:
And then wrap the public facing call so that quackfn can be stored as a function pointer
Here's the whole thing:
The copy constructors are there to be a better match than the templated constructor for copy by value. Codegen is surprisingly good. If the types are all present, the functions are inlined well, except for the overhead of storage into the any. For any unknown AnyDuck, there's a dispatch via pointer indirection:
results in something like
and the
If the implementation of the underlying quack is not available there's a little more work
But far less than I would have expected.
std::any and dispatch to the held type through function pointers referring to lambdas. The lambda allows me to capture the type being stored into the AnyDuck and safely recover it. There's some boilerplate to write to dispatch to the lambda. Perhaps one day, when we have reflection, that can be automated.
For purposes of this paper, I'll assume I have an interface Duck that I want to model:
class Duck { public: void quack(int length) const; };
class Mallard { public: void quack(int length) const; };
auto quack_ = [](std::any const& d, int i) { return std::any_cast<std::remove_reference_t<Duck>>(&d)->quack(i); }
void AnyDuck::quack(int length) const { return quack_(this->duck_, length); }
class AnyDuck { std::any duck_; using quackfn = void (*)(std::any const&, int); quackfn quack_; public: AnyDuck(AnyDuck const&) = default; AnyDuck(AnyDuck&) = default; template <typename Duck> AnyDuck(Duck&& duck) : duck_(std::forward<Duck>(duck)), quack_([](std::any const& d, int i) { return std::any_cast<std::remove_reference_t<Duck>>(&d)->quack( i); }) {} void quack(int length) const { return quack_(this->duck_, length); } };
void test(AnyDuck a) { a.quack(1); }
0000000000000050 <test(scratch::AnyDuck)>: 50: 48 8b 47 10 mov 0x10(%rdi),%rax 54: be 01 00 00 00 mov $0x1,%esi 59: ff e0 jmpq *%rax 5b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
any_cast<> from the address of the passed in std::any is noexcept, but does in general have to check if the any has a value. Not as cheap as pure an interface type, but not terribly more expensive.
For the case where the quack is known, codegen is something like
scratch::AnyDuck::AnyDuck<Duck&>(Duck&)::{lambda(std::any const&, int)#1}::__invoke(std::any const&, int): # @scratch::AnyDuck::AnyDuck<Duck&>(Duck&)::{lambda(std::any const&, int)#1}::__invoke(std::any const&, int) movl %esi, %edi jmp bell(int) # TAILCALL
scratch::AnyDuck::AnyDuck<Mallard&>(Mallard&)::{lambda(std::any const&, int)#1}::__invoke(std::any const&, int): # @scratch::AnyDuck::AnyDuck<Mallard&>(Mallard&)::{lambda(std::any const&, int)#1}::__invoke(std::any const&, int) movl $_ZNSt3any17_Manager_internalI7MallardE9_S_manageENS_3_OpEPKS_PNS_4_ArgE, %ecx xorl %eax, %eax cmpq %rcx, (%rdi) leaq 8(%rdi), %rcx cmoveq %rcx, %rax movq %rax, %rdi jmp Mallard::quack(int) const # TAILCALL
std::any is less awful than I thought.
You can take a look at the code so far here Compiler Explorer Link to see the results
I'll clean up my scratch project and push it at some point.
Walk
Canarsie - Rockaway Pkwy
Walk
Eastchester - Dyre Av
Walk
Walk
Forest Hills - 71 Av
Walk