├── .clang-format
├── .gitignore
├── CMakeLists.txt
├── LICENSE
├── README.md
├── include
    ├── Free.h
    ├── Functor.h
    ├── List.h
    ├── Monad.h
    └── void_t.h
└── test
    ├── CMakeLists.txt
    ├── FreeTest.cpp
    ├── FunctorTest.cpp
    ├── ListTest.cpp
    ├── TestRunner.cpp
    └── catch.hpp


/.clang-format:
--------------------------------------------------------------------------------
 1 | ---
 2 | Language:        Cpp
 3 | # BasedOnStyle:  Google
 4 | AccessModifierOffset: -1
 5 | AlignAfterOpenBracket: Align
 6 | AlignConsecutiveAssignments: true
 7 | AlignConsecutiveDeclarations: false
 8 | AlignEscapedNewlinesLeft: true
 9 | AlignOperands:   true
10 | AlignTrailingComments: true
11 | AllowAllParametersOfDeclarationOnNextLine: true
12 | AllowShortBlocksOnASingleLine: false
13 | AllowShortCaseLabelsOnASingleLine: false
14 | AllowShortFunctionsOnASingleLine: All
15 | AllowShortIfStatementsOnASingleLine: true
16 | AllowShortLoopsOnASingleLine: true
17 | AlwaysBreakAfterDefinitionReturnType: None
18 | AlwaysBreakAfterReturnType: None
19 | AlwaysBreakBeforeMultilineStrings: true
20 | AlwaysBreakTemplateDeclarations: true
21 | BinPackArguments: false
22 | BinPackParameters: false
23 | BraceWrapping:   
24 |   AfterClass:      false
25 |   AfterControlStatement: false
26 |   AfterEnum:       false
27 |   AfterFunction:   false
28 |   AfterNamespace:  false
29 |   AfterObjCDeclaration: false
30 |   AfterStruct:     false
31 |   AfterUnion:      false
32 |   BeforeCatch:     false
33 |   BeforeElse:      false
34 |   IndentBraces:    false
35 | BreakBeforeBinaryOperators: None
36 | BreakBeforeBraces: Attach
37 | BreakBeforeTernaryOperators: true
38 | BreakConstructorInitializersBeforeComma: false
39 | ColumnLimit:     90
40 | CommentPragmas:  '^ IWYU pragma:'
41 | ConstructorInitializerAllOnOneLineOrOnePerLine: true
42 | ConstructorInitializerIndentWidth: 4
43 | ContinuationIndentWidth: 4
44 | Cpp11BracedListStyle: true
45 | DerivePointerAlignment: false
46 | DisableFormat:   false
47 | ExperimentalAutoDetectBinPacking: false
48 | ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
49 | IncludeCategories: 
50 |   - Regex:           '^<.*\.h>'
51 |     Priority:        1
52 |   - Regex:           '^<.*'
53 |     Priority:        2
54 |   - Regex:           '.*'
55 |     Priority:        3
56 | IndentCaseLabels: true
57 | IndentWidth:     2
58 | IndentWrappedFunctionNames: false
59 | KeepEmptyLinesAtTheStartOfBlocks: false
60 | MacroBlockBegin: ''
61 | MacroBlockEnd:   ''
62 | MaxEmptyLinesToKeep: 1
63 | NamespaceIndentation: All
64 | ObjCBlockIndentWidth: 2
65 | ObjCSpaceAfterProperty: false
66 | ObjCSpaceBeforeProtocolList: false
67 | PenaltyBreakBeforeFirstCallParameter: 1
68 | PenaltyBreakComment: 300
69 | PenaltyBreakFirstLessLess: 120
70 | PenaltyBreakString: 1000
71 | PenaltyExcessCharacter: 1000000
72 | PenaltyReturnTypeOnItsOwnLine: 200
73 | PointerAlignment: Left
74 | ReflowComments:  true
75 | SortIncludes:    true
76 | SpaceAfterCStyleCast: false
77 | SpaceBeforeAssignmentOperators: true
78 | SpaceBeforeParens: ControlStatements
79 | SpaceInEmptyParentheses: false
80 | SpacesBeforeTrailingComments: 2
81 | SpacesInAngles:  false
82 | SpacesInContainerLiterals: true
83 | SpacesInCStyleCastParentheses: false
84 | SpacesInParentheses: false
85 | SpacesInSquareBrackets: false
86 | Standard:        Auto
87 | TabWidth:        8
88 | UseTab:          Never
89 | ...
90 | 
91 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /build*/
2 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.0)
 2 | 
 3 | project(FreeCpp)
 4 | 
 5 | set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 6 | 
 7 | # We use Boost for the header-only variant library
 8 | find_package(Boost REQUIRED COMPONENTS)
 9 | 
10 | # Turn on lots of compiler warnings
11 | if(MSVC)
12 |   # Force to always compile with W4
13 |   if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
14 |     string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
15 |   else()
16 |     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
17 |   endif()
18 | elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
19 |   # Update if necessary
20 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
21 | endif()
22 | 
23 | # Define our header-only Monad library
24 | add_library(Monad INTERFACE)
25 | target_include_directories(Monad INTERFACE include ${Boost_INCLUDE_DIRS})
26 | # This turns on C++14 mode
27 | target_compile_features(Monad INTERFACE
28 |   cxx_alias_templates
29 |   cxx_trailing_return_types
30 |   cxx_return_type_deduction)
31 | 
32 | # Tests
33 | add_subdirectory(test)
34 | 
35 | enable_testing()
36 | add_test(NAME Test COMMAND TestRunner)
37 | 
38 | # Support for building Markdown from the specially marked up source files.
39 | find_program(CPP2BLOG cpp2blog PATHS /home/toby/.local/bin)
40 | 
41 | set(ARTICLE_SOURCES
42 |   ${CMAKE_CURRENT_SOURCE_DIR}/include/Functor.h
43 |   ${CMAKE_CURRENT_SOURCE_DIR}/include/Monad.h
44 |   ${CMAKE_CURRENT_SOURCE_DIR}/include/List.h
45 |   ${CMAKE_CURRENT_SOURCE_DIR}/include/Free.h)
46 | add_custom_command(
47 |   OUTPUT implementation.md
48 |   COMMAND ${CPP2BLOG} ${ARTICLE_SOURCES} >implementation.md
49 |   DEPENDS ${ARTICLE_SOURCES}
50 |   )
51 | set(USAGE_SOURCES
52 |   ${CMAKE_CURRENT_SOURCE_DIR}/test/FreeTest.cpp)
53 | add_custom_command(
54 |   OUTPUT usage.md
55 |   COMMAND ${CPP2BLOG} ${USAGE_SOURCES} >usage.md
56 |   DEPENDS ${USAGE_SOURCES}
57 |   )
58 | add_custom_target(article
59 |   DEPENDS implementation.md usage.md)
60 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Toby Allsopp
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Free Monads in C++ #
2 | 
3 | This project is an experiment to see if/how the concept of a Free Monad can be used in C++.
4 | 
5 | See my blog post at
6 | <https://toby-allsopp.github.io/2016/10/12/free-monads-in-cpp.html> for a detailed
7 | explanation.
8 | 


--------------------------------------------------------------------------------
/include/Free.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | // Copyright (c) 2016 Toby Allsopp
  4 | // See LICENSE for license details.
  5 | 
  6 | #include "Functor.h"
  7 | #include "Monad.h"
  8 | 
  9 | /*!
 10 |   ### Free Monads ###
 11 | 
 12 |   Every type _f_ that is a Functor has a "Free" Monad. A Free Monad is some
 13 |   category theory gobbledygook but it's basically the simplest possible Monad
 14 |   that doesn't throw any information away.
 15 | 
 16 |   In Haskell, this is defined quite simply:
 17 | 
 18 |   ```
 19 |   data Free f a = Return a | Bind (f (Free f a))
 20 | 
 21 |   instance (Functor f) => Monad (Free f) where
 22 |   ...
 23 |   ```
 24 | 
 25 |   This is a bit complicated to express in C++ due to the lack of algebraic data
 26 |   types, in particular the lack of a sum type (`tuple` and `struct` provide
 27 |   product types). In C++17 we will get `variant` which plugs the gap acceptably
 28 |   and in the meantime we can use `boost::variant`.
 29 | */
 30 | #include <boost/variant.hpp>
 31 | 
 32 |   /*!
 33 |     To define something like the Haskell `data` with two cases, we define a type
 34 |     for each case and then combine them into a `variant`. Because the `Bind`
 35 |     case is recursive we need to forward-declare them and use
 36 |     `recursive_wrapper` to define the `variant`.
 37 |    */
 38 | namespace Free {
 39 |   template <template <typename> class F, typename A>
 40 |   struct Return;
 41 |   template <template <typename> class F, typename A>
 42 |   struct Bind;
 43 | 
 44 |   /*!
 45 |     We wrap the `variant` in a `struct` so we have somewhere to hang a couple of
 46 |     type aliases that we will need later to be able to write down the type
 47 |     signatures for some functions.
 48 |    */
 49 |   template <template <typename> class F, typename A>
 50 |   struct Free {
 51 |     using ContainedType = A;
 52 |     using ReturnType    = Return<F, A>;
 53 |     boost::variant<boost::recursive_wrapper<Return<F, A>>,
 54 |                    boost::recursive_wrapper<Bind<F, A>>>
 55 |         v;
 56 |   };
 57 | 
 58 |   /*!
 59 |     Now we can define the individual cases, quite analogously to the Haskell
 60 |     definition. The only difference (apart from the syntax) is that we need to
 61 |     name the members something.
 62 |    */
 63 |   template <template <typename> class F, typename A>
 64 |   struct Return {
 65 |     A a;
 66 |   };
 67 |   template <template <typename> class F, typename A>
 68 |   struct Bind {
 69 |     F<Free<F, A>> x;
 70 |   };
 71 | 
 72 |   /*!
 73 |     For our convenience, we define some helper function templates that handle
 74 |     wrapping things up in the `Free` struct and allow some of the template
 75 |     arguments to be deduced.
 76 |   */
 77 | 
 78 |   // This one is for when you know the Functor template argument - it can deduce
 79 |   // the contained type.
 80 |   template <template <typename> class F, typename A>
 81 |   Free<F, A> make_return(const A& x) {
 82 |     return {Return<F, A>{x}};
 83 |   }
 84 | 
 85 |   // This one is for when you know the resulting Free type but not the template
 86 |   // arguments.
 87 |   template <typename FA>
 88 |   FA make_return(const typename FA::ContainedType& x) {
 89 |     return {typename FA::ReturnType{x}};
 90 |   }
 91 | 
 92 |   template <template <typename> class F, typename A>
 93 |   Free<F, A> make_bind(const F<Free<F, A>>& x) {
 94 |     return {Bind<F, A>{x}};
 95 |   }
 96 | 
 97 |   /*!
 98 |     It can be helpful while testing to be able to print out a value of `Free`,
 99 |     so we define an overload of the left shift^W^Wstream out operator. This also
100 |     demonstrates how to get values out of the `variant` in a type-safe way---by
101 |     using a visitor.
102 |   */
103 |   template <template <typename> class F, typename A>
104 |   std::ostream& operator<<(std::ostream& os, const Free<F, A>& free) {
105 |     struct Visitor {
106 |       std::ostream& os;
107 |       std::ostream& operator()(const Return<F, A>& r) {
108 |         return os << "Return{" << r.a << "}";
109 |       }
110 |       std::ostream& operator()(const Bind<F, A>& b) {
111 |         return os << "Bind{" << b.x << "}";
112 |       }
113 |     };
114 |     Visitor v{os};
115 |     return boost::apply_visitor(v, free.v);
116 |   }
117 | 
118 |   /*!
119 |     Now we implement the Functor functions. We don't actually create the
120 |     specialization of the Functor template here because that has to be done in
121 |     the Functor namespace but it is more convenient to write the functions in
122 |     the Free namespace.
123 | 
124 |     The Functor instance for Free is hilariously short and to-the-point in
125 |     Haskell:
126 | 
127 |     ```haskell
128 |     instance Functor f => Functor (Free f) where
129 |       fmap fun (Return x) = Return (fun x)
130 |       fmap fun (Bind x)   = Bind (fmap (fmap fun) x)
131 |     ```
132 | 
133 |     We assume that any user that wants to use the Functor instance of Free for a
134 |     specific Functor F will create a wrapper type like so:
135 | 
136 |     ```
137 |     template<typename A>
138 |     struct Wrapper : Free<F, A> {};
139 |     ```
140 | 
141 |     This is needed so that the template parameters match up correctly - all the
142 |     Functor-related functions expect to deal with a template with a single
143 |     parameter, whereas `Free` has two.
144 |   */
145 |   template <template <typename> class Wrapper>
146 |   struct FunctorImpl {
147 | 
148 |     // The visitor struct can't be defined inside the fmap function because it
149 |     // contains member function templates, which we use to get the compiler to
150 |     // tell us what the template F is in the Free<F, A> inside the wrapper.
151 |     template <typename A, typename Fn>
152 |     struct Visitor {
153 |       Fn& fun;
154 |       template <template <typename> class F>
155 |       auto operator()(const Return<F, A>& r) const {
156 |         return make_return<F>(fun(r.a));
157 |       }
158 |       template <template <typename> class F>
159 |       auto operator()(const Bind<F, A>& b) const {
160 |         using Functor::fmap;
161 |         return make_bind(fmap([&](const auto& f) { return fmap(fun, f); }, b.x));
162 |       }
163 |     };
164 | 
165 |     // fmap :: (a -> b) -> Free f a -> Free f b
166 |     template <typename A, typename Fn>
167 |     static Wrapper<std::result_of_t<Fn(A)>> fmap(Fn&& fun, const Wrapper<A>& f) {
168 |       return boost::apply_visitor(Visitor<A, Fn>{fun}, f.v);
169 |     }
170 |   };
171 | 
172 |   /*!
173 |     Now that we have a way to make `Wrapper<A>`, aka `Free<F, A>`, a Functor, we
174 |     can also make it a Monad. Once again, the instance in Haskell is
175 |     embarrassingly short:
176 | 
177 |     ```haskell
178 |     instance (Functor f) => Monad (Free f) where
179 |       return = Return
180 |       (Bind x)   >>= f = Bind (fmap (>>= f) x)
181 |       (Return r) >>= f = f r
182 |     ```
183 | 
184 |     Again, we're not actually specializing the `Monad` class template here
185 |     because that has to be done in the `Monad` namespace and it's more
186 |     convenient to write this stuff in the `Free` namespace.
187 | 
188 |     Also again, we require the user to wrap their Functor to be Freed into
189 |     something with a single template parameter, as `Free<F, A>` doesn't work
190 |     directly. We make an additional assumption about the wrapper class
191 |     template---it must have a type alias member named `WrappedFree` that is an
192 |     alias for the `Free<F, A>` type that is being wrapped, e.g.
193 | 
194 |     ```
195 |     template<typename A>
196 |     struct Wrapper : Free<F, A> {
197 |       using WrappedType = Free<F, A>;
198 |     };
199 |     ```
200 |   */
201 |   template <template <typename> class Wrapper>
202 |   struct MonadImpl {
203 |     template <typename A>
204 |     using M = Wrapper<A>;
205 | 
206 |     // pure :: a -> m a
207 |     // pure :: a -> Free<F>
208 |     template <typename A>
209 |     static M<A> pure(const A& x) {
210 |       return make_return<typename Wrapper<A>::WrappedFree>(x);
211 |     }
212 | 
213 |     // bind :: Free f a -> (a -> Free f b) -> Free f b
214 |     template <typename A, typename Fn>
215 |     struct BindVisitor {
216 |       using result_type = std::result_of_t<Fn(A)>;
217 |       using B           = typename result_type::ContainedType;
218 |       static_assert(std::is_same<result_type, Wrapper<B>>::value, "");
219 |       Fn&& fun;
220 | 
221 |       // bind (Bind x) f = Bind (fmap (\m -> bind m f) x)
222 |       template <template <typename> class F>
223 |       result_type operator()(const Bind<F, A>& b) {
224 |         auto& f = this->fun;
225 |         return make_bind(Functor::fmap(
226 |             [f](const Free<F, A>& m) {
227 |               return static_cast<Free<F, B>>(Monad::bind(Wrapper<A>(m), f));
228 |             },
229 |             b.x));
230 |       }
231 | 
232 |       // bind (Return r) f = f r
233 |       template <template <typename> class F>
234 |       result_type operator()(const Return<F, A>& r) {
235 |         return fun(r.a);
236 |       }
237 |     };
238 | 
239 |     template <typename A, typename Fn>
240 |     static auto bind(const M<A>& x, Fn&& fun) {
241 |       BindVisitor<A, Fn> v{std::forward<Fn>(fun)};
242 |       return boost::apply_visitor(v, x.v);
243 |     }
244 |   };
245 | 
246 |   /*!
247 |     It is traditional to provide some helpers to make working with free monads
248 |     more convenient. The first of these is "liftFree", which is used to "lift" a
249 |     functor F into a free monad.
250 | 
251 |     The implementation looks like so in Haskell:
252 | 
253 |     ```haskell
254 |     liftFree :: (Functor f) => f a -> Free f a
255 |     liftFree x = Bind (fmap Return x)
256 |     ```
257 | 
258 |     In C++ this looks very similar, yay! A few extra type annotations are
259 |     required to help the compiler but it's not too bad.
260 |    */
261 |   template <template <typename> class F, typename A>
262 |   Free<F, A> liftFree(const F<A>& x) {
263 |     return make_bind<F>(Functor::fmap(&make_return<F, A>, x));
264 |   }
265 | 
266 |   /*!
267 |     The other helper is really the whole point of the exercise; it allows you to
268 |     take a value of `Free<F, A>` and "evaluate" it in some way to yield another
269 |     monadic value.
270 | 
271 |     ```haskell
272 |     foldFree :: Monad m => (forall x . f x -> m x) -> Free f a -> m a
273 |     foldFree _ (Return a)  = return a
274 |     foldFree f (Bind as)   = f as >>= foldFree f
275 |     ```
276 | 
277 |     Because we want to be totally generic with regards to the callable object
278 |     that is passed in, it's not possible to deduce the resulting Monad template,
279 |     so the caller has to specify it. The other template parameters can be
280 |     deduced, however.
281 |   */
282 |   template <template <typename> class M,
283 |             template <typename> class F,
284 |             typename Fun,
285 |             typename A>
286 |   M<A> foldFree(Fun fun, const Free<F, A>& free) {
287 |     struct Visitor {
288 |       Fun fun;
289 | 
290 |       auto operator()(const Return<F, A>& r) { return Monad::pure<M>(r.a); }
291 |       auto operator()(const Bind<F, A>& b) {
292 |         return fun(b.x) >>= [&](const auto& x) { return foldFree<M>(fun, x); };
293 |       }
294 |     };
295 |     Visitor v{fun};
296 |     return boost::apply_visitor(v, free.v);
297 |   }
298 | }
299 | 
300 | /*!
301 |   All that remains to be done is to actually make `Free<F>` a Functor and a
302 |   Monad. Recall that `Free` actually has two template parameters but the
303 |   `Functor` and `Monad` class templates expect a template with one parameter as
304 |   their template argument. So, we require a wrapper class template that has only
305 |   one template parameter.
306 | 
307 |   Given a class template `Wrapper` whose instantiations `Wrapper<A>` have
308 |   `Free<F, A>` as a base and a type alias template member `WrappedFree` equal to
309 |   `Free<F, A>`, we can create a partial speciailization of both `Functor` and
310 |   `Monad`.
311 | 
312 |   The below speciailizations are not quite as constrained as I would like
313 |   because they don't actually mention `Free` anywhere, so they apply to any
314 |   class template that inherits from the class named by its `WrappedFree` member.
315 |   The reason for this is that I haven't been able to figure out how to get the
316 |   `F` out in order to write `Free<F, void>`.
317 |  */
318 | namespace Functor {
319 |   template <template <typename> class Wrapper>
320 |   struct Functor<Wrapper,
321 |                  std::enable_if_t<std::is_base_of<typename Wrapper<void>::WrappedFree,
322 |                                                   Wrapper<void>>::value>>
323 |       : Free::FunctorImpl<Wrapper> {};
324 | }
325 | 
326 | namespace Monad {
327 |   template <template <typename> class Wrapper>
328 |   struct Monad<Wrapper,
329 |                std::enable_if_t<std::is_base_of<typename Wrapper<void>::WrappedFree,
330 |                                                 Wrapper<void>>::value>>
331 |       : Free::MonadImpl<Wrapper> {};
332 | }
333 | 
334 | /*!
335 |   To finish things off, we do some compile-time verification that these partial
336 |   specializations work as we expect by wrapping `NullFunctor`.
337 |  */
338 | namespace Free {
339 |   namespace Test {
340 |     template <typename A>
341 |     struct NullFreeWrapper : Free<Functor::Test::NullFunctor, A> {
342 |       using WrappedFree = Free<Functor::Test::NullFunctor, A>;
343 |     };
344 |     static_assert(Functor::IsFunctor<NullFreeWrapper>,
345 |                   "Functor speciailization for Free wrappers works");
346 |     static_assert(Monad::IsMonad<NullFreeWrapper>,
347 |                   "Monad speciailization for Free wrappers works");
348 |   }
349 | }
350 | 


--------------------------------------------------------------------------------
/include/Functor.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | // Copyright (c) 2016 Toby Allsopp
  4 | // See LICENSE for license details.
  5 | 
  6 | #include <utility>
  7 | 
  8 | /*!
  9 |   ### Functors ###
 10 | 
 11 |   A "Functor" is something very precise in category theory, but you can think of
 12 |   it as something that somehow contains values with some structure and allows
 13 |   you to transform the contained values in a way that preserves the structure.
 14 | 
 15 |   In Haskell, it is defined like so:
 16 | 
 17 |   ```haskell
 18 |   class Functor f where
 19 |     fmap :: (a -> b) -> f a -> f b
 20 |   ```
 21 | 
 22 |   This just says that a type _f_ is a Functor if it supports the `fmap`
 23 |   function, which takes:
 24 | 
 25 |   - a function that operates on each value of type _a_ contained in the Functor,
 26 |     returning a value of type _b_ and
 27 |   - a value of type _f a_, being a particular value of our Functor containing
 28 |     values of type _a_
 29 | 
 30 |   and produces a value of type _f b_, being a particular value o four Functor
 31 |   containing values of type _b_.
 32 | 
 33 |   In C++, we will define a Functor as any class template with a single type
 34 |   parameter for which a valid specialization of the `Functor` class template
 35 |   exists.
 36 | 
 37 | */
 38 | 
 39 | namespace Functor {
 40 |   /*!
 41 |     The default specialization of `Functor` is undefined; this will cause a
 42 |     compile-time error (or substitution failure when used in certain template
 43 |     contexts) if it is used.
 44 | 
 45 |     The first template parameter is the class template to be considered a
 46 |     Functor. The second template parameter is there to enable partial
 47 |     specializations to use SFINAE-based techniques.
 48 |    */
 49 |   template <template <typename> class T, typename = void>
 50 |   struct Functor;
 51 | 
 52 |   /*!
 53 |     It is very useful to have a concise way to query, at compile-time, whether a
 54 |     given class template has a valid `Functor` specialization. This is a perfect
 55 |     application of "Concepts" but as we wish to remain compatible with C++14
 56 |     compilers we have to do it the old-fashioned way, i.e. using partial
 57 |     template specialization and SFINAE.
 58 |    */
 59 |   namespace detail {
 60 | /*!
 61 |   Note that MS Visual C++ doesn't properly support expression SFINAE as of
 62 |   VS2015 update 3, so we just assume everything is a Functor there.
 63 | */
 64 | #ifdef _MSC_VER
 65 |     template <template <typename> class>
 66 |     using IsFunctorT = std::true_type;
 67 | #else
 68 |     /*!
 69 |       In the usual C++ template metaprogramming fashion, we define a class
 70 |       template with the default case and then use partial specialization to
 71 |       change it for specific cases. Another common idiom is the use of an extra,
 72 |       defaulted template parameter that partial specializations can use to
 73 |       SFINAE themselves away.
 74 | 
 75 |       The default case is that any given class template is not a Functor.
 76 |      */
 77 |     template <template <typename> class, typename = void>
 78 |     struct IsFunctorT : std::false_type {};
 79 | 
 80 |     /*!
 81 |       Then we essentially say that any class template `T` is a Functor if a call to
 82 |       `Functor<T>::fmap` compiles and has the correct result type.
 83 |      */
 84 |     struct dummy1 {};
 85 |     struct dummy2 {};
 86 | 
 87 |     template <template <typename> class T>
 88 |     struct IsFunctorT<T,
 89 |                       std::enable_if_t<std::is_same<
 90 |                           T<dummy2>,
 91 |                           decltype(Functor<T>::fmap(std::declval<dummy2(dummy1)>(),
 92 |                                                     std::declval<T<dummy1>>()))>::value>>
 93 |         : std::true_type {};
 94 | #endif
 95 |   }
 96 | 
 97 |   /*!
 98 |     Using the `IsFunctorT` class template is little bit inconvenient, so we hide
 99 |     it away in the `detail` namespace and instead expose a `constexpr` variable
100 |     template. An example of the use of this is coming up in the definition of `fmap`,
101 |     below.
102 |    */
103 |   template <template <typename> class T>
104 |   constexpr bool IsFunctor = detail::IsFunctorT<T>::value;
105 | 
106 |   /*!
107 |     To make using the `fmap` function on a Functor value more convenient, we
108 |     define a free function that wraps it. Using this allows the Functor template
109 |     argument to be deduced.
110 |    */
111 |   template <template <typename> class F,
112 |             typename A,
113 |             typename Fun,
114 |             typename = std::enable_if_t<IsFunctor<F>>>
115 |   F<std::result_of_t<Fun(A)>> fmap(Fun&& fun, const F<A>& f) {
116 |     return Functor<F>::fmap(std::forward<Fun>(fun), f);
117 |   }
118 | 
119 |   /*!
120 |     It is useful for testing purposes to have a very basic Functor---we call
121 |     this `NullFunctor`. It contains exactly zero values, each of the requisite
122 |     type.
123 |   */
124 |   namespace Test {
125 |     template <typename A>
126 |     struct NullFunctor {};
127 |   }
128 |   template <>
129 |   struct Functor<Test::NullFunctor> {
130 |     template <typename F, typename A>
131 |     static Test::NullFunctor<std::result_of_t<F(A)>> fmap(F, Test::NullFunctor<A>) {
132 |       return {};
133 |     }
134 |   };
135 |   static_assert(IsFunctor<Test::NullFunctor>, "NullFunctor must be a Functor");
136 | }
137 | 


--------------------------------------------------------------------------------
/include/List.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // Copyright (c) 2016 Toby Allsopp
 4 | // See LICENSE for license details.
 5 | 
 6 | #include "Functor.h"
 7 | #include "Monad.h"
 8 | 
 9 | #include <algorithm>
10 | #include <iterator>
11 | #include <ostream>
12 | #include <vector>
13 | 
14 | /*!
15 |   ## The List Monad ##
16 | 
17 |   We introduce a special kind of vector that we call List. We could use vector
18 |   directly but this allows us to avoid making every vector a Monad.
19 | */
20 | template <typename A>
21 | struct List : std::vector<A> {
22 |   using std::vector<A>::vector;
23 | };
24 | 
25 | /*!
26 |   It is useful to be able to print out Lists for testing and debugging.
27 | */
28 | template <typename A>
29 | std::ostream& operator<<(std::ostream& os, const List<A>& l) {
30 |   os << "[";
31 |   bool first = true;
32 |   for (const auto& x : l) {
33 |     if (!std::exchange(first, false)) os << ", ";
34 |     os << x;
35 |   }
36 |   os << "]";
37 |   return os;
38 | }
39 | 
40 | /*!
41 |   ### Making List a Functor ###
42 | 
43 |   First, we need to make `List` a Functor by partially specializing `Functor` and
44 |   defining `fmap`.
45 | */
46 | namespace Functor {
47 |   // instance Functor List where
48 |   template <>
49 |   struct Functor<List> {
50 |     // fmap :: (a -> b) -> List a -> List b
51 |     template <typename Fun, typename A>
52 |     static auto fmap(Fun&& f, const List<A>& l) {
53 |       List<std::result_of_t<Fun(A)>> result;
54 |       std::transform(
55 |           l.begin(), l.end(), std::back_inserter(result), std::forward<Fun>(f));
56 |       return result;
57 |     }
58 |   };
59 |   static_assert(IsFunctor<List>, "List should be a Functor");
60 | }
61 | 
62 | /*!
63 |   ### Making List a Monad ###
64 | 
65 |   Then we can make `List` a Monad by partially specializing `Monad` and defining
66 |   `pure` and `bind`.
67 | */
68 | namespace Monad {
69 |   // instance Monad List where
70 |   template <>
71 |   struct Monad<List> {
72 |     // pure :: a -> List a
73 |     template <typename A>
74 |     static List<A> pure(const A& x) {
75 |       return List<A>({x});
76 |     }
77 | 
78 |     // bind :: List a -> (a -> List b) -> List b
79 |     template <typename F, typename A, typename ListB = std::result_of_t<F(A)>>
80 |     static ListB bind(const List<A>& l, F&& f) {
81 |       ListB result;
82 |       for (const A& x : l) {
83 |         auto subresult = std::forward<F>(f)(x);
84 |         std::copy(subresult.begin(), subresult.end(), std::back_inserter(result));
85 |       }
86 |       return result;
87 |     }
88 |   };
89 |   static_assert(IsMonad<List>, "List should be a Monad");
90 | }
91 | 


--------------------------------------------------------------------------------
/include/Monad.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | // Copyright (c) 2016 Toby Allsopp
  4 | // See LICENSE for license details.
  5 | 
  6 | #include "Functor.h"
  7 | #include "void_t.h"
  8 | 
  9 | /*!
 10 |   ### Monads ###
 11 | 
 12 |   The concept of a Monad comes from category theory, but the defintion I'm using
 13 |   is that of its practical application in Haskell.
 14 | 
 15 |   In Haskell, `Monad` is a typeclass, defined something like so:
 16 | 
 17 |   ```haskell
 18 |   class (Functor m) => Monad m where
 19 |     pure :: a -> m a
 20 |     bind :: m a -> (a -> m b) -> m b
 21 |   ```
 22 | 
 23 |   There are some additional laws that Monads are supposed to obey but for now I'm
 24 |   just going to focus on the type signatures.
 25 | 
 26 |   In C++, we can treat the type variable `m` as a class template with a class
 27 |   template template parameter and define a class template `Monad` that we will
 28 |   specialize for each class template `M` that we want to treat as a Monad.
 29 | 
 30 | */
 31 | namespace Monad {
 32 |   template <template <typename> class M, typename Enable = void>
 33 |   struct Monad;
 34 | 
 35 |   /*!
 36 |     C++ doesn't provide a neat way to define the members that we expect
 37 |     specializations of the `Monad` template to have, but we can write a type-level
 38 |     predicate that uses SFINAE to check.
 39 |    */
 40 |   namespace detail {
 41 |     template <template <typename> class M, typename Enable = void>
 42 |     struct IsMonadT : std::false_type {};
 43 | 
 44 |     /*!
 45 |       At the moment we just have a very basic check---is there a specialization
 46 |       of Monad for the template and is the template a Functor.
 47 |      */
 48 |     template <template <typename> class M>
 49 |     struct IsMonadT<M, void_t<Monad<M>, std::enable_if_t<Functor::IsFunctor<M>>>>
 50 |         : std::true_type {};
 51 |   }
 52 | 
 53 |   template <template <typename> class M>
 54 |   constexpr bool IsMonad = detail::IsMonadT<M>::value;
 55 | 
 56 |   /*!
 57 |     Now that we can tell (approximately) whether a class template is a Monad, we
 58 |     can define the Monad operations as free functions so that the template
 59 |     arguments can be deduced in at least some cases.
 60 |   */
 61 |   // pure :: (Monad m) => a -> m a
 62 |   template <template <typename> class M,
 63 |             typename A,
 64 |             typename = std::enable_if_t<IsMonad<M>>>
 65 |   M<A> pure(const A& x) {
 66 |     return Monad<M>::pure(x);
 67 |   }
 68 | 
 69 |   // bind :: (Monad m) => m a -> (a -> m b) -> m b
 70 |   template <typename F,
 71 |             template <typename> class M,
 72 |             typename A,
 73 |             typename = std::enable_if_t<IsMonad<M>>>
 74 |   std::result_of_t<F(A)> bind(const M<A>& m, F&& f) {
 75 |     return Monad<M>::bind(m, std::forward<F>(f));
 76 |   }
 77 | }
 78 | 
 79 | /*!
 80 |   It is common in Haskell to use the infix (>>=) operator as a synonym for
 81 |   _bind_; this reduces the need for parentheses. We can do the same thing in
 82 |   C++, allowing us to write `m >>= [](){}` instead of `bind(m, [](){})`.
 83 |  */
 84 | template <template <typename> class M,
 85 |           typename A,
 86 |           typename F,
 87 |           typename = std::enable_if_t<Monad::IsMonad<M>>>
 88 | auto operator>>=(const M<A>& m, F&& f) {
 89 |   return Monad::bind(m, std::forward<F>(f));
 90 | }
 91 | 
 92 | /*!
 93 |   The (>>) operator is also commonly used in Haskell. It just throws away the
 94 |   result of evaluating the first argument and returns the second argument
 95 |   instead.
 96 | 
 97 |   ```haskell
 98 |   (>>) :: (Monad m) => m a -> m () -> m ()
 99 |   x >> y = x >>= \_ -> y
100 |   ```
101 |  */
102 | template <template <typename> class M,
103 |           typename A,
104 |           typename B,
105 |           typename = std::enable_if_t<Monad::IsMonad<M>>>
106 | M<B> operator>>(const M<A>& m, const M<B>& v) {
107 |   return Monad::bind(m, [=](auto&&) { return v; });
108 | }
109 | 


--------------------------------------------------------------------------------
/include/void_t.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // Copyright (c) 2016 Toby Allsopp
 4 | // See LICENSE for license details.
 5 | 
 6 | template <typename... Ts>
 7 | struct make_void {
 8 |   typedef void type;
 9 | };
10 | template <typename... Ts>
11 | using void_t = typename make_void<Ts...>::type;
12 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.0)
2 | 
3 | add_executable(TestRunner TestRunner.cpp FunctorTest.cpp ListTest.cpp FreeTest.cpp)
4 | target_link_libraries(TestRunner Monad)
5 | 


--------------------------------------------------------------------------------
/test/FreeTest.cpp:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2016 Toby Allsopp
  2 | // See LICENSE for license details.
  3 | 
  4 | #include "Free.h"
  5 | #include "Functor.h"
  6 | #include "List.h"
  7 | #include "Monad.h"
  8 | 
  9 | #include "catch.hpp"
 10 | 
 11 | #include <boost/variant.hpp>
 12 | 
 13 | #include <functional>
 14 | #include <string>
 15 | 
 16 | /*!
 17 |   ### Using Free ###
 18 | 
 19 |   We will define a data structure and its corresponding free monad and show how
 20 |   to use the free monad to build and then interpret expressions in a simple
 21 |   domain-specific language.
 22 | 
 23 |   First, we will need a couple of basic definitions.
 24 | 
 25 |   #### Unit
 26 | 
 27 |   One of the basic types in Haskell is `()`, aka "unit". It has exactly one
 28 |   value, `()`. It is an empty product type. In C++ we have two options for
 29 |   product types: structs or tuples. An empty one of either will do the job but
 30 |   `std::tuple<>` has the advantage of giving us equality and ordering for free.
 31 |  */
 32 | using unit = std::tuple<>;
 33 | 
 34 | std::ostream& operator<<(std::ostream& os, unit) { return os << "unit{}"; }
 35 | 
 36 | /*!
 37 |   #### Identity
 38 | 
 39 |   A very useful generic function is the identity function. In Haskell it is:
 40 | 
 41 |   ```haskell
 42 |   id :: a -> a
 43 |   id x = x
 44 |   ```
 45 | 
 46 |   In C++ we can define a function template to do the same thing.
 47 |  */
 48 | template <typename A>
 49 | A id(A a) {
 50 |   return a;
 51 | }
 52 | 
 53 | /*!
 54 |   #### Function Composition
 55 | 
 56 |   Function composition is ubiquitous in Haskell and we will use it below. It
 57 |   doesn't come predefined in C++ but it's surprisingly easy these days.
 58 | 
 59 |   ```haskell
 60 |   compose :: (b -> c) -> (a -> b) -> a -> c
 61 |   compose f g = \x -> f (g x)
 62 |   ```
 63 | */
 64 | template <typename F, typename G>
 65 | auto compose(F&& f, G&& g) {
 66 |   return [=](auto&& x) { return f(g(std::forward<decltype(x)>(x))); };
 67 | }
 68 | 
 69 | /*!
 70 |   #### Language Definition
 71 | 
 72 |   We define a data type to represent the operations in our language. In our
 73 |   example there are only two operations: `Read`, which takes the value or values
 74 |   so far written and does something, and `Write`, which "writes" a value and
 75 |   then does something.
 76 | 
 77 |   This is all very vague because the details are decoupled from this definition
 78 |   and are supplied separately.
 79 | 
 80 |   In Haskell our data type is just:
 81 | 
 82 |   ```haksell
 83 |   data Prog a =
 84 |       Read (Int -> a)
 85 |     | Write Int (() -> a)
 86 |   ```
 87 | 
 88 |   As usual, things get verbose in C++. We define a struct to correspond to each
 89 |   of the cases and wrap them in a variant.
 90 | 
 91 |   Note that I've cheated somewhat by using `std::function` instead of making the
 92 |   continuation type a template parameter in order to make this code simpler.
 93 |   Doing this probably stops the compiler from optimising this as much as it
 94 |   otherwise could.
 95 |  */
 96 | template <typename Next>
 97 | struct Read {
 98 |   std::function<Next(int)> next;
 99 | };
100 | template <typename Next>
101 | struct Write {
102 |   int x;
103 |   std::function<Next(unit)> next;
104 | };
105 | 
106 | template <typename Next>
107 | struct Prog {
108 |   boost::variant<Read<Next>, Write<Next>> v;
109 | };
110 | 
111 | /*!
112 |   As is typical when using class templates, we define corresponding "make_"
113 |   function templates so that the template arguments can be deduced. These
114 |   function templates have the additional benefit of wrapping the value up in our
115 |   `Prog` struct.
116 |  */
117 | template <typename F>
118 | Prog<std::result_of_t<F(int)>> make_read(F next) {
119 |   return {Read<std::result_of_t<F(int)>>{{next}}};
120 | }
121 | 
122 | template <typename F>
123 | Prog<std::result_of_t<F(unit)>> make_write(int x, F next) {
124 |   return {Write<std::result_of_t<F(unit)>>{x, next}};
125 | }
126 | 
127 | /*!
128 |   In order to use `Prog`'s Free Monad, `Prog` must be a Functor. In Haskell with
129 |   the appropriate extension we could just add `deriving Functor` to the data
130 |   type definition but we're stuck down here in C++ so we'll have to specialize
131 |   the `Functor` class template manually.
132 |  */
133 | 
134 | // instance Functor Prog where
135 | namespace Functor {
136 |   template <>
137 |   struct Functor<Prog> {
138 |     template <typename Fun, typename Next>
139 |     static Prog<std::result_of_t<Fun(Next)>> fmap(Fun&& fun, const Prog<Next>& prog) {
140 |       using Res = std::result_of_t<Fun(Next)>;
141 |       struct Visitor {
142 |         Fun& fun;
143 |         // fmap f (Read n) = Read (f . n)
144 |         Prog<Res> operator()(const Read<Next>& read) const {
145 |           return make_read(compose(fun, read.next));
146 |         }
147 |         // fmap f (Write x n) = Write x (f . n)
148 |         Prog<Res> operator()(const Write<Next>& write) const {
149 |           return make_write(write.x, compose(fun, write.next));
150 |         }
151 |       };
152 |       return boost::apply_visitor(Visitor{fun}, prog.v);
153 |     }
154 |   };
155 | }
156 | 
157 | /*!
158 |   #### The Free Monad
159 | 
160 |   Now, to use `Prog` as a Monad, all we need to do is define a wrapper around
161 |   `Free<Prog, A>` so that we get a template with a single type parameter. The
162 |   specialization of `Monad` defined in `Free.h` takes care of the rest.
163 | */
164 | namespace F = Free; // MSVC doesn't like "Free::Free"
165 | template <typename A>
166 | struct Program : F::Free<Prog, A> {
167 |   using WrappedFree = F::Free<Prog, A>;
168 |   Program(const WrappedFree& free) : F::Free<Prog, A>(free) {}
169 | };
170 | 
171 | /*!
172 |   There is some boilerplate required to lift the constructors of `Prog` into the
173 |   `Program` Monad. This boilerplate is even required in Haskell!
174 | 
175 |   ```haskell
176 |   readF :: Free (Prog Int)
177 |   readF = liftFree (Read id)
178 |   ```
179 | */
180 | Program<int> readF = Free::liftFree(make_read(id<int>));
181 | /*!
182 |   ```haskell
183 |   writeF :: Int -> Free (Prog ())
184 |   writeF x = liftFree (Write x id)
185 |   ```
186 | */
187 | Program<unit> writeF(int x) { return Free::liftFree(make_write(x, id<unit>)); }
188 | 
189 | /*!
190 |   #### An Interpreter
191 | 
192 |   In order to give some meaning to values of `Prog<A>` we need an interpreter,
193 |   i.e. a function that takes an action, somehow performs the action associated
194 |   with it and then invokes its continuation (zero or more times).
195 | 
196 |   For our example we will define an interpreter that keeps track of the values
197 |   written and invokes `Read` continuations once for each such value. Because
198 |   this is C++ and not Haskell, we can keep some mutable state; in Haskell we'd
199 |   need to be in the State Monad or similar.
200 | */
201 | // interpret :: Prog a -> List a
202 | // interpret (Read n) = fmap n STATE
203 | // interpret (Write x n) = STATE+=x; n ()
204 | struct Interpreter {
205 |   List<int> l;  // the values written so far
206 |   template <typename A>
207 |   List<A> operator()(Prog<A> prog) {
208 |     struct Visitor {
209 |       List<int>& l;
210 |       List<A> operator()(const Read<A>& r) {
211 |         // invoke the continuation with each of the values that have been written so far
212 |         return Functor::fmap(r.next, l);
213 |       }
214 |       List<A> operator()(const Write<A>& w) {
215 |         // remember the value and invoke the continuation
216 |         l.push_back(w.x);
217 |         return {w.next(unit{})};
218 |       }
219 |     };
220 |     Visitor v{l};
221 |     return boost::apply_visitor(v, prog.v);
222 |   }
223 | };
224 | 
225 | /*!
226 |   Our interpreter works on values of `Prog<A>`, but when we use the Free Monad
227 |   we will be constructing values of type `Program<A>`, aka `Free<Prog, A>`. So,
228 |   we define a helper that runs our interpreter on such a value, using the
229 |   `foldFree` function we defined in `Free.h`.
230 |  */
231 | // run :: Program a -> List a
232 | // run p = foldFree interpret p
233 | template <typename A>
234 | List<A> run(Program<A> program) {
235 |   Interpreter i;
236 |   return Free::foldFree<List>(i, program);
237 | }
238 | 
239 | /*!
240 |   #### Tests
241 | 
242 |   OK, that's the tedious setup out of the way---now we can actually use our Free
243 |   Monad!
244 | */
245 | TEST_CASE("Free monad for Prog") {
246 |   using std::string;
247 |   using std::to_string;
248 |   auto pure = [](auto&& x) { return Monad::pure<Program>(x); };
249 | 
250 |   /*!
251 |     ```haskell
252 |     do
253 |       readF
254 |     ```
255 |   */
256 |   {
257 |     // clang-format off
258 |     auto free =
259 |       readF;
260 |     // clang-format on
261 |     CHECK(run(free) == List<int>());
262 |   }
263 |   /*!
264 |     ```haskell
265 |     do
266 |       x <- readF
267 |       pure (show x)
268 |     ```
269 |   */
270 |   {
271 |     // clang-format off
272 |     Program<string> free =
273 |       readF >>= [=](int x) { return
274 |       pure(to_string(x));
275 |     };
276 |     // clang-format on
277 |     CHECK(run(free) == List<string>());
278 |   }
279 |   /*!
280 |     ```haskell
281 |     do
282 |       writeF 10
283 |       x <- readF
284 |       writeF 20
285 |       y <- readF
286 |       pure (x + y)
287 |     ```
288 |   */
289 |   {
290 |     // clang-format off
291 |     auto free =
292 |       writeF(10) >>
293 |       readF >>= [=](int x) { return
294 |       writeF(20) >>
295 |       readF >>= [=](int y) { return
296 |       pure(x + y);
297 |     };};
298 |     // clang-format on
299 |     CHECK(run(free) == List<int>({20, 30}));
300 |   }
301 | }
302 | 


--------------------------------------------------------------------------------
/test/FunctorTest.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016 Toby Allsopp
 2 | // See LICENSE for license details.
 3 | 
 4 | #include "Functor.h"
 5 | #include "void_t.h"
 6 | 
 7 | int id(int x) { return x; }
 8 | 
 9 | template <template <typename> class, typename = void>
10 | struct fmap_compiles_t : std::false_type {};
11 | template <template <typename> class T>
12 | struct fmap_compiles_t<T, void_t<decltype(fmap(id, T<int>{}))>> : std::true_type {};
13 | template <template <typename> class T>
14 | constexpr bool fmap_compiles = fmap_compiles_t<T>::value;
15 | 
16 | namespace Functor {
17 | #ifndef _MSC_VER
18 |   template <typename A>
19 |   struct NoSpec {};
20 |   static_assert(!IsFunctor<NoSpec>, "no specialisation is not a Functor");
21 | 
22 |   template <typename A>
23 |   struct Nothing {};
24 |   template <>
25 |   struct Functor<Nothing> {};
26 |   static_assert(!IsFunctor<Nothing>, "specialisation with no members is not a Functor");
27 |   static_assert(!fmap_compiles<Nothing>, "shouldn't compile");
28 | 
29 |   template <typename A>
30 |   struct WrongFmapReturnType {};
31 |   template <>
32 |   struct Functor<WrongFmapReturnType> {
33 |     template <typename F, typename A>
34 |     static void fmap(F, WrongFmapReturnType<A>) {}
35 |   };
36 |   static_assert(!IsFunctor<WrongFmapReturnType>,
37 |                 "specialisation with wrong fmap return type is not a Functor");
38 |   static_assert(!fmap_compiles<WrongFmapReturnType>,
39 |                 "fmap on incorrect specialisation doesn't compile");
40 | #endif
41 | 
42 |   template <typename A>
43 |   struct Correct {};
44 |   template <>
45 |   struct Functor<Correct> {
46 |     template <typename F, typename A>
47 |     static auto fmap(F, Correct<A>) {
48 |       return Correct<std::result_of_t<F(A)>>{};
49 |     }
50 |   };
51 |   static_assert(IsFunctor<Correct>, "correct specialisation is a Functor");
52 | #ifndef _MSC_VER
53 |   static_assert(fmap_compiles<Correct>, "fmap on correct specialisation compiles");
54 | #endif
55 |   void testCorrect() { fmap(id, Correct<int>{}); }
56 | }
57 | 


--------------------------------------------------------------------------------
/test/ListTest.cpp:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2016 Toby Allsopp
 2 | // See LICENSE for license details.
 3 | 
 4 | #include "catch.hpp"
 5 | 
 6 | #include "List.h"
 7 | 
 8 | #include <iostream>
 9 | 
10 | TEST_CASE("List monad") {
11 |   using Functor::fmap;
12 |   using Monad::pure;
13 |   const List<int> l({1, 2, 3});
14 |   SECTION("fmap") {
15 |     auto l0 = fmap([](int x) { return x + 1; }, l);
16 |     REQUIRE(l0 == List<int>({2, 3, 4}));
17 |     REQUIRE(fmap([](int x) { return -x; }, l) == List<int>({-1, -2, -3}));
18 |   }
19 |   SECTION("pure") {
20 |     using namespace std::literals;
21 |     REQUIRE(pure<List>("Hi"s) == List<std::string>({"Hi"}));
22 |   }
23 |   SECTION("bind") {
24 |     // do
25 |     //   x <- l
26 |     //   y <- pure (x*x)
27 |     //   [x, y]
28 |     REQUIRE(
29 |         Monad::bind(l, [](int x) {
30 |           return Monad::bind(pure<List>(x * x), [x](int y) { return List<int>({x, y}); });
31 |         }) == List<int>({1, 1, 2, 4, 3, 9}));
32 |     REQUIRE(
33 |         Monad::bind(l, [](int x) {
34 |           return Monad::bind(pure<List>(x * x), [x](int y) { return List<int>({x, y}); });
35 |         }) == List<int>({1, 1, 2, 4, 3, 9}));
36 |     REQUIRE((l >>= [](int x) {
37 |               return pure<List>(x * x) >>= [x](int y) { return List<int>({x, y}); };
38 |             }) == (List<int>{1, 1, 2, 4, 3, 9}));
39 |     List<int> l1 = Monad::bind(l, [](int x) -> List<int> {
40 |       return Monad::bind(pure<List>(x * x), [x](int y) -> List<int> {
41 |         return List<int>({x, y});
42 |       });
43 |     });
44 |     REQUIRE(l1 == List<int>({1, 1, 2, 4, 3, 9}));
45 |     auto l2 = l >>= [](int x) {
46 |       return pure<List>(x * 2) >>= [&](int y) { return List<int>{x, y}; };
47 |     };
48 |     REQUIRE(l2 == List<int>({1, 2, 2, 4, 3, 6}));
49 |     std::cout << l2 << "\n";
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/test/TestRunner.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2016 Toby Allsopp
2 | // See LICENSE for license details.
3 | 
4 | #define CATCH_CONFIG_MAIN
5 | #include "catch.hpp"
6 | 


--------------------------------------------------------------------------------