GreyCat Control Flow

Conditional

Classic if control flow is offered such as in the following example:

var x = true;
if (x) {
    // x is true
} else {
    // x is false
}

---

Basic Loop

For loops are centric in GreyCat. Built to allow its user to efficiently navigate through time and relationships between elements, the for loops present various facets depending on the type of element they are iterating on.

The basic form of the for loop uses a C-like syntax:

fn main() {
  // from 0 to 9, by step of 1
  for (var i = 0; i < 10; i++) {}
}

Nevertheless, this form is already powerful enough to allow iterating not only on numbers but also on time/duration.

fn main() {
  // from duration 0 to duration 10s step 1s
  for (var i = 0_s; i < 10_s; i = i + 1_s) {}

  // from time 0 to time 10 step 1us.
  for (var i = 0_time; i < 10_time; i = i + 1_us) {}
}

Advanced Loop

In GreyCat, some types can be used as iterators therefore allowing for..in loops to iterate over the elements of that iterators. In this case, the loop presents several particularities and options.

• For loops always have two iteration variables on types. They can be named freely by the developer for easy contextual reference, or replaced by _ if not used (but they are expected).
• Some types support the use of bounds to customize the range of the iteration. Bounds can specify a sub-range of elements to iterate on, and/or the direction of the iteration (forward or backward). Bounds are specified using square brackets [, ], as in [<from>..<to>] where from and to are beginning and end indexes for the loop.
  If from > to, navigation will be backward.
• Some types allow for skipping some elements. This can be specified by using the keyword skip <n> with n the number of elements to skip after each iteration.
• Most types support a limit <n> specifier to limit the total number of iterations to n. The loop stops when either the limit is reached, or there is no more element.

The most complex form of for..in statement is represented by:

fn main() {
  var countries = ["luxembourg", "USA", "Germany", "France", "Netherlands"];
  for (a, b in countries[0..3] skip 2 limit 5) {}
}

This would iterate over countries on the range [0..3], skipping 2 elements between each iteration (0, 3, 6, …), and limiting the number of iterations to 5 elements (in this case, only 2 iterations happen, so the limit is not reached).

For on Arrays

For loops can be used to iterate over arrays. In this configuration, the for loop will offer two iteration variables:

1. The first will bear the index in the array of the current iteration
2. The second the value.

These parameters can be named freely by the developer, or replaced by _ if not used.

fn main() {
  var countries = ["Luxembourg", "France", "Germany"];

  for (index, value in countries) {}

  for (_, value in countries) {}

  for (index, _ in countries) {}
}

Specifying range

The iteration can also be controlled using a range. To this end, from and to indexes can be specified in braces after the array, with the general form Array[<from>..<to>].
When iterating forward, the to bound can be omitted to indicate that the iteration shall continue until the last element.

fn main() {
  var countries = ["Luxembourg", "France", "Germany", "USA", "Canada"];

  // from first to last, all elements
  for (idx, value in countries) {}

  // identical to previous, but with 'from' and 'to' defined
  for (idx, value in countries[0..4]) {}

  // identical to previous, but with omitted 'to'
  for (idx, value in countries[0..]) {}

  // first to last, excluding first
  for (idx, value in countries]0..4]) {}

  // first to last, excluding last
  for (idx, value in countries[0..4[) {}

  // from index 1 to index 2 (inclusive)
  // also note that ranges are not limited to literals, and also accept expressions
  var to = 1 + 1;
  for (idx, value in countries[1..to]) {}
}

Arrays can also be iterated backwards by reversing the bounds.

fn main() {
  var countries = ["Luxembourg", "France", "Germany", "USA", "Canada"];

  // from last to first, all elements
  for (idx, value in countries[4..0]) {}

  // index 2 to index 1 (inclusive)
  for (idx, value in countries[2..1]) {}
}

Bounds from and to must both, and in all cases, be strictly between 0 and Array.size()-1 When navigating backwards, the to bound cannot be omitted. If not specified, it will iterate forward.

For on Maps

For loops can iterate natively on Maps. In this configuration, the for loop will offer two iteration variables:

1. The first will bear the key of the current element
2. The second its value.

These parameters can be named freely by the developer, or replaced by _ if not used.

fn main() {
  var capitals = Map<String,String>{};

  capitals.set("Luxembourg", "Luxembourg");
  capitals.set("France", "Paris");
  capitals.set("Germany", "Berlin");

  for (key, value in capitals) {}

  for (_, value in capitals) {}

  for (key, _ in capitals) {}
}

For loops on Maps do not support bounds, nor skip.

For on TimeSeries

For loops can iterate natively on TimeSeries. In this configuration, the for loop will offer two iteration variables:

1. The first will bear the time of the current element
2. The second its value.

fn main() {
  var sensorData = nodeTime<float>{};

  sensorData.setAt(time::new(1, DurationUnit::seconds), 0.5);
  sensorData.setAt(time::new(2, DurationUnit::seconds), 0.7);
  sensorData.setAt(time::new(3, DurationUnit::seconds), 1.2);
  sensorData.setAt(time::new(4, DurationUnit::seconds), 1.5);
  sensorData.setAt(time::new(5, DurationUnit::seconds), 2.8);

  for (time, value in sensorData) {}

  var from = time::new(1, DurationUnit::seconds);
  var to = time::new(2, DurationUnit::seconds);
  for (time, value in sensorData[from..to]) {}

  for (time, value in sensorData limit 2) {}

  for (time, value in sensorData skip 1) {}

  // bounds don't need to be limited by TimeSeries data
  to = time::new(5, DurationUnit::seconds);
  for (time, value in sensorData[from..to] skip 1 limit 2) {}
}

With TimeSeries, the bounds must be specified in time.

For to sample TimeSeries

A special form of for loops makes it possible to sample data from a TimeSeries by specifying the requested frequency.
In this configuration the for loop has five iteration variables:

1. The time of the iteration
2. The time of the previous closest element in the series
3. The value of the previous closest element in the series
4. The time of the next closest element in the series
5. The value of the next closest element in the series

This form supports only bounds.

fn main() {
    var sensorData = nodeTime<float>{};

    sensorData.setAt(time::new(1, DurationUnit::seconds), 0.5);
    sensorData.setAt(time::new(2, DurationUnit::seconds), 0.7);
    sensorData.setAt(time::new(3, DurationUnit::seconds), 1.2);
    sensorData.setAt(time::new(4, DurationUnit::seconds), 1.5);
    sensorData.setAt(time::new(5, DurationUnit::seconds), 2.8);

    var from = time::new(0, DurationUnit::seconds);
    var to = time::new(10, DurationUnit::seconds);
    for (itTime: time,
      prevElemTime: time,
      prevElemVal: any,
      nextElemTime: time,
      nextElemVal: any in sensorData[from..to]
      sampling 1_s) {
      //...
    }
}

The sampling does not aggregate values in case of down-sampling. You might want to consider using TimeWindow in conjunction to aggregate.

While loop

GreyCat provides C-like while, and do-while to conditionally loop.

while loops are used to execute a block of code, while a condition remains true. Because it is a while, the condition is evaluated pre-iteration.

fn main() {
  var i = 0;
  while (i < 10) {
    i++;
  }
  Assert::equals(i, 10);
}

Do While Loop

do-while loops are used to execute a block of code, while a condition remains true. In opposition to while loops, here the condition is evaluated post-iteration.

fn main() {
  var i = 0;
  do {
    i++;
  } while (i < 10);
  Assert::equals(i, 10);
}

Break

The break instruction can be used in any for loop to exit the current execution flow (i.e.: exit the loop and continue the remainder of the program.)

At (time conditional)

The at keywords is used in GreyCat as a control-flow to specify a contextual time of execution for the associated block statement. It is allowed to nest at statements.

fn main() {
  at (time::new(1, DurationUnit::seconds)) {
    // the execution context is 1 second after `1970-01-01T00:00:00`
    Assert::equals(time::parse("1970-01-01T00:00:01",null), time::current());
  }

  at (3_time) {
    // the execution context is 3 microseconds after `1970-01-01T00:00:00`
    Assert::equals(time::parse("1970-01-01T00:00:00.000003+00:00",null), time::current());
  }
}

Type Checks (Is)

GreyCat provides a binary operator named is to test the type of a value.

fn main() {
  Assert::isTrue(3 is int);
  Assert::isTrue(3.0 is float);
  Assert::isTrue(3_s is duration);
  Assert::isTrue(3_time is time);
  Assert::isTrue("3" is String);
  //...
}

This also allows you to check your own defined types

type Foo{};

fn main(){
  var foo = Foo{};

  Assert::isTrue(foo is Foo);
}

Try-Catch

Try-catch blocks allow for tentatively recover from an Error in the execution.
These blocks are provided to catch anticipated errors, and present the user with a reason why his execution has failed, while maintaining the execution of the main program.

This could be useful to prevent for instance divisions by 0 to have your main loop exiting, in case the denominator is dynamically loaded from the data.

fn willFail() {
  throw "not implemented yet";
}

fn main() {
  try {
    willFail();
  } catch (e) {
    error("Something went wrong: ${e}");
  }
}