language basics

syntax

ghūl syntax is inspired by a number of non-brace languages, including ALGOL 68 and Pascal

identifiers and keywords

Identifiers in ghūl follow the convention of snake_case for variables, functions, methods, and properties, PascalCase for namespaces, traits, abstract classes, unions, and enums, and MACRO_CASE for concrete classes, structs, variants, and enum members. ghūl keywords are lowercase.

An identifier can be written in any script. A letter starts one, and a letter, a digit, a combining mark or a connecting punctuation mark continues one. The compiler reports a format character inside an identifier - a zero-width joiner, a bidirectional control - as an error, because such a character renders as nothing and a name that contains one reads as a name it is not. The compiler accepts characters from the basic multilingual plane only: a character above that plane is written as a surrogate pair, and the compiler reads a surrogate pair as two characters.

A letter is never a symbol, so no character is both an identifier character and an operator character. × is an operator and naïve is a name.

The compiler checks the conventions above with Unicode case. A character that has an upper-case and a lower-case form is checked for its kind whatever script it is in, so ТИП is a concrete class and μέγεθος is a property. The compiler doesn't check the case of a character with neither form, so a name written entirely in a script that has no case - Chinese, Japanese, Arabic, Hebrew - is correct for any kind.

ghul

class TEMPERATURA is

grados: double

init(grados: double) is

self.grados = grados

en_fahrenheit() -> double => grados * 1.8 + 32.0

面積(幅: double, 高さ: double) -> double => 幅 * 高さ

let máxima = TEMPERATURA(21.5)

write_line("{máxima.en_fahrenheit()}")

write_line("{面積(3.0, 4.0)}")

70.7
12

ghūl relies on keywords for block structure where other languages use braces or indentation. Keywords are context specific and generally come in pairs where the closing keyword is the reverse or mirror image of the opening keyword. In the examples below is introduces a method or class body and its block is closed by the reverse keyword si

ghul

let my_variable = 42

print_something(thing: string) is

write_line("The thing is: {thing}")

print_something("a hello")

class PERSON is

name: string

age: int

The thing is: a hello

expressions and statements

Expressions in ghūl are constructs that return a value, while statements perform actions. All expressions can be used where statements are allowed, and most statements can be used as expressions. In a function or method body the last statement is the value the body returns, whenever the type of that statement is assignable to the declared return type. A trailing ; does not change that: the compiler judges the last statement by its type rather than by its terminator - see expression oriented programming for the forms working together.

ghul

// variable declaration statement

let x = 10

// expression used as part of a declaration statement

let y = x * 2

// 'if' is a statement, 'x > 5' is an expression

if x > 5 then

write_line("x is greater than 5")

// 'if' can also be used as an expression

let z = if x > 5 then x else y fi

x is greater than 5

function declarations

Functions in ghūl are declared with a name, a list of parameters in parentheses, an optional return type after ->, and a body enclosed in is and si keywords.

ghul

greet(name: string) -> void is

write_line("Hello, {name}!")

Functions can also have an expression body using => instead of is / si:

ghul

square(x: int) -> int => x * x

control flow

ghūl supports various control flow constructs like if, else, while, for, and case expressions.

ghul

if x > 0 then

write_line("Positive")

elif x < 0 then

write_line("Negative")

else

write_line("Zero")

for item in my_list do

process(item)

Positive

types

ghūl is statically typed, with some support for type inference. Types can be explicitly specified using a colon : plus a type expression

ghul

let x: int = 42

let y = "Hello"

User types are defined using class, struct, trait, enum, and union keywords.

built-in data types

ghūl's built-in data types are primitive types, arrays, tuples, and optionals.

primitive types

ghūl provides the following primitive data types:

integer types: byte, ubyte, short, ushort, int, uint, long, ulong, word, uword
arbitrary-precision integer type: bigint
floating-point types: single, double
decimal floating-point type: decimal
boolean type: bool
character type: char
void type: void

ghul

let my_int: int = 42

let my_float: double = 3.14d

let my_decimal: decimal = 19.99m

let my_bool: bool = true

let my_char: char = 'A'

These types are used to represent basic values in ghūl programs.

bigint is an integer with no fixed width, so it never overflows. It is .NET's System.Numerics.BigInteger under a built-in name. A literal with an n suffix is a bigint, and a value of another integer type converts to one with bigint(...):

ghul

let factorial mut = 1n

for i in 1::30 do

factorial = factorial * bigint(i)

write_line("{factorial}")

265252859812191058636308480000000

As with the other numeric types, the operands of an arithmetic operator must have the same type: total * 2 is rejected where total is a bigint, and total * 2n is the way to write it.

arrays

ghūl supports arrays, which are fixed-size, read-only collections of elements of the same type. Array types are denoted using square brackets [] after the element type.

ghul

let numbers: int[] = [1, 2, 3]

Arrays can be constructed with an array literal

ghul

let primes = [2, 3, 5, 7, 11]

Array elements can be read with indexer syntax

ghul

let p = primes[i]

Indexing with a range takes a slice rather than a single element. .. excludes its end and :: includes it, as they do everywhere else. ..< counts its end back from the end of the source, and ..<< counts both ends back, so ..<0 runs to the end:

ghul

let xs = [10, 20, 30, 40, 50]

write_line(xs[1..3] |> join(", ")) // 20, 30

write_line(xs[1..<1] |> join(", ")) // up to one back from the end

write_line(xs[1..<0] |> join(", ")) // to the end

write_line(xs[3..<<0] |> join(", ")) // the last three

write_line("hello, world"[7..<0]) // a string gives back a string

20, 30
20, 30, 40
20, 30, 40, 50
30, 40, 50
world

A slice is a view onto the source, not a copy. Arrays, strings and lists can all be sliced; slicing a string gives back a string.

tuples

Tuples in ghūl are lightweight, immutable data structures that can hold a fixed number of elements of different types. Tuple types use parentheses ( ), with elements separated by commas. Tuple literals are similarly constructed with ( ) and comma delimited elements. Tuples compare by structural equality: two tuples are equal when their corresponding elements are.

ghul

let point: (int, int) = (10, 20)

let person: (string, int) = ("Alice", 30)

Compare tuples with =~. The == operator is rejected on a tuple, as it is on any struct, because it would compare the value's bytes rather than its elements:

ghul

write_line("{a =~ b}") // true: compares element by element

write_line("{a == b}") // rejected: == is not defined on tuples

== cannot be applied to values of type (int, string) [help: use =~ to compare by value]

Tuple elements can be accessed using the dot . notation followed by the element name:

ghul

let x = point.`0

let y = point.`1

let name = person.`0

let age = person.`1

Tuple elements can be given more descriptive names, either in the type or in the tuple literal:

ghul

let point: (x: int, y: int) = (10, 20)

let person = (name = "Alice", age = 30)

let x = point.x

let y = point.y

let name = person.name

let age = person.age

ghūl also supports tuple destructuring:

ghul

let (a, b) = point

let (name, age) = person

Destructuring also has a by-name form, (local = field, ...), that pulls each element from a named field rather than by position; the positional and by-name forms are covered with pattern matching.

optional types

A type followed by ? is an optional type: a value of T? can be present or absent. The same type written without the ? is non-optional, and a non-optional value is always there.

ghul

let ►name: string? = "Alice" // present

let nickname: string? = null // absent

The postfix ? operator tests whether an optional has a value. A plain if x? narrows x to its non-optional form inside the branch, so the value reads directly:

ghul

if ►name? then

write_line("name is {name}") // name is non-optional here

name is Alice

A non-optional type never holds the absent case, so a T? is not assignable to a T. The compiler rejects it rather than warning:

ghul

// rejected: a string? is not assignable to a string

let title: string = maybe

string? is not assignable to string

[non-optional] string expected but maybe may not hold a value

To pass a T? where a T is wanted, make the value present first: narrow it with if x? or if let (see control flow), assert it with x! (which throws when absent), or supply a fallback with x ?? other. Optional types work for reference types, value types, and type parameters that could be either, and a type with has_value and value properties is treated as optional too. The optional types page covers all of these, the ?? and ?. operators, and the warnings the compiler reports on optional handling.

type conversions

ghūl does not perform implicit type conversion (coercion) between scalar types; all scalar type conversions must be explicitly cast. However, ghūl supports polymorphic behavior by allowing upcasting, where instances of derived classes or interfaces can be automatically coerced to compatible ancestor types in the class/interface hierarchy.

ghul

// OK: both addends are type double

let d = 1.0d + 1.0d

// compile time error: addends are mixed types

// (double vs int)

let e = 1.0d + 1

// OK with explicit cast

let e = 1.0d + cast double(1)

// OK: "hello" is a string, and string derives

// from object

let o: object = "hello"

variables

ghūl has three kinds of variables: locals declared within the body of a function or method, function or method arguments and variables captured by a function literal.

locals

Local variables are declared with let followed by the variable name, an optional explicit type, and an initializer:

ghul

let i = 1234

let j: int = 0

let k: int = 5678

arguments

Arguments will be covered in detail with functions and methods, but the basic form is the argument name followed by its type.

ghul

some_function(argument: type)

captured variables

Variables captured by a function literal will be covered with function literals. They are not declared: a function literal captures the variables its body uses.

scope

The scope of all variable definitions is from the point of declaration to the end of the innermost block that contains the declaration. Blocks will be covered later, but generally a block is a control flow statement or a function or method body.

type inference and explicit types

ghūl infers the type of a local variable from its initializer. An explicit type can be given alongside; it's a compile time error if the initializer is not assignment compatible with it.

literals

Literal expressions represent fixed values of a specific type.

ghul

let integer_literal = 42

let floating_point_literal = 3.14

let string_literal = "Hello, world!"

let boolean_literal_true = true

let boolean_literal_false = false

An integer literal can be written in hexadecimal with a 0x prefix, and can end with a suffix that picks its type: 123L is a long, 0ub is a ubyte, 65c is a char. The digits are read first and as far as they go, so in a hex literal b and c are digits rather than suffixes. A backtick separates a suffix that would otherwise be read as a digit:

ghul

let wide = 0x20AC // int: the C is a hex digit

let euro = 0x20AC`c // char: the backtick separates the suffix

let byte_max = 0xFF`ub // ubyte

write_line("{wide} {euro} {byte_max}")

8364 € 255

In a string or character literal, \u followed by exactly four hex digits writes a character by its code. A character above U+FFFF is written as its two surrogate halves:

ghul

write_line("€") // the euro sign

write_line("😀") // one character above U+FFFF, as a surrogate pair

write_line("Acat") // exactly four digits, so this is Acat

€
😀
Acat

A run of octal digits after a \ is the older way to write a character code. It still works, but the compiler reports a deprecated-octal-escape warning. Write \u instead.

string interpolation

A string literal can interpolate expressions: { starts an expression and } ends it, and the value of the expression is written into the string in its place. There is no + operator on string, so interpolation is also how strings are joined.

How a value is written depends on its type. A string, a number or an enum member is written as .NET writes it, and so is any value whose type declares its own to_string. A bool is written true or false. An optional value is written as the value it holds, or as null when it doesn't hold a value. Any other value, such as an array, a list, a tuple, or a struct or class with no to_string of its own, is written by the runtime's $ function: a sequence as its elements in brackets, a tuple as its parts, and a record as its type and members:

ghul

struct POINT(x: int public, y: int public)

let name = "world"

let nickname: string? = null

let numbers = [1, 2, 3]

write_line("hello {name}")

write_line("{true} {nickname}")

write_line("{numbers} {(1, "one")} {POINT(3, 4)}")

write_line("[{3.14159:F2}] [{42,6}]")

hello world
true null
[1, 2, 3] (1, one) POINT(x = 3, y = 4)
[3.14] [    42]

A format or an alignment after the expression, as in {value:F2} or {value,6}, formats the value the way .NET does. To change how the values of a type are written, give the type a to_string.

operators and expressions

arithmetic operators

ghul

let add = 1 + 2

let sub = 3 - 1

let mul = 3 * 3

let div = 12 / 3

let mod = 13 % 4

comparison and logical operators

ghul

let gt = 3 > 1 // true

let gte = 4 >= 4 // true

let lt = 3 < 1 // false

let lte = 4 <= 4 // true

let eq = 1 == 2 // false

let neq = 1 != 2 // true

ghul

let list = [1, 2, 3]

let index = 4

let search_value = 3

// false

let and_then =

index < list.count /\ list[index] == search_value

// true

let or_else =

index >= list.count \/ list[index] != search_value

bitwise and shift operators

The integer types have the usual bitwise operators - &, |, ^ - and the shift operators << and >>. A shift count is an int, and the result keeps the left operand's type. The count is taken modulo the operand's width, following .NET: shifting an int by 32 is the same as shifting it by 0. >>> is the unsigned right shift: it shifts zeros into the leftmost bits where >> keeps the sign:

ghul

bitwise(a: int, b: int) is

write_line("{a & b} {a | b} {a ^ b}")

// shift counts are int, and '>>>' shifts zeros in

write_line("{1 << 4} {256 >> 3} {-16 >>> 2}")

bitwise(240, 60)

48 252 204
16 32 1073741820

The unary \ operator is the bitwise complement, which flips every bit of its operand:

ghul

let low_bits = 0x0F

write_line("{\low_bits}") // every bit flipped: -16

write_line("{\low_bits & 0xFF}") // 240

-16
240

assignment

variables and properties can be updated via assignment statements

ghul

let i mut = 0

let j = 10

let s mut = "Hello"

i = i + j

s = "{s} World!"

thing.property = i + j

write_line("i = {i}, s = {s}, thing.property = {thing.property}")

i = 10, s = Hello World!, thing.property = 20

language basics ​

syntax ​

identifiers and keywords ​

expressions and statements ​

function declarations ​

control flow ​

types ​

built-in data types ​

primitive types ​

arrays ​

tuples ​

optional types ​

type conversions ​

variables ​

locals ​

arguments ​

captured variables ​

scope ​

type inference and explicit types ​

literals ​

string interpolation ​

operators and expressions ​

arithmetic operators ​

comparison and logical operators ​

bitwise and shift operators ​

assignment ​

language basics

syntax

identifiers and keywords

expressions and statements

function declarations

control flow

types

built-in data types

primitive types

arrays

tuples

optional types

type conversions

variables

locals

arguments

captured variables

scope

type inference and explicit types

literals

string interpolation

operators and expressions

arithmetic operators

comparison and logical operators

bitwise and shift operators

assignment