Nullable

The ability to denote things as null is an important aspect of programming. The following defines the concept and how to handle null in GreyCat.

Nullable types

From time to time, values can be null. This however often breaks the processing flow by requesting explicit null checking, default value management, etc. Every type in GreyCat is non-null by default, to get its nullable counterpart you need to add the character ? after the type identifier.

To indicate that a type is nullable, add the ? character after the type identifier:

// `p` can be anything but cannot be `null`
fn anything_but_null(p: any) {}

// `p` can be anything including `null`
fn anything(p: any?) {}

// `p` can either be a `String` or `null`
fn stringOrNull(p: String?) {}

// `p` can only be `String` and never be `null`
fn strictString(p: String) {}

fn main() {
  anything_but_null(true);

  anything(42);
  anything(null);
  anything("GreyCat");

  stringOrNull("GreyCat");
  stringOrNull(null);

  strictString("DataThings");
  // strictString(null); // this will fail since null is not accepted as parameter, COMMENT/REMOVE THIS LINE to successfully compile.
}

Nullable Optional chaining

Calls to access attributes or function on objects can be protected by placing a ? right after the variable that can be null. In the event the protected variable is effectively null, the remaining of the expression is not executed, and the expression value is null, as presented in the following example.

type City{sensors:any?;}

fn main() {
  var city = City{ sensors: null };

  Assert::isNull(city.sensors?.size());
}

Nullable Arrays access

Accesses to nullable arrays can also be protected by using ?.

fn main() {
  var cities: Array? = null;
  Assert::isNull(cities?[0]);
  cities = ["Luxembourg"];
  Assert::equals(cities[0], "Luxembourg");
}

Nullable Iterators

Using for…in over an optional iterator can also be protected by added a ?:

fn main() {
  var cities: Array? = null;
  var count = 0;

  for (idx, value in cities?[0..]) {
    count++;
  }

  Assert::equals(count, 0);
}

Nullish coalescing operator

If you want to provide for a default value in place of null, you can do so by appending ?? to the nullable expression and provide the default value.

fn main() {
  var city = City{ sensors: null };
  var size = city.sensors?.size() ?? 0;
  Assert::equals(0, size);
}

The previous code snippet is essentially syntactic sugar for:

fn main() {
  var city = City{ sensors: null };
  var size;
  if (city.sensors == null) {
    size = 0;
  } else {
    size = city.sensors.size();
  }
  Assert::equals(0, size);
}

Non-null Assign

fn main() {
  var a: String? = null;
  var b = "initial value";

  a ?= "the value of a";
  b ?= "this is not gonna be assigned"; // because 'b' is already not null

  Assert::equals(a, "the value of a");
  Assert::equals(b, "initial value");
}

Non-null Assertion

Similar to Typescript’s !, in GreyCat it’s !!, it only affects the LSP, and has no bearing on GreyCat code execution.

var data: nodeIndex<String,int>;

fn process() {
  // item is of type int? since it can be null, !! will force item to be of type int.
  var item = data.get("key")!!;

  // Any usage of item henceforth can not be guaranteed to no break code execution.
}

In most cases using !! is a sign of a code-smell. In the previous example, a null check would be a more robust solution, but for the sake of ease of prototyping fast it is useful to by-pass the analysis hence its presence in GreyCat.