optional

Single header implementation of

std::optional

Clang + GCC: MSVC:

std::optional

optional

For example, instead of writing this code:

std::optional get_cute_cat (const image& img) {
    auto cropped = crop_to_cat(img);
    if (!cropped) {
      return std::nullopt;
    }

auto with_tie = add_bow_tie(*cropped);
if (!with_tie) {
  return std::nullopt;
}

auto with_sparkles = make_eyes_sparkle(*with_tie);
if (!with_sparkles) {
  return std::nullopt;
}

return add_rainbow(make_smaller(*with_sparkles));
}

You can do this:

tl::optional get_cute_cat (const image& img) {
    return crop_to_cat(img)
           .and_then(add_bow_tie)
           .and_then(make_eyes_sparkle)
           .map(make_smaller)
           .map(add_rainbow);
}

The interface is the same as

std::optional

• map

  : carries out some operation on the stored object if there is one.

  • tl::optional<:size_t> s = opt_string.map(&std::string::size);

• and_then

  : like

  map

  , but for operations which return a

  tl::optional

  .

  • tl::optional stoi (const std::string& s);

  • tl::optional i = opt_string.and_then(stoi);

• or_else

  : calls some function if there is no value stored.

  • opt.or_else([] { throw std::runtime_error{"oh no"}; });

• map_or

  : carries out a

  map

  if there is a value, otherwise returns a default value.

  • tl::optional<:size_t> s = opt_string.map_or(&std::string::size, 0);

• map_or_else

  : carries out a

  map

  if there is a value, otherwise returns the result of a given default function.

  • std::size_t get_default();

  • tl::optional<:size_t> s = opt_string.map_or_else(&std::string::size, get_default);

• conjunction

  : returns the argument if a value is stored in the optional, otherwise an empty optional.

  • tl::make_optional(42).conjunction(13); //13

  • tl::optional{}.conjunction(13); //empty

• disjunction

  : returns the argument if the optional is empty, otherwise the current value.

  • tl::make_optional(42).disjunction(13); //42

  • tl::optional{}.disjunction(13); //13

• take

  : returns the current value, leaving the optional empty.

  • opt_string.take().map(&std::string::size); //opt_string now empty;

In addition to those member functions, optional references are also supported:

int i = 42;
tl::optional o = i;
*o == 42; //true
i = 12;
*o == 12; //true
&*o == &i; //true

Assignment has rebind semantics rather than assign-through semantics:

int j = 8;
o = j;

&*o == &j; //true

Compiler support

Tested on:

• Linux
  • clang 6.0.1
  • clang 5.0.2
  • clang 4.0.1
  • clang 3.9
  • clang 3.8
  • clang 3.7
  • clang 3.6
  • clang 3.5
  • g++ 8.0.1
  • g++ 7.3
  • g++ 6.4
  • g++ 5.5
  • g++ 4.9
  • g++ 4.8
• Windows
  • MSVC 2015
  • MSVC 2017

Dependencies

Requires Standardese for generating documentation.

Requires Catch for testing. This is bundled in the test directory.

Standards Proposal

This library also serves as an implementation of WG21 standards paper P0798R0: Monadic operations for std::optional. This paper proposes adding

map

and_then

or_else

std::optional

To the extent possible under law, Simon Brand has waived all copyright and related or neighboring rights to the

optional