auto unsafe = [] { // a function that throws, sometimes we can't avoid it... if (true) { throw std::runtime_error("error"); } return 1; } Either<std::exception, int> e = Try<std::exception>(unsafe); // let's lift the exception into the typesystem e.left() .map([](auto const& e) { return std::cerr << e.what() << std::endl; }); // print error if available int result = e .leftMap([](auto) { return 42; }) // do nothing with exception and map to 42 .rightMap([](auto x) { return x * 2; }) // do further computation if value available .join() // join both sides of either ASSERT_TRUE(result == 42); 

Either<std::string, int> compute(int x) { if(x<0) return left("don't pass x<0"); return right(x*x); } std::string resultString = compute(5) .rightMap([](auto x){ return x/2.0;}) // success case .join( [](auto errorStr) { return "compute said: " + errorStr; }, // error-case [](auto x) { return "compute said: " + std::to_string(x); } // success-case ); std::cout << resultString << std::endl; 

neither::Either<my_error_t, int> f1(); neither::Either<my_error_t, float> f2(); void compose() { auto value = f1() .rightFlatMap([](const struct_a& v){ return f2(); }) .rightMap([](const struct_b& v){ return 5; }) .leftMap([](const auto& my_error){ return 6; }).join(); // value should be either 5 or 6 } 

Maybe<float> compute(float x) { if(x<0) return {}; return {sqrtf(x)}; } Maybe<float> x = compute(-4) .map([](auto x){ return x*x;}) .map([](auto x){ return x+1 }); if(!x.hasValue) { std::cerr << "error occured" << std::endl; } 

int sum(int x, int y){ return x+y; } //... auto monadicSum = lift(sum); // transforms sum to: Maybe<int> MonadicSum(Maybe<int>, Maybe<int>) ASSERT_TRUE( monadicSum( maybe(5) , maybe(7) ).get(0) == 12 ); ASSERT_TRUE( monadicSum( maybe(), maybe(1) ).hasValue == false);