-- Values are the default. No `let mut`, no `var`.
let name = "JAPL"
let point = { x = 3.0, y = 4.0 }
let items = [1, 2, 3, 4, 5]

-- Transformation produces new values, never mutates in place.
let shifted = { point | x = point.x + 1.0 }
let doubled = List.map items (fn x -> x * 2)

-- Process-local state via recursion (pure, no mutation)
fn counter(n: Int, acc: Int) -> Int =
  if n == 0 then acc
  else counter(n - 1, acc + n)

-- Explicit mutable state via effect
fn accumulate(items: List[Int]) -> Int with State[Int] =
  List.each items (fn x -> State.modify (fn acc -> acc + x))
  State.get()

-- Resource-layer mutable buffer (ownership tracked)
fn fill_buffer() -> Bytes with Io =
  let buf = Buffer.alloc(1024)   -- linear resource
  Buffer.write(buf, 0, data)
  Buffer.freeze(buf)              -- converts to immutable Bytes

type CounterMsg =
  | Increment
  | Decrement
  | GetCount(Reply[Int])

fn counter_process(count: Int) -> Never with Process[CounterMsg] =
  match Process.receive() with
  | Increment -> counter_process(count + 1)
  | Decrement -> counter_process(count - 1)
  | GetCount(reply) ->
      Reply.send(reply, count)
      counter_process(count)

-- Spawning a process
let pid = Process.spawn(fn -> counter_process(0))
Process.send(pid, Increment)

-- Result types for expected failures
type ParseError =
  | InvalidSyntax(String, Int)
  | UnexpectedEof

fn parse(input: String) -> Result[Ast, ParseError] =
  -- ...

-- Pattern matching forces handling
match parse(source) with
| Ok(ast) -> compile(ast)
| Err(InvalidSyntax(msg, line)) -> report_error(msg, line)
| Err(UnexpectedEof) -> report_error("unexpected end of file", 0)

-- Crash semantics for unexpected failures
fn database_worker(conn: DbConn) -> Never with Process[DbQuery] =
  -- If this crashes, the supervisor restarts it with a fresh connection
  let query = Process.receive()
  let result = Db.execute(conn, query)  -- may crash on connection loss
  Process.send(query.reply_to, result)
  database_worker(conn)

-- Connect to a remote node
let remote = Node.connect("worker-2.cluster.local:9000")

-- Spawn a process on a remote node
let pid = Process.spawn_on(remote, fn -> image_processor())

-- Send a message -- same syntax regardless of location
Process.send(pid, ProcessImage(image_data))

-- Service discovery
let registry = Registry.connect("service-registry.local")
let workers = Registry.lookup(registry, "image-processor")

-- Functions compose naturally
let process_order =
  validate_order
  >> calculate_totals
  >> apply_discounts
  >> generate_invoice

-- Pipelines for readability
let result =
  raw_data
  |> parse_csv
  |> List.filter(fn row -> row.amount > 0)
  |> List.map(to_transaction)
  |> List.sort_by(fn t -> t.date)

-- Modules group related functions
module Json =
  fn parse(input: String) -> Result[JsonValue, ParseError] = ...
  fn encode(value: JsonValue) -> String = ...
  fn pretty_print(value: JsonValue, indent: Int) -> String = ...

-- Runtime introspection is built in
let info = Process.info(pid)
-- { status: Running, message_queue_len: 3, memory: 4096, ... }

let tree = Supervisor.which_children(sup)
-- Visual tree of all supervised processes and their states

-- Module declaration
module Http.Server

-- Import
import Http.{Request, Response, Status}
import Json

-- Type alias
type alias Headers = Map[String, String]

-- Function declaration
fn handle_request(req: Request) -> Response with Io, Net =
  let body = Json.parse(req.body)
  match body with
  | Ok(data) -> Response.json(Status.Ok, data)
  | Err(_) -> Response.text(Status.BadRequest, "invalid JSON")

-- No semicolons, no braces for blocks, indentation-aware
-- No classes, no `this`/`self`, no method dispatch

-- Sum type (tagged union)
type Shape =
  | Circle(Float)
  | Rectangle(Float, Float)
  | Triangle(Float, Float, Float)

-- Parametric polymorphism
fn map(list: List[a], f: fn(a) -> b) -> List[b] =
  match list with
  | [] -> []
  | [x, ..rest] -> [f(x), ..map(rest, f)]

-- Row-polymorphic record
fn get_name(r: { name: String | rest }) -> String =
  r.name

-- This works for ANY record that has a `name: String` field
let _ = get_name({ name = "Alice", age = 30 })
let _ = get_name({ name = "Bob", email = "[email protected]" })

-- Trait definition
trait Show[a] =
  fn show(value: a) -> String

-- Trait implementation
impl Show[Shape] =
  fn show(shape) =
    match shape with
    | Circle(r) -> "Circle(" ++ Float.to_string(r) ++ ")"
    | Rectangle(w, h) -> "Rectangle(" ++ Float.to_string(w) ++ ", " ++ Float.to_string(h) ++ ")"
    | Triangle(a, b, c) -> "Triangle(...)"

-- Capability type
type FileHandle = capability {
  read: fn(Int) -> Bytes with Io,
  write: fn(Bytes) -> Result[Int, IoError] with Io,
  close: fn() -> Unit with Io,
}

-- Pure layer: GC-managed, immutable, freely shareable
let data = [1, 2, 3, 4, 5]
let copy = data  -- sharing is fine, data is immutable

-- Resource layer: ownership-tracked, must be consumed
fn process_file(path: String) -> Result[String, IoError] with Io =
  -- `use` binds a linear resource that must be consumed
  use file = File.open(path, Read)?
  let contents = File.read_all(file)?
  File.close(file)  -- consumed here; forgetting this is a compile error
  Ok(contents)

-- Transfer ownership
fn send_to_worker(buf: own Buffer, pid: Pid[WorkerMsg]) -> Unit =
  Process.send(pid, ProcessBuffer(buf))
  -- `buf` is moved; using it here is a compile error

-- Borrow (read-only reference, does not consume)
fn peek(buf: ref Buffer) -> Byte =
  Buffer.get(buf, 0)

-- Pure function: no annotation needed
fn add(a: Int, b: Int) -> Int =
  a + b

-- Effectful function: effects listed after `with`
fn read_config(path: String) -> Config with Io, Fail[ConfigError] =
  let text = File.read_to_string(path)?
  parse_config(text)?

-- Effects compose: calling effectful functions in a pure context is a type error
fn handler(req: Request) -> Response with Io, Net, Fail[AppError] =
  let config = read_config("/etc/app.conf")?    -- adds Io, Fail[ConfigError]
  let data = Http.get(config.data_url)?          -- adds Net
  process_response(data)

-- Effect handlers: run effectful code, providing the effect implementation
fn main() -> Unit with Io =
  let result = State.run(0, fn ->
    accumulate([1, 2, 3, 4, 5])
  )
  Io.println(Int.to_string(result))

-- Define message types
type WorkerMsg =
  | DoWork(Task, Reply[TaskResult])
  | Shutdown

-- Define a worker process
fn worker(state: WorkerState) -> Never with Process[WorkerMsg] =
  match Process.receive() with
  | DoWork(task, reply) ->
      let result = execute_task(state, task)
      Reply.send(reply, result)
      worker(state)
  | Shutdown ->
      cleanup(state)
      Process.exit(Normal)

-- Typed mailbox prevents sending wrong message types
let pid: Pid[WorkerMsg] = Process.spawn(fn -> worker(initial_state))
Process.send(pid, DoWork(my_task, reply_channel))

-- Selective receive with timeout
fn wait_for_response(timeout_ms: Int) -> Result[Response, Timeout] with Process[Msg] =
  Process.receive_with_timeout(timeout_ms) {
  | DataReady(data) -> Ok(process(data))
  | _ -> Err(Timeout)
  }

type RestartStrategy =
  | OneForOne      -- restart only the failed child
  | AllForOne      -- restart all children if one fails
  | RestForOne     -- restart the failed child and all children started after it

type ChildSpec =
  { id: String
  , start: fn() -> Never
  , restart: Permanent | Transient | Temporary
  , shutdown: Timeout(Int) | Brutal
  }

fn start_app() -> Pid[SupervisorMsg] with Process =
  Supervisor.start(
    strategy = OneForOne,
    max_restarts = 5,
    max_seconds = 60,
    children = [
      { id = "db_pool"
      , start = fn -> DbPool.start(config.database)
      , restart = Permanent
      , shutdown = Timeout(5000)
      },
      { id = "http_server"
      , start = fn -> HttpServer.start(config.http)
      , restart = Permanent
      , shutdown = Timeout(10000)
      },
      { id = "background_jobs"
      , start = fn -> JobRunner.start(config.jobs)
      , restart = Transient
      , shutdown = Timeout(30000)
      },
    ]
  )

type AppError =
  | NotFound(String)
  | Unauthorized
  | ValidationError(List[FieldError])
  | DatabaseError(DbError)

fn get_user(id: UserId) -> Result[User, AppError] with Io =
  let row = Db.query_one(sql, [id])? |> map_err(DatabaseError)?
  validate_user(row)?
  Ok(to_user(row))

-- The `?` operator propagates errors, analogous to Rust
-- Equivalent to:
--   match Db.query_one(sql, [id]) with
--   | Ok(row) -> ...
--   | Err(e) -> Err(DatabaseError(e))

-- A process that crashes is restarted by its supervisor
-- No need to handle every possible failure in the process itself
fn tcp_acceptor(listener: TcpListener) -> Never with Process[AcceptorMsg], Io =
  let conn = Tcp.accept(listener)  -- may crash on OS error
  let pid = Process.spawn(fn -> handle_connection(conn))
  Process.link(pid)                -- link so we know if handler crashes
  tcp_acceptor(listener)           -- loop; if WE crash, supervisor restarts us

-- Node configuration
let node = Node.start(
  name = "web-1",
  cookie = Env.get("CLUSTER_COOKIE"),
  listen = "0.0.0.0:9000",
)

-- Remote process spawn
let remote_node = Node.connect("worker-1.internal:9000")
let pid = Process.spawn_on(remote_node, fn ->
  heavy_computation(params)
)

-- Monitor remote process
Process.monitor(pid)

-- Receive results (same syntax as local)
match Process.receive() with
| ComputationResult(data) -> handle_result(data)
| ProcessDown(^pid, reason) -> handle_failure(reason)

-- Type-derived serialization: any type that derives Serialize
-- can cross node boundaries
type JobRequest deriving(Serialize, Deserialize) =
  { id: JobId
  , payload: Bytes
  , priority: Priority
  }

-- Built-in test syntax
test "parsing a valid integer" =
  assert parse_int("42") == Ok(42)

test "parsing rejects non-numeric input" =
  assert parse_int("abc") == Err(InvalidInt("abc"))

-- Property-based testing
property "reversing a list twice is identity" =
  forall (xs: List[Int]) ->
    List.reverse(List.reverse(xs)) == xs

-- Benchmarks
bench "fibonacci 30" =
  fibonacci(30)

-- The compiler statically determines which layer each value lives in

-- Immutable heap (automatic)
let config = { host = "localhost", port = 8080 }

-- Resource arena (explicit)
use socket = Tcp.connect(config.host, config.port)?
let response = Tcp.send(socket, request)?
Tcp.close(socket)  -- deterministic cleanup

-- Declare a foreign function
foreign "C" fn sqlite3_open(filename: CString, db: Ptr[Ptr[Sqlite3]]) -> CInt

-- Wrap in a safe JAPL interface
fn open_database(path: String) -> Result[Database, DbError] with Io =
  use filename = CString.from(path)
  use db_ptr = Ptr.alloc[Ptr[Sqlite3]]()
  let rc = unsafe sqlite3_open(filename, db_ptr)
  if rc == 0 then
    Ok(Database.from_raw(Ptr.read(db_ptr)))
  else
    Err(DbError.from_code(rc))

-- WASM interop
foreign "wasm" module "image_codec" =
  fn encode_png(data: Bytes, width: Int, height: Int) -> Bytes
  fn decode_png(data: Bytes) -> Result[Image, CodecError]

-- Module definition
module Map

-- Opaque type (implementation hidden)
opaque type Map[k, v]

-- Public interface
fn empty() -> Map[k, v]
fn insert(map: Map[k, v], key: k, value: v) -> Map[k, v] where Ord[k]
fn lookup(map: Map[k, v], key: k) -> Option[v] where Ord[k]
fn delete(map: Map[k, v], key: k) -> Map[k, v] where Ord[k]
fn fold(map: Map[k, v], init: acc, f: fn(acc, k, v) -> acc) -> acc

-- Module signature (interface)
signature KeyValueStore[k, v] =
  type Store
  fn create() -> Store with Io
  fn get(store: Store, key: k) -> Option[v] with Io
  fn set(store: Store, key: k, value: v) -> Unit with Io
  fn delete(store: Store, key: k) -> Unit with Io

-- Module implementing a signature
module RedisStore : KeyValueStore[String, String] =
  type Store = RedisConnection
  fn create() -> Store with Io = Redis.connect(default_config)
  fn get(store, key) with Io = Redis.get(store, key)
  fn set(store, key, value) with Io = Redis.set(store, key, value)
  fn delete(store, key) with Io = Redis.del(store, key)

-- 1. Process-local state via recursion (most common)
fn server_loop(state: ServerState) -> Never with Process[ServerMsg] =
  let msg = Process.receive()
  let new_state = handle_message(state, msg)
  server_loop(new_state)

-- 2. State effect (for single-threaded stateful computation)
fn parser(input: String) -> Ast with State[ParserState], Fail[ParseError] =
  State.put({ input = input, pos = 0, errors = [] })
  let ast = parse_expression()
  let final_state = State.get()
  if List.is_empty(final_state.errors) then ast
  else Fail.raise(ParseError(final_state.errors))

-- 3. Linear mutable cells (for performance-critical code)
fn sort_in_place(arr: own MutableArray[Int]) -> own MutableArray[Int] =
  let len = MutableArray.length(arr)
  -- imperative loop with owned mutable array
  loop i = 0, arr = arr while i < len do
    loop j = i + 1, arr = arr while j < len do
      if MutableArray.get(arr, j) < MutableArray.get(arr, i) then
        let arr = MutableArray.swap(arr, i, j)
        continue(j + 1, arr)
      else
        continue(j + 1, arr)
    continue(i + 1, arr)
  arr

-- Packed struct layout (contiguous memory, no pointers)
type Vec3 = packed { x: Float32, y: Float32, z: Float32 }

-- Tagged unions have efficient representations
type Particle = packed
  | Active(Vec3, Vec3, Float32)   -- position, velocity, mass
  | Inactive

-- Structural records (anonymous, row-polymorphic)
let point = { x = 1.0, y = 2.0 }

-- Zero-copy byte slicing
fn parse_header(data: Bytes) -> Header with Fail[ParseError] =
  let magic = Bytes.slice(data, 0, 4)    -- no copy, just a view
  let version = Bytes.read_u32_be(data, 4)
  let length = Bytes.read_u32_be(data, 8)
  { magic, version, length }

fn routes() -> Router =
  Router.new()
  |> Router.get("/users/:id", get_user_handler)
  |> Router.post("/users", create_user_handler)
  |> Router.delete("/users/:id", delete_user_handler)

fn get_user_handler(req: Request) -> Response with Io, Net, Fail[AppError] =
  let id = Request.param(req, "id") |> parse_user_id?
  let user = UserRepo.find_by_id(id)?
  match user with
  | Some(u) -> Response.json(200, User.to_json(u))
  | None -> Response.json(404, Json.object([("error", Json.string("not found"))]))

fn create_user_handler(req: Request) -> Response with Io, Net, Fail[AppError] =
  let body = Request.json_body(req)?
  let params = CreateUserParams.from_json(body)?
  let user = UserRepo.create(params)?
  Response.json(201, User.to_json(user))

-- Pure function: transforms data
fn calculate_price(item: Item, quantity: Int, discount: Discount) -> Money =
  let base = Money.multiply(item.price, quantity)
  Discount.apply(discount, base)

-- Process: owns state over time, delegates logic to functions
fn order_processor(state: OrderState) -> Never with Process[OrderMsg] =
  match Process.receive() with
  | NewOrder(order) ->
      let priced = List.map(order.items, fn item ->
        { item | total = calculate_price(item, item.qty, order.discount) }
      )
      let new_state = { state | pending = Map.insert(state.pending, order.id, priced) }
      order_processor(new_state)
  | ConfirmOrder(id, reply) ->
      match Map.lookup(state.pending, id) with
      | Some(order) ->
          Reply.send(reply, Ok(order))
          order_processor({ state | pending = Map.delete(state.pending, id) })
      | None ->
          Reply.send(reply, Err(OrderNotFound(id)))
          order_processor(state)

Int          -- arbitrary precision integer
Float        -- 64-bit IEEE 754
Float32      -- 32-bit IEEE 754
Bool         -- True | False
Char         -- Unicode scalar value
String       -- UTF-8 encoded, immutable
Bytes        -- raw byte sequence, immutable
Unit         -- the unit type, single value ()
Never        -- the bottom type, no values (for non-terminating processes)

-- Sum types (tagged unions)
type Option[a] =
  | Some(a)
  | None

type Result[a, e] =
  | Ok(a)
  | Err(e)

type List[a] =
  | Cons(a, List[a])
  | Nil

-- Product types (records)
type User =
  { id: UserId
  , name: String
  , email: String
  , created_at: Timestamp
  }

-- Signature required at module boundary
fn process(items: List[Item]) -> Summary with Io =
  -- Types inferred within the body
  let totals = List.map(items, fn item -> item.price * item.quantity)
  let sum = List.fold(totals, 0, fn acc, t -> acc + t)
  { item_count = List.length(items), total = sum }

trait Eq[a] =
  fn eq(x: a, y: a) -> Bool

trait Ord[a] where Eq[a] =
  fn compare(x: a, y: a) -> Ordering

trait Functor[f] =
  fn map(fa: f[a], func: fn(a) -> b) -> f[b]

trait Serialize[a] =
  fn serialize(value: a) -> Bytes
  fn deserialize(data: Bytes) -> Result[a, SerializeError]

-- Deriving
type Point deriving(Eq, Ord, Show, Serialize) =
  { x: Float, y: Float }

-- This function works on ANY record with a `name` field
fn greet(person: { name: String | r }) -> String =
  "Hello, " ++ person.name ++ "!"

-- All of these work:
greet({ name = "Alice" })
greet({ name = "Bob", age = 30 })
greet({ name = "Charlie", role = Admin, email = "[email protected]" })

type FsCapability = capability { root: Path, permissions: FsPermissions }

fn read_file(cap: FsCapability, path: Path) -> Result[String, IoError] with Io =
  if Path.is_within(path, cap.root) && cap.permissions.read then
    File.read_to_string(path)
  else
    Err(PermissionDenied)

Pure < State[s] < Io
Pure < Fail[e]
Pure < Process < Async
Pure < Net < Io

-- Running a State effect
let result: Int = State.run(initial_state, fn ->
  stateful_computation()
)

-- Running a Fail effect
let result: Result[a, e] = Fail.catch(fn ->
  fallible_computation()
)

-- Effects can be handled at any level
fn main() -> Unit with Io =
  let result = Fail.catch(fn ->
    State.run(0, fn ->
      complex_computation()
    )
  )
  match result with
  | Ok(value) -> Io.println("Success: " ++ show(value))
  | Err(e) -> Io.println("Error: " ++ show(e))

-- The compiler infers this function has effects: Io, Fail[ParseError]
fn load_config(path: String) -> Config with Io, Fail[ParseError] =
  let text = File.read_to_string(path)   -- infers Io
  parse_config(text)                       -- infers Fail[ParseError]

Spawned -> Running -> (Waiting | Running) -> Exited(reason)

-- Spawn
let pid: Pid[Msg] = Process.spawn(fn -> process_body())

-- Send (async, non-blocking, always succeeds for local processes)
Process.send(pid, message)

-- Receive (blocking, with optional timeout)
let msg = Process.receive()
let msg = Process.receive_with_timeout(5000)

-- Selective receive
let msg = Process.receive_matching(fn msg ->
  match msg with
  | Priority(High, _) -> True
  | _ -> False
)

-- Links (bidirectional failure propagation)
Process.link(pid)

-- Monitors (unidirectional failure observation)
let ref = Process.monitor(pid)
-- Receives ProcessDown(ref, pid, reason) when monitored process exits

type LoggerMsg =
  | Log(Level, String)
  | Flush(Reply[Unit])
  | SetLevel(Level)

-- This process can only receive LoggerMsg
fn logger(config: LogConfig) -> Never with Process[LoggerMsg] =
  match Process.receive() with
  | Log(level, msg) ->
      if level >= config.min_level then
        write_log(config.output, level, msg)
      logger(config)
  | Flush(reply) ->
      flush_output(config.output)
      Reply.send(reply, ())
      logger(config)
  | SetLevel(level) ->
      logger({ config | min_level = level })

            Application Supervisor
           /          |           \
     DB Pool      HTTP Server    Job Runner
     /    \        /    \            |
  Conn1  Conn2  Acc1   Acc2     Worker Pool
                                /    |    \
                             W1     W2     W3

+--------------------------------------------------+
|                  JAPL Process                      |
|                                                    |
|  +-------------------+  +----------------------+  |
|  |   Immutable Heap   |  |   Resource Arena     |  |
|  |   (GC-managed)     |  |   (Ownership-managed)|  |
|  |                     |  |                      |  |
|  |  - ADT values       |  |  - File handles      |  |
|  |  - Records          |  |  - Sockets           |  |
|  |  - Closures         |  |  - Buffers           |  |
|  |  - Strings          |  |  - FFI pointers      |  |
|  |  - Lists/Maps       |  |  - GPU resources     |  |
|  |                     |  |                      |  |
|  |  Freely shareable   |  |  Single owner        |  |
|  |  across processes   |  |  Deterministic free  |  |
|  +-------------------+  +----------------------+  |
+--------------------------------------------------+

-- Resource lifecycle
fn example() -> Unit with Io =
  use conn = Db.connect(url)?        -- conn is owned here
  let result = Db.query(ref conn, sql)?  -- borrow for query
  Db.close(conn)                     -- ownership consumed, resource freed
  -- conn cannot be used here: compile error