Standard library#

-- `ByteBuffer` is a real builtin type with methods, unlike the `int`
-- handles used elsewhere. It is a seekable binary read/write cursor.
task main() -> void {
    pilot buf: ByteBuffer = ByteBuffer::new()

    buf.write_word("hi")
    buf.write_int(7)
    buf.write_byte(255)

    say word_from_int(buf.length())
    say word_from_int(buf.position())

    -- Rewind and read the same values back.
    buf.seek(0)
    say buf.read_word(2)
    say word_from_int(buf.read_int())
    say word_from_int(buf.read_byte())
    say word_from_int(buf.remaining())

    -- status() reports the last failure; 0 means clean.
    say word_from_int(buf.status())

    buf.release()
}

11
0
hi
7
255
0
0

-- Two numeric surfaces exist side by side:
--   `math::*` are compiler builtins over `num` (floating point).
--   `std_*` come from std/math.fk and work on `int`.
task main() -> void {
    -- builtins, num
    say format_num(math::sqrt(144.0))
    say format_num(math::pow(2.0, 10.0))
    say format_num(math::floor(3.9))
    say format_num(math::ceil(3.1))
    say format_num(math::sin(0.0))
    say format_num(math::cos(0.0))

    -- std/math.fk, int
    say word_from_int(std_abs(0 - 9))
    say word_from_int(std_max(3, 8))
    say word_from_int(std_min(3, 8))
    say word_from_int(std_clamp(42, 0, 10))
    say word_from_int(std_pow(2, 8))
    say word_from_int(std_gcd(84, 30))
    say word_from_int(std_lcm(4, 6))
    say word_from_int(std_factorial(6))
    say word_from_int(std_fibonacci(12))
    say word_from_bool(std_is_even(4))
    say word_from_int(std_sign(0 - 3))
}

12
1024
3
4
0
1
9
8
3
10
256
6
12
720
144
true
-1

-- `fs::*` are compiler builtins. Paths are plain `word` values.
task main() -> void {
    fs::write("sortie.log", "launch\n")
    fs::append("sortie.log", "engage\n")

    if fs::exists("sortie.log") {
        say fs::read("sortie.log").trim()
    }

    fs::make_dir("hangar_out")
    say word_from_bool(fs::exists("hangar_out"))

    -- `fs::delete` is file-only in V3, and reports true when the file is
    -- gone -- whether this call removed it or it was already absent.
    say word_from_bool(fs::delete("sortie.log"))
    say word_from_bool(fs::exists("sortie.log"))
}

launch
engage
true
true
false

-- Process and clock builtins.
-- Note: `process::args()` is deliberately rejected by V3. Use the
-- indexed pair `process::args_count()` / `process::arg(i)` instead.
task main() -> void {
    pilot argc: int = process::args_count()
    say word_from_int(argc)

    pilot mut i: int = 0
    repeat argc times {
        say "arg {i}: " + process::arg(i)
        i += 1
    }

    pilot started: int = time::now_ms()
    pilot mut spin: int = 0
    repeat 1000 times {
        spin += 1
    }
    pilot elapsed: int = time::now_ms() - started
    say word_from_bool(elapsed >= 0)
    say word_from_bool(process::env("PATH").length() > 0)
}

3
arg 0: C:\Users\cozor\AppData\Local\Temp\fkdocs_e8et7pyk\process_time.exe
arg 1: alpha
arg 2: bravo
true
true

-- Two numeric surfaces exist side by side:
--   `math::*` are compiler builtins over `num` (floating point).
--   `std_*` come from std/math.fk and work on `int`.
task main() -> void {
    -- builtins, num
    say format_num(math::sqrt(144.0))
    say format_num(math::pow(2.0, 10.0))
    say format_num(math::floor(3.9))
    say format_num(math::ceil(3.1))
    say format_num(math::sin(0.0))
    say format_num(math::cos(0.0))

    -- std/math.fk, int
    say word_from_int(std_abs(0 - 9))
    say word_from_int(std_max(3, 8))
    say word_from_int(std_min(3, 8))
    say word_from_int(std_clamp(42, 0, 10))
    say word_from_int(std_pow(2, 8))
    say word_from_int(std_gcd(84, 30))
    say word_from_int(std_lcm(4, 6))
    say word_from_int(std_factorial(6))
    say word_from_int(std_fibonacci(12))
    say word_from_bool(std_is_even(4))
    say word_from_int(std_sign(0 - 3))
}

-- std/convert.fk: base conversion and safe parsing.
task main() -> void {
    say int_to_hex(255)
    say int_to_bin(10)
    say int_to_oct(64)
    say word_from_int(char_to_digit("7"))
    say word_from_int(word_to_int_safe("not a number"))
    say word_from_int(word_to_int_safe("123"))
    say bool_to_word(true)
}

ff
1010
100
7
0
123
true

-- std/json.fk is a pure-FREAK parser. Values are `int` handles.
task main() -> void {
    json_init()

    pilot doc: int = json_parse("{\"unit\":\"Valkyries\",\"members\":4,\"ready\":true}")

    say json_get_type(doc)
    say word_from_int(json_obj_len(doc))
    say word_from_bool(json_obj_has(doc, "unit"))

    say json_get_str(json_obj_get(doc, "unit"))
    say word_from_int(json_get_int(json_obj_get(doc, "members")))
    say word_from_bool(json_get_bool(json_obj_get(doc, "ready")))

    pilot list: int = json_parse("[10, 20, 30]")
    say word_from_int(json_arr_len(list))
    say word_from_int(json_get_int(json_arr_get(list, 1)))
}

o
3
true
Valkyries
4
true
3
20

-- std/version.fk implements semver parsing and constraint matching.
task main() -> void {
    pilot parsed: word = ver_parse("2.14.1-rc.1+build7")

    say word_from_int(ver_major(parsed))
    say word_from_int(ver_minor(parsed))
    say word_from_int(ver_patch(parsed))
    say ver_pre(parsed)
    say ver_build(parsed)
    say ver_to_string(parsed)

    say word_from_bool(ver_lt("1.2.3", "1.10.0"))
    say word_from_bool(ver_gt("2.0.0", "1.9.9"))
    say word_from_bool(ver_eq("1.0.0", "1.0.0"))
    say word_from_bool(ver_satisfies("1.4.2", "^1.4"))
    say word_from_bool(ver_satisfies("2.0.0", "^1.4"))
}

2
14
1
rc.1
build7
2.14.1-rc.1+build7
false
true
true
true
false