The egg Programming Language Syntax

Informal Syntax

egg Railroad Diagrams

egg Syntax

Comments

// This is a comment until the end of the line

/* This is a comment
    that's split over
     multiple lines */

Modules

Statements

• a compound statement consisting of zero or more statements within a pair of curly braces,
• a simple statement with a trailing semicolon,
• a function definition, or
• a flow control statement.

Simple Statement

Action Statement

Assignment Statement

target = value;

target += value;

target = target + value;

• a variable,
• a dereferenced pointer expression,
• an indexed expression, or
• a property of an expression.

int a;
a = 123; // Assign to variable

int* b = &a;
*b = 321; // Assign via pointer

int[] c = [9, 2, 3];
c[0] = 1; // Assign to indexed element

object d = {};
d.field = 321; // Assign to property

Increment/Decrement Statement

++target;
--target;

target = target + 1;
target = target - 1;

for (i = 0; i < 100; ++i) {
  // Loops from 0 to 99 inclusive
}

Flow Control

If Statement

if (condition1) {
  // Do this only if 'condition1' is true
}

if (condition2) {
  // Do this only if 'condition2' is true
} else {
  // Do this only if 'condition2' is false
}

if (condition3) {
  // Do this only if 'condition3' is true
} else if (condition4) {
  // Do this only if 'condition3' is false but 'condition4' is true
} else {
  // Do this if both 'condition3' and 'condition4' are false
}

Switch Statement

switch (greeting) {
  case "hello":
  case "hi":
    english = true;
    continue;
  case greetingInLocalLanguage():
    print("greeting is ", greeting, "\n");
    break;
  default:
    throw "unknown greeting";
}

While Loop

// Find the factorial of n
var factorial = 1;
while (n > 1) {
  factorial *= n;
  --n;
}

while (condition1) {
  if (condition2) {
    break;
  }
  if (condition3) {
    continue;
  }
  doSomething();
  // 'continue' jumps to here
}
// 'break' jumps to here
doSomethingAfter();

Do Loop

// Print 10 to 1 in descending order
var i = 10;
do {
  print(i, "\n");
  --i;
} while (i > 0);

do {
  if (condition1) {
    break;
  }
  if (condition2) {
    continue;
  }
  doSomething();
  // 'continue' jumps to here
} while (condition3);
// 'break' jumps to here
doSomethingAfter();

For Loop

// Sum the integers up to and including 'n'
var sum = 0;
for (var i = 1; i <= n; ++i) {
  sum += i;
}

// Sum the elements of an array
var array = [1, 2, 3, 5, 8, 13, 21];
var sum = 0;
for (var i : array) {
  sum += i;
}

for (var i = 0; i < n; ++i) {
  if (condition1) {
    break;
  }
  if (condition2) {
    continue;
  }
  doSomething();
  // 'continue' jumps to here
}
// 'break' jumps to here
doSomethingAfter();

Break Statement

// Sum the elements until the total is greater than twenty
var array = [1, 2, 3, 5, 8, 13, 21];
var sum = 0;
for (var i : array) {
  sum += i;
  if (sum > 20) {
    break;
  }
}
// 'break' jumps to here

Continue Statement

Throw Statement

float safeSqrt(float x) {
  if (x < 0) {
    throw "attempt to take the square root of a negative number";
  }
  return math.sqrt(x);
}

float y;
try {
  y = safeSqrt(-1);
} catch (any exception) {
  print("exception thrown: ", exception);
  // Handle the problem here
}

try {
  y = safeSqrt(-1);
} catch (any exception) {
  print("exception thrown: ", exception);
  throw; // Re-throw the exception
}

Try Statement

try {
  runSomethingThatMightFail();
} catch (ArithmeticException exception) {
  reportProblem("arithmetic", exception);
} catch (any exception) {
  reportProblem("something else", exception);
}

var resource = acquireResource();
try {
  processResource(resource);
} finally {
  // Guaranteed to be called
  releaseResource(resource);
}

Return Statement

double computeSquare(double x) {
  // Return the square of 'x'
  return x * x;
}

void squareIt(double* p) {
  // Squares the value pointed to by 'p'
  *p *= *p;
  return;
}

Yield Statement

int! fibonacci(int a, int b) {
  // Compute an infinite series of Fibonacci numbers
  for (;;) {
    yield a;
    var c = a + b;
    a = b;
    b = c;
  }
}

any! prefix(any head, any! tail) {
  // Yield 'head' then all the values in 'tail'
  yield  head;
  yield ...tail;
}

Definitions

Identifiers

• hello
• HelloWorld
• hello_world
• _
• _hello
• hello123
• olá (trailing accented letters are permitted)

• 123hello (must not start with a digit)
• hello world (must not contain spaces)
• hello-world (must not contain ASCII non-alphanumerics such as a hyphen)
• γειά_σου (must not start with a non-ASCII character)

Function Definition

1. The return type
2. The function name (variable identifier)
3. The parameter list inside parentheses
4. The statement block inside curly braces

void greet() {
  print("hello\n");
}

float square(float x) {
  return x * x;
}
print(square.name, "\n"); // Prints 'square'
print(square(9), "\n"); // Prints '81'

float logarithm(float x, float? base = null) {
  if (base == null) {
    return math.ln(x);
  }
  return math.ln(x) / math.ln(base);
}

float divide(...object vargs) {
  return vargs.x / vargs.y;
}
print(divide(x: 3, y: 4, z: 6), "\n"); // Prints '0.75' (z is ignored)

int sum(...int[] vargs) {
  int total = 0;
  for (var element : vargs) {
    total += element;
  }
  return total;
}
print(sum(3, 1, 4, 1, 5, 9), "\n"); // Prints '23'

Generator Function Definition

Type Definition

type Number = int|float;
Number n; // Synonymous with 'int|float n'

type Dictionary<K, V> = {
  properties: {
    add: bool(K key, V value),
    remove: bool(K key),
    find: V?(K key)
  }
};

Variable Definition

int i; // 'i' is undefined
i = 10; // 'i' now has the value ten

int i = 10; // 'i' has the value ten

var i = 4;     // 'i' is an 'int' with value four
var j = i * i; // 'j' is an 'int' with value sixteen

float? root(float x) {
  if (x < 0) {
    return null;
  }
  return math.sqrt(x);
}

var x = root(4);   // 'x' is a 'float' with value two
var? y = root(-4); // 'y' is a 'float?' with value null
var z = root(-4);  // This causes a runtime error

Literals

Integer Literal

Floating-Point Literal

String Literal

print("\U+1f95a;\n");

Object Literal

var a = {
  "well-known": true,
  x: "hello",
  y: 123,
  z: [1, 2, 3]
};

var a = { x: "hello", y: 123, z: [1, 2, 3] };
var b = a;
var c = { ...a };

c.y = 321; // Do not affect 'a.y'
b.y = 321; // Affects 'a.y' also

var a = { x: 1, y: 2, z: 3 };
var b = { ...a, y: 4 }; // 'b' equals '{ x: 1, y: 4, z: 3 }'
var c = { y: 4, ...a }; // 'c' equals '{ x: 1, y: 2, z: 3 }'

var e = {};

Array Literal

var a = [
  true,     // Element 0, a Boolean
  "hello",  // Element 1, a string
  123,      // Element 2, an integer
  [1, 2, 3] // Element 4, another array
];

int[] b = [1, 2, 3];

var a = ["hello", 123, [1, 2, 3]];
var b = [true, ...a, 3.14159]; // Equals [true, "hello", 123, [1, 2, 3], 3.14159]

var c = [...a]; // Shallow copies 'a' into 'c'

var e = [];

Type Literal

Value Expressions

Ternary Operator

var w = x ? y : z;

any? w;
if (x) {
  w = y;
} else {
  w = z;
}

Binary Operator

Unary Operator

Primary Expression

• a variable identifier,
• a literal,
• a function expression,
• a lambda expression, or
• another expression inside parentheses ().

Function Expression

var func = int(int a, int b) { return a + b; };
print(func(2, 3), "\n"); // Prints 5
func = int(int a, int b) { return a - b; };
print(func(2, 3), "\n"); // Prints -1

Lambda Expression

int applyBinary(int(int a, int b) func, int x, int y) {
  return func(x, y);
}
var p = applyBinary((a, b) => { return a + b; }, 2, 3);
print(p, "\n"); // Prints 5
var q = applyBinary((a, b) => { return a - b; }, 2, 3);
print(q, "\n"); // Prints -1

var p = applyBinary((a, b) => a + b, 2, 3);
print(p, "\n"); // Prints 5
var q = applyBinary((a, b) => a - b, 2, 3);
print(q, "\n"); // Prints -1

int applyUnary(int(int a) func, int x) {
  return func(x);
}
var p = applyUnary(a => -a, 2);
print(p, "\n"); // Prints -2
var q = applyUnary(a => a * a, 2);
print(q, "\n"); // Prints 4

Indexing

var arr = ["first", "second", "third", "fourth"];
print(arr[1], "\n"); // Prints "second"

var obj = {
  forename: "Charlie",
  surname: "Chaplin",
  year: 1889
};
print(obj["surname"], "\n"); // Prints "Chaplin"

Properties

var arr = ["a", "b", "c", "d"];
print(arr.length, "\n"); // Prints 4

var obj = {
  forename: "Charlie",
  surname: "Chaplin",
  "year-of-birth": 1889
};
print(obj.forename, "\n"); // Prints "Charlie"
print(obj["surname"], "\n"); // Prints "Chaplin". Could also use 'obj.surname'
print(obj["year-of-birth"], "\n"); // Prints 1889. Cannot use "dot" notation

Type Expressions

• a parametrized generic type,
• a fundamental type,
• a type literal, or
• another type expression inside parentheses ().

Fundamental Type

void greet(string name) {
  print("hello ", name, "\n");
}

void display(any value) {
  print("The value is ", value, "\n");
}

Nullable Type

string name;
name = null; // Not permitted!

string? name;
name = null; // Permitted

type NullableString1 = string?;
type NullableString2 = string|type null;

Iterator Type

(T|void) someIterator() {
 // ...
}

(T|void)() someGenerator(any someParameter1, any someParameter2) {
 // ...
}

(T|void)() someFunction((T|void)() someInputIterator) {
 // ...
}

T! someGenerator() {
 // ...
}

T! someFunction(T! someInputIterator) {
 // ...
}

Pointer Type

string comedian = "Laurel";
string* pointer = &comedian;   // 'pointer' now points to variable 'comedian'
*pointer = "Hardy";            // 'comedian' now contains "Hardy"
string swashbuckler = "Flynn";
pointer = &swashbuckler;       // 'pointer' now points to variable 'swashbuckler'

int i = 123;
int*? p = &i; // 'p' can point to an integer or be null
p = null;

int totalPositives(float[] input, float* output) {
  int count = 0;
  *output = 0.0;
  for (var value : input) {
    if (value > 0) {
      *output += value;
      ++count;
    }
  }
  return count;
}

Indexed Type

int[string] lookup1 = createLookup1(); // 'lookup1' maps strings to integers
var value1 = lookup1["key"]; // 'value1' is of type 'int' if "key" is in 'lookup1'

string[] lookup2 = createLookup2(); // 'lookup2' is an array of strings
var value2 = lookup2[3]; // 'value2' is of type 'string' if the array has at least four elements

Function Type

type BinaryFunction = float(float, float);
BinaryFunction add = (a, b) => a + b;
print(add(3, 4), "\n"); // Prints 7
BinaryFunction sub = (a, b) => a - b;
print(sub(3, 4), "\n"); // Prints -1

Generic Type

type Dictionary<K, V> = {
  properties: {
    add: bool(K key, V value),
    remove: bool(K key),
    find: V?(K key)
  }
};
Dictionary<int, string> dict = createDictionary();
dict.add(8, "eight");

Conditions

Boolean Condition

if (a < b) {
  print("a is smaller\n")
} else {
  print("a is not smaller\n")
}

Guard Condition

int? toInteger(any? value) {
  if (int i = value) {
    return i;
  }
  return null;
}

any?! takeAlternate(any?! input) {
  while (any? a = input())
    yield a;
    if (any? _ = input()) {
      // Do not yield the element
    } else {
      break;
    }
  }
}

if (var x = someFunction()) {
  // 'x' is defined here
} else {
  // 'x' is not defined here
}

Function Calls

• an unnamed value,
• an array of values (preceded by an ellipsis ...) to be used in sequence, or
• a named value.

Function Call Statement

void greet(string name) {
  print("hello ", name, "\n");
}
greet("world"); // Prints "hello world"

Function Call Expression

float square(float x) {
  return x * x;
}
var s = square(1.5);
print(s, "\n"); // Prints 2.25

Attributes

@test(timeout: 0.001)
void testFibonacci() {
  assert(fibonacci(8) == 21);
}

egg Syntax Poster

Formal Syntax

EBNF

Railroad