A Constrained Duck Typed Value Type
The overall pattern I’ve settled on for now is to hold the type in a 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; };
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:
class Mallard { public: void quack(int length) const; };
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:
auto quack_ = [](std::any const& d, int i) { return std::any_cast<std::remove_reference_t<Duck>>(&d)->quack(i); }
And then wrap the public facing call so that quackfn can be stored as a function pointer
void AnyDuck::quack(int length) const { return quack_(this->duck_, length); }
Here’s the whole thing:
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); } };
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:
void test(AnyDuck a) { a.quack(1); }
results in something like
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)
and the 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
If the implementation of the underlying quack is not available there’s a little more work
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
But far less than I would have expected. 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.