builtin #

fn compare_f32(a &f32, b &f32) int

compare_f32 for []f32 sort_with_compare() ref. compare_i64(...)

fn compare_f64(a &f64, b &f64) int

compare_f64 for []f64 sort_with_compare() ref. compare_i64(...)

fn compare_i64(a &i64, b &i64) int

compare_i64 for []f64 sort_with_compare() sort []i64 with quicksort usage : mut x := [i64(100),10,70,28,92] x.sort_with_compare(compare_i64) println(x) // Sorted i64 Array output: [10, 28, 70, 92, 100]

fn compare_strings(a &string, b &string) int

compare_strings returns -1 if a < b, 1 if a > b else 0.

fn copy(dst []byte, src []byte) int

copy copies the src byte array elements to the dst byte array. The number of the elements copied is the minimum of the length of both arrays. Returns the number of elements copied. TODO: implement for all types

fn cstring_to_vstring(cstr byteptr) string

cstring_to_vstring creates a copy of cstr and turns it into a v string.

fn eprint(s string)

eprint prints a message to stderr. Both stderr and stdout are flushed.

fn eprintln(s string)

eprintln prints a message with a line end, to stderr. Both stderr and stdout are flushed.

fn error(message string) Option

error returns an optional containing the error given in message. if ouch { return error('an error occurred') }

fn error_with_code(message string, code int) Option

error_with_code returns an optional containing both error message and error code. if ouch { return error_with_code('an error occurred',1) }

fn exit(code int)

fn f32_abs(a f32) f32

f32_abs returns the absolute value of a as a f32 value.

assert f32_abs(-2.0) == 2.0

fn f32_max(a f32, b f32) f32

f32_max returns the largest f32 of input a and b.

assert f32_max(2.0,3.0) == 3.0

fn f32_min(a f32, b f32) f32

f32_min returns the smallest f32 of input a and b.

assert f32_min(2.0,3.0) == 2.0

fn f64_max(a f64, b f64) f64

f64_max returns the largest f64 of input a and b.

assert f64_max(2.0,3.0) == 3.0

fn free(ptr voidptr)

free allows for manually freeing memory allocated at the address ptr.

fn is_atty(fd int) int

is_atty returns 1 if the fd file descriptor is open and refers to a terminal

fn isnil(v voidptr) bool

isnil returns true if an object is nil (only for C objects).

fn malloc(n int) byteptr

malloc dynamically allocates a n bytes block of memory on the heap. malloc returns a byteptr pointing to the memory address of the allocated space. unlike the calloc family of functions - malloc will not zero the memory block.

fn memdup(src voidptr, sz int) voidptr

memdup dynamically allocates a sz bytes block of memory on the heap memdup then copies the contents of src into the allocated space and returns a pointer to the newly allocated space.

fn panic(s string)

panic prints a nice error message, then exits the process with exit code of 1. It also shows a backtrace on most platforms.

fn print(s string)

print prints a message to stdout. Unlike println stdout is not automatically flushed. A call to flush() will flush the output buffer to stdout.

fn print_backtrace()

print_backtrace shows a backtrace of the current call stack on stdout

fn println(s string)

println prints a message with a line end, to stdout. stdout is flushed.

fn proc_pidpath(int, voidptr, int) int

fn ptr_str(ptr voidptr) string

ptr_str returns the address of ptr as a string.

fn string_from_wide(_wstr &u16) string

fn string_from_wide2(_wstr &u16, len int) string

fn tos(s byteptr, len int) string

tos converts a C string to a V string. String data is reused, not copied.

fn tos2(s byteptr) string

tos2 does the same as tos, but also calculates the length. Called by string(bytes) casts. Used only internally.

fn tos3(s charptr) string

tos3 does the same as tos2, but for char*, to avoid warnings.

fn tos4(s byteptr) string

tos4 does the same as tos2, but returns an empty string on nil ptr.

fn tos5(s charptr) string

tos5 does the same as tos4, but for char*, to avoid warnings.

fn tos_clone(s byteptr) string

tos_clone returns a copy of s.

fn tos_lit(s charptr) string

fn utf32_to_str(code u32) string

Convert utf32 to utf8 utf32 == Codepoint

fn utf32_to_str_no_malloc(code u32, buf voidptr) string

fn utf8_char_len(b byte) int

fn utf8_getchar() int

Reads an utf8 character from standard input

fn v_calloc(n int) byteptr

v_calloc dynamically allocates a zeroed n bytes block of memory on the heap. v_calloc returns a byteptr pointing to the memory address of the allocated space.

fn v_realloc(b byteptr, n int) byteptr

v_realloc resizes the memory block b with n bytes. The b byteptr must be a pointer to an existing memory block previously allocated with malloc, v_calloc or vcalloc.

fn vcalloc(n int) byteptr

vcalloc dynamically allocates a zeroed n bytes block of memory on the heap. vcalloc returns a byteptr pointing to the memory address of the allocated space. Unlike v_calloc vcalloc checks for negative values given in n.

fn vstrlen(s byteptr) int

vstrlen returns the V length of the C string s (0 terminator is not counted).

fn (b []byte) bytestr() string

TODO remove this once runes are implemented

fn (b []byte) clone() []byte

fn (b []byte) hex() string

hex returns a string with the hexadecimal representation of the byte elements of the array.

fn (mut a []int) sort()

sort sorts array of int in place in ascending order.

fn (a []int) reduce(iter fn (int, int) int, accum_start int) int

reduce executes a given reducer function on each element of the array, resulting in a single output value.

fn (a1 []string) eq(a2 []string) bool

array_eq<T> checks if two arrays contain all the same elements in the same order. []int == []int (also for: i64, f32, f64, byte, string) eq checks if the arrays have the same elements or not. TODO: make it work with all types.

fn (a []string) index(v string) int

index returns the first index at which a given element can be found in the array or -1 if the value is not found.

fn (a []string) join(del string) string

fn (s []string) substr(a, b int) string { return join_strings(s.slice_fast(a, b)) } join joins a string array into a string using del delimiter.

assert ['Hello','V'].join(' ') == 'Hello V'

fn (s []string) join_lines() string

join joins a string array into a string using a \n newline delimiter.

fn (mut s []string) sort()

sort sorts the string array.

fn (mut s []string) sort_by_len()

sort_by_len sorts the the string array by each string's .len length.

fn (mut s []string) sort_ignore_case()

sort_ignore_case sorts the string array using case insesitive comparing.

fn (a []string) str() string

str returns a string representation of the array of strings => '["a", "b", "c"]'.

fn (b bool) str() string

str returns the value of the bool as a string.

assert (2 > 1).str() == 'true'

fn (b byte) ascii_str() string

ascii_str returns the contents of byte as a zero terminated ASCII string character.

assert byte(97).ascii_str() == 'a'

fn (nn byte) hex() string

hex returns the value of the byte as a hexadecimal string. Note that the output is zero padded for values below 16.

assert byte(2).hex() == '02'

assert byte(15).hex() == '0f'

assert byte(255).hex() == 'ff'

fn (c byte) is_bin_digit() bool

is_bin_digit returns true if the byte is a binary digit (0 or 1) and false otherwise.

assert byte(`0`) == true

fn (c byte) is_capital() bool

Define this on byte as well, so that we can do s[0].is_capital()

fn (c byte) is_digit() bool

is_digit returns true if the byte is in range 0-9 and false otherwise.

assert byte(`9`) == true

fn (c byte) is_hex_digit() bool

is_hex_digit returns true if the byte is either in range 0-9, a-f or A-F and false otherwise.

assert byte(`F`) == true

fn (c byte) is_letter() bool

is_letter returns true if the byte is in range a-z or A-Z and false otherwise.

assert byte(`V`) == true

fn (c byte) is_oct_digit() bool

is_oct_digit returns true if the byte is in range 0-7 and false otherwise.

assert byte(`7`) == true

fn (c byte) is_space() bool

is_space returns true if the byte is a white space character. The following list is considered white space characters: , \n, \t, \v, \f, \r, 0x85, 0xa0

assert byte(` `).is_space() == true

fn (c byte) is_white() bool

fn (b byte) str() string

str returns the contents of byte as a zero terminated string.

assert byte(111).str() == '111'

fn (b byte) str_escaped() string

str_escaped returns the contents of byte as an escaped string.

assert byte(0).str_escaped() == r'`\0`'

fn (nn byteptr) str() string

hex returns the value of the byteptr as a hexadecimal string. Note that the output is not zero padded.

fn (data byteptr) vbytes(len int) []byte

byteptr.vbytes() - makes a V []byte structure from a C style memory buffer. NB: the data is reused, NOT copied!

fn (bp byteptr) vstring() string

vstring converts a C style string to a V string. NB: the string data is reused, NOT copied.

fn (bp byteptr) vstring_with_len(len int) string

vstring_with_len converts a C style string to a V string. NB: the string data is reused, NOT copied.

fn (ch chan) close()

The following methods are only stubs. The real implementation is in vlib/sync/channels.v

fn (ch chan) try_pop(obj voidptr) ChanState

fn (ch chan) try_push(obj voidptr) ChanState

fn (cp charptr) vstring() string

vstring converts C char* to V string. NB: the string data is reused, NOT copied.

fn (cp charptr) vstring_with_len(len int) string

vstring_with_len converts C char* to V string. NB: the string data is reused, NOT copied.

fn (x f32) str() string

str returns a f32 as string in suitable notation.

fn (x f32) strsci(digit_num int) string

strsci returns the f32 as a string in scientific notation with digit_num deciamals displayed, max 8 digits.

assert f32(1.234).strsci(3) == '1.234e+00'

fn (x f32) strlong() string

strlong returns a decimal notation of the f32 as a string.

fn (a f32) eq_epsilon(b f32) bool

eq_epsilon returns true if the f32 is equal to input b. using an epsilon of typically 1E-5 or higher (backend/compiler dependent).

assert f32(2.0).eq_epsilon(2.0)

fn (x f64) str() string

str return a f64 as string in suitable notation.

fn (x f64) strsci(digit_num int) string

strsci returns the f64 as a string in scientific notation with digit_num deciamals displayed, max 17 digits.

assert f64(1.234).strsci(3) == '1.234e+00'

fn (x f64) strlong() string

strlong returns a decimal notation of the f64 as a string.

assert f64(1.23456).strlong() == '1.23456'

fn (a f64) eq_epsilon(b f64) bool

eq_epsilon returns true if the f64 is equal to input b. using an epsilon of typically 1E-9 or higher (backend/compiler dependent).

assert f64(2.0).eq_epsilon(2.0)

fn (d float_literal) str() string

str returns the value of the float_literal as a string.

fn (n i16) str() string

str returns the value of the i16 as a string.

assert i16(-20).str() == '-20'

fn (nn i16) hex() string

hex returns the value of the i16 as a hexadecimal string. Note that the output is not zero padded.

assert i16(2).hex() == '2'

assert i16(200).hex() == 'c8'

fn (nn i64) str() string

str returns the value of the i64 as a string.

assert i64(-200000).str() == '-200000'

fn (nn i64) hex() string

hex returns the value of the i64 as a hexadecimal string. Note that the output is not zero padded.

assert i64(2).hex() == '2'

assert i64(-200).hex() == 'ffffffffffffff38'

assert i64(2021).hex() == '7e5'

fn (n i8) str() string

str returns the value of the i8 as a string.

assert i8(-2).str() == '-2'

fn (nn i8) hex() string

hex returns the value of the i8 as a hexadecimal string. Note that the output is zero padded for values below 16.

assert i8(8).hex() == '08'

assert i8(10).hex() == '0a'

assert i8(15).hex() == '0f'

fn (n int) str() string

str returns the value of the int as a string.

assert int(-2020).str() == '-2020'

fn (nn int) hex() string

hex returns the value of the int as a hexadecimal string. Note that the output is not zero padded.

assert int(2).hex() == '2'

assert int(200).hex() == 'c8'

fn (n int) hex2() string

hex2 returns the value of the int as a 0x-prefixed hexadecimal string. Note that the output after 0x is not zero padded.

assert int(8).hex2() == '0x8'

assert int(15).hex2() == '0xf'

assert int(18).hex2() == '0x12'

fn (n int_literal) str() string

str returns the value of the int_literal as a string.

fn (nn int_literal) hex() string

hex returns the value of the int_literal as a hexadecimal string. Note that the output is not zero padded.

fn (o Option) str() string

str returns the string representation of the Option.

fn (c rune) str() string

This was never working correctly, the issue is now fixed however the type checks in checker need to be updated. if you uncomment it you will see the issue type rune = int

fn (n u16) str() string

str returns the value of the u16 as a string.

assert u16(20).str() == '20'

fn (nn u16) hex() string

hex returns the value of the u16 as a hexadecimal string. Note that the output is not zero padded.

assert u16(2).hex() == '2'

assert u16(200).hex() == 'c8'

fn (nn u32) str() string

str returns the value of the u32 as a string.

assert u32(20000).str() == '20000'

fn (nn u32) hex() string

hex returns the value of the u32 as a hexadecimal string. Note that the output is not zero padded.

assert u32(2).hex() == '2'

assert u32(200).hex() == 'c8'

fn (nn u64) str() string

str returns the value of the u64 as a string.

assert u64(2000000).str() == '2000000'

fn (nn u64) hex() string

hex returns the value of the u64 as a hexadecimal string. Note that the output is not zero padded.

assert u64(2).hex() == '2'

assert u64(2000).hex() == '7d0'

fn (nn u64) hex_full() string

hex_full returns the value of the u64 as a full 16-digit hexadecimal string.

assert u64(2).hex_full() == '0000000000000002'

assert u64(255).hex_full() == '00000000000000ff'

fn (nn voidptr) str() string

hex returns the value of the voidptr as a hexadecimal string. Note that the output is not zero padded.

fn (data voidptr) vbytes(len int) []byte

voidptr.vbytes() - makes a V []byte structure from a C style memory buffer. NB: the data is reused, NOT copied!

struct array {
pub:
	element_size int
pub mut:
	data voidptr
	len  int
	cap  int
}

array is a struct used for denoting array types in V

fn (a array) repeat(count int) array

repeat returns a new array with the given array elements repeated given times.

fn (mut a array) sort_with_compare(compare voidptr)

sort sorts array in-place using given compare function as comparator.

fn (mut a array) insert(i int, val voidptr)

insert inserts a value in the array at index i

fn (mut a array) insert_many(i int, val voidptr, size int)

insert_many inserts many values into the array from index i.

fn (mut a array) prepend(val voidptr)

prepend prepends one value to the array.

fn (mut a array) prepend_many(val voidptr, size int)

prepend_many prepends another array to this array.

fn (mut a array) delete(i int)

delete deletes array element at index i.

fn (mut a array) clear()

clear clears the array without deallocating the allocated data.

fn (mut a array) trim(index int)

trim trims the array length to "index" without modifying the allocated data. If "index" is greater than len nothing will be changed.

fn (a array) first() voidptr

first returns the first element of the array.

fn (a array) last() voidptr

last returns the last element of the array.

fn (mut a array) pop() voidptr

pop returns the last element of the array, and removes it.

fn (mut a array) delete_last()

delete_last efficiently deletes the last element of the array.

fn (a &array) clone() array

clone returns an independent copy of a given array.

fn (mut a3 array) push_many(val voidptr, size int)

val is array.data TODO make private, right now it's used by strings.Builder

fn (mut a array) reverse_in_place()

reverse_in_place reverses existing array data, modifying original array.

fn (a array) reverse() array

reverse returns a new array with the elements of the original array in reverse order.

fn (a &array) free()

pub fn (a []int) free() { free frees all memory occupied by the array.

fn (mut a array) grow_cap(amount int)

grow_cap grows the array's capacity by amount elements.

fn (mut a array) grow_len(amount int)

grow_len ensures that an array has a.len + amount of length

fn (a array) pointers() []voidptr

pointers returns a new array, where each element is the address of the corresponding element in the array.

struct FieldData {
pub:
	name   string
	attrs  []string
	is_pub bool
	is_mut bool
	typ    int
}

struct FunctionData {
pub:
	name        string
	attrs       []string
	args        []MethodArgs
	return_type int
	typ         int
}

struct map {
	key_bytes int
	value_bytes int
mut:
	even_index u32
	cached_hashbits byte
	shift byte
	key_values DenseArray
	metas &u32
	extra_metas     u32
	has_string_keys bool
	hash_fn         MapHashFn
	key_eq_fn       MapEqFn
	clone_fn        MapCloneFn
	free_fn         MapFreeFn
pub mut:
	len int
}

fn (mut m map) delete(key string)

delete this

fn (mut m map) delete_1(key voidptr)

Removes the mapping of a particular key from the map.

fn (m &map) keys() []string

bootstrap delete this

fn (m &map) clone() map

fn (m &map) free()

struct MethodArgs {
pub:
	typ int
}

struct SortedMap {
	value_bytes int
mut:
	root &mapnode
pub mut:
	len int
}

fn (mut m SortedMap) delete(key string)

fn (m &SortedMap) keys() []string

fn (mut m SortedMap) free()

fn (m SortedMap) print()

struct string {
pub:
	str byteptr
	len int
mut:
	is_lit int
}

fn (s string) after(dot string) string

after returns the contents after the last occurence of dot in the string.

assert '23:34:45.234'.after(':') == '45.234'

fn (s string) after_char(dot byte) string

after_char returns the contents after the first occurence of dot character in the string.

assert '23:34:45.234'.after_char(`:`) == '34:45.234'

fn (s string) all_after(dot string) string

all_after returns the contents after dot in the string.

assert '23:34:45.234'.all_after('.') == '234'

fn (s string) all_after_last(dot string) string

all_after_last returns the contents after the last occurence of dot in the string.

assert '23:34:45.234'.all_after_last(':') == '45.234'

fn (s string) all_before(dot string) string

all_before returns the contents before dot in the string.

assert '23:34:45.234'.all_before('.') == '23:34:45'

fn (s string) all_before_last(dot string) string

all_before_last returns the contents before the last occurence of dot in the string.

assert '23:34:45.234'.all_before_last(':') == '23:34'

fn (s string) bool() bool

bool returns true if the string equals the word "true" it will return false otherwise.

fn (s string) bytes() []byte

bytes returns the string converted to a byte array.

fn (s string) capitalize() string

capitalize returns the string with the first character capitalized.

assert 'hello'.capitalize() == 'Hello'

fn (a string) clone() string

clone returns a copy of the V string a.

fn (s string) contains(substr string) bool

contains returns true if the string contains substr.

fn (s string) contains_any(chars string) bool

contains_any returns true if the string contains any chars in chars.

fn (s string) contains_any_substr(substrs []string) bool

contains_any_substr returns true if the string contains any of the strings in substrs.

fn (s string) count(substr string) int

count returns the number of occurrences of substr in the string. count returns -1 if no substr could be found.

fn (s string) ends_with(p string) bool

ends_with returns true if the string ends with p.

fn (s string) f32() f32

f32 returns the value of the string as f32 '1.0'.f32() == f32(1).

fn (s string) f64() f64

f64 returns the value of the string as f64 '1.0'.f64() == f64(1).

fn (s string) fields() []string

fields returns a string array of the string split by \t and

assert '\t\tv = v'.fields() == ['', '', 'v', '=', 'v']

fn (s string) find_between(start string, end string) string

find_between returns the string found between start string and end string.

assert 'hey [man] how you doin'.find_between('[', ']') == 'man'

fn (s &string) free()

free allows for manually freeing the memory occupied by the string

fn (s string) hash() int

hash returns an integer hash of the string.

fn (s string) i16() i16

i16 returns the value of the string as i16 '1'.i16() == i16(1).

fn (s string) i64() i64

i64 returns the value of the string as i64 '1'.i64() == i64(1).

fn (s string) i8() i8

i8 returns the value of the string as i8 '1'.i8() == i8(1).

fn (s string) index(p string) ?int

index returns the position of the first character of the input string. It will return none if the input string can't be found.

fn (s string) index_after(p string, start int) int

index_after returns the position of the input string, starting search from start position.

fn (s string) index_any(chars string) int

index_any returns the position of any of the characters in the input string - if found.

fn (s string) index_byte(c byte) int

index_byte returns the index of byte c if found in the string. index_byte returns -1 if the byte can not be found.

fn (s string) int() int

int returns the value of the string as an integer '1'.int() == 1.

fn (s string) is_capital() bool

is_capital returns true if the first character in the string is a capital letter.

assert 'Hello'.is_capital() == true

fn (s string) is_lower() bool

is_lower returns true if all characters in the string is lowercase.

assert 'hello developer'.is_lower() == true

fn (s string) is_title() bool

is_title returns true if all words of the string is capitalized.

assert 'Hello V Developer'.is_title() == true

fn (s string) is_upper() bool

is_upper returns true if all characters in the string is uppercase.

assert 'HELLO V'.is_upper() == true

fn (s string) last_index(p string) ?int

last_index returns the position of the last occurence of the input string.

fn (s string) last_index_byte(c byte) int

last_index_byte returns the index of the last occurence of byte c if found in the string. last_index_byte returns -1 if the byte is not found.

fn (s string) limit(max int) string

limit returns a portion of the string, starting at 0 and extending for a given number of characters afterward. 'hello'.limit(2) => 'he' 'hi'.limit(10) => 'hi'

fn (s string) repeat(count int) string

repeat returns a new string with count number of copies of the string it was called on.

fn (s string) replace(rep string, with string) string

replace replaces all occurences of rep with the string passed in with.

fn (s string) replace_each(vals []string) string

TODO replace_each replaces all occurences of the string pairs given in vals.

assert 'ABCD'.replace_each(['B','C/','C','D','D','C']) == 'AC/DC'

fn (s string) replace_once(rep string, with string) string

replace_once replaces the first occurence of rep with the string passed in with.

fn (s string) reverse() string

reverse returns a reversed string.

assert 'Hello V'.reverse() == 'V olleH'

fn (s string) split(delim string) []string

split splits the string to an array by delim. If delim is empty the string is split by it's characters.

assert 'A B C'.split(' ') == ['A','B','C']

assert 'DEF'.split('') == ['D','E','F']

fn (s string) split_by_whitespace() []string

split_by_whitespace - extract only the non whitespace tokens/words from the given string s. example: ' sss ssss'.split_by_whitespace() => ['sss', 'ssss']

fn (s string) split_into_lines() []string

split_into_lines splits the string by newline characters. Both \n and \r\n newline endings is supported.

fn (s string) split_nth(delim string, nth int) []string

split_nth splits the string based on the passed delim substring. It returns the first Nth parts. When N=0, return all the splits. The last returned element has the remainder of the string, even if the remainder contains more delim substrings.

fn (s string) starts_with(p string) bool

starts_with returns true if the string starts with p.

fn (s string) str() string

str returns the string itself.

fn (s string) strip_margin() string

strip_margin allows multi-line strings to be formatted in a way that removes white-space before a delimeter. by default | is used. Note: the delimiter has to be a byte at this time. That means surrounding the value in ``. Example: st := 'Hello there, |this is a string, | Everything before the first | is removed'.strip_margin() Returns: Hello there, this is a string, Everything before the first | is removed

fn (s string) strip_margin_custom(del byte) string

strip_margin_custom does the same as strip_margin but will use del as delimiter instead of |

fn (s string) substr(start int, end int) string

substr returns the string between index positions start and end.

assert 'ABCD'.substr(1,3) == 'BC'

fn (s string) title() string

title returns the string with each word capitalized.

assert 'hello v developer'.title() == 'Hello V Developer'

fn (s string) to_lower() string

to_lower returns the string in all lowercase characters. TODO only works with ASCII

fn (s string) to_upper() string

to_upper returns the string in all uppercase characters.

assert 'Hello V'.to_upper() == 'HELLO V'

fn (_str string) to_wide() &u16

fn (s string) trim(cutset string) string

trim strips any of the characters given in cutset from the start and end of the string.

assert ' ffHello V ffff'.trim(' f') == 'Hello V'

fn (s string) trim_left(cutset string) string

trim_left strips any of the characters given in cutset from the left of the string.

assert 'd Hello V developer'.trim_left(' d') == 'Hello V developer'

fn (s string) trim_prefix(str string) string

trim_prefix strips str from the start of the string.

assert 'WorldHello V'.trim_prefix('World') == 'Hello V'

fn (s string) trim_right(cutset string) string

trim_right strips any of the characters given in cutset from the right of the string.

assert ' Hello V d'.trim_right(' d') == ' Hello V'

fn (s string) trim_space() string

trim_space strips any of , \n, \t, \v, \f, \r from the start and end of the string.

assert ' Hello V '.trim_space() == 'Hello V'

fn (s string) trim_suffix(str string) string

trim_suffix strips str from the end of the string.

assert 'Hello VWorld'.trim_suffix('World') == 'Hello V'

fn (s string) u16() u16

u16 returns the value of the string as u16 '1'.u16() == u16(1).

fn (s string) u32() u32

u32 returns the value of the string as u32 '1'.u32() == u32(1).

fn (s string) u64() u64

u64 returns the value of the string as u64 '1'.u64() == u64(1).

fn (s string) ustring() ustring

ustring converts the string to a unicode string.

fn (s string) ustring_tmp() ustring

fn (_rune string) utf32_code() int

Convert utf8 to utf32

struct ustring {
pub mut:
	s     string
	runes []int
	len   int
}

mut: hash_cache int NB string.is_lit is an enumeration of the following: .is_lit == 0 => a fresh string, should be freed by autofree .is_lit == 1 => a literal string from .rodata, should NOT be freed .is_lit == -98761234 => already freed string, protects against double frees. ---------> ^^^^^^^^^ calling free on these is a bug. Any other value means that the string has been corrupted.

fn (s ustring) str() string

str returns the string itself.

fn (u ustring) add(a ustring) ustring

add concatenates ustring with the string given in s.

fn (u ustring) index_after(p ustring, start int) int

index_after returns the position of the input string, starting search from start position.

fn (u ustring) count(substr ustring) int

count returns the number of occurrences of substr in the string. count returns -1 if no substr could be found.

fn (u ustring) substr(_start int, _end int) string

substr returns the string between index positions _start and _end.

assert 'ABCD'.substr(1,3) == 'BC'

fn (u ustring) left(pos int) string

left returns the nth leftmost characters of the ustring.

assert 'hello'.left(2) == 'he'

fn (u ustring) right(pos int) string

right returns the nth rightmost characters of the ustring.

assert 'hello'.right(2) == 'lo'

fn (u ustring) at(idx int) string

at returns the string at index idx.

assert 'ABC'.at(1) == 'B'

struct VAssertMetaInfo {
pub:
	fpath   string
	line_nr int
	fn_name string
	src     string
	op      string
	llabel  string
	rlabel  string
	lvalue  string
	rvalue  string
}

VAssertMetaInfo is used during assertions. An instance of it is filled in by compile time generated code, when an assertion fails.