wip

Author: jll63

README.md

@@ -17,26 +17,29 @@ turn on optimizations (`-O2 -DNDEBUG`) and to select the Boost library.
 
 ## OpenMethod vs Boost.TypeErasure
 
-At first sight, OpenMethod and TypeErasure exist in the same space: runtime
-polymorphic systems that offer a solution to the Expression Problem.
+OpenMethod and TypeErasure exist in the same space: runtime polymorphic systems
+that offer a solution to the Expression Problem.
 
-Thanks to BOOST_TYPE_ERASURE_FREE, one can add operations to existing classes,
-without the need to modify them. And of course one can add new classes to
-existing operations, by providing the required functions on them. However, one
-quickly hits a wall, and this is related to the fact that in B.TE polymorphism
-is imbued to a "magic" handle, `any`, whereas in OpenMethod, polymorphism is
-attached to the object itself.
+Thanks to BOOST_TYPE_ERASURE_FREE, we can add operations to existing classes,
+without the need to modify them. And of course we can add new classes to
+existing operations, by providing the required functions on them.
 
-To make this more concrete, let's look at an example. Consider a matrix library,
-which contains several matrix subtypes (let's limit ourselves to "ordinary" and
-"symmetric") and operations (let's just focus on transposition).
+However, we quickly hits a wall, and this is related to the fact that in B.TE
+polymorphism is imbued to a "magic" handle, `any`, whereas in OpenMethod,
+polymorphism is attached to the object itself.
+
+Let's look at an example. Consider a matrix library, which contains several
+matrix subtypes (let's limit ourselves to "ordinary" and "symmetric") and
+operations (let's just focus on transposition).
 
 Here is (what I believe is) a plausible design:
 
 ```c++
 #include <boost/mpl/vector.hpp>
 #include <boost/type_erasure/any.hpp>
 #include <boost/type_erasure/free.hpp>
+#include <boost/type_erasure/typeid_of.hpp>
+#include <boost/core/demangle.hpp>
 #include <iostream>
 
 namespace mpl = boost::mpl;
@@ -45,51 +48,62 @@ using namespace boost::type_erasure;
 BOOST_TYPE_ERASURE_FREE(transpose);
 
 struct ordinary_matrix_impl {
-    ordinary_matrix_impl() {
-        std::cout << "ordinary_matrix_impl\n";
-    }
+    virtual ~ordinary_matrix_impl() { /* ... */ }
+    std::size_t rows, cols;
+    std::vector<double> elements; // rows x cols doubles
 };
 
 struct symmetric_matrix_impl {
-    symmetric_matrix_impl() {
-        std::cout << "symmetric_matrix_impl\n";
-    }
+    virtual ~symmetric_matrix_impl() { /* ... */ }
+    std::size_t rows; // cols == rows
+    std::vector<double> elements; // rows doubles
 };
 
 struct matrix {
-    any<mpl::vector<copy_constructible<>, has_transpose<matrix(_self&)>>> impl;
+    any<mpl::vector<copy_constructible<>, has_transpose<matrix(_self&)>, typeid_<>>> impl;
 };
 
 auto transpose(matrix m) {
     return transpose(m.impl);
 }
 
 auto transpose(ordinary_matrix_impl& m) {
-    std::cout << "transpose ordinary matrix\n";
     return matrix{ordinary_matrix_impl()};
 }
 
 auto transpose(symmetric_matrix_impl& m) {
-    std::cout << "transpose symmetric matrix\n";
     return matrix{m};
 }
 
 auto main() -> int {
     {
         matrix m{ordinary_matrix_impl()};
         auto t = transpose(m);
+        std::cout << boost::core::demangle(typeid_of(t.impl).name()) << "\n";
+            // ordinary_matrix_impl
     }
 
     {
         matrix m{symmetric_matrix_impl()};
         auto t = transpose(m);
+        std::cout << boost::core::demangle(typeid_of(t.impl).name()) << "\n";
+            // symmetric_matrix_impl
     }
 
     return 0;
 }
 ```
 
-([Compiler Explorer](https://godbolt.org/z/hWoM6jWdd))
+([Compiler Explorer](https://godbolt.org/z/613Eo5zGP)
+
+We were able to add new behavior to existing classes (the "impl" classes)
+without needing to modify them. This is promising.
+
+Here is the equivalent using open-methods:
+
+```c++
+```
+
+
 
-Now let's suppose that an application needs to serialize matrices to JSON. The
-operation can be added to the matrix library in the same way as `transpose`:
+We can also add serialization to JSON:

doc/introduction.adoc

@@ -9,6 +9,13 @@ the Expression Problem:
 to add new operations on the existing types, and new types to the existing
 operations, without modifying existing code?
 
+Open-methods also offer a solution to the banana-gorilla-jungle problem:
+
+> The problem with object-oriented languages is they’ve got all this implicit
+environment that they carry around with them. You wanted a banana but what you
+got was a gorilla holding the banana and the entire jungle.  — Joe Armstrong,
+creator of Erlang progamming language
+
 As a bonus, open-methods can take more than one argument into account when
 selecting the appropriate function to call - aka multiple dispatch. For that
 reason, open-methods are often called multi-methods, but that term is