+Below is a simple example program that defines a `drawable` wrapper for any type
+that provides a `draw` member function. (The details will be explained later.)
+
+``` Cpp
+ // This example is an adaptation of one found in Louis Dione's dyno library.
+ #include <folly/Poly.h>
+ #include <iostream>
+
+ struct IDrawable {
+ // Define the interface of something that can be drawn:
+ template <class Base> struct Interface : Base {
+ void draw(std::ostream& out) const { folly::poly_call<0>(*this, out);}
+ };
+ // Define how concrete types can fulfill that interface (in C++17):
+ template <class T> using Members = folly::PolyMembers<&T::draw>;
+ };
+
+ // Define an object that can hold anything that can be drawn:
+ using drawable = folly::Poly<IDrawable>;
+
+ struct Square {
+ void draw(std::ostream& out) const { out << "Square\n"; }
+ };
+
+ struct Circle {
+ void draw(std::ostream& out) const { out << "Circle\n"; }
+ };
+
+ void f(drawable const& d) {
+ d.draw(std::cout);
+ }
+
+ int main() {
+ f(Square{}); // prints Square
+ f(Circle{}); // prints Circle
+ }
+```
+
+The above program prints:
+
+```
+ Square
+ Circle
+```
+
+Here is another (heavily commented) example of a simple implementation of a