| 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; } } } ``` |