OverCaml

(* Hello World in OCaml *)
let () =
  let name = "World" in
  Printf.printf "Hello, %s!\n" name;
  let x = 5 in
  let y = 3.2 in
  Printf.printf "Sum: %f\n"
    (float_of_int x +. y)

# Hello World in OverCaml
name = "World"
print(f"Hello, {name}!")
x = 5
y = 3.2
print(f"Sum: {x + y}")

type user = { name: string; age: int }

let find_user id =
  if id <= 0 then Error "Invalid ID"
  else Ok { name = "Alice"; age = 30 }

let process id =
  match find_user id with
  | Error e -> Error e
  | Ok user ->
    match validate user with
    | Error e -> Error e
    | Ok v ->
      match save v with
      | Error e -> Error e
      | Ok result -> Ok result

type User:
    name: str
    age: int

def find_user(id: int) -> Result[User, str]:
    if id <= 0: Err("Invalid ID")
    else: Ok(User("Alice", 30))

def process(id: int) -> Result[str, str]:
    user = find_user(id)?
    v = validate(user)?
    result = save(v)?
    Ok(result)

(* OCaml: forced into binary true/false *)
let classify confidence threshold =
  if confidence > threshold then
    "positive"
  else
    "negative"
    (* What if confidence is 0.51 and
       threshold is 0.50?
       OCaml FORCES a decision.
       No way to say "I don't know" *)

# OverCaml: three-valued honest AI
def classify(confidence, threshold) -> tlogic:
    match confidence:
        p when p > threshold     => true
        p when p < 1.0 - threshold => false
        _                        => unknown
        # "I don't know" is a VALID answer!
        # AI safety: no hallucination

(* comparable.mli — separate interface file *)
module type COMPARABLE = sig
  type t
  val compare : t -> t -> int
end

(* comparable.ml — implementation *)
module IntComparable : COMPARABLE
  with type t = int = struct
  type t = int
  let compare = Int.compare
end

(* Functor: 14 lines for a sorted set *)
module MakeSortedSet
  (M : COMPARABLE) = struct
  type t = M.t list
  let empty = []
  let add x s = (*...*) s
end

# Single file. No .mli needed.
trait Comparable:
    def compare(self, other: Self) -> int

impl Comparable for int:
    def compare(self, other):
        self - other

# Generic sorted set: 4 lines
def sorted_insert[T: Comparable](x: T, s: list[T]):
    s |> filter(e => e.compare(x) != 0)
      |> append(x)
      |> sort()

type state = {
  balances: (string * int) list;
  total_supply: int;
}

let transfer state sender to_ amount =
  let bal = List.assoc_opt sender
    state.balances
    |> Option.value ~default:0 in
  if bal < amount then
    Error "Insufficient balance"
  else
    (* No proof that total_supply
       is conserved! Trust me bro. *)
    Ok { state with balances =
      update sender (bal - amount)
        state.balances }

@contract(chain: ethereum)
@proof
def transfer(state, sender, to, amount):
    requires:
        state.balances[sender] >= amount
    ensures result:
        match result:
            Ok(new_state) =>
                # PROVEN: total supply conserved
                new_state.total_supply ==
                    state.total_supply
    body:
        bal = state.balances.get(sender, 0)
        if bal < amount:
            Err(InsufficientBalance)
        else:
            Ok(state with balances:
                update(sender, bal - amount))