# # ghūl programming language

- The ghūl language, compiler, tools, and this website are all very much a
work-in-progress.- Whatever the ghūl compiler (opens new window) accepts is currently the definitive ghūl language reference.
- ghūl is pronounced 'ghoul'.

## # why ghūl?

Why not 🤔

ghūl is mainly an opportunity for me (opens new window) to experiment with programming language design. Apart from a slightly quirky syntax, ghūl is a fairly conventional programming language. Although ghūl is a hobby project maintained by a single person, its goal is to be sufficiently expressive for general-purpose development: the ghūl compiler (opens new window) itself is written in ghūl.

## # features

**type safety**: ghūl enforces type safety at compile-time.**functional programming elements**: ghūl supports anonymous functions with closures.**OOP**: ghūl supports classes, objects, inheritance, polymorphism, and other Object-Oriented Programming concepts.**error handling**: the language includes try/catch/finally for error handling.**generics**: ghūl types, methods, and functions can have generic type parameters.**.NET integration**: ghūl targets .NET, producing and consuming NuGet packages and supporting inter-operation with other .NET languages.

## # examples

### # hello world!

```
entry() =>
IO.Std.write_line("hello world");
```

### # functional

```
use IO.Std.write_line;
entry() is
// lazily generates an infinite sequence of fibonacci numbers:
let fibonacci_sequence = GENERATE(
(0, 1),
state: (int, int) =>
let
(prev, current) = state,
next = prev + current
in
((current, next), next)
);
// lazily generates an infinite sequence of factorials:
let factorial_sequence = GENERATE(
(1, 1),
state: (int, int) =>
let
(p, prev) = state,
n = p + 1,
next = prev * n
in
((n, next), next)
);
write_line("first 10 fibonacci numbers: {fibonacci_sequence | .take(10)}");
write_line("first 10 factorial numbers: {factorial_sequence | .take(10)}");
write_line("first 10 even fibonacci numbers: {fibonacci_sequence | .filter(x => x % 2 == 0) .take(10)}");
for (i, (fib, fact)) in fibonacci_sequence | .zip(factorial_sequence) .take(10) .index() do
write_line("fibonacci {i} is {fib}");
write_line("factorial {i} is {fact}");
od;
si
```

### # OOP

```
use IO.Std.write_line;
class CALCULATOR is
init() is
si
add(x: single, y: single) -> single =>
x + y;
subtract(x: single, y: single) -> single =>
x - y;
multiply(x: single, y: single) -> single =>
x * y;
divide(x: single, y: single) -> single =>
if y != 0.0 then
x / y;
else
throw System.DivideByZeroException("oops: division by zero");
fi;
si
entry() is
let calc = CALCULATOR();
let a = 10.0;
let b = 5.0;
write_line("Addition: {calc.add(a, b)}");
write_line("Subtraction: {calc.subtract(a, b)}");
write_line("Multiplication: {calc.multiply(a, b)}");
write_line("Division: {calc.divide(a, b)}");
si
```

### # examples project

See the ghūl examples repository (opens new window) for projects with these examples and others that can be viewed, edited and run from Visual Studio Code or a GitHub Codespace.