Appearance

Sidebar Navigation

ghūl

overview

getting started

tour

expression oriented programming

functional programming

object oriented programming

unions and pattern matching

generics

optional types and narrowing

async and generators

.NET integration

guides

runtime library

scripts, the REPL and notebooks

tooling

reference

language basics

syntax

definitions

expressions

control flow

optional types

type narrowing

type inference

grammar

known issues

examples

hello world

literals

control flow

assert

if

if expression

while

while let

for

try

let use

expression-oriented code

expression bodies

if expressions

case expressions

let in expressions

block expressions

loop as expression

return from block

block as function body

assert in expressions

functional programming

first class functions

map filter reduce

expression bodies

pure functions

self recursion

mutual recursion

immutable data

higher order functions

custom operator

if and case expressions

unions

currying

partial application

streams

closures

pipes

anonymous functions

lists and ranges

filter

map and for

reduce sum product

chaining

zip

cat

collecting

comprehensions

object-oriented programming

unions

shape areas

labelling shapes

describing shapes

lookups

pattern matching

optional matching

type matching

destructuring

literal patterns

chained clauses

case expressions

case binding patterns

if let guards

case arm guards

match by value

while let

nested destructuring

generics

optional types

reading optionals

presence narrowing

coalescing

safe member access

asynchronous code

compute

classify

run side effects

sum doubled

divide then double

generators

basic generator

composing generators

fibonacci

type inference

local variables

constructors

array and tuple literals

destructuring

for loop variables

type arguments from later use

function literals from call context

function literal return types

iterative inference

bidirectional convergence

closures and currying

generic function arguments

union narrowing

rosetta code

tasks

about

implementation

history

resources

privacy

expression-oriented code: return from block

open on GitHub

previousexpression-oriented code: loop as expression nextexpression-oriented code: block as function body