Flix —

/// Demonstrates composing multiple HTTP middleware
/// via `with` clauses. Stacks base URL, default
/// headers, retry, circuit breaker, and logging.
/// Each `with` wraps the
/// preceding block. The `Http` and `Logger` effects
/// propagate to `main` and are handled automatically
/// via their default handlers. Relative paths are
/// resolved against the base URL; absolute URLs
/// bypass it.
def main(): Unit \ { Clock, Http, Logger, IO } =
    let defaultHeaders = Map#{
        "Accept"        => List#{"application/json"},
        "Authorization" => List#{"Bearer tok123"}
    };
    run {
        let urls = List#{"/api/users", "/api/posts"};
        foreach (url <- urls) {
            match Http.get(url) {
                case Ok(res) => println("${url} -> ${status(res)}")
                case Err(err) => println("${url} -> ${err}")
            }
        };
        match Http.get("https://notfound.flix.dev/") {
            case Ok(res) => println("notfound -> ${status(res)}")
            case Err(err) => println("notfound -> ${err}")
        }
    } with Http.withBaseUrl("https://flix.dev")
      with Http.withDefaultHeaders(defaultHeaders)
      with Http.withRetry(
        Retry.linear(maxRetries = 2, delay = milliseconds(100)))
      with Http.withCircuitBreaker(
        failureThreshold = 3, cooldown = seconds(5))
      with Http.withLogging

enum Shape {
    case Circle(Int32),
    case Square(Int32),
    case Rectangle(Int32, Int32)
}

def area(s: Shape): Int32 = match s {
    case Circle(r)       => 3 * (r * r)
    case Square(w)       => w * w
    case Rectangle(h, w) => h * w
}

def origin(): (Int32, Int32) = (0, 0)

def oneByOne():  {w = Int32, h = Int32} = {w = 1, h = 1}

def twoByFour(): {w = Int32, h = Int32} = {w = 2, h = 4}

def area(rect: {w = Int32, h = Int32 | r}): Int32 =
    rect#w * rect#h

def f(): Int32 = area({h = 1, color = "Blue", w = 2})

/// A pure function is annotated with `\ {}`.
def inc1(x: Int32): Int32 \ {} = x + 1

/// An impure function is annotated with `\ IO`.
def inc2(x: Int32): Int32 \ IO =
    println("x = ${x}");
    x + 1

def f(): Int32 \ IO =     // f is impure
    let r1 = inc1(123);   // pure
    let r2 = inc2(456);   // impure
    r1 + r2               // pure

///
/// The purity of `map` depends on the purity of `f`.
///
def map(f: a -> b \ ef, l: List[a]): List[b] \ ef =
    match l {
        case Nil     => Nil
        case x :: xs => f(x) :: map(f, xs)
    }

import java.time.LocalDateTime

eff HourOfDay {
    def getCurrentHour(): Int32
}

def greeting(): String \ {HourOfDay} =
    let h = HourOfDay.getCurrentHour();
    if (h <= 12) "Good morning"
    else if (h <= 18) "Good afternoon"
    else "Good evening"

def main(): Unit \ IO =
    run {
        println(greeting())
    } with handler HourOfDay {
        def getCurrentHour(_, resume) =
            let dt = LocalDateTime.now();
            resume(dt.getHour())
    }

use Fs.FileRead
use Sys.Env
use Time.Clock
use Time.TimeUnit

/// The `Clock`, `Env`, `FileRead`, and `Logger`
/// effects all have default handlers, hence `main`
/// requires no explicit handlers.
def main(): Unit \ { Clock, Env, FileRead, Logger } =
    let ts = Clock.currentTime(TimeUnit.Milliseconds);
    let os = Env.getOsName();
    Logger.info("Timestamp: ${ts}");
    Logger.info("Operating System: ${os}");
    match FileRead.read("data.txt") {
        case Ok(content) => Logger.info("Read: ${content}")
        case Err(err)    => Logger.warn("Error: ${err}")
    }

///
/// We can implement a *pure* `sort` function which
/// internally converts an immutable list to an array,
/// sorts the array in-place, and then converts it
/// back to an immutable list.
///
def sort(l: List[a]): List[a] \ {} with Order[a] =
    region r {
        List.toArray(r,l) !> Array.sort! |> Array.toList
    }

///
/// We can also write a *pure* `toString` function which
/// internally uses a mutable StringBuilder.
///
def toString(l: List[a]): String with ToString[a] =
    region r {
        let sb = StringBuilder.new(r);
        foreach (x <- l) {
            StringBuilder.appendString!("${x} :: ", sb)
        };
        StringBuilder.appendString!("Nil", sb);
        StringBuilder.toString(sb)
    }

struct Person[r] {
    name: String,
    mut age: Int32
}

mod Person {
    /// Creates a fresh `Person` in the region `rc`.
    pub def mkPerson(name: String, rc: Region[r]): Person[r] \ r =
        new Person @ rc { name = name, age = 0 }

    /// Increments the age of the given person `p`.
    pub def birthday(p: Person[r]): Unit \ r =
        p->age = p->age + 1

    /// Returns a description of the given person `p`.
    pub def describe(p: Person[r]): String \ r =
        "${p->name} is ${p->age} years old"
}

///
/// We can inspect the purity of a function argument.
///
def inspect(f: a -> b \ ef): Unit \ IO =
    reifyEff(f) {
        case Pure(g) => println("f is pure")
        case _       => println("f is not pure")
    }

///
/// We can use purity information to safely switch between
/// lazy (or parallel) evaluation. In this case, if f is
/// pure then perform the map operation lazily.
///
def map(f: a -> b \ ef, l: LazyList[a]): LazyList[b] \ ef =
    reifyEff(f) {
        case Pure(g) => mapL(g, l)
        case _       => mapE(f, l)
    }

///
/// A parallel implementation of the List.map function.
///
def parMap(f: a -> b, l: List[a]): List[b] = match l {
    case Nil     => Nil
    case x :: xs =>
        // Evaluate f(x) and parMap(f, xs) in parallel.
        par (r <- f(x); rs <- parMap(f, xs))
            yield r :: rs
}

def main(): Unit \ IO =
    region rc {
        // A channel which can buffer one message.
        let (tx, rx) = Channel.buffered(rc, 1);
        spawn say("Meow!", tx) @ rc; // thread 1
        spawn say("Woof!", tx) @ rc; // thread 2
        Channel.recv(rx) |> println
    } // Execution is blocked until both threads finish.

/// Sends the string s on the given channel tx.
def say(s: String, tx: Sender[String, r]): Unit \ r =
    Channel.send(s, tx)

trait Eq[a] {
    def eq(x: a, y: a): Bool
    def neq(x: a, y: a): Bool = not Eq.eq(x, y)
}

instance Eq[(a1, a2)] with Eq[a1], Eq[a2] {
    def eq(t1: (a1, a2), t2: (a1, a2)): Bool =
        let (x1, x2) = t1;
        let (y1, y2) = t2;
        x1 == y1 and x2 == y2
}

trait Foldable[t : Type -> Type] {

    ///
    /// Left-associative fold of a structure.
    ///
    def foldLeft(f: (b, a) -> b \ ef, s: b, t: t[a]): b \ ef

    ///
    /// Right-associative fold of a structure.
    ///
    def foldRight(f: (a, b) -> b \ ef, s: b, t: t[a]): b \ ef

}

trait Coll[a] {

    /// The element type of the collection.
    type Elm

    /// Converts the collection to a list of its elements.
    def toList(coll: a): List[Coll.Elm[a]]
}

instance Coll[Map[k, v]] {
    type Elm = (k, v)

    def toList(m: Map[k, v]): List[(k, v)] = ...
}

trait Coll[a] {

    /// The element type of the collection.
    type Elm

    /// The effect associated with the collection.
    type Aef

    /// Converts the collection to a list of its elements.
    def toList(coll: a): List[Coll.Elm[a]] \ Coll.Aef[a]
}

instance Coll[MutMap[k, v, r]] {
    type Elm = (k, v)
    type Aef = r

    def toList(m: Map[k, v]): List[(k, v)] \ r = ...
}

def divide(x: Int32, y: Int32): Option[Int32] =
    if (y == 0) None else Some(x / y)

def f(): Option[Int32] =
    forM (
        x <- divide(5, 2);
        y <- divide(x, 8);
        z <- divide(9, y)
    ) yield x + y + z

def validateUser(s: String): Validation[Err, String] = ...

def validatePass(s: String): Validation[Err, String] = ...

def conn(u: String, p: String): Validation[Err, Connection] =
    forA (
        user <- validateUser(u);
        pass <- validatePass(p)
    ) yield Connection(user, pass)

import java.io.File
import java.io.FileWriter
import java.io.IOException

def main(): Unit \ IO =
    let f = new File("foo.txt");
    try {
        let w = new FileWriter(f);
        w.append("Hello World\n");
        w.close()
    } catch {
        case ex: IOException =>
            println("Unable to write file")
    }

enum Tree[a] {
    case Leaf(a)
    case Node(Tree[a], Tree[a])
}

/// The compiler verifies that `size` is structurally
/// recursive and hence terminates on all inputs.
@Terminates
def size(t: Tree[Int32]): Int32 = match t {
    case Tree.Leaf(_)    => 1
    case Tree.Node(l, r) => size(l) + size(r)
}

let p = #{
    /// Parts and the components they depend on.
    PartDepends("Car",       "Chassis").
    PartDepends("Car",       "Engine").
    PartDepends("Engine",    "Piston").
    PartDepends("Engine",    "Ignition").

    /// Time required to assemble a part from its components.
    AssemblyTime("Car",     7).
    AssemblyTime("Engine",  2).

    /// Expected delivery date for certain components.
    DeliveryDate("Chassis";  2).
    DeliveryDate("Piston";   1).
    DeliveryDate("Ignition"; 7).

    /// A part is ready when it is delivered.
    ReadyDate(part; date) :-
        DeliveryDate(part; date).

    /// Or when it can be assembled from its components.
    ReadyDate(part; assemblyTime + componentDate) :-
        PartDepends(part, component),
        AssemblyTime(part, assemblyTime),
        ReadyDate(component; componentDate).
};

// Computes the delivery date for each component.
let r = query p select (c, d) from ReadyDate(c; d)