Standard Library

import "std/env"

fun main() {
  let host = env_or("HOST", "localhost")
  let port = env_int("PORT")             // maybe<int>
  println("Connecting to {host}")
  match port {
    Some(p) => println("port: {p}"),
    None => println("port not set")
  }
}

import "std/dotenv"
import "std/env"

fun main() {
  dotenv_load(".env")             // load .env; don't overwrite existing vars
  let db = env_or("DB_URL", "sqlite://dev.db")
  let port = env_or("PORT", "3000")
  println("DB: {db}")
  println("PORT: {port}")
}

fun main() {
  // Transform a maybe value
  let doubled = Some(5) |> map_maybe((x) => x * 2)
  println(doubled)                // Some(10)

  // Chain maybe-returning functions
  let parsed = Some("42") |> and_then((s) => parse_int(s))
  println(parsed)                 // Some(42)

  // Safe extraction
  println(unwrap_maybe_or(None, 0))   // 0
  println(is_some(Some(1)))           // true
}

fun main() {
  // Write and read back
  write_file("greeting.txt", "hello, world!\n")
  let content = read_file("greeting.txt") |> unwrap
  println(content)

  // Line-oriented I/O (throws on error)
  write_lines("names.txt", ["Kalle", "Olle", "Lisa"])
  let names = read_lines("names.txt")
  for name in names {
    println("Hi, {name}!")
  }

  // Handle errors explicitly
  match read_file("missing.txt") {
    Ok(text) => println(text),
    Err(msg) => println("Could not read: {msg}")
  }

  // Provide a fallback
  let data = read_file("config.txt") |> unwrap_or("default")
  println(data)
}

fun main() {
  println(range(0, 5))                      // [0, 1, 2, 3, 4]
  println(range_inc(1, 5))                   // [1, 2, 3, 4, 5]
  println(sum([1, 2, 3, 4, 5]))           // 15
  println(sort_by([3, 1, 4], (a, b) => a <= b))  // [1, 3, 4]
  println(unique([1, 2, 3, 2, 1]))        // [1, 2, 3]
  println(chunks([1, 2, 3, 4, 5], 2))     // [[1, 2], [3, 4], [5]]
  println(head([10, 20, 30]))             // Some(10)
  println(last([10, 20, 30]))             // Some(30)
  println(flat_map([1, 2, 3], (x) => [x, x * 10]))  // [1, 10, 2, 20, 3, 30]
  println(head_or([], 0))                 // 0
  println(take_while([1,2,3,4,5], (n) => n < 4))  // [1, 2, 3]
  println(drop_while([1,2,3,4,5], (n) => n < 4))  // [4, 5]
  println(count([1,2,3,4,5], (n) => n % 2 == 0))  // 2
  let gs = group_by(["cat","cup","dog"], (w) => w[0:1])
  println(length(gs))                     // 2 groups: "c", "d"
  let words = ["hi", "hello", "hey"]
  match min_by(words, (s) => str_length(s)) {
    Some(w) => println(w),               // hi
    None => println("empty")
  }
}

import "std/stream"
import "std/list"

fun main() {
  // Basic pipeline with zero intermediate list allocations:
  let lazy_result = stream([1..20])
    .filter((x) => x % 2 == 0)
    .map((x) => x * x)
    .take(5)
    .collect()
  println("stream: {lazy_result}") // [4, 16, 36, 64, 100]

  // Early termination (source stops generating after finding 3 matches):
  let first_threes = stream([1..1000])
    .filter((x) => x % 7 == 0)
    .take(3)
    .collect()
  println("first 3 multiples of 7: {first_threes}") // [7, 14, 21]

  // Fold without materialising lists:
  let sum_squares = stream([1..1000])
    .filter((x) => x % 2 == 0)
    .map((x) => x * x)
    .take(10)
    .fold(0, (acc, x) => acc + x)
  println("sum: {sum_squares}") // 1540

  // Zip and Enumerate:
  let words = ["hello", "hica"]
  let indexed = stream(words).enumerate().collect()
  println(indexed) // [(0, "hello"), (1, "hica")]
}

import "std/stream"
import "std/xform"

fun main() {
  // Build a reusable transducer pipeline (no data source is bound yet!)
  let double_evens =
    xf_filter((x) => x % 2 == 0)
    |> xf_map((x) => x * 2)
    |> xf_take(3)

  let list1 = [1..10]
  let list2 = [11..20]

  // Apply the transducer pipeline to multiple sources
  let r1 = list1 |> transduce(double_evens)
  let r2 = list2 |> transduce(double_evens)

  println("r1: {r1}") // [4, 8, 12]
  println("r2: {r2}") // [24, 28, 32]

  // Start a transducer with map
  let double_only =
    xf_map_start((x) => x * 2)
    |> xf_filter_with((x) => x > 10)

  let r3 = [1..10] |> transduce(double_only)
  println("r3: {r3}") // [12, 14, 16, 18, 20]
}

import "std/nel"
import "std/validated"

fun validate_name(s: string) : Validated =>
  if str_length(s) < 3 { invalid("Name too short") } else { valid(s) }

fun validate_email(s: string) : Validated =>
  if !contains(s, "@") { invalid("Invalid email format") } else { valid(s) }

fun main() {
  // Zip/combine multiple validations to accumulate all failures:
  let outcome = zip_validated(
    validate_name("jd"),
    validate_email("invalid-email"),
    (name, email) => "{name}:{email}"
  )

  match outcome {
    Valid(info) => println("Success: {info}"),
    Invalid(errs) => {
      println("Failed with errors:")
      for err in nel_to_list(errs) {
        println("  - {err}")
      }
    }
  }
}

fun main() {
  let scores = {"kalle": 95, "olle": 87}
  println(scores.map_get("kalle"))       // Just(95)

  let scores2 = scores.map_set("lisa", 92)
  println(scores2.map_keys())            // ["kalle", "olle", "lisa"]

  let scores3 = scores2.map_remove("olle")
  println(scores3.map_size())            // 2
}

fun main() {
  let t = now_unix()
  let s = now_iso()
  println("epoch: {t}")
  println("iso:   {s}")
  println(unix_to_iso(1716800000))   // "2024-05-27T08:53:20Z"
}

fun main() {
  let die = random(1, 6)
  println("You rolled a {die}")
  let f = random_float()
  println(f >= 0.0 && f < 1.0)   // true
}

fun main() {
  let flags = 0b1010_1100
  let masked = bit_and(flags, 0x0F)   // keep low nibble → 12
  println(masked)

  // UFCS / dot-call style
  let shifted = flags.bit_shr(4)       // → 10
  println(shifted)
}

fun main() {
  println(show_fixed(3.14159, 2))  // "3.14"
  println(show_fixed(100.0 / 3.0, 1))  // "33.3"
}

fun main() {
  let name = input("What is your name? ")
  println("Hello, {name}!")
}

fun main() {
  println(sqrt(16.0))     // 4.0
  println(floor(3.7))     // 3
  println(ceil(3.2))      // 4
  println(round(3.5))     // 4
  println(to_float(42))   // 42.0
  println(pow(2, 10))     // 1024
  println(lcm(12, 18))    // 36
  println(isqrt(25))      // 5
  println(isqrt(26))      // 5
}

fun main() {
  let cs = chars("hello")
  println(cs)              // ['h', 'e', 'l', 'l', 'o']
  println(from_chars(cs))  // "hello"

  // Construct chars from code points
  println(chr(65))         // A
  println(ord('A'))        // 65

  // Build strings from code points
  let hi = from_chars([chr(72), chr(105)])
  println(hi)              // Hi
}

fun main() {
  println("apple" < "banana")   // true
  println("zoo" > "abc")        // true
  println("abc" <= "abc")       // true
}

fun main() {
  let s = "hello"
  println(s[0])      // 'h'
  println(s[1:4])    // "ell"
  println(s[:3])     // "hel"
  println(s[-1])     // 'o'
}

import "std/trusted"

// Only Trusted values may reach this function — enforced at compile time.
fun audit_log(event: string, actor: Trusted) {
  println("[AUDIT] " + event + " actor=" + trusted_value(actor))
}

fun handle_request(raw_actor: string) {
  let actor = validate_and(
    validate_nonempty(raw_actor),
    validate_alnum(raw_actor)        // rejects spaces, control chars, metacharacters
  )
  match actor {
    Some(a) => audit_log("login", a),
    None    => println("rejected: invalid actor")
  }

  // This does NOT compile — raw string cannot be passed where Trusted is required:
  // audit_log("login", raw_actor)
}

fun main() {
  // Character classification
  println(is_digit(chr(48)))          // true ('0')
  println(is_alpha(chr(65)))          // true ('A')
  println(all_digits("12345"))        // true
  println(all_upper("HELLO"))         // true

  // Simple glob
  println(glob_match("*.txt", "readme.txt"))   // true
  println(glob_match("h?llo", "hello"))        // true

  // Path glob with **
  println(glob_match_path("src/**/*.hc", "src/lib/util.hc"))   // true
  println(glob_match_path("**/*.txt", "a/b/c/file.txt"))       // true
}

import "std/datetime"

fun main() {
  let deadline = date_to_unix("2026-12-31")
  let release  = date_to_unix("2024-01-01")
  println(days_since(release))                    // days since release
  println(is_older_than_days(deadline, 365))      // false — still in the future
  println(days_diff(deadline, date_to_unix("2026-01-01")))  // 364
}

import "std/datetime"

fun main() {
  let created_at = now_unix() - 7300   // simulate a 2-hour-old record
  println(hours_since(created_at))           // 2
  println(is_older_than_hours(created_at, 1)) // true
  let updated_at = now_unix() - 172800
  println(days_diff(now_unix(), updated_at))  // 2
}

import "std/datetime"

fun main() {
  println(datetime_kind("07:32:00"))                // "local-time"

  // Decompose a date
  match date_parts("2024-05-15") {
    Ok(parts) => println("{parts.0}-{parts.1}-{parts.2}"),
    Err(e) => println(e)
  }

  // Compare dates
  println(is_before("2024-01-01", "2024-12-31"))    // true

  // Offset conversion
  match offset_to_minutes("+05:30") {
    Ok(m) => println(m),   // 330
    Err(e) => println(e)
  }

  // Weekday
  match day_of_week("2026-05-15") {
    Ok(d) => println(d),   // "friday"
    Err(e) => println(e)
  }
}

fun main() {
  let nums = [1, 2, 3, 4, 5]
  let evens = filter(nums, (x) => x % 2 == 0)
  let doubled = map(nums, (x) => x * 2)
  println(evens)
  println(doubled)
}

fun main() {
  let nums = [1, 2, 3, 4, 5]
  let total = fold(nums, 0, (acc, x) => acc + x)
  println(total)
}

fun main() {
  // Pipe style
  let a = [1, 2, 3, 4, 5]
    |> filter((x) => x % 2 == 0)
    |> map((x) => x * 10)
    |> fold(0, (acc, x) => acc + x)
  println(a)

  // Dot-call style (equivalent)
  let b = [1, 2, 3, 4, 5]
    .filter((x) => x % 2 == 0)
    .map((x) => x * 10)
    .fold(0, (acc, x) => acc + x)
  println(b)
}

fun main() {
  let msg = "  Hello, World!  "
  println(trim(msg))
  println(to_upper(trim(msg)))
  println(contains(msg, "World"))

  let csv = "kalle,olle,lisa"
  println(split(csv, ","))
  println(join(split(csv, ","), " & "))
  println(replace(csv, ",", " | "))
}

fun main() {
  println(words("the  quick   fox"))
  println(pad_left("42", 6, "0"))
  println(surround("hello", "**"))
}