| C++ | P0095R1 | This proposal |
|---|---|---|
| + +```c++ +struct set_score { + std::size_t value; +}; + +struct fire_missile {}; + +struct fire_laser { + unsigned intensity; +}; + +struct rotate { + double amount; +}; + +struct command { + std::variant< + set_score, + fire_missile, + fire_laser, + rotate > value; +}; +``` + + | + +```c++ +lvariant command { + std::size_t set_score; + std::monostate fire_missile; + unsigned fire_laser; + double rotate; +}; +``` + + | + +```carbon +choice command { + set_score(u64), + fire_missile, + fire_laser(u32), + rotate(f64) +} +``` + + |
| C++ | P0095R1 | This proposal |
|---|---|---|
| + +```c++ +namespace { +struct Output { + std::ostream& operator()(std::ostream& stream, const set_score& ss) const { + return stream << "Set the score to " << ss.value << ".\n"; + } + std::ostream& operator()(std::ostream& stream, const fire_missile&) const { + return stream << "Fire a missile.\n"; + } + std::ostream& operator()(std::ostream& stream, const fire_laser& fl) const { + return stream << "Fire a laser with " << fl.intensity << " intensity.\n"; + } + std::ostream& operator()(std::ostream& stream, const rotate& r) const { + return stream << "Rotate by " << r.degrees << " degrees.\n" + } +}; +} + +std::ostream& operator<<(std::ostream& stream, const command& cmd) { + return std::visit(std::bind(Output(), std::ref(stream), std::placeholders::_1), + cmd.value); +} +``` + + | + +```c++ +std::ostream& operator<<(std::ostream& stream, const command& cmd) { + return inspect(cmd) { + set_score value => + stream << "Set the score to " << value << ".\n" + fire_missile _ => + stream << "Fire a missile.\n" + fire_laser intensity => + stream << "Fire a laser with " << intensity << " intensity.\n" + rotate degrees => + stream << "Rotate by " << degrees << " degrees.\n" + } +} +``` + + | + +```carbon +impl command as Printable { + fn Print[me: Self](stream: Cpp.std.ostream*) { + match (me) { + case .set_score(value: u64) => { + stream->Print("Set the score to {0}.\n", value); + } + case .fire_missile => { + stream->Print("Fire a missile.\n"); + } + case .fire_laser(intensity: u32) => { + stream->Print("Fire a laser with {0} intensity.\n", intensity); + } + case .rotate(degrees: f64) => { + stream->Print("Rotate by {0} degrees.\n", degrees); + } + } + } +} +``` + + |
| C++ | P0095R1 | This proposal |
|---|---|---|
| + +```c++ +enum color { red, yellow, green, blue }; +``` + + | + +```carbon +choice color { red, yellow, green, blue } +``` + + | |
| + +```c++ +const Vec3 opengl_color = [&c] { + switch(c) { + case red: + return Vec3(1.0, 0.0, 0.0); + break; + case yellow: + return Vec3(1.0, 1.0, 0.0); + break; + case green: + return Vec3(0.0, 1.0, 0.0); + break; + case blue: + return Vec3(0.0, 0.0, 1.0); + break; + default: + std::abort(); + }(); +``` + + | + +```c++ +const Vec3 opengl_color = + inspect(c) { + red => Vec3(1.0, 0.0, 0.0) + yellow => Vec3(1.0, 1.0, 0.0) + green => Vec3(0.0, 1.0, 0.0) + blue => Vec3(0.0, 0.0, 1.0) + }; +``` + + | + +```carbon +// Carbon has neither expression-match nor lambdas yet, +// so this can't easily be done in line. +fn GetOpenGLColor(c: color) -> Vec3 { + match (c) { + case .red => { return Vec3.Make(1.0, 0.0, 0.0); } + case .yellow => { return Vec3.Make(1.0, 1.0, 0.0); } + case .green => { return Vec3.Make(0.0, 1.0, 0.0); } + case .blue => { return Vec3.Make(0.0, 0.0, 1.0); } + } +} +let opengl_color: Vec3 = GetOpenGLColor(c); +``` + + |
| C++ | P0095R1 | This proposal |
|---|---|---|
|
+
+```c++
+struct expression;
+
+struct sum_expression {
+ std::unique_ptr |
+
+```c++
+lvariant expression;
+
+struct sum_expression {
+ std::unique_ptr | + +```carbon +choice expression { + sum(UniquePtr(expression), UniquePtr(expression)), + literal(i32), + var: String +} + +// This assumes that UniquePtr provides the matching +// functionality described in #2187. +fn simplify(exp: expression) -> expression { + match (exp) { + case .sum(.PtrTo(.literal(0)), .PtrTo(rhs: expression)) => { + return simplify(rhs); + } + case .sum(.PtrTo(lhs: expression), .PtrTo(.literal(0))) => { + return simplify(lhs); + } + case .sum(.PtrTo(lhs: expression), .PtrTo(rhs: expression)) => { + return expression.sum(MakeUnique(simplify(lhs)), + MakeUnique(simplify(rhs))); + } + default => { return exp; } + } +} +``` + + |
| C++ | P0095R1 | This proposal |
|---|---|---|
| + +```c++ +struct player { + std::string name; + int hitpoints; + int lives; +}; +``` + + | + +```carbon +class player { + var name: String; + var hitpoints: i32; + var lives: i32; +} +``` + + | |
| + +```c++ +void takeDamage(player &p) { + if(p.hitpoints == 0 && p.lives == 0) + gameOver(); + else if(p.hitpoints == 0) { + p.hitpoints = 10; + p.lives--; + } + else if(p.hitpoints <= 3) { + p.hitpoints--; + messageAlmostDead(); + } + else { + p.hitpoints--; + } +} +``` + + | + +```c++ +void takeDamage(player &p) { + inspect(p) { + {hitpoints: 0, lives:0} => gameOver(); + {hitpoints:hp@0, lives:l} => hp=10, l--; + {hitpoints:hp} if (hp <= 3) => { hp--; messageAlmostDead(); } + {hitpoints:hp} => hp--; + } +} +``` + + | + +```carbon +fn takeDamage(p: player*) { + match (*p) { + case {.hitpoints = 0, .lives = 0, _} => { gameOver(); } + case {.hitpoints = 0, _} => { p->hitpoints = 10; --p->lives; } + case {.hitpoints = hp: i32, _} if hp <= 3 => { + --p->hitpoints; + messageAlmostDead(); + } + default => { --p->hitpoints; } + } +} +``` + + |