One language for apps,
services, and interfaces.

module rocket {
    use std.units::*

    // Contracts belong to the function.
    def burnTime(fuel Mass, rate MassFlow) !Time {
        expects {
            assert rate > 0 onerror fail "engine off"
        }

        let t = fuel / rate
        return t

        provides {
            assert t < 10(min) onerror fail "burn too long"
        }
    }

    // A function that can run on the GPU.
    cuda def cool(temps float64[], by float64) !none {
        int i = blockIdx.x * blockDim.x + threadIdx.x;
        if (i < temps_len) temps[i] -= by;
    }

    // Foreign runtimes are callable too.
    @external.node("telemetry.js")
    async def publish(message string);
}

application Launch {
    use (std.units::* rocket)

    let fuel Mass = 0

    def load(m Mass) {
        begin { fuel += m }
        rollback { fuel -= m }
    }

    def fuelUp(m Mass) !none {
        transaction {
            load(m)
            let t = try rocket.burnTime(fuel, 2.5(t/s))
            println("burn for {t.str(s)}")
        } onerror (err error) {
            println("scrubbed: {err.message}")
            recover none
        }
        return none
    }

    def new(args string[]) int {
        fuelUp(2000(t)) onerror return 1

        let temps = float64[910.0, 870.0, 1020.0, 880.0]

        // One iteration per CPU worker.
        forall let (i, temp) in temps {
            rocket.publish("engine {i}: {int(temp)} K")
        }

        // SIMD is a language-level type.
        let v vec4<float64>
        if v.load(temps, 0).gt(v.splat(1000.0)).any() {
            rocket.cool(temps, 50.0) onerror recover none
        }

        return 0
    }
}