Objects

An object in GreyCat is an instance of a defined type.

Types are essential units to define GreyCat data structure.

Types define aggregated typed fields into a named type, later instantiated as an Object. It is a very similar concept to Classes used in other Object Oriented programming languages.

Type definition

Here is an example of a type in GreyCat:

type Country {
  name: String;
  phoneCode: int;
  location: geo;
}

type City {
  name: String;
  population: int?;
}

• Type Country has 3 attributes: name, phoneCode, location
• Type City has 2 attributes: name, population
• Population is of type int?. The ? stands for nullable (can be null if we don’t know the population of a city)
• Population is a non-mandatory field
• In GreyCat we can define several types in the same file

---

Type instance

An object in GreyCat is an instance of a defined type.

Let’s create luxembourg object, an instance of type Country:

fn main() {
    var luxembourg = Country {
        name: "Luxembourg",
        phoneCode: 352,
        location: geo{49.8153, 6.1296},
    };
    println(luxembourg);
    println(luxembourg.phoneCode);
}

greycat run
# {"_type":"project.Country","name":"Luxembourg","phoneCode":352,"location":{"_type":"core.geo","lat":49.815300005,"lng":6.129600001}}
# 352

• Objects in greycat are compatible with JSON format
• Objects are not persistent => Meaning they exist in RAM only (not stored)

---

Static attributes

Objects can hold static attributes for default values or parameters. Example:

type Country {
    static unknown_country_name: String = "Unknown Country";

    name: String;
    phoneCode: int;
    location: geo;
}

fn main() {
    println(Country::unknown_country_name);
}

• Static attributes are the only attributes that can be given a default value in the type definition
• Static attributes can be accessed through the type name and the :: operator (Country::unknown_country_name)
• Normal attributes can be accessed through an instance and the . operator (luxembourg.name)

---

Private attributes

Keyword private is now available to protect type attributes from external mutations. The following example illustrates the semantics associated to the keyword.

Essentially, only local methods are allowed to mutate private attributes.

type Foo {
  private x: int;

  fn set(x: int) {
    this.x = x; // correct
  }
}

fn main() {
  var foo = Foo { x: 5 };
  foo.set(100);
  Assert::equals(foo.x, 100); // allowed to read private attribute

  // foo.x = 42; // this will raise an error
}

Protected field names

If needed, it is also possible to use String protection " " to include special characters withing field names.

type A {
    "my field &": String;
}

fn main(){
  var a = A {
     "my field &": "hello"
  };
  pprint(a."my field &"); // pretty print
}

---

Decorator on attributes

Precision

The @precision decorator allows you to constrain how many values float will store, this will save you a lot of storage space if you only require a certain precision.

type Data {
  @precision(0.01)
  myFloat: float;
}

In the above code myFloat will only store two values after the comma.

Volatile

This is primarily intended to only be used for frontend GUI, intermediate parsers (Csv, Json, Text), anything that is not to be stored on the graph.

@volatile
type Foo {
  bar: String;
}

@volatile
type Foo {
  /* ... */
  baz: String; // new non null field, No need to remove the state anymore
}

---

Functions on types

Functions on types can be static, or non static

type CountryB {
    name: String;
    location: geo;

    fn print() {
        println("Hello from ${this.name}, location is latitude: ${this.location.lat()}, longitude: ${this.location.lng()}");
    }
}
fn main() {
    var luxembourg = CountryB { name: "luxembourg", location: geo{49.815300005, 6.129600001} };
    luxembourg.print();
}

greycat run
# Hello from Luxembourg, location is latitude: 49.815300005, longitude: 6.129600001

---

Enum

Enums are list of values known at compile-time that cannot be extended dynamically. They are very useful tools when list of options are part of a domain definition. They are declared with the keyword enum and the fields may or may not contain primitives.

enum DaysOfTheWeek {
    monday("Monday");
    tuesday("Tuesday");
    wednesday("Wednesday");
    thursday("Thursday");
    friday("Friday");
    saturday("Saturday");
    sunday("Sunday");
}
enum TransactionChannel {
    web(0);
    mobile(1);
    other(2);
}
fn main() {
    var day = DaysOfTheWeek::monday; // same accessor as the static ::
}

---

Generic parameters

GreyCat supports up to two generic parameters for classes. As an example, the type Map from the standard library is defined as follows:

native type Map<K, V> {
  // ...
  native fn get(k: K): V;
  // ...
}

The generic parameters can be specialized during instance creation such as:

var m = Map<String, float>{};
m.get("my_key");

---

Inheritance with abstract types

GreyCat supports a simplified model of inheritance using the keyword extends. The child inherits all attributes and functions from its parent type.

Beware that the parent needs to have the keyword abstract in order to be extended, such as:

abstract type Animal {
    age: int;

    fn eat() {
        println("Animal is eating");
    }
}

type Dog extends Animal {
    breed: String;
}

fn main() {
    var dog = Dog {
        age: 10,
        breed: "Golden Retriever"
    };
    dog.eat();
}

GreyCat does not allow the child to override the parents functions, you can however define abstract functions on the parent, be advised these will become required on all Children

abstract type Animal {
    abstract fn makeSound();
}

type Dog extends Animal {
    fn makeSound() {
        println("Woof");
    }
}

---

Composition

GreyCat supports type composition such as:

abstract type Job {
  salary: int;
}

type Programmer extends Job {}

type Person {
  job: Job;
}

fn main() {
  var programmer = Programmer {
    salary: 1000
  };
  var person = Person {
    job: programmer
  };
}

---

Dot Operator

Used to access attributes inside an object:

type CountryC {
    name: String;
}

fn main() {
  var country: CountryC = CountryC { name: "Luxembourg" };
  Assert::equals(country.name, "Luxembourg");
}

---

Static Operator (Scope resolution operator)

Useful when accessing static methods:

abstract type CountryService {
    static fn resolveCountry(nCountry: node<String>): String {
        return *nCountry;
    }
}

fn main() {
  var nCountry = node<String>{"Luxembourg"};

  // access the static method 'resolveCountry' from the 'CountryService' and validate its content
  Assert::equals(CountryService::resolveCountry(nCountry), "Luxembourg");
}