API

Builtins

USE_COLOR

USE_COLOR : Bool

Whether or not the console prefers ANSI color escape sequences in the output.

ask

ask : func(prompt: Text, bold: Bool = yes, force_tty: Bool = yes -> Text?)

Gets a line of user input text with a prompt.

When a program is receiving input from a pipe or writing its output to a pipe, this flag (which is enabled by default) forces the program to write the prompt to /dev/tty and read the input from /dev/tty, which circumvents the pipe. This means that foo | ./tomo your-program | baz will still show a visible prompt and read user input, despite the pipes. Setting this flag to no will mean that the prompt is written to stdout and input is read from stdin, even if those are pipes.

Return: A line of user input text without a trailing newline, or empty text if something went wrong (e.g. the user hit Ctrl-D).

Example:

>> ask("What's your name? ")
= "Arthur Dent"

exit

exit : func(message: Text? = none, status: Int32 = Int32(1) -> Void)

Exits the program with a given status and optionally prints a message.

Return: This function never returns.

Example:

exit(status=1, "Goodbye forever!")

fail

fail : func(message: Text -> Abort)

Prints a message to the console, aborts the program, and prints a stack trace.

Return: Nothing, aborts the program.

Example:

fail("Oh no!")

getenv

getenv : func(name: Text -> Text?)

Gets an environment variable.

Return: If set, the environment variable’s value, otherwise, none.

Example:

>> getenv("TERM")
= "xterm-256color"?

print

print : func(text: Text, newline: Bool = yes -> Void)

Prints a message to the console (alias for say()).

Return: Nothing.

Example:

print("Hello ", newline=no)
print("world!")

say

say : func(text: Text, newline: Bool = yes -> Void)

Prints a message to the console.

Return: Nothing.

Example:

say("Hello ", newline=no)
say("world!")

setenv

setenv : func(name: Text, value: Text -> Void)

Sets an environment variable.

Return: Nothing.

Example:

setenv("FOOBAR", "xyz")

sleep

sleep : func(seconds: Num -> Void)

Pause execution for a given number of seconds.

Return: Nothing.

Example:

sleep(1.5)

Bool

Bool.parse

Bool.parse : func(text: Text -> Bool?)

Converts a text representation of a boolean value into a boolean. Acceptable boolean values are case-insensitive variations of yes/no, y/n, true/false, on/off.

Return: yes if the string matches a recognized truthy boolean value; otherwise return no.

Example:

>> Bool.parse("yes")
= yes : Bool?
>> Bool.parse("no")
= no : Bool?
>> Bool.parse("???")
= none : Bool?

Byte

Byte.hex

Byte.hex : func(byte: Byte, uppercase: Bool = yes, prefix: Bool = no -> Text)

Convert a byte to a hexidecimal text representation.

Return: The byte as a hexidecimal text.

Example:

>> Byte(18).hex()
= "0x12"

Byte.is_between

Byte.is_between : func(x: Byte, low: Byte, high: Byte -> Bool)

Determines if an integer is between two numbers (inclusive).

Return: yes if low <= x and x <= high, otherwise no

Example:

>> Byte(7).is_between(1, 10)
= yes
>> Byte(7).is_between(100, 200)
= no
>> Byte(7).is_between(1, 7)
= yes

Byte.parse

Byte.parse : func(text: Text -> Byte?)

Parse a byte literal from text.

Return: The byte parsed from the text, if successful, otherwise none.

Example:

>> Byte.parse("5")
= Byte(5)?
>> Byte.parse("asdf")
= none

Byte.to

Byte.to : func(first: Byte, last: Byte, step: Byte? = none -> func(->Byte?))

Returns an iterator function that iterates over the range of bytes specified.

Return: An iterator function that returns each byte in the given range (inclusive).

Example:

>> Byte(2).to(5)
= func(->Byte?)
>> [x for x in Byte(2).to(5)]
= [Byte(2), Byte(3), Byte(4), Byte(5)]
>> [x for x in Byte(5).to(2)]
= [Byte(5), Byte(4), Byte(3), Byte(2)]

>> [x for x in Byte(2).to(5, step=2)]
= [Byte(2), Byte(4)]

Int

Int.abs

Int.abs : func(x: Int -> Int)

Calculates the absolute value of an integer.

Return: The absolute value of x.

Example:

>> (-10).abs()
= 10

Int.choose

Int.choose : func(n: Int, k: Int -> Int)

Computes the binomial coefficient of the given numbers (the equivalent of n choose k in combinatorics). This is equal to n.factorial()/(k.factorial() * (n-k).factorial()).

Return: The binomial coefficient, equivalent to the number of ways to uniquely choose k objects from among n objects, ignoring order.

Example:

>> (4).choose(2)
= 6

Int.clamped

Int.clamped : func(x: Int, low: Int, high: Int -> Int)

Returns the given number clamped between two values so that it is within that range.

Return: The first argument clamped between the other two arguments.

Example:

>> (2).clamped(5, 10)
= 5

Int.factorial

Int.factorial : func(n: Int -> Text)

Computes the factorial of an integer.

Return: The factorial of the given integer.

Example:

>> (10).factorial()
= 3628800

Int.hex

Int.hex : func(i: Int, digits: Int = 0, uppercase: Bool = yes, prefix: Bool = yes -> Text)

Converts an integer to its hexadecimal representation.

Return: The hexadecimal string representation of the integer.

Example:

>> (255).hex(digits=4, uppercase=yes, prefix=yes)
= "0x00FF"

Int.is_between

Int.is_between : func(x: Int, low: Int, high: Int -> Bool)

Determines if an integer is between two numbers (inclusive).

Return: yes if low <= x and x <= high, otherwise no

Example:

>> (7).is_between(1, 10)
= yes
>> (7).is_between(100, 200)
= no
>> (7).is_between(1, 7)
= yes

Int.is_prime

Int.is_prime : func(x: Int, reps: Int = 50 -> Bool)

Determines if an integer is a prime number.

This function is probabilistic. With the default arguments, the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.

Return: yes if x is a prime number, no otherwise.

Example:

>> (7).is_prime()
= yes
>> (6).is_prime()
= no

Int.next_prime

Int.next_prime : func(x: Int -> Int)

Finds the next prime number greater than the given integer.

This function is probabilistic, but the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.

Return: The next prime number greater than x.

Example:

>> (11).next_prime()
= 13

Int.octal

Int.octal : func(i: Int, digits: Int = 0, prefix: Bool = yes -> Text)

Converts an integer to its octal representation.

Return: The octal string representation of the integer.

Example:

>> (64).octal(digits=4, prefix=yes)
= "0o0100"

Int.onward

Int.onward : func(first: Int, step: Int = 1 -> Text)

Return an iterator that counts infinitely from the starting integer (with an optional step size).

Return: An iterator function that counts onward from the starting integer.

Example:

nums : &[Int] = &[]
for i in (5).onward()
nums.insert(i)
stop if i == 10
>> nums[]
= [5, 6, 7, 8, 9, 10]

Int.parse

Int.parse : func(text: Text -> Int?)

Converts a text representation of an integer into an integer.

Return: The integer represented by the text. If the given text contains a value outside of the representable range or if the entire text can’t be parsed as an integer, none will be returned.

Example:

>> Int.parse("123")
= 123 : Int?
>> Int.parse("0xFF")
= 255 : Int?

# Can't parse:
>> Int.parse("asdf")
= none : Int?

# Outside valid range:
>> Int8.parse("9999999")
= none : Int8?

Int.prev_prime

Int.prev_prime : func(x: Int -> Int?)

Finds the previous prime number less than the given integer. If there is no previous prime number (i.e. if a number less than 2 is provided), then the function will create a runtime error.

This function is probabilistic, but the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.

Return: The previous prime number less than x, or none if x is less than 2.

Example:

>> (11).prev_prime()
= 7

Int.sqrt

Int.sqrt : func(x: Int -> Int)

Calculates the nearest square root of an integer.

Return: The integer part of the square root of x.

Example:

>> (16).sqrt()
= 4
>> (17).sqrt()
= 4

Int.to

Int.to : func(first: Int, last: Int, step: Int? = none -> func(->Int?))

Returns an iterator function that iterates over the range of numbers specified.

Return: An iterator function that returns each integer in the given range (inclusive).

Example:

>> (2).to(5)
= func(->Int?)
>> [x for x in (2).to(5)]
= [2, 3, 4, 5]
>> [x for x in (5).to(2)]
= [5, 4, 3, 2]

>> [x for x in (2).to(5, step=2)]
= [2, 4]

List

List.binary_search

List.binary_search : func(list: [T], by: func(x,y:&T->Int32) = T.compare -> Int)

Performs a binary search on a sorted list.

Return: Assuming the input list is sorted according to the given comparison function, return the index where the given item would be inserted to maintain the sorted order. That is, if the item is found, return its index, otherwise return the place where it would be found if it were inserted and the list were sorted.

Example:

>> [1, 3, 5, 7, 9].binary_search(5)
= 3

>> [1, 3, 5, 7, 9].binary_search(-999)
= 1

>> [1, 3, 5, 7, 9].binary_search(999)
= 6

List.by

List.by : func(list: [T], step: Int -> [T])

Creates a new list with elements spaced by the specified step value.

Return: A new list with every step-th element from the original list.

Example:

>> [1, 2, 3, 4, 5, 6].by(2)
= [1, 3, 5]

List.clear

List.clear : func(list: @[T] -> Void)

Clears all elements from the list.

Return: Nothing.

Example:

>> my_list.clear()

List.counts

List.counts : func(list: [T] -> {T=Int})

Counts the occurrences of each element in the list.

Return: A table mapping each element to its count.

Example:

>> [10, 20, 30, 30, 30].counts()
= {10=1, 20=1, 30=3}

List.find

List.find : func(list: [T], target: T -> Int?)

Finds the index of the first occurrence of an element (if any).

Return: The index of the first occurrence or none if not found.

Example:

>> [10, 20, 30, 40, 50].find(20)
= 2 : Int?

>> [10, 20, 30, 40, 50].find(9999)
= none : Int?

List.from

List.from : func(list: [T], first: Int -> [T])

Returns a slice of the list starting from a specified index.

Return: A new list starting from the specified index.

Example:

>> [10, 20, 30, 40, 50].from(3)
= [30, 40, 50]

List.has

List.has : func(list: [T], target: T -> Bool)

Checks if the list has an element.

Return: yes if the list has the element, no otherwise.

Example:

>> [10, 20, 30].has(20)
= yes

List.heap_pop

List.heap_pop : func(list: @[T], by: func(x,y:&T->Int32) = T.compare -> T?)

Removes and returns the top element of a heap or none if the list is empty. By default, this is the minimum value in the heap.

Return: The removed top element of the heap or none if the list is empty.

Example:

>> my_heap := [30, 10, 20]
>> my_heap.heapify()
>> my_heap.heap_pop()
= 10

List.heap_push

List.heap_push : func(list: @[T], item: T, by = T.compare -> Void)

Adds an element to the heap and maintains the heap property. By default, this is a minimum heap.

Return: Nothing.

Example:

>> my_heap.heap_push(10)

List.heapify

List.heapify : func(list: @[T], by: func(x,y:&T->Int32) = T.compare -> Void)

Converts a list into a heap.

Return: Nothing.

Example:

>> my_heap := [30, 10, 20]
>> my_heap.heapify()

List.insert

List.insert : func(list: @[T], item: T, at: Int = 0 -> Void)

Inserts an element at a specified position in the list.

Since indices are 1-indexed and negative indices mean “starting from the back”, an index of 0 means “after the last item”.

Return: Nothing.

Example:

>> list := [10, 20]
>> list.insert(30)
>> list
= [10, 20, 30]

>> list.insert(999, at=2)
>> list
= [10, 999, 20, 30]

List.insert_all

List.insert_all : func(list: @[T], items: [T], at: Int = 0 -> Void)

Inserts a list of items at a specified position in the list.

Since indices are 1-indexed and negative indices mean “starting from the back”, an index of 0 means “after the last item”.

Return: Nothing.

Example:

list := [10, 20]
list.insert_all([30, 40])
>> list
= [10, 20, 30, 40]

list.insert_all([99, 100], at=2)
>> list
= [10, 99, 100, 20, 30, 40]

List.pop

List.pop : func(list: &[T], index: Int = -1 -> T?)

Removes and returns an item from the list. If the given index is present in the list, the item at that index will be removed and the list will become one element shorter.

Since negative indices are counted from the back, the default behavior is to pop the last value.

Return: none if the list is empty or the given index does not exist in the list, otherwise the item at the given index.

Example:

>> list := [10, 20, 30, 40]

>> list.pop()
= 40
>> list
= &[10, 20, 30]

>> list.pop(index=2)
= 20
>> list
= &[10, 30]

List.random

List.random : func(list: [T], random: func(min,max:Int64->Int64)? = none -> T)

Selects a random element from the list.

Return: A random element from the list.

Example:

>> [10, 20, 30].random()
= 20

List.remove_at

List.remove_at : func(list: @[T], at: Int = -1, count: Int = 1 -> Void)

Removes elements from the list starting at a specified index.

Since negative indices are counted from the back, the default behavior is to remove the last item.

Return: Nothing.

Example:

list := [10, 20, 30, 40, 50]
list.remove_at(2)
>> list
= [10, 30, 40, 50]

list.remove_at(2, count=2)
>> list
= [10, 50]

List.remove_item

List.remove_item : func(list: @[T], item: T, max_count: Int = -1 -> Void)

Removes all occurrences of a specified item from the list.

A negative max_count means “remove all occurrences”.

Return: Nothing.

Example:

list := [10, 20, 10, 20, 30]
list.remove_item(10)
>> list
= [20, 20, 30]

list.remove_item(20, max_count=1)
>> list
= [20, 30]

List.reversed

List.reversed : func(list: [T] -> [T])

Returns a reversed slice of the list.

Return: A slice of the list with elements in reverse order.

Example:

>> [10, 20, 30].reversed()
= [30, 20, 10]

List.sample

List.sample : func(list: [T], count: Int, weights: [Num]? = none, random: func(->Num)? = none -> [T])

Selects a sample of elements from the list, optionally with weighted probabilities.

Errors will be raised if any of the following conditions occurs: - The given list has no elements and count >= 1 - count < 0 (negative count) - The number of weights provided doesn’t match the length of the list. - Any weight in the weights list is negative, infinite, or NaN - The sum of the given weights is zero (zero probability for every element).

Return: A list of sampled elements from the list.

Example:

>> [10, 20, 30].sample(2, weights=[90%, 5%, 5%])
= [10, 10]

List.shuffle

List.shuffle : func(list: @[T], random: func(min,max:Int64->Int64)? = none -> Void)

Shuffles the elements of the list in place.

Return: Nothing.

Example:

>> list.shuffle()

List.shuffled

List.shuffled : func(list: [T], random: func(min,max:Int64->Int64)? = none -> [T])

Creates a new list with elements shuffled.

Return: A new list with shuffled elements.

Example:

>> [10, 20, 30, 40].shuffled()
= [40, 10, 30, 20]

List.slice

List.slice : func(list: [T], from: Int, to: Int -> [T])

Returns a slice of the list spanning the given indices (inclusive).

Return: A new list spanning the given indices. Note: negative indices are counted from the back of the list, so -1 refers to the last element, -2 the second-to-last, and so on.

Example:

>> [10, 20, 30, 40, 50].slice(2, 4)
= [20, 30, 40]

>> [10, 20, 30, 40, 50].slice(-3, -2)
= [30, 40]

List.sort

List.sort : func(list: @[T], by = T.compare -> Void)

Sorts the elements of the list in place in ascending order (small to large).

Return: Nothing.

Example:

list := [40, 10, -30, 20]
list.sort()
>> list
= [-30, 10, 20, 40]

list.sort(func(a,b:&Int): a.abs() <> b.abs())
>> list
= [10, 20, -30, 40]

List.sorted

List.sorted : func(list: [T], by = T.compare -> [T])

Creates a new list with elements sorted.

Return: A new list with sorted elements.

Example:

>> [40, 10, -30, 20].sorted()
= [-30, 10, 20, 40]

>> [40, 10, -30, 20].sorted(func(a,b:&Int): a.abs() <> b.abs())
= [10, 20, -30, 40]

List.to

List.to : func(list: [T], last: Int -> [T])

Returns a slice of the list from the start of the original list up to a specified index (inclusive).

Return: A new list containing elements from the start up to the specified index.

Example:

>> [10, 20, 30, 40, 50].to(3)
= [10, 20, 30]

>> [10, 20, 30, 40, 50].to(-2)
= [10, 20, 30, 40]

List.unique

List.unique : func(list: [T] -> |T|)

Returns a Set that contains the unique elements of the list.

Return: A set containing only unique elements from the list.

Example:

>> [10, 20, 10, 10, 30].unique()
= {10, 20, 30}

List.where

List.where : func(list: [T], predicate: func(item:&T -> Bool) -> Int)

Find the index of the first item that matches a predicate function (if any).

Return: Returns the index of the first item where the predicate is true or none if no item matches.

Example:

>> [4, 5, 6].where(func(i:&Int): i.is_prime())
= 5 : Int?
>> [4, 6, 8].find(func(i:&Int): i.is_prime())
= none : Int?

Num

Num.1_PI

Num.1_PI : Num

The constant .

Num.2_PI

Num.2_PI : Num

The constant .

Num.2_SQRTPI

Num.2_SQRTPI : Num

The constant .

Num.E

Num.E : Num

The base of the natural logarithm ().

Num.INF

Num.INF : Num

Positive infinity.

Num.LN10

Num.LN10 : Num

The natural logarithm of 10.

Num.LN2

Num.LN2 : Num

The natural logarithm of 2.

Num.LOG2E

Num.LOG2E : Num

The base 2 logarithm of

Num.PI

Num.PI : Num

Pi ().

Num.PI_2

Num.PI_2 : Num

Num.PI_4

Num.PI_4 : Num

Num.SQRT1_2

Num.SQRT1_2 : Num

Num.SQRT2

Num.SQRT2 : Num

Num.TAU

Num.TAU : Num

Tau ()

Num.abs

Num.abs : func(n: Num -> Num)

Calculates the absolute value of a number.

Return: The absolute value of n.

Example:

>> (-3.5).abs()
= 3.5

Num.acos

Num.acos : func(x: Num -> Num)

Computes the arc cosine of a number.

Return: The arc cosine of x in radians.

Example:

>> (0.0).acos() // -> (π/2)
= 1.5708

Num.acosh

Num.acosh : func(x: Num -> Num)

Computes the inverse hyperbolic cosine of a number.

Return: The inverse hyperbolic cosine of x.

Example:

>> (1.0).acosh()
= 0

Num.asin

Num.asin : func(x: Num -> Num)

Computes the arc sine of a number.

Return: The arc sine of x in radians.

Example:

>> (0.5).asin()  // -> (π/6)
= 0.5236

Num.asinh

Num.asinh : func(x: Num -> Num)

Computes the inverse hyperbolic sine of a number.

Return: The inverse hyperbolic sine of x.

Example:

>> (0.0).asinh()
= 0

Num.atan

Num.atan : func(x: Num -> Num)

Computes the arc tangent of a number.

Return: The arc tangent of x in radians.

Example:

>> (1.0).atan() // -> (π/4)
= 0.7854

Num.atan2

Num.atan2 : func(x: Num, y: Num -> Num)

Computes the arc tangent of the quotient of two numbers.

Return: The arc tangent of x/y in radians.

Example:

>> Num.atan2(1, 1) // -> (π/4)
= 0.7854

Num.atanh

Num.atanh : func(x: Num -> Num)

Computes the inverse hyperbolic tangent of a number.

Return: The inverse hyperbolic tangent of x.

Example:

>> (0.5).atanh()
= 0.5493

Num.cbrt

Num.cbrt : func(x: Num -> Num)

Computes the cube root of a number.

Return: The cube root of x.

Example:

>> (27.0).cbrt()
= 3

Num.ceil

Num.ceil : func(x: Num -> Num)

Rounds a number up to the nearest integer.

Return: The smallest integer greater than or equal to x.

Example:

>> (3.2).ceil()
= 4

Num.clamped

Num.clamped : func(x: Num, low: Num, high: Num -> Num)

Returns the given number clamped between two values so that it is within that range.

Return: The first argument clamped between the other two arguments.

Example:

>> (2.5).clamped(5.5, 10.5)
= 5.5

Num.copysign

Num.copysign : func(x: Num, y: Num -> Num)

Copies the sign of one number to another.

Return: A number with the magnitude of x and the sign of y.

Example:

>> (3.0).copysign(-1)
= -3

Num.cos

Num.cos : func(x: Num -> Num)

Computes the cosine of a number (angle in radians).

Return: The cosine of x.

Example:

>> (0.0).cos()
= 1

Num.cosh

Num.cosh : func(x: Num -> Num)

Computes the hyperbolic cosine of a number.

Return: The hyperbolic cosine of x.

Example:

>> (0.0).cosh()
= 1

Num.erf

Num.erf : func(x: Num -> Num)

Computes the error function of a number.

Return: The error function of x.

Example:

>> (0.0).erf()
= 0

Num.erfc

Num.erfc : func(x: Num -> Num)

Computes the complementary error function of a number.

Return: The complementary error function of x.

Example:

>> (0.0).erfc()
= 1

Num.exp

Num.exp : func(x: Num -> Num)

Computes the exponential function for a number.

Return: The value of .

Example:

>> (1.0).exp()
= 2.7183

Num.exp2

Num.exp2 : func(x: Num -> Num)

Computes for a number.

Return: The value of .

Example:

>> (3.0).exp2()
= 8

Num.expm1

Num.expm1 : func(x: Num -> Num)

Computes for a number.

Return: The value of .

Example:

>> (1.0).expm1()
= 1.7183

Num.fdim

Num.fdim : func(x: Num, y: Num -> Num)

Computes the positive difference between two numbers.

Return: The positive difference .

Example:

fd

>> (5.0).fdim(3)
= 2

Num.floor

Num.floor : func(x: Num -> Num)

Rounds a number down to the nearest integer.

Return: The largest integer less than or equal to x.

Example:

>> (3.7).floor()
= 3

Num.hypot

Num.hypot : func(x: Num, y: Num -> Num)

Computes the Euclidean norm, , of two numbers.

Return: The Euclidean norm of x and y.

Example:

>> Num.hypot(3, 4)
= 5

Num.is_between

Num.is_between : func(x: Num, low: Num, high: Num -> Bool)

Determines if a number is between two numbers (inclusive).

Return: yes if low <= x and x <= high, otherwise no

Example:

>> (7.5).is_between(1, 10)
= yes
>> (7.5).is_between(100, 200)
= no
>> (7.5).is_between(1, 7.5)
= yes

Num.isfinite

Num.isfinite : func(n: Num -> Bool)

Checks if a number is finite.

Return: yes if n is finite, no otherwise.

Example:

>> (1.0).isfinite()
= yes
>> Num.INF.isfinite()
= no

Num.isinf

Num.isinf : func(n: Num -> Bool)

Checks if a number is infinite.

Return: yes if n is infinite, no otherwise.

Example:

>> Num.INF.isinf()
= yes
>> (1.0).isinf()
= no

Num.j0

Num.j0 : func(x: Num -> Num)

Computes the Bessel function of the first kind of order 0.

Return: The Bessel function of the first kind of order 0 of x.

Example:

>> (0.0).j0()
= 1

Num.j1

Num.j1 : func(x: Num -> Num)

Computes the Bessel function of the first kind of order 1.

Return: The Bessel function of the first kind of order 1 of x.

Example:

>> (0.0).j1()
= 0

Num.log

Num.log : func(x: Num -> Num)

Computes the natural logarithm (base ) of a number.

Return: The natural logarithm of x.

Example:

>> Num.E.log()
= 1

Num.log10

Num.log10 : func(x: Num -> Num)

Computes the base-10 logarithm of a number.

Return: The base-10 logarithm of x.

Example:

>> (100.0).log10()
= 2

Num.log1p

Num.log1p : func(x: Num -> Num)

Computes for a number.

Argument	Type	Description	Default
x	Num	The number for which is to be calculated.	-

Return: The value of .

Example:

>> (1.0).log1p()
= 0.6931

Num.log2

Num.log2 : func(x: Num -> Num)

Computes the base-2 logarithm of a number.

Return: The base-2 logarithm of x.

Example:

>> (8.0).log2()
= 3

Num.logb

Num.logb : func(x: Num -> Num)

Computes the binary exponent (base-2 logarithm) of a number.

Return: The binary exponent of x.

Example:

>> (8.0).logb()
= 3

Num.mix

Num.mix : func(amount: Num, x: Num, y: Num -> Num)

Interpolates between two numbers based on a given amount.

Return: The interpolated number between x and y based on amount.

Example:

>> (0.5).mix(10, 20)
= 15
>> (0.25).mix(10, 20)
= 12.5

Num.near

Num.near : func(x: Num, y: Num, ratio: Num = 1e-9, min_epsilon: Num = 1e-9 -> Bool)

Checks if two numbers are approximately equal within specified tolerances. If two numbers are within an absolute difference or the ratio between the two is small enough, they are considered near each other.

Return: yes if x and y are approximately equal within the specified tolerances, no otherwise.

Example:

>> (1.0).near(1.000000001)
= yes

>> (100.0).near(110, ratio=0.1)
= yes

>> (5.0).near(5.1, min_epsilon=0.1)
= yes

Num.nextafter

Num.nextafter : func(x: Num, y: Num -> Num)

Computes the next representable value after a given number towards a specified direction.

Return: The next representable value after x in the direction of y.

Example:

>> (1.0).nextafter(1.1)
= 1.0000000000000002

Num.parse

Num.parse : func(text: Text -> Num?)

Converts a text representation of a number into a floating-point number.

Return: The number represented by the text or none if the entire text can’t be parsed as a number.

Example:

>> Num.parse("3.14")
= 3.14
>> Num.parse("1e3")
= 1000

Num.percent

Num.percent : func(n: Num, precision: Num = 0.01 -> Text)

Convert a number into a percentage text with a percent sign.

Return: A text representation of the number as a percentage with a percent sign.

Example:

>> (0.5).percent()
= "50%"
>> (1./3.).percent(2)
= "33.33%"
>> (1./3.).percent(2, precision=0.0001)
= "33.3333%"
>> (1./3.).percent(2, precision=10.)
= "30%"

Num.rint

Num.rint : func(x: Num -> Num)

Rounds a number to the nearest integer, with ties rounded to the nearest even integer.

Return: The nearest integer value of x.

Example:

>> (3.5).rint()
= 4
>> (2.5).rint()
= 2

Num.round

Num.round : func(x: Num -> Num)

Rounds a number to the nearest whole number integer.

Return: The nearest integer value of x.

Example:

>> (2.3).round()
= 2
>> (2.7).round()
= 3

Num.significand

Num.significand : func(x: Num -> Num)

Extracts the significand (or mantissa) of a number.

Return: The significand of x.

Example:

>> (1234.567).significand()
= 0.1234567

Num.sin

Num.sin : func(x: Num -> Num)

Computes the sine of a number (angle in radians).

Return: The sine of x.

Example:

>> (0.0).sin()
= 0

Num.sinh

Num.sinh : func(x: Num -> Num)

Computes the hyperbolic sine of a number.

Return: The hyperbolic sine of x.

Example:

>> (0.0).sinh()
= 0

Num.sqrt

Num.sqrt : func(x: Num -> Num)

Computes the square root of a number.

Return: The square root of x.

Example:

>> (16.0).sqrt()
= 4

Num.tan

Num.tan : func(x: Num -> Num)

Computes the tangent of a number (angle in radians).

Return: The tangent of x.

Example:

>> (0.0).tan()
= 0

Num.tanh

Num.tanh : func(x: Num -> Num)

Computes the hyperbolic tangent of a number.

Return: The hyperbolic tangent of x.

Example:

>> (0.0).tanh()
= 0

Num.tgamma

Num.tgamma : func(x: Num -> Num)

Computes the gamma function of a number.

Return: The gamma function of x.

Example:

>> (1.0).tgamma()
= 1

Num.trunc

Num.trunc : func(x: Num -> Num)

Truncates a number to the nearest integer towards zero.

Return: The integer part of x towards zero.

Example:

>> (3.7).trunc()
= 3
>> (-3.7).trunc()
= -3

Num.with_precision

Num.with_precision : func(n: Num, precision: Num -> Num)

Round a number to the given precision level (specified as 10, .1, .001 etc).

Return: The number, rounded to the given precision level.

Example:

>> (0.1234567).with_precision(0.01)
= 0.12
>> (123456.).with_precision(100)
= 123500
>> (1234567.).with_precision(5)
= 1234565

Num.y0

Num.y0 : func(x: Num -> Num)

Computes the Bessel function of the second kind of order 0.

Return: The Bessel function of the second kind of order 0 of x.

Example:

>> (1.0).y0()
= -0.7652

Num.y1

Num.y1 : func(x: Num -> Num)

Computes the Bessel function of the second kind of order 1.

Return: The Bessel function of the second kind of order 1 of x.

Example:

>> (1.0).y1()
= 0.4401

Path

Path.accessed

Path.accessed : func(path: Path, follow_symlinks: Bool = yes -> Int64?)

Gets the file access time of a file.

Return: A 64-bit unix epoch timestamp representing when the file or directory was last accessed, or none if no such file or directory exists.

Example:

>> (./file.txt).accessed()
= 1704221100?
>> (./not-a-file).accessed()
= none

Path.append

Path.append : func(path: Path, text: Text, permissions: Int32 = Int32(0o644) -> Void)

Appends the given text to the file at the specified path, creating the file if it doesn’t already exist. Failure to write will result in a runtime error.

Return: Nothing.

Example:

(./log.txt).append("extra line$(\n)")

Path.append_bytes

Path.append_bytes : func(path: Path, bytes: [Byte], permissions: Int32 = Int32(0o644) -> Void)

Appends the given bytes to the file at the specified path, creating the file if it doesn’t already exist. Failure to write will result in a runtime error.

Return: Nothing.

Example:

(./log.txt).append_bytes([104, 105])

Path.base_name

Path.base_name : func(path: Path -> Text)

Returns the base name of the file or directory at the specified path.

Return: The base name of the file or directory.

Example:

>> (./path/to/file.txt).base_name()
= "file.txt"

Path.by_line

Path.by_line : func(path: Path -> func(->Text?)?)

Returns an iterator that can be used to iterate over a file one line at a time, or returns none if the file could not be opened.

Return: An iterator that can be used to get lines from a file one at a time or none if the file couldn’t be read.

Example:

# Safely handle file not being readable:
if lines := (./file.txt).by_line()
for line in lines
say(line.upper())
else
say("Couldn't read file!")

# Assume the file is readable and error if that's not the case:
for line in (/dev/stdin).by_line()!
say(line.upper())