Slide 1
Slide 1 text
Mitama.Result v2
C++でもResultが使いたい
Slide 2
Slide 2 text
自己紹介
主にTwitterに生息しています @mitama_rs
仕事でC++17でなんかやってます
その前は高校で理科を教えていた
Slide 3
Slide 3 text
例外じゃない
エラーハンドリングほしくない？
標準化委員会でもstd::expectedとかの提案があるが
まってらんねえ
Boost.Outcomeもあるが
モナディック関数がないやつは僕の欲しいものじゃない
いつものようにマイライブラリでなんとかする（）
Slide 4
Slide 4 text
RustのResult
Rustのエラーハンドリングで使われる型
成功を表し値を含むOk（T）
およびエラーを表しエラー値を含むErr（E）
の列挙型（代数的データ型）
正常値も異常値も両方運搬できる
エラーメッセージも運搬できる
Slide 5
Slide 5 text
Mitama.Result v2
https://github.com/LoliGothick/mitama-cpp-result
Resultの主要なAPIをほとんど再現したC++17のライブラリ
サポートコンパイラは
gcc-8.3
gcc-9.1
clang-7
clang-8
依存ライブラリ（Boost）
Hana, Variant, Optional, Format
Slide 6
Slide 6 text
クラス宣言
enum class mutability: bool {
mut = false,
immut = true,
};
template
class basic_result;
Slide 7
Slide 7 text
ミュータビリティ
ミュータビリティが型に埋め込まれいる（正直やりすぎ感ある）
内部で保持する値へのアクセスの制御に使われている
利用者はシノニムを利用する
/// alias template for immutable result
template
using result = basic_result;
/// alias template for mutable result
template
using mut_result = basic_result;
Slide 8
Slide 8 text
resultの構築
success, failureというfactoryクラスから作れる
関数からresultを返す場合も
result res(success{"foo"});
result res(failure{"foo"});
auto func(bool b) -> result {
if (b) {
return success{"foo"};
}
else {
return failure{"bar"};
}
}
Slide 9
Slide 9 text
おしらせ
以降
正常値の型をTとします
異常値の型をEとします
幅節約のためstd::stringのエイリアスとしてstrを使います
Slide 10
Slide 10 text
APIs
Observers
Slide 11
Slide 11 text
is_ok(), is_err()
それぞれ正常値・異常値を保持しているかをboolで返す
result res(success{"foo"});
res.is_ok(); // true
res.is_err(); // false
result res(failure{"foo"});
res.is_ok(); // false
res.is_err(); // true
Slide 12
Slide 12 text
ok(), err()
それぞれ正常値・異常値をboost::optionalで取得できる
result res(success{42});
res.ok(); // Some(42)
res.err(); // None
result res(failure{42});
res.ok(); // None
res.err(); // Some(42)
Slide 13
Slide 13 text
unwrap(), unwrap_err()
それぞれ正常値・異常値を取り出す
値を持っていなければ例外を送出する
result res(success{42});
res.unwrap(); // 42
res.unwrap_err(); // raise the exception `mitama::runtime_panic`
result res(failure{42});
res.unwrap(); // raise the exception `mitama::runtime_panic`
res.unwrap_err(); // 42
Slide 14
Slide 14 text
unwrap_or(T optb)
正常値を取り出す
値を持っていなければ指定された値optbを返す
result res(success{42});
res.unwrap_or(57); // 42
result res(failure{42});
res.unwrap_or(57); // 57
Slide 15
Slide 15 text
unwrap_or_else(F func)
F: E -> T
正常値を取り出す
異常値errを持っていなければfunc(err)を返す
遅延評価したいときに使う
引数なしで呼べる場合はなしで呼ぶ
result res(success{42});
res.unwrap_or_else([](int err){ return err.length(); }); // 42
result res(failure{42});
res.unwrap_or_else([]{ return 57; }); // 57
Slide 16
Slide 16 text
unwrap_or_default()
正常値を取り出す
値を持っていなければ指定された値を返す
正常型がデフォルトコンストラクション可能かアグリゲートである必要がある
result res(success{42});
res.unwrap_or_default(); // 42
result res(failure{42});
res.unwrap_or_default(); // 0
Slide 17
Slide 17 text
expect(string_view msg)
unwrap()の亜種で例外のメッセージに含める文字列を指定できりゅ
result res(failure{42});
auto ok = res.expect("foo");
// panicked at 'foo: failure(42)'
result res(failure{42});
auto ok = res.unwrap();
// panicked at 'called `result::unwrap()` on a value: failure(42)'
Slide 18
Slide 18 text
expect_err(string_view msg)
unwrap_err()の亜種で例外のメッセージに含める文字列を指定できりゅ
result res(success{42});
auto err = res.expect_err("foo");
// panicked at 'foo: success(42)'
result res(success{42});
auto err = res.unwrap_err();
// panicked at 'called `result::unwrap_err()` on a value: success(42)'
Slide 19
Slide 19 text
APIs
Monadic functions
Slide 20
Slide 20 text
map(op)
op: T -> U
正常値okを持っているとき場合、op(ok) を適用しresultとして返す
異常値を持っていた場合はそれをresultとして返す
result res(success{42});
res.map([](auto ok){ return ok + 1; }); // success(43)
result res(failure{42});
res.map([](auto ok){ return ok + 1; }); // failure(42)
Slide 21
Slide 21 text
map_err(op)
op: E -> F
異常値errを持っているとき場合、op(err) を適用しresultとして返す
正常値を持っていた場合はそれをresultとして返す
result res(success{42});
res.map_err([](auto err){ return err - 1; }); // success(42)
result res(failure{42});
res.map_err([](auto err){ return err - 1; }); // failure(41)
Slide 22
Slide 22 text
and_then(op)
op: T -> result
正常値を持っているとき、更に失敗する可能性のある関数へチェインする
result res(success{41});
res.and_then([](auto ok) -> result {
if ( ok % 2 == 0 )
return success{ok+1};
else
return failure{ok}; // ここを通る
}); // failure(41)
Slide 23
Slide 23 text
or_else(op)
op: E -> result
異常値を持っているとき、更に失敗する可能性のある関数へチェインする
result res(failure{42});
res.or_else([](auto ok) -> result {
if ( ok % 2 == 0 )
return success{ok+1};
else
return failure{ok};
}); // success(43)
Slide 24
Slide 24 text
参照のResult
Slide 25
Slide 25 text
参照のResult
result< T&, E& >
内部ではBoost.VariantとBoost.Optionalを利用
ライフタイム安全性を考慮してdanglingを導入（後述）
Slide 26
Slide 26 text
参照のResult
mutabilityは保持する値のアクセスでも伝搬する
str hoge = "foo";
mut_result res(success{hoge});
res.unwrap() = "bar";
// now hoge == "bar"
result res(success{hoge});
// Error: immutable result’s unwrap returns const reference
res.unwrap() = "bar";
Slide 27
Slide 27 text
as_ref()
Resultの参照を参照のResultに変換する
Resultが内部に持っている値のconstな参照を持つResultを作れる
result res(success{"bar"});
res.as_ref();
// new result, containing a const reference into the original
Slide 28
Slide 28 text
as_mut()
Resultのミュータブルな参照をミュータブルな参照のResultに変換する
Resultが内部に持っている値の参照を持つResultを作れる
mut_result res(success{"foo"});
res
.as_mut() // new result, containing a reference into the original
.unwrap() = "bar";
// now res contains a successful value "bar"
Slide 29
Slide 29 text
indirect()
要素型をデリファレンスした型の参照のResultを作る
result＜T*, E*＞ => result＜T, E＞
(T ok, E err) に対して { *ok, *err } という操作が要求されりゅ
using vec_iter = typename std::vector::iterator;
std::vector vec{1, 2, 3};
mut_result res(success{vec.begin()});
auto indirect = res.indirect(); // indirect: `mut_result`
auto& ref = indirect.unwrap();
ref = 42;
Slide 30
Slide 30 text
indirect_ok()
success型をデリファレンスした型の参照のResultを作る
result＜T*, E＞ => result＜T, E＞
(T ok) に対して { *ok } という操作が要求されりゅ
using vec_iter = typename std::vector::iterator;
std::vector vec{1, 2, 3};
mut_result res(success{vec.begin()});
auto indirect = res.indirect_ok(); // indirect: `mut_result`
auto& ref = indirect.unwrap();
ref = 42;
Slide 31
Slide 31 text
indirect_err()
failure型をデリファレンスした型の参照のResultを作る
result＜T, E*＞ => result＜T, E＞
(E err) に対して { *err } という操作が要求されりゅ
using vec_iter = typename std::vector::iterator;
std::vector vec{1, 2, 3};
mut_result res(failure{vec.begin()});
auto indirect = res.indirect_err(); // indirect: `mut_result`
auto& ref = indirect.unwrap();
ref = 42;
Slide 32
Slide 32 text
ライフタイムについて
右辺値のresultで内部を参照して場合、寿命切れている可能性がる
using vec = std::vector;
mut_result(success{vec{1, 2, 3}})
.as_mut()
.unwrap() // undefined behavior!
Slide 33
Slide 33 text
dangling
右辺値のresultの内部を参照した場合
dangling>（ dangle_ref ）ができる
using vec = std::vector;
mut_result(success{vec{1, 2, 3}})
.as_mut();
// returns `mut_result, dangle_ref>`
Slide 34
Slide 34 text
dangling::transmute()
参照が生きていることを確信する場合は明示的に中身を取り出す
using vec = std::vector;
vec v{1, 2, 3};
mut_result(success{v})
.unwrap() // `mut_result, dangle_ref>`
.transmute(); // get `vec&`
Slide 35
Slide 35 text
さいごに
Rustの？に相当する操作がないので使いにくい
match式もないし、作ったとしても網羅検査がないので心もとない
でもなにもないよりはだいぶまし
使ってみてフィードバックほしい