Standard Library

import "std/bool"

bool flag = true
str s = flag.str()  # "true" or "false"
int i = flag.int()  # 1 or 0
bool neg = !flag  # logical NOT — use the ! operator

import "std/int"

int x = -42
int absVal = x.abs()  # 42
str hex = (255).format(16)  # "ff"  — format(radix), radix 2..36
str bin = (10).format(2)  # "1010"

import "std/str"

str text = "Hello"
array[byte] bytes = text.bytes()  # [72, 101, 108, 108, 111]

import "std/array"

array[byte] bytes = new array[byte]{72, 101, 108, 108, 111}
str text = bytes.str()  # "Hello"

Terminal term = new Terminal()
term.print("Hello")  # Output without newline
term.println("World")  # Output with newline
str input = term.input()  # Read string from console

Time time = new Time()
time.sleep(1000)  # Sleep for 1000 milliseconds
int unixTime = time.unix()  # Unix timestamp in seconds
int t = time.millis()  # monotonic milliseconds (for measuring elapsed time)

Http http = new Http()
str response = http.get("https://example.com")
int status = http.statusCode()

# POST request
str jsonBody = "{\"key\": \"value\"}"
str postResponse = http.post("https://api.example.com/data", jsonBody, "")

FileSystem fs = new FileSystem()

# Reading and writing strings
fs.write("file.txt", "Content")
str content = fs.read("file.txt")
fs.append("file.txt", "\nMore content")

# Reading and writing byte arrays
import "std/str"
array[byte] data = "binary data".bytes()
fs.writeBytes("file.bin", data)
array[byte] loaded = fs.readBytes("file.bin")
fs.appendBytes("file.bin", data)

# Checks
bool exists = fs.exists("file.txt")
bool isFile = fs.isFile("file.txt")
bool isDir = fs.isDir("directory")

# Directory operations
fs.mkdir("new_dir")
array[str] files = fs.list(".")

# File operations
fs.copy("source.txt", "dest.txt")
fs.move("old.txt", "new.txt")
fs.delete("file.txt")

# Information
int fileSize = fs.size("file.txt")

Socket sock = new Socket()
sock.connect("127.0.0.1", 9876)

sock.writeLine("Hello!")
str reply = sock.readLine()

sock.close()

Socket srv = new Socket()
srv.bind(9876)

Socket client = srv.accept()  # blocks until a client connects
str msg = client.readLine()
client.writeLine("Echo: " + msg)

client.close()
srv.close()

import "std/map"

Map[str, int] ages = new Map[str, int]()

# Operator syntax
ages["Alice"] = 30
ages["Bob"] = 25

# Method syntax
ages.put("Charlie", 35)

# operator [] returns V directly — it is at(), and raises on a missing key
int age = ages["Alice"]  # 30
int same = ages.at("Alice")  # 30 — [] is defined as at()

# get() returns ptr[V] — null if key is not found
ptr[int] val = ages.get("Alice")
if (val != null) {
    int a = val.val()
}

# getOrDefault() returns V directly, with a fallback
int eveAge = ages.getOrDefault("Eve", 0)  # 0

Map[str, int] counts = new Map[str, int]()

# not this — it raises ERR_BOUNDS the first time a word is seen
# counts[word] = counts[word] + 1

counts[word] = counts.getOrDefault(word, 0) + 1

bool has = ages.key("Bob")  # true
bool empty = ages.empty()  # false
int count = ages.len  # number of entries (a field — no parentheses)

# putIfAbsent — inserts only if key is missing, returns true if inserted
bool added = ages.putIfAbsent("Diana", 28)  # true
bool again = ages.putIfAbsent("Diana", 99)  # false, value stays 28

bool removed = ages.del("Charlie")  # true
bool noop = ages.del("Charlie")  # false (already gone)

array[str] k = ages.keys()  # array of all keys
array[int] v = ages.vals()  # array of all values

int i = 0
while (i < k.len()) {
    # process k[i] and v[i]
    i = i + 1
}

ages.clear()
# ages.len is 0, ages.empty() is true

Map[int, int] big = new Map[int, int]()
int n = 0
while (n < 100) {
    big[n] = n * n
    n = n + 1
}
# capacity has grown automatically, all 100 entries are accessible

import "std/random"

Random r = new Random(42)  # seed it like java.util.Random(long)
r.nextInt()  # -1170105035 (same as the JVM)
r.nextIntBound(100)  # uniform in [0, 100)
r.nextBoolean()  # true / false
r.nextFloat()  # float in [0, 1)
r.setSeed(12345)  # reseed in place

import "std/base64"
import "std/crc32"
import "std/deflate"
import "std/zip"
import "std/str"  # for .bytes()

# Base64 — text in, text out
str encoded = base64.encode("hello")  # "aGVsbG8="
str decoded = base64.decode(encoded)  # "hello"

# CRC-32 checksum of a byte array
int sum = crc32.checksum("hello".bytes())  # 907060870

# Raw DEFLATE compression (inflate with any standard zlib, wbits = -15)
array[byte] packed = rawDeflate.compress("hello".bytes())

# Build a single-entry ZIP archive
array[byte] archive = zip.create("hello".bytes(), "greeting.txt")