Need help with optional?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

TartanLlama
574 Stars 46 Forks Other 264 Commits 19 Opened issues

Description

C++11/14/17 std::optional with functional-style extensions and reference support

Services available

!
?

Need anything else?

Contributors list

# 118,274
Shell
Linux
assembl...
compile...
132 commits
# 185,557
Shell
cpp17
constex...
XML
3 commits
# 169,463
Shell
embedde...
Terrafo...
constex...
2 commits
# 84,725
c-plus-...
Shell
ipc
golang
2 commits
# 235,600
gazebo
monospa...
C
travis
1 commit
# 309,176
C
commonm...
TypeScr...
Shell
1 commit
# 546,773
C
Shell
TypeScr...
1 commit
# 223,225
Shell
python3
gRPC
paxos
1 commit
# 303,812
Elixir
asio
cpp17
Redis
1 commit
# 13,552
Lua
trello
cpp17
lua-bin...
1 commit
# 618,984
Rust
C++
1 commit
# 618,764
C++
Shell
C
1 commit

optional

Single header implementation of

std::optional
with functional-style extensions and support for references.

Documentation Status Clang + GCC: Linux Build Status MSVC: Windows Build Status

std::optional
is the preferred way to represent an object which may or may not have a value. Unfortunately, chaining together many computations which may or may not produce a value can be verbose, as empty-checking code will be mixed in with the actual programming logic. This implementation provides a number of utilities to make coding with
optional
cleaner.

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
, but the following member functions are also defined. Explicit types are for clarity.
  • 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

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
, and
or_else
to
std::optional
.

CC0

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

optional
library. This work is published from: United Kingdom.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.