Helper functions

GreyCat offers some helper functions on types as well as for debugging code

Converting String to Numbers

fn main() {
    println(parseNumber("123")); // 123
    println(parseNumber("12.3")); // 12.3
}

Cloning objects

Cloning is useful when dealing with Ownership issues, in Maps or Objects. It is a deep clone, meaning objects within objects will also be cloned.

type MyType {
    name: String;
    items: Array<int>;
}
fn main() {
    var original = MyType{
        name:"foo",
        items: Array<int>{1,2,3}
    };
    var copy  = clone(original);
    copy.name = "bar";
    copy.items = Array<int>{4,5,6};

    println(original); // MyType{name:"foo",items:Array<int>{1,2,3}}
    println(copy); // MyType{name:"bar",items:Array<int>{4,5,6}}
}

Type native functions

type comes with a set of native functions, some static, others directly accessible to any custom type.

type MyType {
    name: String;
    items: Array<int>;
}
fn main() {
    var original = MyType{
        name:"foo",
        items: Array<int>{1,2,3}
    };

    // static type::of() to access the type of an object 
    Assert::isTrue(type::of("123") == String);
    Assert::isTrue(type::of(original) == MyType);

    // Access the number of fields of any type
    println(Gaussian.nb_fields()); // 5
    println(MyType.nb_fields()); // 2

    // Get list of fields of any type
    println(Gaussian.fields()); // Array<field>{util::Gaussian::sum,util::Gaussian::sumsq,util::Gaussian::count,util::Gaussian::min,util::Gaussian::max}
    println(MyType.fields()); // Array<field>{project::MyType::name,project::MyType::items}

    // Get fields by their name
    println(Gaussian.field_by_name("min")); // util::Gaussian::min
    println(MyType.field_by_name("name")); // project::MyType::name

    // Get the positon of fields by name
    println(Gaussian.field_offset_by_name("min")); // 3
    println(MyType.field_offset_by_name("name")); // 0

    // overwriting fields of object given another source object, optionally clone to transfer ownership
    var source = MyType{
        name: "bar",
        items: Array<int>{4,5,6}
    };
    type::fields_set_from(original,source,true);
    println(original); // MyType{name:"bar",items:Array<int>{4,5,6}}

    // set field by offset
    type::field_set(original,0,"Gromperekichelchen");
    println(original); // MyType{name:"Gromperekichelchen",items:Array<int>{4,5,6}}

    // Get the field of object by the offset
    println(type::field_get(original, 0)); // Gromperekichelchen

} 

Enum Type native functions

There are also a set of native functions to used specifically for enumeration types.

enum MyEnum {
    foo("bar");
    zig("zag");
    ping("pong");
}
fn main() {
    // get the number of values of an enum
    println(MyEnum.nb_enum_values()); // 3

    // get the values of an enum
    println(MyEnum.enum_values()); // Array{MyEnum::foo,MyEnum::zig,MyEnum::ping}

    // get an enum value by its name
    println(type::enum_by_name(MyEnum, "foo")); // MyEnum::foo

    // get the name of a given enum
    println(type::enum_name(MyEnum::foo)); // foo

    // get an enum value by its offset
    println(type::enum_by_offset(MyEnum, 0)); // MyEnum::foo

    // get the offset of an enum 
    println(type::enum_offset(MyEnum::ping)); // 2
}