dogma:core

import { println, push, str } from "dogma:core"

Output🔗

Function	Signature	Description
`print`	`(value: T)`	Print to stdout without newline
`println`	`(value: T)`	Print to stdout with newline

Array operations🔗

Function	Signature	Description
`push`	`(array: [T], value: T) -> [T]`	Return new array with value appended
`pop`	`(array: [T]) -> [T]`	Return new array with last element removed

Arrays in Dogma are immutable. push and pop return new arrays.

import { push, println } from "dogma:core"

fn main() {
    let nums = [1, 2, 3]
    let nums2 = push(nums, 4)   // [1, 2, 3, 4]
    println(f"Length: {nums2.len()}")
}

Type conversions🔗

Function	Signature	Description
`str`	`(value: T) -> String`	Convert any value to its string representation
`int`	`(s: String) -> i64`	Parse string as 64-bit integer (panics on failure)
`float`	`(s: String) -> f64`	Parse string as 64-bit float (panics on failure)

Math🔗

Function	Signature	Description
`abs`	`(n: i32) -> i32`	Absolute value
`min`	`(a: i32, b: i32) -> i32`	Minimum of two values
`max`	`(a: i32, b: i32) -> i32`	Maximum of two values

Assertions🔗

Function	Signature	Description
`assert`	`(condition: bool)`	Panic if condition is false
`assert_eq`	`(a: T, b: T)`	Panic if values are not equal

import { assert, assert_eq } from "dogma:core"

assert(1 + 1 == 2)
assert_eq("hello", "hello")