├── .dockerignore
├── tests
    ├── main.cpp
    ├── utils.h
    ├── CMakeLists.txt
    ├── function_test.cpp
    ├── variant_test.cpp
    ├── optional_test.cpp
    └── sequence_container_test.cpp
├── .travis.yml
├── profiles
    └── common
├── Dockerfile
├── conanfile.py
├── include
    └── kitten
    │   ├── kitten.h
    │   ├── detail
    │       ├── deriving
    │       │   └── from_monad
    │       │   │   ├── derive_functor.h
    │       │   │   └── derive_applicative.h
    │       └── ranges
    │       │   └── algorithm.h
    │   ├── instances
    │       ├── variant.h
    │       ├── function.h
    │       ├── optional.h
    │       └── sequence_container.h
    │   ├── multifunctor.h
    │   ├── functor.h
    │   ├── monad.h
    │   └── applicative.h
├── .clang-format
├── .gitignore
├── LICENSE
├── CMakeLists.txt
├── Makefile
└── README.md


/.dockerignore:
--------------------------------------------------------------------------------
1 | build
2 | 


--------------------------------------------------------------------------------
/tests/main.cpp:
--------------------------------------------------------------------------------
1 | #define CATCH_CONFIG_MAIN
2 | 
3 | #include <catch2/catch.hpp>
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: cpp
2 | 
3 | services:
4 |   - docker
5 | 
6 | script:
7 |   - make env-format-check
8 |   - make env-test
9 | 


--------------------------------------------------------------------------------
/profiles/common:
--------------------------------------------------------------------------------
1 | [settings]
2 | compiler=gcc
3 | compiler.version=8
4 | compiler.libcxx=libstdc++11
5 | os=Linux
6 | os_build=Linux
7 | arch=x86_64
8 | arch_build=x86_64


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM conanio/gcc9:1.22.2
 2 | 
 3 | RUN pip install clang-format
 4 | 
 5 | USER root
 6 | 
 7 | WORKDIR kitten
 8 | 
 9 | COPY . .
10 | 
11 | CMD ["/bin/bash"]
12 | 


--------------------------------------------------------------------------------
/conanfile.py:
--------------------------------------------------------------------------------
1 | from conans import ConanFile
2 | 
3 | class KittenConan(ConanFile):
4 | 
5 |     build_requires  = "catch2/2.11.3"
6 |     generators      = "cmake_find_package"
7 | 


--------------------------------------------------------------------------------
/include/kitten/kitten.h:
--------------------------------------------------------------------------------
1 | #ifndef RVARAGO_KITTEN_KITTEN_H
2 | #define RVARAGO_KITTEN_KITTEN_H
3 | 
4 | #include "kitten/applicative.h"
5 | #include "kitten/functor.h"
6 | #include "kitten/monad.h"
7 | #include "kitten/multifunctor.h"
8 | 
9 | #endif


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | ---
 2 | BasedOnStyle: Microsoft
 3 | BreakBeforeBraces: Attach
 4 | UseTab: Never
 5 | ---
 6 | Language: Cpp
 7 | SortIncludes: true
 8 | SortUsingDeclarations: true
 9 | FixNamespaceComments: false
10 | AlwaysBreakTemplateDeclarations: Yes


--------------------------------------------------------------------------------
/tests/utils.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_TEST_UTILS_H
 2 | #define RVARAGO_KITTEN_TEST_UTILS_H
 3 | 
 4 | namespace rvarago::kitten::test::utils {
 5 | 
 6 | template <typename T1, typename T2>
 7 | inline constexpr bool is_same_after_decaying = std::is_same<std::decay_t<T1>, std::decay_t<T2>>::value;
 8 | }
 9 | 
10 | #endif


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 
34 | .idea/
35 | build/
36 | 


--------------------------------------------------------------------------------
/include/kitten/detail/deriving/from_monad/derive_functor.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_DERIVE_FUNCTOR_H
 2 | #define RVARAGO_KITTEN_DERIVE_FUNCTOR_H
 3 | 
 4 | #include "kitten/functor.h"
 5 | #include "kitten/monad.h"
 6 | 
 7 | namespace rvarago::kitten::detail::deriving {
 8 | 
 9 | template <template <typename...> typename M, typename A, typename UnaryFunction>
10 | constexpr decltype(auto) fmap(M<A> const &input, UnaryFunction f) {
11 |     using MonadT = monad<M>;
12 |     return MonadT::bind(input, [&f](auto const &value) { return MonadT::wrap(f(value)); });
13 | }
14 | 
15 | }
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/include/kitten/detail/ranges/algorithm.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_ALGORITHM_H
 2 | #define RVARAGO_KITTEN_ALGORITHM_H
 3 | 
 4 | #include <algorithm>
 5 | 
 6 | // TODO: Use standard ranges
 7 | namespace rvarago::kitten::detail::ranges {
 8 | 
 9 | template <typename Range, typename OutIterator>
10 | constexpr decltype(auto) copy(Range &&range, OutIterator out) {
11 |     return std::copy(std::cbegin(range), std::cend(range), out);
12 | }
13 | 
14 | template <typename Range, typename UnaryFunction>
15 | constexpr decltype(auto) for_each(Range &&range, UnaryFunction f) {
16 |     return std::for_each(std::cbegin(range), std::cend(range), f);
17 | }
18 | 
19 | }
20 | 
21 | #endif


--------------------------------------------------------------------------------
/include/kitten/detail/deriving/from_monad/derive_applicative.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_DERIVE_APPLICATIVE_H
 2 | #define RVARAGO_KITTEN_DERIVE_APPLICATIVE_H
 3 | 
 4 | #include "kitten/applicative.h"
 5 | #include "kitten/monad.h"
 6 | 
 7 | namespace rvarago::kitten::detail::deriving {
 8 | 
 9 | template <template <typename...> typename M, typename A, typename B, typename BinaryFunction>
10 | constexpr auto combine(M<A> const &first, M<B> const &second, BinaryFunction f)
11 |     -> M<decltype(f(std::declval<A>(), std::declval<B>()))> {
12 |     using MonadT = monad<M>;
13 |     return MonadT::bind(first, [&second, f](auto const &first_value) {
14 |         return MonadT::bind(
15 |             second, [&first_value, f](auto const &second_value) { return MonadT::wrap(f(first_value, second_value)); });
16 |     });
17 | }
18 | 
19 | template <template <typename...> typename M, typename A>
20 | constexpr auto pure(A &&value) -> M<A> {
21 |     using MonadT = monad<M>;
22 |     return MonadT::wrap(std::forward<A>(value));
23 | }
24 | 
25 | }
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/include/kitten/instances/variant.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_VARIANT_H
 2 | #define RVARAGO_KITTEN_VARIANT_H
 3 | 
 4 | #include <variant>
 5 | 
 6 | #include "kitten/multifunctor.h"
 7 | 
 8 | namespace rvarago::kitten {
 9 | 
10 | namespace syntax {
11 | 
12 | template <typename... Rest>
13 | struct overloaded final : Rest... {
14 |     using Rest::operator()...;
15 | };
16 | 
17 | template <typename... Rest>
18 | overloaded(Rest...)->overloaded<Rest...>;
19 | 
20 | }
21 | 
22 | template <>
23 | struct multifunctor<std::variant> {
24 | 
25 |     template <typename UnaryFunction, typename... Rest>
26 |     static constexpr auto multimap(std::variant<Rest...> const &input, UnaryFunction f)
27 |         -> std::variant<decltype(f(std::declval<Rest>()))...> {
28 |         using ResultT = std::variant<decltype(f(std::declval<Rest>()))...>;
29 |         return std::visit([&f](auto const &value) { return ResultT{f(value)}; }, input);
30 |     }
31 | };
32 | 
33 | namespace traits {
34 | template <>
35 | struct is_multifunctor<std::variant> : std::true_type {};
36 | }
37 | 
38 | }
39 | 
40 | #endif
41 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | project(kitten_tests LANGUAGES CXX)
 2 | 
 3 | set(CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR})
 4 | 
 5 | add_executable(${PROJECT_NAME}
 6 |         function_test.cpp
 7 |         optional_test.cpp
 8 |         main.cpp
 9 |         sequence_container_test.cpp
10 |         variant_test.cpp
11 | )
12 | 
13 | if (${CMAKE_CXX_COMPILER_ID} MATCHES "GNU|Clang")
14 |     target_compile_options(${PROJECT_NAME}
15 |             PRIVATE
16 |                 -Wall -Wextra -Werror -ansi -pedantic
17 |     )
18 | elseif (${CMAKE_CXX_COMPILER_ID} MATCHES "MSVC")
19 |     target_compile_options(${PROJECT_NAME}
20 |             PRIVATE
21 |                 /Wall /W4
22 |     )
23 | else()
24 |     message("Unknown compiler..skipping configuration for warnings")
25 | endif()
26 | 
27 | target_include_directories(${PROJECT_NAME}
28 |         PRIVATE
29 |         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
30 | )
31 | 
32 | find_package(Catch2 REQUIRED)
33 | 
34 | target_link_libraries(${PROJECT_NAME}
35 |         PRIVATE
36 |             rvarago::kitten
37 |             Catch2::Catch2
38 | )
39 | 
40 | add_test(${PROJECT_NAME} ${PROJECT_NAME})
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Rafael Varago
 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 | 


--------------------------------------------------------------------------------
/tests/function_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <catch2/catch.hpp>
 2 | 
 3 | #include <kitten/instances/function.h>
 4 | #include <string>
 5 | 
 6 | namespace {
 7 | 
 8 | using namespace std::string_literals;
 9 | 
10 | using namespace rvarago::kitten;
11 | using namespace types;
12 | 
13 | SCENARIO("function_wrapper admits a functor instance", "[function_wrapper]") {
14 | 
15 |     GIVEN("a functor instance") {
16 | 
17 |         AND_GIVEN("a function from double to int") {
18 | 
19 |             auto double_to_int = [](double const v) { return static_cast<int>(v); };
20 | 
21 |             AND_GIVEN("a function from int to string") {
22 | 
23 |                 auto int_to_string = [](int const v) { return std::to_string(v); };
24 | 
25 |                 WHEN("they are wrapped in function wrappers") {
26 | 
27 |                     AND_WHEN("fmap") {
28 | 
29 |                         THEN("return the composition of a function wrapper from double to string") {
30 | 
31 |                             auto const double_to_string = fn(double_to_int) | fn(int_to_string);
32 | 
33 |                             CHECK(double_to_string(3.14) == "3"s);
34 |                         }
35 |                     }
36 |                 }
37 |             }
38 |         }
39 |     }
40 | }
41 | 
42 | }


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.10)
 2 | 
 3 | project(kitten LANGUAGES CXX)
 4 | 
 5 | # Definition
 6 | 
 7 | option(BUILD_TESTS "Build test executable" ON)
 8 | 
 9 | add_library(${PROJECT_NAME} INTERFACE)
10 | 
11 | add_library(rvarago::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
12 | 
13 | target_include_directories(${PROJECT_NAME}
14 |         INTERFACE
15 |             $<INSTALL_INTERFACE:include>
16 |             $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
17 | )
18 | 
19 | target_compile_features(${PROJECT_NAME}
20 |         INTERFACE
21 |             cxx_std_17
22 | )
23 | 
24 | # Installation
25 | 
26 | include(GNUInstallDirs)
27 | 
28 | # Generate the config file with the target
29 | install(TARGETS ${PROJECT_NAME}
30 |         EXPORT ${PROJECT_NAME}Config
31 | )
32 | 
33 | install(DIRECTORY include/
34 |         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
35 | )
36 | 
37 | # Make the target be importable from the installation directory
38 | install(EXPORT ${PROJECT_NAME}Config
39 |         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
40 |         NAMESPACE rvarago::
41 | )
42 | 
43 | # Make the target be importable from the build directory via package registry
44 | export(EXPORT ${PROJECT_NAME}Config
45 |        NAMESPACE rvarago::
46 | )
47 | 
48 | export(PACKAGE ${PROJECT_NAME})
49 | 
50 | # Tests
51 | if(BUILD_TESTS)
52 |     include(CTest)
53 |     add_subdirectory(tests)
54 | endif()
55 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | PROJECT_NAME            = kitten
 2 | PROFILE                 = ../profiles/common
 3 | BUILD_DIR               = build
 4 | BUILD_TESTS             = ON
 5 | BUILD_TYPE              = Debug
 6 | 
 7 | .PHONY: all test install compile gen dep mk clean env env-test env-format-check format-check format
 8 | 
 9 | all: compile
10 | 
11 | env:
12 | 	docker build -t $(PROJECT_NAME) .
13 | 
14 | env-format-check: env
15 | 	docker run --rm $(PROJECT_NAME) make format-check --no-print-directory
16 | 
17 | env-test: env
18 | 	docker run --rm $(PROJECT_NAME) make compile test --no-print-directory
19 | 
20 | install:
21 | 	cd $(BUILD_DIR) && cmake --build . --target install
22 | 
23 | test:
24 | 	cd $(BUILD_DIR) && ctest -VV .
25 | 
26 | compile: gen
27 | 	cd $(BUILD_DIR) && cmake --build .
28 | 
29 | gen: dep
30 | 	cd $(BUILD_DIR) && cmake -D BUILD_TESTS=$(BUILD_TESTS) -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) ..
31 | 
32 | dep: mk
33 | 	cd $(BUILD_DIR) && conan install .. --build=missing -pr $(PROFILE) -s build_type=$(BUILD_TYPE)
34 | 
35 | mk:
36 | 	mkdir -p $(BUILD_DIR)
37 | 
38 | clean:
39 | 	rm -rf $(BUILD_DIR)
40 | 
41 | format-check:
42 | 	@if git ls-files -- '*.cpp' '*.h' | xargs clang-format -style=file -output-replacements-xml | grep -q "<replacement "; then \
43 | 		echo "Source code did not adhere to the expected formatting style"; exit 1; \
44 | 	fi
45 | 
46 | format:
47 | 	@git ls-files -- '*.cpp' '*.h' | xargs clang-format -i -style=file
48 | 


--------------------------------------------------------------------------------
/include/kitten/multifunctor.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_MULTIFUNCTOR_H
 2 | #define RVARAGO_KITTEN_MULTIFUNCTOR_H
 3 | 
 4 | namespace rvarago::kitten {
 5 | 
 6 | /**
 7 |  * A multifunctor is an abstraction that allows to be mapped over for multiple types "in parallel".
 8 |  *
 9 |  * Given a multifunctor fi: F[A1, ..., Z1] and a function f: A1, ..., Z1 -> A2, ..., Z2
10 |  *  It uses f to map over over fa and then return a new functor fb: F[A2, ..., Z2].
11 |  */
12 | template <template <typename...> typename MF, typename = void>
13 | struct multifunctor;
14 | 
15 | namespace traits {
16 | template <template <typename...> typename, typename = void>
17 | struct is_multifunctor : std::false_type {};
18 | 
19 | template <template <typename...> typename MF>
20 | inline constexpr bool is_multifunctor_v = is_multifunctor<MF>::value;
21 | }
22 | 
23 | /**
24 |  * Forwards to the multifunctor implementation.
25 |  *
26 |  * @param input a n-functor fa: F[A1, ..., Z1]
27 |  * @param f a function A1, ..., Z1 -> A2, ..., Z2 that maps over the value wrapped inside fa to yield a value b: A2,
28 |  * ..., Z2
29 |  * @return a new multifunctor fb: F[A2, ..., Z2] resulting from applying f over the wrapped value inside fa
30 |  */
31 | template <template <typename...> typename MF, typename... Rest, typename UnaryFunction>
32 | constexpr decltype(auto) multimap(MF<Rest...> const &input, UnaryFunction f) {
33 |     static_assert(traits::is_multifunctor_v<MF>, "type constructor MF does not have a multifunctor instance");
34 |     return multifunctor<MF>::multimap(input, f);
35 | }
36 | 
37 | /**
38 |  * Infix version of multimap.
39 |  */
40 | template <template <typename...> typename MF, typename A, typename... Rest, typename UnaryFunction>
41 | constexpr decltype(auto) operator||(MF<A, Rest...> const &input, UnaryFunction f) {
42 |     return multimap(input, f);
43 | }
44 | }
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/include/kitten/instances/function.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_FUNCTION_H
 2 | #define RVARAGO_KITTEN_FUNCTION_H
 3 | 
 4 | #include "kitten/functor.h"
 5 | 
 6 | #include <utility>
 7 | 
 8 | namespace rvarago::kitten {
 9 | 
10 | namespace types {
11 | 
12 | template <typename Function>
13 | class function_wrapper {
14 |     Function const f;
15 | 
16 |   public:
17 |     explicit constexpr function_wrapper(Function invokable) noexcept : f{std::move(invokable)} {
18 |     }
19 | 
20 |     template <typename... Args>
21 |     constexpr auto operator()(Args &&... args) const noexcept -> decltype(f(std::forward<Args>(args)...)) {
22 |         return f(std::forward<Args>(args)...);
23 |     }
24 | };
25 | 
26 | template <typename Function>
27 | constexpr function_wrapper<Function> fn(Function invokable) {
28 |     return function_wrapper{std::move(invokable)};
29 | }
30 | 
31 | }
32 | 
33 | template <>
34 | struct functor<types::function_wrapper> {
35 | 
36 |     /**
37 |      * Composes the functions first and second, in such a way that the result of the first feeds the second, i.e:
38 |      *  fmap(first, second)(x) = second(fist(second))
39 |      *
40 |      * @param first a function A -> B to applied when the argument A are provided
41 |      * @param second function B -> C to be applied with the result from previous application of first
42 |      * @return a function composition A -> C that, when its argument is provided, applied first and then second
43 |      */
44 |     template <typename UnaryFunctionA, typename UnaryFunctionB>
45 |     static constexpr decltype(auto) fmap(types::function_wrapper<UnaryFunctionA> const &first,
46 |                                          types::function_wrapper<UnaryFunctionB> const &second) {
47 |         return types::fn(
48 |             [first, second](auto &&... args) { return second(first(std::forward<decltype(args)>(args)...)); });
49 |     }
50 | };
51 | 
52 | namespace traits {
53 | template <>
54 | struct is_functor<types::function_wrapper> : std::true_type {};
55 | }
56 | 
57 | }
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/include/kitten/instances/optional.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_OPTIONAL_H
 2 | #define RVARAGO_KITTEN_OPTIONAL_H
 3 | 
 4 | #include <optional>
 5 | 
 6 | #include "kitten/applicative.h"
 7 | #include "kitten/functor.h"
 8 | #include "kitten/monad.h"
 9 | 
10 | #include "kitten/detail/deriving/from_monad/derive_applicative.h"
11 | #include "kitten/detail/deriving/from_monad/derive_functor.h"
12 | 
13 | namespace rvarago::kitten {
14 | 
15 | template <>
16 | struct monad<std::optional> {
17 | 
18 |     template <typename A, typename UnaryFunction>
19 |     static constexpr auto bind(std::optional<A> const &input, UnaryFunction f) -> decltype(f(std::declval<A>())) {
20 |         if (!input.has_value()) {
21 |             return std::nullopt;
22 |         }
23 |         return f(*input);
24 |     }
25 | 
26 |     template <typename A>
27 |     static constexpr auto wrap(A &&value) -> std::optional<A> {
28 |         return std::make_optional(std::forward<A>(value));
29 |     }
30 | };
31 | 
32 | template <>
33 | struct applicative<std::optional> {
34 | 
35 |     template <typename A, typename B, typename BinaryFunction>
36 |     static constexpr auto combine(std::optional<A> const &first, std::optional<B> const &second, BinaryFunction f)
37 |         -> std::optional<decltype(f(std::declval<A>(), std::declval<B>()))> {
38 |         return detail::deriving::combine(first, second, f);
39 |     }
40 | 
41 |     template <typename A>
42 |     static constexpr auto pure(A &&value) -> std::optional<A> {
43 |         return detail::deriving::pure<std::optional>(std::forward<A>(value));
44 |     }
45 | };
46 | 
47 | template <>
48 | struct functor<std::optional> {
49 | 
50 |     template <typename A, typename UnaryFunction>
51 |     static constexpr auto fmap(std::optional<A> const &input, UnaryFunction f)
52 |         -> std::optional<decltype(f(std::declval<A>()))> {
53 |         return detail::deriving::fmap(input, f);
54 |     }
55 | };
56 | 
57 | namespace traits {
58 | template <>
59 | struct is_monad<std::optional> : std::true_type {};
60 | 
61 | template <>
62 | struct is_applicative<std::optional> : std::true_type {};
63 | 
64 | template <>
65 | struct is_functor<std::optional> : std::true_type {};
66 | }
67 | 
68 | }
69 | 
70 | #endif
71 | 


--------------------------------------------------------------------------------
/include/kitten/functor.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_FUNCTOR_H
 2 | #define RVARAGO_KITTEN_FUNCTOR_H
 3 | 
 4 | namespace rvarago::kitten {
 5 | 
 6 | /**
 7 |  * A functor is an abstraction that allows to be mapped over.
 8 |  *
 9 |  * Given a functor fa: F[A] and a function f: A -> B
10 |  *  It uses f to map over the unwrapped value from fa and then returns a new functor fb: F[B].
11 |  *
12 |  * Laws:
13 |  *
14 |  * - Identity: fmap (f . g)  ==  fmap f . fmap g
15 |  * - Composition: fmap id = id
16 |  */
17 | template <template <typename...> typename F, typename = void>
18 | struct functor;
19 | 
20 | namespace traits {
21 | template <template <typename...> typename, typename = void>
22 | struct is_functor : std::false_type {};
23 | 
24 | template <template <typename...> typename F>
25 | inline constexpr bool is_functor_v = is_functor<F>::value;
26 | }
27 | 
28 | /**
29 |  * Unwraps the functor fa: F[A], feeds the unwrapped value of type A into the function f: A -> B, and then returns
30 |  * its result wrapped in a functor F[B].
31 |  *
32 |  * @param input a functor fa: F[A]
33 |  * @param f a function A -> B that maps over the value unwrapped from fa to yield a value b: B
34 |  * @return a new functor fb: F[B] resulting from wrapping the application of f over the unwrapped value from fa
35 |  */
36 | template <template <typename...> typename F, typename A, typename UnaryFunction>
37 | constexpr decltype(auto) fmap(F<A> const &input, UnaryFunction f) {
38 |     static_assert(traits::is_functor_v<F>, "type constructor F does not have a functor instance");
39 |     return functor<F>::fmap(input, f);
40 | }
41 | 
42 | /**
43 |  * Infix version of fmap.
44 |  */
45 | template <template <typename...> typename F, typename A, typename UnaryFunction>
46 | constexpr decltype(auto) operator|(F<A> const &input, UnaryFunction f) {
47 |     return fmap(input, f);
48 | }
49 | 
50 | /**
51 |  * Lifts a function A -> B into a function F[A] -> F[B], where F[_] is a functor.
52 |  *
53 |  * @param f a function A -> B that shall be applied to the content of F[A] where it's later provided
54 |  * @return a lifted function F[A] -> F[B]
55 |  */
56 | template <template <typename...> typename F, typename UnaryFunction>
57 | constexpr decltype(auto) liftF(UnaryFunction f) {
58 |     return [f](auto const &input) { return functor<F>::fmap(input, f); };
59 | }
60 | 
61 | }
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/tests/variant_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <catch2/catch.hpp>
 2 | 
 3 | #include <optional>
 4 | #include <string>
 5 | 
 6 | #include <kitten/instances/variant.h>
 7 | 
 8 | #include "utils.h"
 9 | 
10 | namespace {
11 | 
12 | using namespace rvarago::kitten;
13 | using test::utils::is_same_after_decaying;
14 | 
15 | struct error_t final {
16 |     explicit error_t(int _code) : code{_code} {
17 |     }
18 | 
19 |     int const code;
20 | };
21 | 
22 | SCENARIO("variant admits a multifunctor instance", "[variant]") {
23 | 
24 |     GIVEN("A variant") {
25 | 
26 |         AND_GIVEN("a function that maps all the choices") {
27 | 
28 |             auto choices_mapper =
29 |                 syntax::overloaded{[](int v) { return std::optional{v * 10}; }, [](std::string v) { return v; },
30 |                                    [](error_t) { return error_t{-2}; }};
31 | 
32 |             WHEN("in an error choice") {
33 | 
34 |                 auto const error_choice = std::variant<int, std::string, error_t>{error_t{-1}};
35 | 
36 |                 THEN("return a mapped variant also in an error choice") {
37 | 
38 |                     auto const mapped_error = error_choice || choices_mapper;
39 | 
40 |                     static_assert(is_same_after_decaying<decltype(mapped_error),
41 |                                                          std::variant<std::optional<int>, std::string, error_t>>);
42 | 
43 |                     CHECK(std::holds_alternative<error_t>(mapped_error));
44 |                     CHECK(std::get<error_t>(mapped_error).code == -2);
45 |                 }
46 |             }
47 | 
48 |             WHEN("in an integer choice") {
49 | 
50 |                 auto const integer_choice = std::variant<int, std::string, error_t>{1};
51 | 
52 |                 THEN("return a mapped variant also in an integer choice") {
53 | 
54 |                     auto const mapped_optional_of_integer = integer_choice || choices_mapper;
55 | 
56 |                     static_assert(is_same_after_decaying<decltype(mapped_optional_of_integer),
57 |                                                          std::variant<std::optional<int>, std::string, error_t>>);
58 | 
59 |                     CHECK(std::holds_alternative<std::optional<int>>(mapped_optional_of_integer));
60 |                     CHECK(std::get<std::optional<int>>(mapped_optional_of_integer) == std::optional{10});
61 |                 }
62 |             }
63 |         }
64 |     }
65 | }
66 | 
67 | }


--------------------------------------------------------------------------------
/include/kitten/monad.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_MONAD_H
 2 | #define RVARAGO_KITTEN_MONAD_H
 3 | 
 4 | #include <type_traits>
 5 | 
 6 | namespace rvarago::kitten {
 7 | 
 8 | /**
 9 |  * A monad is an abstraction that allows to be mapped over where the mapping function itself returns a monad.
10 |  *
11 |  * Given a monad ma: M[A] and a function f: A -> M[B]
12 |  *  It uses f to map over the value unwrapped from ma, flats the return type, and then returns a new monad mb: M[B].
13 |  *
14 |  * Note that if we had done as we do for functors, i.e. to do map(ma, f), we'd have a M[M[B]] that would have to be
15 |  * flattened. Whereas bind performs both the mapping and the flattening.
16 |  *
17 |  * Laws:
18 |  *
19 |  * - Left identity: return a >> f == f a
20 |  * - Right identity: m >> return == m
21 |  * - Associativity: (m >> f) >> g == m >> (\x -> f x >> g)
22 |  */
23 | template <template <typename...> typename M, typename = void>
24 | struct monad;
25 | 
26 | namespace traits {
27 | template <template <typename...> typename, typename = void>
28 | struct is_monad : std::false_type {};
29 | 
30 | template <template <typename...> typename M>
31 | inline constexpr bool is_monad_v = is_monad<M>::value;
32 | }
33 | 
34 | /**
35 |  * Lifts a value of type A into a monad M[A].
36 |  *
37 |  * @param value the type parameter that defines the type of the element wrapped by the monad
38 |  * @param tail eventual remaining type parameters used by the monad, considered as implementation detail
39 |  * @return a new monad m: M[A] that wraps the contained value of type A
40 |  */
41 | template <template <typename...> typename M, typename A>
42 | constexpr decltype(auto) wrap(A &&value) {
43 |     static_assert(traits::is_monad_v<M>, "type constructor M does not have a monad instance");
44 |     return monad<M>::wrap(std::forward<A>(value));
45 | }
46 | 
47 | /**
48 |  * Unwraps the monad ma: M[A], feeds the unwrapped value of type A into the function f: A -> M[B], and then returns
49 |  * its result.
50 |  *
51 |  * @param input a monad ma: M[A]
52 |  * @param f a function A -> M[B] that maps over the value wrapped inside ma to produce a new monad mb_temp: M[B]
53 |  * @return a new monad mb: M[B] resulting from applying f over the unwrapped value from ma and then flattening the
54 |  * result
55 |  */
56 | template <template <typename...> typename M, typename A, typename UnaryFunction>
57 | constexpr decltype(auto) bind(M<A> const &input, UnaryFunction f) {
58 |     static_assert(traits::is_monad_v<M>, "type constructor M does not have a monad instance");
59 |     return monad<M>::bind(input, f);
60 | }
61 | 
62 | /**
63 |  * Infix version of bind.
64 |  */
65 | template <template <typename...> typename M, typename A, typename UnaryFunction>
66 | constexpr decltype(auto) operator>>(M<A> const &input, UnaryFunction f) {
67 |     return bind(input, f);
68 | }
69 | 
70 | }
71 | 
72 | #endif
73 | 


--------------------------------------------------------------------------------
/include/kitten/applicative.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_APPLICATIVE_H
 2 | #define RVARAGO_KITTEN_APPLICATIVE_H
 3 | 
 4 | #include <functional>
 5 | #include <tuple>
 6 | 
 7 | namespace rvarago::kitten {
 8 | 
 9 | /**
10 |  * An applicative is an abstraction that allows the combination of two wrapped values.
11 |  *
12 |  * Given two applicatives apa: AP[A] and  apb: AP[B] and a binary function f: (A, B) -> C
13 |  *  It uses f to map over the values unwrapped from apa and apb and then returns a new applicative apc: AP[C].
14 |  *
15 |  */
16 | template <template <typename...> typename AP, typename = void>
17 | struct applicative;
18 | 
19 | namespace traits {
20 | template <template <typename...> typename, typename = void>
21 | struct is_applicative : std::false_type {};
22 | 
23 | template <template <typename...> typename AP>
24 | inline constexpr bool is_applicative_v = is_applicative<AP>::value;
25 | }
26 | 
27 | /**
28 |  * Lifts a value of type A into an applicative AP[A].
29 |  *
30 |  * @param value the type parameter that defines the type of the element wrapped by the applicative
31 |  * @param tail eventual remaining type parameters used by the applicative, considered as implementation detail
32 |  * @return a new monad m: AP[A] that wraps the contained value of type A
33 |  */
34 | template <template <typename...> typename AP, typename A>
35 | constexpr decltype(auto) pure(A &&value) {
36 |     static_assert(traits::is_applicative_v<AP>, "type constructor M does not have an applicative instance");
37 |     return applicative<AP>::pure(std::forward<A>(value));
38 | }
39 | 
40 | /**
41 |  * Unwraps the applicatives apa: AP[A] and apb: AP[B], feeds the unwrapped value of types A and B into the function
42 |  * f: (A, B) -> C, and then returns its result wrapped in a functor F[B]..
43 |  *
44 |  * @param first an applicative apa: AP[A]
45 |  * @param second an applicative apb: AP[B]
46 |  * @param f a function A -> B -> C that maps over the values unwrapped from apa and apb to yield a value c: C
47 |  * @return a new applicative apc: AP[C] resulting from wrapping the application of f over the wrapped value inside apa
48 |  * and apb
49 |  */
50 | template <template <typename...> typename AP, typename A, typename B, typename BinaryFunction = std::plus<>>
51 | constexpr decltype(auto) combine(AP<A> const &first, AP<B> const &second, BinaryFunction f = BinaryFunction{}) {
52 |     static_assert(traits::is_applicative_v<AP>, "type constructor AP does not have an applicative instance");
53 |     return applicative<AP>::combine(first, second, f);
54 | }
55 | 
56 | /**
57 |  * Infix version of combine. Since operator+ expects two arguments, we had to wrap the applicatives in a tuple.
58 |  */
59 | template <template <typename...> typename AP, typename A, typename B, typename BinaryFunction>
60 | constexpr decltype(auto) operator+(std::tuple<AP<A>, AP<B>> const &input, BinaryFunction f) {
61 |     return combine(std::get<0>(input), std::get<1>(input), f);
62 | }
63 | 
64 | /**
65 |  * Infix version of combine that receives unwrapped applicatives and uses + as a binary function.
66 |  */
67 | template <template <typename...> typename AP, typename A, typename B>
68 | constexpr decltype(auto) operator+(AP<A> const &first, AP<B> const &second) {
69 |     return combine(first, second);
70 | }
71 | 
72 | /**
73 |  * lifts a binary function f: A -> B -> C into an applicative context fap: AP[A] -> AP[B] -> AP[C].
74 |  *
75 |  * @param f binary function f: A -> B -> C to be lifted into the applicative AP[T] context.
76 |  * @return the lifted version of f that operates on applicatives.
77 |  */
78 | template <template <typename...> typename AP, typename BinaryFunction>
79 | constexpr decltype(auto) liftA2(BinaryFunction f) {
80 |     return [f](auto const &first, auto const &second) { return combine<AP>(first, second, f); };
81 | }
82 | 
83 | }
84 | 
85 | #endif
86 | 


--------------------------------------------------------------------------------
/include/kitten/instances/sequence_container.h:
--------------------------------------------------------------------------------
 1 | #ifndef RVARAGO_KITTEN_SEQUENCE_CONTAINER_H
 2 | #define RVARAGO_KITTEN_SEQUENCE_CONTAINER_H
 3 | 
 4 | #include <deque>
 5 | #include <list>
 6 | #include <type_traits>
 7 | #include <vector>
 8 | 
 9 | #include "kitten/applicative.h"
10 | #include "kitten/functor.h"
11 | #include "kitten/monad.h"
12 | 
13 | #include "kitten/detail/deriving/from_monad/derive_applicative.h"
14 | #include "kitten/detail/deriving/from_monad/derive_functor.h"
15 | 
16 | #include "kitten/detail/ranges/algorithm.h"
17 | 
18 | namespace rvarago::kitten {
19 | 
20 | // TODO: Use standard concepts
21 | namespace detail {
22 | 
23 | template <template <typename...> typename Container>
24 | struct is_sequence_container : std::false_type {};
25 | 
26 | template <>
27 | struct is_sequence_container<std::deque> : std::true_type {};
28 | 
29 | template <>
30 | struct is_sequence_container<std::list> : std::true_type {};
31 | 
32 | template <>
33 | struct is_sequence_container<std::vector> : std::true_type {};
34 | 
35 | template <template <typename...> typename Container>
36 | using enable_if_sequence_container = typename std::enable_if_t<is_sequence_container<Container>::value>;
37 | 
38 | }
39 | 
40 | template <template <typename...> typename SequenceContainer>
41 | struct monad<SequenceContainer> {
42 | 
43 |     template <typename A, typename UnaryFunction, typename = detail::enable_if_sequence_container<SequenceContainer>>
44 |     static constexpr auto bind(SequenceContainer<A> const &input, UnaryFunction f) -> decltype(f(std::declval<A>())) {
45 |         using namespace detail::ranges;
46 |         auto mapped_sequence = decltype(f(std::declval<A>())){};
47 |         for_each(input, [&](auto const &e) { copy(f(e), std::back_inserter(mapped_sequence)); });
48 |         return mapped_sequence;
49 |     }
50 | 
51 |     template <typename A, typename = detail::enable_if_sequence_container<SequenceContainer>>
52 |     static constexpr auto wrap(A &&value) -> SequenceContainer<A> {
53 |         return SequenceContainer<A>{std::forward<A>(value)};
54 |     }
55 | };
56 | 
57 | template <template <typename...> typename SequenceContainer>
58 | struct applicative<SequenceContainer> {
59 | 
60 |     template <typename A, typename B, typename BinaryFunction,
61 |               typename = detail::enable_if_sequence_container<SequenceContainer>>
62 |     static constexpr auto combine(SequenceContainer<A> const &first, SequenceContainer<B> const &second,
63 |                                   BinaryFunction f)
64 |         -> SequenceContainer<decltype(f(std::declval<A>(), std::declval<B>()))> {
65 |         return detail::deriving::combine(first, second, f);
66 |     }
67 | 
68 |     template <typename A, typename = detail::enable_if_sequence_container<SequenceContainer>>
69 |     static constexpr auto pure(A &&value) -> SequenceContainer<A> {
70 |         return detail::deriving::pure<SequenceContainer>(std::forward<A>(value));
71 |     }
72 | };
73 | 
74 | template <template <typename...> typename SequenceContainer>
75 | struct functor<SequenceContainer> {
76 | 
77 |     template <typename A, typename UnaryFunction, typename = detail::enable_if_sequence_container<SequenceContainer>>
78 |     static constexpr auto fmap(SequenceContainer<A> const &input, UnaryFunction f)
79 |         -> SequenceContainer<decltype(f(std::declval<A>()))> {
80 |         return detail::deriving::fmap(input, f);
81 |     }
82 | };
83 | 
84 | namespace traits {
85 | template <template <typename...> typename SequenceContainer>
86 | struct is_monad<SequenceContainer> : std::true_type {};
87 | 
88 | template <template <typename...> typename SequenceContainer>
89 | struct is_applicative<SequenceContainer> : std::true_type {};
90 | 
91 | template <template <typename...> typename SequenceContainer>
92 | struct is_functor<SequenceContainer> : std::true_type {};
93 | }
94 | 
95 | }
96 | 
97 | #endif


--------------------------------------------------------------------------------
/tests/optional_test.cpp:
--------------------------------------------------------------------------------
  1 | #include <catch2/catch.hpp>
  2 | 
  3 | #include <kitten/instances/optional.h>
  4 | #include <string>
  5 | 
  6 | #include "utils.h"
  7 | #include <functional>
  8 | 
  9 | namespace {
 10 | 
 11 | using namespace std::string_literals;
 12 | 
 13 | using namespace rvarago::kitten;
 14 | using test::utils::is_same_after_decaying;
 15 | 
 16 | SCENARIO("optional admits functor, applicative, and monad instances", "[optional]") {
 17 | 
 18 |     GIVEN("An optional") {
 19 | 
 20 |         AND_GIVEN("a functor instance") {
 21 | 
 22 |             AND_GIVEN("fmap") {
 23 | 
 24 |                 auto to_string = [](auto const v) { return std::to_string(v); };
 25 | 
 26 |                 WHEN("empty") {
 27 | 
 28 |                     std::optional<int> const none;
 29 | 
 30 |                     THEN("return an empty optional") {
 31 | 
 32 |                         auto const none_of_string = none | to_string;
 33 | 
 34 |                         static_assert(is_same_after_decaying<decltype(none_of_string), std::optional<std::string>>);
 35 | 
 36 |                         CHECK(!none_of_string.has_value());
 37 |                     }
 38 |                 }
 39 | 
 40 |                 WHEN("not empty") {
 41 | 
 42 |                     auto const some_one = std::optional{1};
 43 | 
 44 |                     THEN("return a non-empty optional containing the mapped value") {
 45 | 
 46 |                         auto const some_one_of_string = some_one | to_string;
 47 | 
 48 |                         static_assert(is_same_after_decaying<decltype(some_one_of_string), std::optional<std::string>>);
 49 | 
 50 |                         CHECK(some_one_of_string.has_value());
 51 |                         CHECK(some_one_of_string.value() == "1"s);
 52 |                     }
 53 |                 }
 54 |             }
 55 | 
 56 |             AND_GIVEN("liftF") {
 57 | 
 58 |                 auto to_string_lifted = liftF<std::optional>([](auto const v) { return std::to_string(v); });
 59 | 
 60 |                 WHEN("empty") {
 61 | 
 62 |                     std::optional<int> const none;
 63 | 
 64 |                     THEN("return an empty optional") {
 65 | 
 66 |                         auto const none_of_string = to_string_lifted(none);
 67 | 
 68 |                         static_assert(is_same_after_decaying<decltype(none_of_string), std::optional<std::string>>);
 69 | 
 70 |                         CHECK(!none_of_string.has_value());
 71 |                     }
 72 |                 }
 73 | 
 74 |                 WHEN("not empty") {
 75 | 
 76 |                     auto const some_one = std::optional{1};
 77 | 
 78 |                     THEN("return an empty optional") {
 79 | 
 80 |                         auto const some_one_of_string = to_string_lifted(some_one);
 81 | 
 82 |                         static_assert(is_same_after_decaying<decltype(some_one_of_string), std::optional<std::string>>);
 83 | 
 84 |                         CHECK(some_one_of_string.has_value());
 85 |                         CHECK(some_one_of_string.value() == "1"s);
 86 |                     }
 87 |                 }
 88 |             }
 89 |         }
 90 | 
 91 |         AND_GIVEN("an applicative instance") {
 92 | 
 93 |             AND_GIVEN("pure") {
 94 | 
 95 |                 THEN("lift into a non-empty optional") {
 96 | 
 97 |                     auto const some_one = pure<std::optional>("1"s);
 98 | 
 99 |                     static_assert(is_same_after_decaying<decltype(some_one), std::optional<std::string>>);
100 | 
101 |                     CHECK(some_one.has_value());
102 |                     CHECK(some_one.value() == "1"s);
103 |                 }
104 |             }
105 | 
106 |             AND_GIVEN("combine") {
107 | 
108 |                 auto to_product_as_string = [](auto const &a, auto const &b) { return std::to_string(a * b); };
109 | 
110 |                 WHEN("empty") {
111 | 
112 |                     std::optional<int> const none;
113 | 
114 |                     THEN("return an empty optional") {
115 | 
116 |                         auto const some_three = std::optional{3};
117 |                         auto const none_of_string = std::tuple{none, some_three} + to_product_as_string;
118 | 
119 |                         static_assert(is_same_after_decaying<decltype(none_of_string), std::optional<std::string>>);
120 | 
121 |                         CHECK(!none_of_string.has_value());
122 |                     }
123 |                 }
124 | 
125 |                 WHEN("not empty") {
126 | 
127 |                     auto const some_two = std::optional{2};
128 | 
129 |                     THEN("return a non-empty optional with the combined value") {
130 | 
131 |                         auto const some_three = std::optional<int>{3};
132 |                         auto const product_of_string = std::tuple{some_two, some_three} + to_product_as_string;
133 | 
134 |                         static_assert(is_same_after_decaying<decltype(product_of_string), std::optional<std::string>>);
135 | 
136 |                         CHECK(product_of_string.has_value());
137 |                         CHECK(product_of_string.value() == "6"s);
138 |                     }
139 |                 }
140 |             }
141 | 
142 |             AND_GIVEN("liftA2") {
143 | 
144 |                 auto const lifted_plus = liftA2<std::optional>(std::plus<int>{});
145 | 
146 |                 WHEN("any is empty") {
147 | 
148 |                     THEN("the lifted function that adds to integers into one should return an empty optional") {
149 | 
150 |                         std::optional<int> const none = std::nullopt;
151 |                         auto const some = std::optional{42};
152 | 
153 |                         auto const left_sum = lifted_plus(none, some);
154 |                         auto const right_sum = lifted_plus(some, none);
155 | 
156 |                         static_assert(is_same_after_decaying<decltype(left_sum), std::optional<int>>);
157 |                         static_assert(is_same_after_decaying<decltype(right_sum), std::optional<int>>);
158 | 
159 |                         CHECK(!left_sum.has_value());
160 |                         CHECK(!right_sum.has_value());
161 |                     }
162 |                 }
163 | 
164 |                 WHEN("both are not empty") {
165 | 
166 |                     THEN("the lifted function that adds to integers into one should return a filled optional "
167 |                          "containing the sum") {
168 | 
169 |                         auto const some_1 = std::optional{1};
170 |                         auto const some_2 = std::optional{2};
171 | 
172 |                         auto const sum = lifted_plus(some_1, some_2);
173 | 
174 |                         static_assert(is_same_after_decaying<decltype(sum), std::optional<int>>);
175 | 
176 |                         CHECK(sum.has_value());
177 |                         CHECK(sum.value() == 3);
178 |                     }
179 |                 }
180 |             }
181 |         }
182 | 
183 |         AND_GIVEN("a monad instance") {
184 | 
185 |             AND_GIVEN("wrap") {
186 | 
187 |                 THEN("lift into a non-empty optional") {
188 | 
189 |                     auto const some_one = wrap<std::optional>("1"s);
190 | 
191 |                     static_assert(is_same_after_decaying<decltype(some_one), std::optional<std::string>>);
192 | 
193 |                     CHECK(some_one.has_value());
194 |                     CHECK(some_one.value() == "1"s);
195 |                 }
196 |             }
197 | 
198 |             AND_GIVEN("bind") {
199 | 
200 |                 auto to_optional_string = [](auto v) { return std::optional{std::to_string(v)}; };
201 |                 auto to_optional_int = [](auto v) { return std::optional{std::stoi(v)}; };
202 | 
203 |                 WHEN("empty") {
204 | 
205 |                     std::optional<int> const none;
206 | 
207 |                     THEN("return an empty optional") {
208 | 
209 |                         auto const none_of_string = none >> to_optional_string >> to_optional_int;
210 | 
211 |                         static_assert(is_same_after_decaying<decltype(none_of_string), std::optional<int>>);
212 | 
213 |                         CHECK(!none_of_string.has_value());
214 |                     }
215 |                 }
216 | 
217 |                 WHEN("not empty") {
218 | 
219 |                     auto const some_one = std::optional{1};
220 | 
221 |                     THEN("return a non-empty optional containing the bound value") {
222 | 
223 |                         auto const some_one_of_string = some_one >> to_optional_string >> to_optional_int;
224 | 
225 |                         static_assert(is_same_after_decaying<decltype(some_one_of_string), std::optional<int>>);
226 | 
227 |                         CHECK(some_one_of_string.has_value());
228 |                         CHECK(some_one_of_string.value() == 1);
229 |                     }
230 |                 }
231 |             }
232 |         }
233 |     }
234 | }
235 | }
236 | 


--------------------------------------------------------------------------------
/tests/sequence_container_test.cpp:
--------------------------------------------------------------------------------
  1 | #include <catch2/catch.hpp>
  2 | 
  3 | #include "utils.h"
  4 | #include <functional>
  5 | #include <iterator>
  6 | #include <kitten/instances/sequence_container.h>
  7 | #include <string>
  8 | 
  9 | namespace {
 10 | 
 11 | using namespace std::string_literals;
 12 | 
 13 | using namespace rvarago::kitten;
 14 | using test::utils::is_same_after_decaying;
 15 | 
 16 | template <typename T, typename Allocator = std::allocator<T>>
 17 | using SequenceContainer = std::vector<T, Allocator>;
 18 | 
 19 | SCENARIO("SequenceContainer admits functor, applicative, and monad instances", "[SequenceContainer]") {
 20 | 
 21 |     GIVEN("A SequenceContainer") {
 22 | 
 23 |         AND_GIVEN("a functor instance") {
 24 | 
 25 |             AND_GIVEN("fmap") {
 26 | 
 27 |                 auto to_string = [](auto const v) { return std::to_string(v); };
 28 | 
 29 |                 WHEN("empty") {
 30 | 
 31 |                     SequenceContainer<int> const empty;
 32 | 
 33 |                     THEN("return an empty SequenceContainer") {
 34 | 
 35 |                         auto const empty_of_strings = empty | to_string;
 36 | 
 37 |                         static_assert(
 38 |                             is_same_after_decaying<decltype(empty_of_strings), SequenceContainer<std::string>>);
 39 | 
 40 |                         CHECK(empty_of_strings.empty());
 41 |                     }
 42 |                 }
 43 | 
 44 |                 WHEN("not empty") {
 45 | 
 46 |                     auto const container_of_ints = SequenceContainer<int>{1, 2};
 47 | 
 48 |                     THEN("return a non-empty SequenceContainer containing the mapped values") {
 49 | 
 50 |                         auto const container_of_strings = container_of_ints | to_string;
 51 | 
 52 |                         static_assert(
 53 |                             is_same_after_decaying<decltype(container_of_strings), SequenceContainer<std::string>>);
 54 | 
 55 |                         CHECK(container_of_strings.size() == 2);
 56 |                         CHECK(container_of_strings == SequenceContainer<std::string>{"1", "2"});
 57 |                     }
 58 |                 }
 59 |             }
 60 | 
 61 |             AND_GIVEN("liftF") {
 62 | 
 63 |                 auto to_string_lifted = liftF<SequenceContainer>([](auto const v) { return std::to_string(v); });
 64 | 
 65 |                 WHEN("empty") {
 66 | 
 67 |                     SequenceContainer<int> const empty;
 68 | 
 69 |                     THEN("return an empty SequenceContainer") {
 70 | 
 71 |                         auto const empty_of_strings = to_string_lifted(empty);
 72 | 
 73 |                         static_assert(
 74 |                             is_same_after_decaying<decltype(empty_of_strings), SequenceContainer<std::string>>);
 75 | 
 76 |                         CHECK(empty_of_strings.empty());
 77 |                     }
 78 |                 }
 79 | 
 80 |                 WHEN("not empty") {
 81 | 
 82 |                     auto const container_of_ints = SequenceContainer<int>{1, 2};
 83 | 
 84 |                     THEN("return a non-empty SequenceContainer containing the mapped values") {
 85 | 
 86 |                         auto const container_of_strings = to_string_lifted(container_of_ints);
 87 | 
 88 |                         static_assert(
 89 |                             is_same_after_decaying<decltype(container_of_strings), SequenceContainer<std::string>>);
 90 | 
 91 |                         CHECK(container_of_strings.size() == 2);
 92 |                         CHECK(container_of_strings == SequenceContainer<std::string>{"1", "2"});
 93 |                     }
 94 |                 }
 95 |             }
 96 |         }
 97 | 
 98 |         AND_GIVEN("an applicative instance") {
 99 | 
100 |             AND_GIVEN("pure") {
101 | 
102 |                 THEN("lift into a non-empty SequenceContainer") {
103 | 
104 |                     auto const singleton = pure<SequenceContainer>("1"s);
105 | 
106 |                     static_assert(is_same_after_decaying<decltype(singleton), SequenceContainer<std::string>>);
107 | 
108 |                     CHECK(singleton.size() == 1);
109 |                     CHECK(singleton == SequenceContainer<std::string>{"1"});
110 |                 }
111 |             }
112 | 
113 |             AND_GIVEN("combine") {
114 | 
115 |                 auto to_product_as_string = [](auto const &a, auto const &b) {
116 |                     return std::to_string(std::stoi(a) * b);
117 |                 };
118 | 
119 |                 WHEN("empty") {
120 | 
121 |                     SequenceContainer<std::string> const empty_of_string;
122 | 
123 |                     THEN("return an empty SequenceContainer") {
124 | 
125 |                         auto const container_int = SequenceContainer<int>{20, 30};
126 |                         auto const product_of_string =
127 |                             std::tuple{empty_of_string, container_int} + to_product_as_string;
128 | 
129 |                         static_assert(
130 |                             is_same_after_decaying<decltype(product_of_string), SequenceContainer<std::string>>);
131 | 
132 |                         CHECK(product_of_string.empty());
133 |                     }
134 |                 }
135 | 
136 |                 WHEN("not empty") {
137 | 
138 |                     auto const first_container_of_string = SequenceContainer<std::string>{"2", "3"};
139 | 
140 |                     THEN("return a non-empty SequenceContainer with the combined value") {
141 | 
142 |                         auto const second_container_of_int = SequenceContainer<int>{20, 30};
143 |                         auto const product_of_string =
144 |                             std::tuple{first_container_of_string, second_container_of_int} + to_product_as_string;
145 | 
146 |                         static_assert(
147 |                             is_same_after_decaying<decltype(product_of_string), SequenceContainer<std::string>>);
148 | 
149 |                         CHECK(product_of_string.size() == 4);
150 |                         CHECK(product_of_string == SequenceContainer<std::string>{"40", "60", "60", "90"});
151 |                     }
152 |                 }
153 |             }
154 | 
155 |             AND_GIVEN("liftA2") {
156 | 
157 |                 auto const lifted_plus = liftA2<SequenceContainer>(std::plus<int>{});
158 | 
159 |                 WHEN("any is empty") {
160 | 
161 |                     THEN("the lifted function that adds to integers into one should return an empty optional") {
162 | 
163 |                         SequenceContainer<int> const empty{};
164 |                         auto const singleton_one = SequenceContainer<int>{1};
165 | 
166 |                         auto const left_sum = lifted_plus(empty, singleton_one);
167 |                         auto const right_sum = lifted_plus(singleton_one, empty);
168 | 
169 |                         static_assert(is_same_after_decaying<decltype(left_sum), SequenceContainer<int>>);
170 |                         static_assert(is_same_after_decaying<decltype(right_sum), SequenceContainer<int>>);
171 | 
172 |                         CHECK(left_sum.empty());
173 |                         CHECK(right_sum.empty());
174 |                     }
175 |                 }
176 | 
177 |                 WHEN("both are not empty") {
178 | 
179 |                     THEN("the lifted function that adds to integers into one should return a filled optional "
180 |                          "containing the sum") {
181 | 
182 |                         auto const first_container = SequenceContainer<int>{1, 2};
183 |                         auto const second_container = SequenceContainer<int>{10, 20};
184 | 
185 |                         auto const sum = lifted_plus(first_container, second_container);
186 | 
187 |                         static_assert(is_same_after_decaying<decltype(sum), SequenceContainer<int>>);
188 | 
189 |                         CHECK(sum.size() == 4);
190 |                         CHECK(sum == SequenceContainer<int>{11, 21, 12, 22});
191 |                     }
192 |                 }
193 |             }
194 |         }
195 |     }
196 | 
197 |     AND_GIVEN("a monad instance") {
198 | 
199 |         AND_GIVEN("wrap") {
200 | 
201 |             THEN("lift into a non-empty SequenceContainer") {
202 | 
203 |                 auto const singleton = wrap<SequenceContainer>("1"s);
204 | 
205 |                 static_assert(is_same_after_decaying<decltype(singleton), SequenceContainer<std::string>>);
206 | 
207 |                 CHECK(singleton.size() == 1);
208 |                 CHECK(singleton == SequenceContainer<std::string>{"1"});
209 |             }
210 |         }
211 | 
212 |         AND_GIVEN("bind") {
213 | 
214 |             auto to_SequenceContainer_string = [](auto v) {
215 |                 return SequenceContainer<std::string>{std::to_string(v), std::to_string(v)};
216 |             };
217 | 
218 |             WHEN("empty") {
219 | 
220 |                 SequenceContainer<int> const empty;
221 | 
222 |                 THEN("return an empty SequenceContainer") {
223 | 
224 |                     auto const empty_of_string = SequenceContainer<int>{} >> to_SequenceContainer_string;
225 | 
226 |                     static_assert(is_same_after_decaying<decltype(empty_of_string), SequenceContainer<std::string>>);
227 | 
228 |                     CHECK(empty_of_string.empty());
229 |                 }
230 |             }
231 | 
232 |             WHEN("not empty") {
233 | 
234 |                 auto const container = SequenceContainer<int>{1, 2};
235 | 
236 |                 THEN("return a non-empty SequenceContainer containing the bound value") {
237 | 
238 |                     auto const container_of_string = container >> to_SequenceContainer_string;
239 | 
240 |                     static_assert(
241 |                         is_same_after_decaying<decltype(container_of_string), SequenceContainer<std::string>>);
242 | 
243 |                     CHECK(container_of_string.size() == 4);
244 |                     CHECK(container_of_string == SequenceContainer<std::string>{"1", "1", "2", "2"});
245 |                 }
246 |             }
247 |         }
248 |     }
249 | }
250 | }
251 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # kitten
  2 | 
  3 | This is a small header-only library with some machinery meant to extend the already great STL with some concepts obtained from Category Theory, such as functors and monads, in order to make the composition of some C++ type constructors even simpler.
  4 | 
  5 | It's basically a collection of utilities from my recent studies of Category Theory expressed in C++.
  6 | 
  7 | Category Theory -> Category -> Cat -> Kitten 🐈
  8 | 
  9 | [![Build Status](https://travis-ci.org/rvarago/absent.svg?branch=master)](https://travis-ci.org/rvarago/kitten)
 10 | 
 11 | ## Problem description
 12 | 
 13 | Functors, applicatives, monads, etc are mathematical structures studied in Category Theory that capture the essence of composition. And given that programming is all about composition, they have plenty of practical applications, particularly in Pure Functional Programming.
 14 | 
 15 | Furthermore, they are structures that must respect mathematical laws that restrict their behavior. [learnyouahaskell](http://learnyouahaskell.com/functors-applicative-functors-and-monoids)
 16 | provides a very good explanation about these laws in terms of programming, but of course, there are many other
 17 | resources to learn about them.
 18 | 
 19 | Although they're fairly abstract concepts, there are many practical applications for them when we want to compose
 20 | _effectful functions_. We can think about an effectful function as a function `f` that instead of returning a value of type
 21 | `A` it returns a value of type `X<A>` where `X` represents an effect which models an "extra information" about the computation
 22 | done inside `f`.
 23 | 
 24 | For example:
 25 | 
 26 | - A function `f` that can fail to produce a value of type `A` might return an `std::optional<A>`
 27 | where `std::optional` is a piece of extra information (an effect) that models the absence of a value.
 28 | - A function `f` that can return multiple values of type `A` might return an `std::vector<A>` where
 29 | `std::vector` is a piece of "extra information" (an effect) that models multiple values.
 30 | 
 31 | When we have functions `f: A -> B` and `g: B -> C` we can compose these two functions into a new function
 32 | `h: A -> C` by using the usual function composition:
 33 | 
 34 | ` h(x) = g(f(x)), A -> C`
 35 | 
 36 | Therefore, it eliminates the intermediate steps involving `B`.
 37 | 
 38 | That's only possible because of the co-domain `A` of `f` matches with the domain `B` of `g`, i.e.
 39 | the output of the first function can be fed as the input for the second function. But, what happens when we have effectful
 40 | functions involved?
 41 | 
 42 | _kitten_ has the goal of providing instances for some common abstractions from Category Theory to C++. Internally,
 43 |  it makes heavy-usage of the STL to extend the capabilities of supported C++ types.
 44 | 
 45 | ### Functors
 46 | 
 47 | Now, consider `f` as an effectful function: `f: A -> X<B>`, where `X` models some effect. We can't compose
 48 | `g: B -> C` anymore, since it expects `B` and therefore can't be fed with an `X<B>`.
 49 | 
 50 | Given that we can't do the usual function composition, we need a more powerful way to do composition.
 51 | 
 52 | We need a functor.
 53 | 
 54 | If `X<T>` admits a functor for some type parameter `T`, we can compose `f` and `g` by using `fmap`:
 55 | 
 56 | `fmap(X<A>, w: A -> B): X<B>`
 57 | 
 58 | `fmap` receives a functor `X<A>`, a function `w: A -> B` that would do the composition of the types `A` and `B`, and
 59 | it returns a new functor `X<B>`. It basically:
 60 |  
 61 | 1. unwraps `X<A>` into `A`
 62 | 2. feeds `A` into `w`
 63 | 3. wraps (or lifts) the output of `w` into an `X<B>`
 64 | 4. then returns `X<B>`
 65 | 
 66 | Hence, we can do:
 67 | 
 68 | `fmap(f(), g)`
 69 | 
 70 | Using _kitten_, one example of using a functor is:
 71 | 
 72 | ```
 73 | auto const maybe_name = maybe_find_person() | get_name; // or fmap(maybe_find_person(), get_name)
 74 | ```
 75 | 
 76 | Where `maybe_find_person` returns an `std::optional<person>`, and then the wrapped object of type `person` is fed into
 77 | `get_name` that returns an object of type `name`.
 78 | 
 79 | Thus, the result of the whole composition is of type `std::optional<name>`.
 80 | 
 81 | An equivalent way to define a functor is by providing the function `liftF`,
 82 | which maps a function `w: A -> B` into another function `z: X[A] -> X[B]`,
 83 | where `X[T]` is a functor.
 84 | 
 85 | ### Applicatives
 86 | 
 87 | What happens if `f` takes several arguments? For instance, we have the objects `xa: X<A>` and `xb: X<B>` and the
 88 | function `f: (A, B) -> C`.
 89 | How can we combine two effects `xa` and `xb` via `f` to obtain `X<C>`?
 90 | 
 91 | If we use `fmap` as we did before, we wouldn't be able, because `fmap` accepts only one argument, and we need to somehow
 92 | provide two.
 93 | 
 94 | We need a structure that's more powerful than a functor, we need an applicative.
 95 | 
 96 | If `X<T>` admits an applicative for some type parameter `T`, we can compose `f` using `combine` (also called `liftA2`):
 97 | 
 98 | `combine(X<A>, X<B>, w: (A, B) -> C): X<C>`
 99 | 
100 | `combine` receives the applicatives `X<A>` and `X<B>`, a binary function `w: (A, B) -> C` that would do the composition
101 | of the types `A` and `B`, and it returns a new applicative `X<B>`. It basically:
102 | 
103 | 1. unwraps `X<A>` into `A`
104 | 2. unwraps `X<B>` into `B`
105 | 3. feeds `A` and `B` into `w`
106 | 3. wraps the result `C` into `X<C>`
107 | 4. then returns `X<C>`
108 | 
109 | Hence, we can do:
110 | 
111 | `combine(xa, xb, f)`
112 | 
113 | In addition, an applicative also has a function `pure(A): X<A>` that allows one to lift a value
114 | of type `A` into an applicative `X<A>`.
115 | 
116 | Using _kitten_, one example of using an applicative is:
117 | 
118 | ```
119 | auto const maybe_three = maybe_one() + maybe_two(); // or combine(maybe_one(), maybe_two(), std::plus{})
120 | ```
121 | 
122 | Where `maybe_one` and `maybe_two` return instances of `std::optional<int>`, and then unwrapped objects of types
123 | `int` and `int` are fed into operator `+` (that defaults to `std::plus{}` for the unwrapped types) that returns an object
124 | of type `int` which is finally wrapped again in an `std::optional<int>`.
125 | 
126 | Thus, the result of the whole composition is of type `std::optional<int>`.
127 | 
128 | And what happens if we have n-ary rather than binary function `f`?
129 | 
130 | We can simply chaining operator `+`, like:
131 | 
132 | ```
133 | auto const maybe_ten = maybe_one() + maybe_two() + maybe_three() + maybe_four(); // and so on ...
134 | ```
135 | 
136 | And what should we do if we need a different operation instead of addition?
137 | 
138 | Given that operator `+` accepts two parameters, we have to use a convenient and general overload that accepts a tuple of two applicatives:
139 | 
140 | ```
141 | auto const maybe_six_as_string = std::tuple{maybe_two, maybe_three} + [](auto const& first, auto const& second) {
142 |             return std::to_string(first * second);
143 | };
144 | ```
145 | 
146 | Another helpful function provided by applicatives is  `liftA2`, which generalizes `liftF` for binaries functions of kind
147 | `w: A -> B -> C`, lifting it into another function `z: X[A] -> X[B] -> X[C]`, where `X[T]` is some applicative.
148 | 
149 | ### Monads
150 | 
151 | What happens if `f` and `g` are both effectul functions: `f: A -> X<B>` and `g: B -> X<C>`. How can
152 | we compose `f` and `g`?
153 | 
154 | If we use `fmap` as we did before, we would end up with a return type `X<X<C>>`, that nests the same effect. This type
155 | would then need to be flattened, or collapsed, into an `X<C>`, we need a structure that knows how to flat the effects.
156 | 
157 | We need a structure that's more powerful than a functor, we need a monad.
158 | 
159 | If `X<T>` admits a monad for some type parameter `T`, we can compose `f` and `g` by using `bind`:
160 | 
161 | `bind(X<A>, w: A -> X<B>): X<B>`
162 | 
163 | `bind` receives a monad `X<A>`, a function `w: A -> X<B>` that would do the composition of the types `A` and
164 | `X<B>`, and it returns a new monad `X<B>`. It basically:
165 |  
166 | 1. unwraps `X<A>` into `A`
167 | 2. feeds `A` into `w`
168 | 3. flats `X<X<B>>` into `X<B>`
169 | 4. then returns `X<B>`
170 | 
171 | Hence, we can do:
172 | 
173 | `bind(f(), g)`
174 | 
175 | In addition, a monad also has a function `wrap(A): X<A>` that allows one to lift a value
176 | of type `A` into a monad `X<A>`.
177 | 
178 | Using _kitten_, one example of using a monad is:
179 | 
180 | ```
181 | auto const maybe_name = maybe_find_person() >> maybe_get_name; // or bind(maybe_find_person(), maybe_get_name)
182 | ```
183 | 
184 | Where `maybe_find_person` returns an `std::optional<person>`, and then the wrapped object of type `person` is fed into
185 | `maybe_get_name` that itself returns an object of type `std::optional<name>`.
186 | 
187 | Thus, the result of the whole composition is of type `std::optional<name>`.
188 | 
189 | ## Multi-functors
190 | 
191 | A multi-functor generalizes a functor in the sense that instead of having only 1 type parameter, it can have `N` different types.
192 | 
193 | Given a multi-functor of arity 2, also called bi-functor,`X<A1, B1>`, and the functions `fa: A1 -> A2` and `fb: B1-> B2`,
194 | a multi-functor uses `multimap` to instantiate a new bi-functor `X<A2, B2>` via mapping the types through  `fa` and `fb`.
195 | 
196 | An interesting use case for a multi-functor is where we have a function that returns an `std::variant<A1, B1, C1>` and we
197 | want to map such type to `std::variant<A2, B2, C2>` via several functions `fa: A1 -> A2`, `fb: B1 -> B2`, and `fc: C1 -> C2`
198 | using _kitten_, we can do:
199 | 
200 | ```
201 | auto const variant_A2_B2_C2 = variant_A1_B1_C1 || syntax::overloaded {
202 |     [](A1 value) { return A1_to_A2(value); },
203 |     [](B1 value) { return B1_to_B2(value); },
204 |     [](C1 value) { return C1_to_C2(value); }
205 | };
206 | ```
207 | 
208 | Where `syntax::overloaded` is a helper function that enables us to create a function object on-the-fly, that receives a
209 | set of lambda expressions, and the right overload is then selected at compile-time depending on the type held by the
210 | `std::variant<A1, B1, C1>`.
211 | 
212 | ## kitten
213 | 
214 | _kitten_ relies on the STL to provide functor, applicative, monad, and multi-functor instances for some C++ data types. Given that the data type admits
215 | such instances, it's then possible to use the combinators available as free functions.
216 | 
217 | To simplify the notation, many combinators also come with overloaded operators that enable a, hopefully, nicer infix syntax
218 | suitable for chaining several calls.
219 | 
220 | The combinators are available conveniently in the header: `kitten/kitten.h`, or by importing each one separately. And
221 | the main namespace is `rvarago::kitten`.
222 | 
223 | Note that it's possible that a type may not admit instances for all the structures, e.g a type may have a functor but not a monad.
224 | 
225 | ### Functor
226 | 
227 | |    Combinator     |   Infix  |
228 | |:-----------------:|:--------:|
229 | |      `fmap`       | &#x7c;   |
230 | |      `liftF`      |          |
231 | 
232 | ### Multi-functor
233 | 
234 | |    Combinator     |      Infix    |
235 | |:-----------------:|:-------------:|
236 | |      `multimap`   |  &#x7c;&#x7c; |
237 | 
238 | ### Applicative
239 | 
240 | |    Combinator     |      Infix    |
241 | |:-----------------:|:-------------:|
242 | |      `pure`       |               |
243 | |      `combine`    |        +      |
244 | |      `liftA2`     |               |
245 | 
246 | 
247 | ### Monad
248 | 
249 | |    Combinator     |      Infix    |
250 | |:-----------------:|:-------------:|
251 | |      `wrap`       |               |
252 | |      `bind`       |        >>     |
253 | 
254 | ### Adapters
255 | 
256 | The following types are currently supported:
257 | 
258 | |         Type                      | Functor | Applicative | Monad   | Multi-functor |
259 | |:---------------------------------:|:-------:|-------------|---------|:-------------:|
260 | | `types::function_wrapper<F>`      |    x    |             |         |               |
261 | | `std::optional<T>`                |    x    |     x       |   x     |               |
262 | | `std::deque<T>`                   |    x    |     x       |   x     |               |
263 | | `std::list<T>`                    |    x    |     x       |   x     |               |
264 | | `std::variant<T...>`              |         |             |         |       x       |
265 | | `std::vector<T>`                  |    x    |     x       |         |               |
266 | 
267 | - `types::function_wrapper<F>` is a callable wrapper around a function-like type, e.g. function, function object, etc.
268 | And it allows using `fmap` to compose functions, e.g. given `fx : A -> B` and
269 | `fy: B -> C`, and both wrapped around `types::function_wrapper` which can conveniently be done
270 | by the helper function `types::fn`, then `fmap(fx, fy)` returns a new `types::function_wrapper`
271 |  `fz: A -> C` that applies `fx` and then `fy`. So, by providing an argument
272 |  `x` of type `A`, we have: `fmap(fx, fy)(x) == fy(fx(x))`.
273 | 
274 | ## Requirements
275 | 
276 | ### Mandatory
277 | 
278 | * C++17
279 | 
280 | ### Optional
281 | 
282 | * CMake (_only if you need to build from sources_)
283 | * Make (_only if you want to use it to orchestrate task execution_)
284 | * Conan (_only if you want generate a package or build the tests using conan as a provider for the test framework_)
285 | * Docker (_only if you want build from inside a docker container_)
286 | 
287 | ## Build
288 | 
289 | The _Makefile_ wraps the commands to download dependencies (Conan), generate the build configuration, build, run the
290 | unit tests, and clear the build folder. Please consult the Makefile to adapt
291 | the commands in case you want to build _absent_ directly without using make.
292 | 
293 | * Compile:
294 | 
295 | ``
296 | make
297 | ``
298 | 
299 | By default, it also builds the unit tests, you can disable the behavior by:
300 | 
301 | ``
302 | make BUILD_TESTS=OFF
303 | ``
304 | 
305 | 
306 | The build always assumes that the default profile (*profiles/common*) applies to your build. If that's not, then you
307 | can specify your profile by setting _PROFILE_ as:
308 | 
309 | ``
310 | make PROFILE=<path_to_your_profile>
311 | ``
312 | 
313 | And to build with Release mode (by default it builds with Debug mode enabled):
314 | 
315 | ``
316 | make BUILD_TYPE=Release
317 | ``
318 | 
319 | * To run the unit tests, if previously compiled:
320 | 
321 | ``
322 | make test
323 | ``
324 | 
325 | ### Run unit tests inside a Docker container
326 | 
327 | Optionally, it's also possible to run the unit tests inside a Docker container by executing:
328 | 
329 | ``
330 | make env-test
331 | ``
332 | 
333 | ## Installing on the system
334 | 
335 | To install _kitten_:
336 | 
337 | ``
338 | make install
339 | ``
340 | 
341 | Then, it's possible to import _kitten_ into external CMake projects, say in a target _myExample_, by simply adding the
342 | following commands to its _CMakeLists.txt_:
343 | 
344 | ```
345 | find_package(kitten)
346 | target_link_libraries(myExample rvarago::kitten)
347 | ```
348 | 
349 | ## Package managers
350 | 
351 | To simplify the integration, _kitten_ can also be provided by the following package managers:
352 | 
353 | 1. [Conan](https://bintray.com/conan/conan-center/kitten%3A_)


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