cstr - constant string

Defined in: builtins line 1

cstr

cstr - extract the cstr from unsafe_temp string

Defined in: std/core/string.s line 218

cstr(cstr cstr, str) -> (cstr)

This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.

cstr - extract the cstr from unsafe_temp string

Defined in: std/core/string.s line 218

cstr(unsafe_temp {tag, cstr cstr, str}) -> (cstr)

This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.

cstr - extract the cstr from unsafe_temp string

Defined in: std/core/string.s line 218

cstr(unsafe_temp {tag, cstr cstr, str}) -> (cstr)

This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.

cstr - a cstr description of an error code

Defined in: std/core/error.s line 19

cstr(last_error) -> (cstr)

Error codes should not be compared numerically against given numbers, as their numbering changes for different programs. Instead, they should be converted to a cstr string with this function, which can then be compared. This comparison is also one numerical comparison, as care is taken for all cstr to point to the same memory location.

int - a signed integer value

Defined in: builtins line 1

int

Represents values in the range 2^-63 to 2^63-1.

int - cast to int

Defined in: std/core/convert.s line 75

int(bits {tag, nat value}) -> (int)

Converts a bit representation to the corresponding integer.

int - cast to int

Defined in: std/core/convert.s line 27

int(nat) -> (int)

Overflows are mapped to negative integers without any numerical safeguards.

int - cast to int

Defined in: std/core/convert.s line 27

int(int) -> (int)

Serves as a tautology function for code that parses on multiple number types.

int - cast to int

Defined in: std/core/convert.s line 27

int(float) -> (int)

May lose information due to truncating.

int - converts a string to an integer

Defined in: std/core/convertstr.s line 148

int(str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) -> (int)

int - converts a string to an integer

Defined in: std/core/convertstr.s line 148

int(cstr) -> (int)

int - reads an integer from the console

Defined in: std/core/convertstr.s line 36

int(console {tag}) -> (int)

nat - an unsigned integer value

Defined in: builtins line 1

nat

Represents values in the range 0 to 2^64-1.

nat - retrieved unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 170

nat(nat32) -> (nat)

nat - retrieved unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 170

nat(nat16) -> (nat)

nat - retrieved unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 170

nat(nat8) -> (nat)

nat - cast to nat

Defined in: std/core/convert.s line 70

nat(bits {tag, nat value}) -> (nat)

Converts a bit representation to the corresponding natural number.

nat - cast to nat

Defined in: std/core/convert.s line 35

nat(nat) -> (nat)

Converting to natural numbers loses information. Fails on negative inputs to guard against assumption errors.

nat - cast to nat

Defined in: std/core/convert.s line 35

nat(int) -> (nat)

Converting to natural numbers loses information. Fails on negative inputs to guard against assumption errors.

nat - cast to nat

Defined in: std/core/convert.s line 35

nat(float) -> (nat)

Converting to natural numbers loses information. Fails on negative inputs to guard against assumption errors.

nat - converts a string to an unsigned integer

Defined in: std/core/convertstr.s line 171

nat(str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) -> (nat)

nat - converts a string to an unsigned integer

Defined in: std/core/convertstr.s line 171

nat(cstr) -> (nat)

nat - reads an unsigned integer from the console

Defined in: std/core/convertstr.s line 60

nat(console {tag}) -> (nat)

nat32 - a 32-bit unsigned integer value

Defined in: builtins line 1

nat32

Represents values in the range 0 to 2^32-1.

nat32 - retrieved 32-bit unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 175

nat32(nat16) -> (nat32)

nat32 - retrieved 32-bit unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 175

nat32(nat8) -> (nat32)

nat32 - convert unsigned number to 32-bit unsigned number

Defined in: std/core/convert.s line 162

nat32(nat x, "truncate") -> (nat32)

The conversion truncates the given input, if it would not fit. For example, 4294967295 becomes 1.

nat32 - convert unsigned number to 32-bit unsigned number

Defined in: std/core/convert.s line 154

nat32(nat) -> (nat32)

The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.

nat16 - a 16-bit unsigned integer value

Defined in: builtins line 1

nat16

Represents values in the range 0 to 2^16-1.

nat16 - retrieved 16-bit unsigned number from lesser-bit unsigned number

Defined in: std/core/convert.s line 180

nat16(nat8) -> (nat16)

nat16 - convert unsigned number to 16-bit unsigned number

Defined in: std/core/convert.s line 147

nat16(nat x, "truncate") -> (nat16)

This conversion truncates the given input, if it would not fit. For example, 65536 becomes 1.

nat16 - convert unsigned number to 16-bit unsigned number

Defined in: std/core/convert.s line 139

nat16(nat) -> (nat16)

The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.

nat8 - a 8-bit unsigned integer value

Defined in: builtins line 1

nat8

Represents values in the range 0 to 255.

nat8 - convert a character to 8-bit unsigned number

Defined in: std/core/convert.s line 132

nat8(char) -> (nat8)

The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.

nat8 - convert unsigned number to 8-bit unsigned number

Defined in: std/core/convert.s line 120

nat8(nat) -> (nat8)

The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.

float

Defined in: builtins line 1

float

float - cast to float

Defined in: std/core/convert.s line 81

float(bits {tag, nat value}) -> (float)

Converts a bit representation to the corresponding float number.

float - cast to float

Defined in: std/core/convert.s line 20

float(nat) -> (float)

May lose information because floats are not exact representation of all integers.

float - cast to float

Defined in: std/core/convert.s line 20

float(int) -> (float)

May lose information because floats are not exact representation of all integers.

float - cast to float

Defined in: std/core/convert.s line 20

float(float) -> (float)

Serves as a tautology function for code that parses on multiple number types.

float - converts a string to a float

Defined in: std/core/convertstr.s line 183

float(str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) -> (float)

float - converts a string to a float

Defined in: std/core/convertstr.s line 183

float(cstr) -> (float)

float - reads a float from the console

Defined in: std/core/convertstr.s line 80

float(console {tag}) -> (float)

bool - boolean value

Defined in: builtins line 1

bool

Can only be true or false.

blank - empty tuple

Defined in: builtins line 1

blank() -> ()

This is the type of non-existent variables, empty parantheses, and functions of no returns.

char - a character

Defined in: builtins line 1

char

Represents characters in the numeric range 0 to 255.

char - treat as character

Defined in: std/core/string.s line 115

char(cstr) -> (char)

The first character of a string is extracted, for example to write c = char "C".

char - treat as character

Defined in: std/core/string.s line 109

char(str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) -> (char)

The first character of a string is extracted, for example to write c = char str "C".

char

Defined in: std/core/convertstr.s line 24

char(console {tag}) -> (char)

any - any type

Defined in: builtins line 1

any() -> ()

Represents a generic for buffers and pointers for type-independent code that can be matched to a concrete type later. This type ordains special treatment by the compiler.

eq - equals

Defined in: std/core/bool.s line 51

eq(false, true) -> (false)

This is a compile-time operation that does not evoke any runtime booleans.

eq - equals

Defined in: std/core/bool.s line 46

eq(true, false) -> (false)

This is a compile-time operation that does not evoke any runtime booleans.

eq - equals

Defined in: std/core/bool.s line 41

eq(false, false) -> (true)

This is a compile-time operation that does not evoke any runtime booleans.

eq - equals

Defined in: std/core/bool.s line 36

eq(true, true) -> (true)

This is a compile-time operation that does not evoke any runtime booleans.

eq - equals

Defined in: std/core/bool.s line 20

eq(bool x, bool y) -> (bool)

eq - equals

Defined in: std/core/numbers.s line 56

eq(any ptr x, any ptr y) -> (bool)

Compares the address of two pointers.

eq - equals

Defined in: std/core/numbers.s line 40

eq(last_error x, last_error y) -> (bool)

Compares two error messages. This comparison is used only for comparing error messages produced by the same running program.

eq - equals

Defined in: std/core/numbers.s line 26

eq(nat x, nat y) -> (bool)

eq - equals

Defined in: std/core/numbers.s line 26

eq(int x, int y) -> (bool)

eq - equals

Defined in: std/core/numbers.s line 26

eq(float x, float y) -> (bool)

eq - equals

Defined in: std/core/bool.s line 82

eq(bool value, false) -> (bool)

eq - equals

Defined in: std/core/bool.s line 78

eq(false, bool value) -> (bool)

eq - equals

Defined in: std/core/bool.s line 74

eq(bool value, true) -> (bool)

eq - equals

Defined in: std/core/bool.s line 70

eq(true, bool value) -> (bool)

eq - equals

Defined in: std/core/string.s line 295

eq(cstr x, str) -> (bool)

eq - equals

Defined in: std/core/string.s line 289

eq(str, cstr y) -> (bool)

eq - equals

Defined in: std/core/string.s line 261

eq(str, str) -> (bool)

This implementation avoids indirection by checking for the first string character first, which will typically be stored only one indirection away instead of two, and is thus very friendly to CPU cache usage when manipulating strings.

It is interesting to consider what happens should the memory surfaces where strings are stored be corrupted by replacing string data while the string is still used in code (this is a logical bug but memory-safe). In that case, two strings could have the exact same contents but be deemed not equal to each other. This contradiction occurs only when active strings are overwritten with new data, and is in fact a good way to check for logical inconsistencies. In the rare cases where you want to guarantee the outcome of this equality under data corruptions use eq(revalidate x, revalidate y) to re-retrieve the first characters. This is still faster than full comparison of large strings, given that most string comparisons yield false.

eq - equals

Defined in: std/core/string.s line 252

eq(cstr x, cstr y) -> (bool)

Comparing two cstrs is as simple as comparing their addresses, so this operation is exceedingly lightweight and a convenient means for checking for runtime tags. The compier enforces that two same-content cstr will always have the same memory address.

eq - equals

Defined in: std/core/string.s line 122

eq(char x, char y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(int ptr _x, int ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(float ptr _x, float _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(float ptr _x, float ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 43

eq(cstr ptr x, cstr ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 43

eq(cstr ptr x, str ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 43

eq(str ptr x, cstr ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 43

eq(str ptr x, str ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 39

eq(cstr x, cstr ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 39

eq(cstr x, str ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 39

eq(str, cstr ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 39

eq(str, str ptr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 35

eq(cstr ptr x, cstr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 35

eq(cstr ptr x, str) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 35

eq(str ptr x, cstr y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 35

eq(str ptr x, str) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(nat _x, nat ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(int _x, int ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(float _x, float ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(nat ptr _x, nat _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(nat ptr _x, nat ptr _y) -> (bool)

eq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 63

eq(int ptr _x, int _y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 25

neq(bool x, bool y) -> (bool)

neq - not equal

Defined in: std/core/numbers.s line 48

neq(last_error x, last_error y) -> (bool)

Compares two error messages. This comparison is used only for comparing error messages produced by the same running program.

neq - not equal

Defined in: std/core/numbers.s line 33

neq(nat x, nat y) -> (bool)

neq - not equal

Defined in: std/core/numbers.s line 33

neq(int x, int y) -> (bool)

neq - not equal

Defined in: std/core/numbers.s line 33

neq(float x, float y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 90

neq(bool x, false y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 90

neq(bool x, true y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 86

neq(false x, bool y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 86

neq(true x, bool y) -> (bool)

neq - not equal

Defined in: std/core/bool.s line 66

neq(false x, false y) -> (false)

neq - not equal

Defined in: std/core/bool.s line 66

neq(false x, true y) -> (true)

neq - not equal

Defined in: std/core/bool.s line 66

neq(true x, false y) -> (true)

neq - not equal

Defined in: std/core/bool.s line 66

neq(true x, true y) -> (false)

neq - not equal

Defined in: std/unsafe.s line 19

neq(any ptr x, any ptr y) -> (bool)

Compares the address of two pointers.

neq - not equals

Defined in: std/core/string.s line 301

neq(cstr x, cstr y) -> (bool)

Negates the outcome of equality checks between cstr and strings.

neq - not equals

Defined in: std/core/string.s line 301

neq(cstr x, str) -> (bool)

Negates the outcome of equality checks between cstr and strings.

neq - not equals

Defined in: std/core/string.s line 301

neq(str, cstr y) -> (bool)

Negates the outcome of equality checks between cstr and strings.

neq - not equals

Defined in: std/core/string.s line 301

neq(str, str) -> (bool)

Negates the outcome of equality checks between cstr and strings.

neq - not equals

Defined in: std/core/string.s line 127

neq(char x, char y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 55

neq(cstr ptr x, cstr ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 55

neq(cstr ptr x, str ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 55

neq(str ptr x, cstr ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 55

neq(str ptr x, str ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 51

neq(cstr x, cstr ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 51

neq(cstr x, str ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 51

neq(str, cstr ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 51

neq(str, str ptr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 47

neq(cstr ptr x, cstr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 47

neq(cstr ptr x, str) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 47

neq(str ptr x, cstr y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 47

neq(str ptr x, str) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(nat _x, nat ptr _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(int _x, int ptr _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(float _x, float ptr _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(nat ptr _x, nat _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(nat ptr _x, nat ptr _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(int ptr _x, int _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(int ptr _x, int ptr _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(float ptr _x, float _y) -> (bool)

neq - overloads an operator while dereferencing pointer data

Defined in: std/ptrpeek.s line 73

neq(float ptr _x, float ptr _y) -> (bool)

not - logical inverse

Defined in: std/core/bool.s line 61

not(false) -> (true)

This is a compile-time operation on the compiler::false type rather than a runtime boolean.

not - logical inverse

Defined in: std/core/bool.s line 56

not(true) -> (false)

This is a compile-time operation on the compiler::true type rather than a runtime boolean.

not - logical inverse

Defined in: std/core/bool.s line 30

not(bool) -> (bool)

This operates on boolean values at runtime.

nat - an unsigned integer value

Defined in: builtins line 1

nat

Represents values in the range 0 to 2^64-1.

float

Defined in: builtins line 1

float

int - a signed integer value

Defined in: builtins line 1

int

Represents values in the range 2^-63 to 2^63-1.

is_different

Defined in: std/core/numbers.s line 23

is_different(nat x, nat y) -> (false)

is_different

Defined in: std/core/numbers.s line 23

is_different(nat x, int y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(nat x, float y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(int x, nat y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(int x, int y) -> (false)

is_different

Defined in: std/core/numbers.s line 23

is_different(int x, float y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(float x, nat y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(float x, int y) -> (true)

is_different

Defined in: std/core/numbers.s line 23

is_different(float x, float y) -> (false)

neg - negative of a number

Defined in: std/core/numbers.s line 62

neg(nat) -> (nat)

neg - negative of a number

Defined in: std/core/numbers.s line 62

neg(int) -> (int)

neg - negative of a number

Defined in: std/core/numbers.s line 62

neg(float) -> (float)

add - add

Defined in: std/core/numbers.s line 67

add(nat x, nat y) -> (nat)

Adds two numbers of the same type. This is an overload for the + operator.

add - add

Defined in: std/core/numbers.s line 67

add(int x, int y) -> (int)

Adds two numbers of the same type. This is an overload for the + operator.

add - add

Defined in: std/core/numbers.s line 67

add(float x, float y) -> (float)

Adds two numbers of the same type. This is an overload for the + operator.

add - pointer addition

Defined in: std/unsafe.s line 66

add(any ptr allocated, nat offset) -> (any ptr {follows any ptr allocated})

Adds a natural number offset to a pointer.

add - concatenate two strings

Defined in: std/core/string.s line 458

add(edit arena, cstr _s1, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation ensures that consecutively allocated strings, or adding to strings placed at the end of buffers, does not needlessly copy memory. This way, consecutive additions do not copy the previous result before appending to it. For example, consider the following:

import std.core
def main()
    CLI = edit console()
    CHARS = edit arena alloc 10
    s1 = copy 123
    s2 = copy 456
    s3 = s1+s2
    print s3+copy(78)+copy(9)

The snippet fits the result in a contiguous area on the arena’s buffer, with only one copying operation for each character. This does not magically optimize all copying operations, but it does makes most convenient optimizatins when allocating and immediately concatenating.

add - concatenate two strings

Defined in: std/core/string.s line 458

add(edit arena, cstr _s1, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation ensures that consecutively allocated strings, or adding to strings placed at the end of buffers, does not needlessly copy memory. This way, consecutive additions do not copy the previous result before appending to it. For example, consider the following:

import std.core
def main()
    CLI = edit console()
    CHARS = edit arena alloc 10
    s1 = copy 123
    s2 = copy 456
    s3 = s1+s2
    print s3+copy(78)+copy(9)

The snippet fits the result in a contiguous area on the arena’s buffer, with only one copying operation for each character. This does not magically optimize all copying operations, but it does makes most convenient optimizatins when allocating and immediately concatenating.

add - concatenate two strings

Defined in: std/core/string.s line 458

add(edit arena, str, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation ensures that consecutively allocated strings, or adding to strings placed at the end of buffers, does not needlessly copy memory. This way, consecutive additions do not copy the previous result before appending to it. For example, consider the following:

import std.core
def main()
    CLI = edit console()
    CHARS = edit arena alloc 10
    s1 = copy 123
    s2 = copy 456
    s3 = s1+s2
    print s3+copy(78)+copy(9)

The snippet fits the result in a contiguous area on the arena’s buffer, with only one copying operation for each character. This does not magically optimize all copying operations, but it does makes most convenient optimizatins when allocating and immediately concatenating.

add - concatenate two strings

Defined in: std/core/string.s line 458

add(edit arena, str, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation ensures that consecutively allocated strings, or adding to strings placed at the end of buffers, does not needlessly copy memory. This way, consecutive additions do not copy the previous result before appending to it. For example, consider the following:

import std.core
def main()
    CLI = edit console()
    CHARS = edit arena alloc 10
    s1 = copy 123
    s2 = copy 456
    s3 = s1+s2
    print s3+copy(78)+copy(9)

The snippet fits the result in a contiguous area on the arena’s buffer, with only one copying operation for each character. This does not magically optimize all copying operations, but it does makes most convenient optimizatins when allocating and immediately concatenating.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit list, cstr _s1, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit list, cstr _s1, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit list, str, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit list, str, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit circular, cstr _s1, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit circular, cstr _s1, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit circular, str, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit circular, str, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit bucket, cstr _s1, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit bucket, cstr _s1, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit bucket, str, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(edit bucket, str, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

add - concatenate two strings

Defined in: std/core/string.s line 432

add(new CHARS, cstr _s1, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

free(mut any ptr) -> ()

add - concatenate two strings

Defined in: std/core/string.s line 432

add(new CHARS, cstr _s1, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

free(mut any ptr) -> ()

add - concatenate two strings

Defined in: std/core/string.s line 432

add(new CHARS, str, cstr _s2) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

free(mut any ptr) -> ()

add - concatenate two strings

Defined in: std/core/string.s line 432

add(new CHARS, str, str) -> (str {tag, char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first}) with effects CHARS

The result is placed on an allocator effect CHARS. This implementation creates a new allocation and is therefore slower compared to using a simple arena, circular buffer, or even an automatically resized list. Since that allocation defers its deallocation too, it cannot be returned from nested code blocks. Switch to a different character allocator to produce more dynamic yet safe and fast code.

free(mut any ptr) -> ()

add - vector addition

Defined in: std/sci/vec.s line 93

add(edit circular, float v1, vec) -> (mut vec {tag, mut float ptr unsafe_ptr, mut nat pos, mut nat length}) with effects FLOATS

Grabs a FLOATS allocator effect to store the result.

add - vector addition

Defined in: std/sci/vec.s line 93

add(edit arena, float v1, vec) -> (mut vec {tag, mut float ptr unsafe_ptr, mut nat pos, mut nat length}) with effects FLOATS

Grabs a FLOATS allocator effect to store the result.

add - vector addition

Defined in: std/sci/vec.s line 93

add(new FLOATS, float v1, vec) -> (mut vec {tag, mut float ptr unsafe_ptr, mut nat pos, mut nat length}) with effects FLOATS