Cigma — User Guide

$/mynamespace {
  $ myconst:int = 10;
  $ myfunc:(a:int, _:bool) -> :{ $b: = 10, -> myconst + a * b };
  $:myclass{ $.x, .y:int };
};

# this is a comment
# spanning two lines

$ main:() -> :!int
{  (1)
  #-> 1;
   (2)
  -> 0;
};

$ n:int = [/std:numeric_limits[:int] max()];

$[:T]:Is {
  $[:Arg].extract:(arg:^Arg) -> :!Arg {
    [assert([:T == :~volatile~&Arg])];  (1)
    -> ^[:Arg]arg;
  };
};

$[:T] is:Is[:T]<[];  (2)

/std cout << [:int == :/std:int32_t] << "\n"';  (1)
/std cout << [:int != :/std:int64_t] << "\n"';  (2)

[assert([:~~int == :!int])];  (1)
[assert([:~~&int == :!int])];  (2)
[assert([:&~&int == :&int])];  (3)
[assert([:~& &int == :int])];  (4)
[assert([:~&^int == :!int])];  (5)
[assert([:~&!int == :!int])];  (6)

$:Car { $.accelerate:() -> { /std cout << "wroom\n" } };  (1)

$:RoadRunner { $.accelerate:() -> { /std cout << "meep meep\n" } };  (2)

$:Plane {
  $.rate:size_t;
  $.accelerate:() -> { /std cout << "wh" << :/std:string<(.rate, "o"') << "sh\n" }
};

$/lib
{  (3)
  $:Motorcycle { $.accelerate:() -> { /std cout << "brrrrrr\n" } };
};

$:Vehicle? { $.accelerate:() -> };  (4)

$ makeVehicle:(name:&/std:string) -> :!Vehicle
{
  switch name {
    "car" { -> :Car<() };
    "plane" { -> :Plane<{4} };
    "roadrunner" { -> :RoadRunner<() };
    _ { exit(1); };  (5)
  };
};

$vehicles:!/std:vector[:!Vehicle];
vehicles.push_back(makeVehicle("car"));
vehicles.push_back(makeVehicle("plane"));
vehicles.push_back(makeVehicle("roadrunner"));
vehicles.push_back(:!/lib:Motorcycle<());

for $..vehicle:& = vehicles {
  vehicle.accelerate();
};

$:A { $.x:!double };
$ pa:!'A = nullptr;
$ y:![(pa'.x)];  (1)
$ z:[((pa'.x))] = y;  (2)

$[:T, :U] add:(t:T, u:U) -> :[(t + u)]  (3)
{
  -> t + u;
};

$ main:() -> :!int
{
  $i:int = 33;
  $j:[(i)] = i * 2;

  $f: = _:(a, b:int) -> :int { -> a * b };

  $g:[(f)] = f;  (4)
  $fr: = f(2, 2);
  $gr: = g(3, 3);

  -> 0;
};

$:Color = |:{ red, green, blue };
$r:Color = red;

$:Foo = |:{
  a, b, c: = 10;
  d, e: = 1;
  f, g: = f + c;
};

$:smallenum = |:int16_t{ a, b, c };

$|:{ a, b, c: = 0, d: = a + 2 };

$:Color |:{ red, green: = 20, blue };

$:Handle |:uint32_t{ Invalid: = 0 };

$[:T, :A]:vector {};
$[:T]:Alloc {};
$[:T]:Vec = :vector[:T, :Alloc[:T]];
$ v:Vec[:int];  (1)

$[:_..]:void_tpl = :void;
$[:T] f:() -> :void_tpl[:'T:foo] {?};

f[:int]();  (1)

$/foo {
  $/bar/baz {
    $ qux:int = 42;
  };
};

$/fb = /foo/bar;

$/fbz = /fb/baz;

/std cout << /fbz qux << /std endl;

$ a:.(2) int <{1, 2};
${x, y}: = a;
${xr, yr}:& = a;

$ myset:!/std:set[:!/std:string];
if ${iter, success}: = myset.insert("Hello"); success {
  /std cout << "insert is successful. The value is " << /std quoted(iter') << "\n"';
} else {
  /std cout << "The value " << /std quoted(iter') << " already exists in the set\n";
};

$ mymap:!/std:map[:/std:string, :float];
for $..{key, value}:^ = mymap {
  ...
};

$ x:float<{};
$ y:!char<{};
$ z:int<{};
$ tpl:.[:&float, :^char, :int]<{x, ^y, z};  (1)
${a, b, c}:& = tpl;

$ func:(x<{3}, y<{4}:int) -> {};

func();
func(<(), 8);
func(<{}, 9);

$:S2 {
  $.f:(i:int) -> {
    _:() \(&) {};           (1)
    _:() \(&, i) {};        (2)
    _:() \(&, i&) {};       (3)
    _:() \(&, this) {};     (4)
    _:() \(&, this, i) {};  (5)
  };
};

$x:!int = 4;
$y: = (_:() -> :int \(r& = x, x = x + 1) {
  r += 2, -> x * x;
})();  (1)

$ make_function:(x:&int) -> :{
  -> _:() \(&) { /std cout << x << /std endl };
}

$i:!int = 3;
$f: = make_function(i);
i = 5;
f();  (1)

$ use:(x, y:int) -> {
  ...
}

$:S {
  $.x:!int = 0;
  $.f:()! -> {
    $i:!int = 0;
    $l1: = _:() \(i, .x) { use(i, .x) };  (1)
    $l2: = _:() \(i, x = .x) { use(i, x) };  (2)
    i = 1, .x = 1, l2();  (3)
    $l3: = _:() \(i, x& = .x) { use(i, x) };  (4)
    i = 2, .x = 2, l3();  (5)
  };
};

$ gcd:[a, b:int] -> :int {
  -> (if b == 0 {a} else {gcd(b, a % b)});
};

$ i:int = [gcd(11, 121)];  (1)

$ a: = 11;
$ b: = 121;
$ j:int = gcd(a, b);  (2)

$i:int = 2;
if i > 2 {
  /std cout << i << " is greater than 2" << /std endl;
} else {
  /std cout << i << " is not greater than 2" << /std endl;
};

$ m:!/std:map[:int, :!/std:string];
$ mx:!/std:mutex;
$ shared_flag:!bool;
$ demo:() -> :int {
  if $it: = .m.find(10), (it != .m.end()) {
    -> it'.second.size();
  };
  if $buf:.(10)!char, /std fgets(buf, 10, stdin) {
    .m.(0) += buf;
  };
  if $lock:/std:lock_guard<(.mx), shared_flag {
    shared_flag = false;
  };
  if $s:!int, $count:int = scanf("%d", &s) {
    if $keywords: = <{"if", "for", "while"};
     /std any_of(keywords.begin(), keywords.end(),
      _:(kw:'char) \(s&) { -> s == strlen(kw) }) {
      /std cerr << "Token must not be a keyword" << /std endl;
    };
  };
};

$[:T] get_value:(t:T) -> :{
  if [/std is_pointer_v[:T]] {
    -> t';  (1)
  } else {
    -> t;  (2)
  };
};

for $i:! = 0, i < 10, ++i {
  /std cout << i << " "';
};
/std cout << "\n"';

$ v:/std:vector[:!int]<{3, 1, 4, 5, 9};
for $iter:! = v.begin(); iter != v.end(); ++iter {
  /std cout << iter' << " "';
};
/std cout << "\n"';

$ v:/std:vector[:!int]<{1, 2, 3, 4, 5};
for $..i:&int = v {  (1)
  /std cout << i << " "';
};
/std cout << "\n"';
for $..i: = v {  (2)
  /std cout << i << " "';
};
/std cout << "\n"';
for $..i:^ = v {  (3)
  /std cout << i << " "';
};
/std cout << "\n"';
$ cv:& = v;
for $..i:^ = cv {  (4)
  /std cout << i << " "';
};
/std cout << "\n"';
for $..n:int<{0, 1, 2, 3, 4, 5} {  (5)
  /std cout << n << " "';
};
/std cout << "\n"';

$n: = 5;
switch n {
  0 { /std cout << "zero" };
  1...10 { /std cout << "between 1 and 10" };
  | { /std cout << "other" };
};

$n: = 0;
switch n {
  | 1 | 2 | 3 {
    /std cout << "small positive";
  } @{fallthrough};
  | {
    /std cout << "don't care";
  };
};

$s: = "baz"s;
switch s {
  "foo" { /std cout << "got foo" };
  "bar" { /std cout << "got bar" };
      | { /std cout << "don't care" };
};

$p:.[:int, :int] <{1, 2};
switch p {
  ${0,   0} { /std cout << "on origin" };
  ${0,   _} { /std cout << "on y-axis" };
  ${_,   0} { /std cout << "on x-axis" };
  ${$x, $y} { /std cout << x << ", " << y };
};

$v:|[:int, :float] = 84;
switch v {
  .[:int]$i { /std cout << "got int:" << i };
  .[:float]$f { /std cout << "got float: " << f };
};

$a:.(:?) = 48;
switch a {
  .(:int)$i { /std cout << "got int:" << i };
  .(:float)$f { /std cout << "got float: " << f };
};

$v:|[:int, :int]<(.[0] = 5);
switch v {
  .[0]$i0 { /std cout << "got first int:" << i0 };
  .[1]$i1 { /std cout << "got second int: " << i1 };
};

switch t {
  [:int] { /std cout << "got int:" << t };
  [:float] { /std cout << "got float: " << t };
};

$:Shape { $>:() @{default} };
$:Circle { +$:Shape, $.radius:double };
$:Rectangle { +$:Shape, $.width, .height:double };

$ get_area:(shape:&Shape) -> :double {
  -> (switch shape {
    (:Circle)${$r} { 3.14 * r * r };
    (:Rectangle)${$w, $h} { w * h };
  });
};

$:Player{
  $.name:!/std:string, $.hitpoints, .coins:!int = 0;
  $.ni:(_:int) -> :{ -> .name };
};
$p:!Player;
switch (p) {
  .{.hitpoints ~ 1} { /std cout << "Almost destroyed" };
  .{.hitpoints ~ 0...9, .coins ~ 10} { /std cout << "Need hints" };
  .{.coins ~ 10} { /std cout << "Get more hitponts" };
  .{.hitpoints ~ 10}$e { /std cout << "Get more ammo to " << e.name };
  .{.ni(0) ~ $n} && n == "The Bruce Dickinson" {
    /std cout << "More cowbell";
  };
};

$:Color = |:{Red, Black};
$[:T]:Node {
  $.color:!Color;
  $.lhs:!/std:shared_ptr[:!Node];
  $.value:!T;
  $.rhs:!/std:shared_ptr[:!Node];
  $.balance:()! -> {
    this = (this ~ {
      ${Black, ?'${Red, ?'${Red, $a, $x, $b}, $y, $c}, $z, $d} {
        :Node<{Red, /std make_shared[:!Node](Black, a, x, b),
                 y, /std make_shared[:!Node](Black, c, z, d)};
      };
      ${Black, ?'${Red, $a, $x, ?'${Red, $b, $y, $c}}, $z, $d} {
        :Node<{Red, /std make_shared[:!Node](Black, a, x, b),
                 y, /std make_shared[:!Node](Black, c, z, d)};
      };
      ${Black, $a, $x, ?'${Red, ?'${Red, $b, $y, $c}, $z, $d}} {
        :Node<{Red, /std make_shared[:!Node](Black, a, x, b),
                 y, /std make_shared[:!Node](Black, c, z, d)};
      };
      ${Black, $a, $x, ?'${Red, $b, $y, ?'${Red, $c, $z, $d}}} {
        :Node<{Red, /std make_shared[:!Node](Black, a, x, b),
                 y, /std make_shared[:!Node](Black, c, z, d)};
      };
      | { this };
    });
  };
};