guangie88/rustfp

C++ implementation of Rust Option/Result and Iterator.

rustfp

Overview

C++14 implementation of Rust Option/Result (monads) and Iterator concepts, useful for expressing items and result manipulation in a more functional style.

• https://doc.rust-lang.org/std/option/
• https://doc.rust-lang.org/std/result/
• https://doc.rust-lang.org/std/iter/

Currently tested to be compiling on g++-5 and above, MSVC2015 and above. clang should work as well, as long as the version supports C++14.

Repository Checkout

For Git version 1.6.5 or later:

git clone --recursive https://github.com/guangie88/rustfp.git

For already cloned repository or older Git version:

git clone https://github.com/guangie88/rustfp.git
git submodule update --init --recursive

Compilation and Installation

The solution uses CMake (at least version 3.6) for compilation and installation. To enable unit tests to be compiled for rustfp, add -DRUSTFP_INCLUDE_UNIT_TESTS=ON during the CMake configuration step.

Windows Generator Names

• MSVC

  • 32-bit

    • MSVC2015: Visual Studio 14
    • MSVC2017: Visual Studio 15

  • 64-bit

    • MSVC2015: Visual Studio 14 Win64
    • MSVC2017: Visual Studio 15 Win64

Windows Compilation

Debug and Release Compilation Example

mkdir build
cd build
cmake .. -G "Visual Studio 14 Win64" -DCMAKE_INSTALL_PREFIX:PATH=install
cmake --build . --config debug
cmake --build . --config release --target install

Linux Generator Names

For Linux, simply run export CC=<path-to-desired-CC-compiler>; export CXX=<path-to-desired-CXX-compiler> before running the CMake commands. As such, there should be no need to set -G <generator-name>.

Example

export CC=/usr/bin/gcc-5; export CXX=/usr/bin/g++-5

Linux Compilation

Note that gcc requires the build type to be specified at the CMake configuration step.

Debug Compilation Example

mkdir build-debug
cd build-debug
cmake .. -DCMAKE_BUILD_TYPE=Debug
cmake --build .

Release Compilation Example

mkdir build-release
cd build-release
cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=install
cmake --build . --target install

Installation Extraction

For the header files that are required to be included in other solutions, simply extract out the following directories in build/install/include into your other desired include directory:

• nonstd
• mpark
• rustfp

Usage Examples

#include "rustfp/collect.h"
#include "rustfp/iter.h"
#include "rustfp/map.h"

#include <cassert>
#include <string>
#include <vector>

int main() {
    const std::vector<int> v_int{0, 1, 2};

    // rustfp::iter works differently from C++ iterator.
    // containers with proper begin/cbegin and end/cend
    // has to be wrapped by rustfp::iter before any of
    // the FP operations (e.g. map, filter, fold) can be
    // used.

    const auto v_str = rustfp::iter(v_int)
        | rustfp::map([](const auto &v) {
            // v is of const int & type
            return std::to_string(v);
        })
        | rustfp::collect<std::vector<std::string>>();

    assert(v_str[0] == "0");
    assert(v_str[1] == "1");
    assert(v_str[2] == "2");
}

rustfp's Issues

Add cartesian operation

static_assert issue with TEST(Result, MatchOk) in unit_test

Need to check the issue with the type inference over in both branches of .match.

Add `cloned` method to Option.

.collect to allow chars into std::string

Add additional specialization to allow collecting chars into string.

Update README.md.

Include git operations and more examples.

Better component unit tests.

Add pass and fail individual pattern, logger, sink string content parsing.

Add flat_map operation

Add void return type to Result

Add the void type to Result class, like: Result<void, E>,and use "Ok()" to return the success void type.

cycle acting on single value instead of iterator

Need to change cycle to be like the other operation.

Allow some sort of implicit conversion from OkImpl and ErrImpl to Result.

For ergonomics sake, otherwise some of the Result return statements get very long.

Missing `or` and `and` methods to `Option` and `Result`.