varianttalk's Introduction

Example code for my talk "std::variant and the Power of Pattern Matching"

This repository contains the example code shown in my presentation "std::variant and the power of pattern matching". To build, a C++ 17 compatible compiler is required. I have tested it on the following compilers:

Microsoft Visual Studio 2017 (version 15.8.9)
clang 7.0.0 (with libc++)

In addition, the library SFML is required. I tested versions 2.4 and 2.5. On Mac OS, you can install it via homebrew:

brew install sfml

You can also find the slides for my presentation in the slides directory.

All the code in this repository is shared under the MIT license (see LICENSE).

Blog post

I wrote a guest post for Bartek's coding blog, which focuses specifically on the state machine/space game part of this talk.

Licenses for graphics/fonts

There are some non-code assets in the state-machine/resources directory. Except for the following exceptions, these files are made by me and covered by a Creative Commons "CC by" license.

The following files are Copyright Ascender (see Apache-License.txt):

DroidSans.ttf
DroidSans-Bold.ttf

The following file is Copyright ESA, NASA, and L. Calcada (ESO for STScI) (see NASA-License.txt):

space-bg.jpg source

varianttalk's People

Contributors

Stargazers

Watchers

varianttalk's Issues

private variants

After the talk I suggested a downside to variants being complete, so extending a variant later (e.g. in the case of events). I came up with a possible solution:

namespace nonexhaustive_variant {
namespace detail {
template <class... T>
class nonexhaustive_variant {
  struct P {};

 public:
  using type = std::variant<T..., P>;
};
}  // namespace detail

template <class... T>
using nonexhaustive_variant = typename detail::nonexhaustive_variant<T...>::type;
}  // namespace nonexhaustive_variant

using nonexhaustive_variant forces users of match to always provide a generic matcher:

struct A {};
struct B {};

using V = nonexhaustive_variant::nonexhaustive_variant<A, B>;

void foo(const V& v) {
  match(v,  //
        [](const A&) { std::cout << "A" << std::endl; },
        [](const B&) { std::cout << "B" << std::endl; },
        [](const auto&) { std::cout << "???" << std::endl; });
}

Since the type P is private since it cannot be matched explicitely. This allows extending V in an interface without breaking all users of a library.

Recommend Projects

lethal-guitar / varianttalk Goto Github PK

varianttalk's Introduction

Example code for my talk "std::variant and the Power of Pattern Matching"

Blog post

Licenses for graphics/fonts

varianttalk's People

Contributors

Stargazers

Watchers

Forkers

varianttalk's Issues

private variants

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent