EgretDoc
Back to Home
Location:system/std

Module

Module documentation.

modulestd

Classes

Classes and inheritance.

classstd::StringView
@brief`StringView` type.
@details`StringView` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class StringView {
    /*
    @brief `data` field.
classstd::CStringView
@brief`CStringView` type.
@details`CStringView` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class CStringView {
    /*
    @brief `data` field.
classstd::StringBuilder
@brief`StringBuilder` type.
@details`StringBuilder` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class StringBuilder {
    /*
    @brief `h` field.

Functions

Free functions and class methods.

functionstd::__strlen
Signatureextern func __strlen(s: String) -> Int;
extern func __strlen(s: String) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_byte_at`.
@briefBinds the low-level runtime symbol `__strlen`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • sInput string.
@returnReturns the operation result as `Int`.
functionstd::__string_byte_at
Signatureextern func __string_byte_at(s: String, idx: Int) -> Int;
extern func __string_byte_at(s: String, idx: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__streq`.
@briefBinds the low-level runtime symbol `__string_byte_at`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • sInput string.
  • idxZero-based index.
@returnReturns the operation result as `Int`.
functionstd::__streq
Signatureextern func __streq(a: String, b: String) -> Int;
extern func __streq(a: String, b: String) -> Int;
/*
@brief Binds the low-level runtime symbol `__strcmp`.
@briefBinds the low-level runtime symbol `__streq`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns the operation result as `Int`.
functionstd::__strcmp
Signatureextern func __strcmp(a: String, b: String) -> Int;
extern func __strcmp(a: String, b: String) -> Int;
/*
@brief Binds the low-level runtime symbol `__concat`.
@briefBinds the low-level runtime symbol `__strcmp`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns the operation result as `Int`.
functionstd::__concat
Signatureextern func __concat(a: String, b: String) -> String;
extern func __concat(a: String, b: String) -> String;
/*
@brief Binds the low-level runtime symbol `__substr`.
@briefBinds the low-level runtime symbol `__concat`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns the operation result as `String`.
functionstd::__substr
Signatureextern func __substr(s: String, start: Int, len: Int) -> String;
extern func __substr(s: String, start: Int, len: Int) -> String;
/*
@brief Binds the low-level runtime symbol `__char_from_code`.
@briefBinds the low-level runtime symbol `__substr`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • sInput string.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `String`.
functionstd::__char_from_code
Signatureextern func __char_from_code(code: Int) -> String;
extern func __char_from_code(code: Int) -> String;
/*
@brief Binds the low-level runtime symbol `__string_cstr`.
@briefBinds the low-level runtime symbol `__char_from_code`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • codeNumeric status, error, signal, opcode, or platform code handled by this API.
@returnReturns the operation result as `String`.
functionstd::__string_cstr
Signatureextern func __string_cstr(s: String) -> Ptr;
extern func __string_cstr(s: String) -> Ptr;
/*
@brief Binds the low-level runtime symbol `__string_from_cstr`.
@briefBinds the low-level runtime symbol `__string_cstr`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • sInput string.
@returnReturns the operation result as `Ptr`.
functionstd::__string_from_cstr
Signatureextern func __string_from_cstr(p: Ptr) -> String;
extern func __string_from_cstr(p: Ptr) -> String;
/*
@brief Binds the low-level runtime symbol `__string_view_byte_at`.
@briefBinds the low-level runtime symbol `__string_from_cstr`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
@returnReturns the operation result as `String`.
functionstd::__string_view_byte_at
Signatureextern func __string_view_byte_at(p: Ptr, len: Int, idx: Int) -> Int;
extern func __string_view_byte_at(p: Ptr, len: Int, idx: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_slice_ptr`.
@briefBinds the low-level runtime symbol `__string_view_byte_at`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • idxZero-based index.
@returnReturns the operation result as `Int`.
functionstd::__string_view_slice_ptr
Signatureextern func __string_view_slice_ptr(p: Ptr, len: Int, start: Int, take: Int) -> Ptr;
extern func __string_view_slice_ptr(p: Ptr, len: Int, start: Int, take: Int) -> Ptr;
/*
@brief Binds the low-level runtime symbol `__string_view_slice_len`.
@briefBinds the low-level runtime symbol `__string_view_slice_ptr`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • takeNumber of elements or bytes to take from the input sequence.
@returnReturns the operation result as `Ptr`.
functionstd::__string_view_slice_len
Signatureextern func __string_view_slice_len(len: Int, start: Int, take: Int) -> Int;
extern func __string_view_slice_len(len: Int, start: Int, take: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_starts_with`.
@briefBinds the low-level runtime symbol `__string_view_slice_len`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • takeNumber of elements or bytes to take from the input sequence.
@returnReturns the operation result as `Int`.
functionstd::__string_view_starts_with
Signatureextern func __string_view_starts_with(p: Ptr, len: Int, pp: Ptr, plen: Int) -> Int;
extern func __string_view_starts_with(p: Ptr, len: Int, pp: Ptr, plen: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_ends_with`.
@briefBinds the low-level runtime symbol `__string_view_starts_with`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • ppPointer-to-pointer or parser position value updated by the operation.
  • plenSize or length value that limits how much data the operation processes.
@returnReturns the operation result as `Int`.
functionstd::__string_view_ends_with
Signatureextern func __string_view_ends_with(p: Ptr, len: Int, pp: Ptr, plen: Int) -> Int;
extern func __string_view_ends_with(p: Ptr, len: Int, pp: Ptr, plen: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_eq`.
@briefBinds the low-level runtime symbol `__string_view_ends_with`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • ppPointer-to-pointer or parser position value updated by the operation.
  • plenSize or length value that limits how much data the operation processes.
@returnReturns the operation result as `Int`.
functionstd::__string_view_eq
Signatureextern func __string_view_eq(p: Ptr, len: Int, q: Ptr, qlen: Int) -> Int;
extern func __string_view_eq(p: Ptr, len: Int, q: Ptr, qlen: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_find`.
@briefBinds the low-level runtime symbol `__string_view_eq`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • qQueue object, query string, or query handle processed by the operation.
  • qlenSize or length value that limits how much data the operation processes.
@returnReturns the operation result as `Int`.
functionstd::__string_view_find
Signatureextern func __string_view_find(p: Ptr, len: Int, q: Ptr, qlen: Int, start: Int) -> Int;
extern func __string_view_find(p: Ptr, len: Int, q: Ptr, qlen: Int, start: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_view_to_string`.
@briefBinds the low-level runtime symbol `__string_view_find`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • qQueue object, query string, or query handle processed by the operation.
  • qlenSize or length value that limits how much data the operation processes.
  • startZero-based starting index, byte offset, or range boundary for the operation.
@returnReturns the operation result as `Int`.
functionstd::__string_view_to_string
Signatureextern func __string_view_to_string(p: Ptr, len: Int) -> String;
extern func __string_view_to_string(p: Ptr, len: Int) -> String;
/*
@brief Binds the low-level runtime symbol `__string_byte_sum_repeat`.
@briefBinds the low-level runtime symbol `__string_view_to_string`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `String`.
functionstd::__string_byte_sum_repeat
Signatureextern func __string_byte_sum_repeat(s: String, n: Int) -> Int;
extern func __string_byte_sum_repeat(s: String, n: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_new`.
@briefBinds the low-level runtime symbol `__string_byte_sum_repeat`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • sInput string.
  • nCount, size, or limit value.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_new
Signatureextern func __string_builder_new(cap: Int) -> Int;
extern func __string_builder_new(cap: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_bind_gc`.
@briefBinds the low-level runtime symbol `__string_builder_new`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • capInitial or requested storage capacity for the created container or buffer.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_bind_gc
Signatureextern func __string_builder_bind_gc(obj: Any) -> Void;
extern func __string_builder_bind_gc(obj: Any) -> Void;
/*
@brief Binds the low-level runtime symbol `__string_builder_append`.
@briefBinds the low-level runtime symbol `__string_builder_bind_gc`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • objObject instance or encoded object value inspected, converted, or serialized by the operation.
@returnVoid
functionstd::__string_builder_append
Signatureextern func __string_builder_append(h: Int, s: String) -> Int;
extern func __string_builder_append(h: Int, s: String) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_append_view`.
@briefBinds the low-level runtime symbol `__string_builder_append`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
  • sInput string.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_append_view
Signatureextern func __string_builder_append_view(h: Int, p: Ptr, len: Int) -> Int;
extern func __string_builder_append_view(h: Int, p: Ptr, len: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_append_view_slice`.
@briefBinds the low-level runtime symbol `__string_builder_append_view`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_append_view_slice
Signatureextern func __string_builder_append_view_slice(h: Int, p: Ptr, len: Int, start: Int, take: Int) -> Int;
extern func __string_builder_append_view_slice(h: Int, p: Ptr, len: Int, start: Int, take: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_to_string`.
@briefBinds the low-level runtime symbol `__string_builder_append_view_slice`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
  • pNative pointer address passed to the runtime binding.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • takeNumber of elements or bytes to take from the input sequence.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_to_string
Signatureextern func __string_builder_to_string(h: Int) -> String;
extern func __string_builder_to_string(h: Int) -> String;
/*
@brief Binds the low-level runtime symbol `__string_builder_len`.
@briefBinds the low-level runtime symbol `__string_builder_to_string`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
@returnReturns the operation result as `String`.
functionstd::__string_builder_len
Signatureextern func __string_builder_len(h: Int) -> Int;
extern func __string_builder_len(h: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__string_builder_free`.
@briefBinds the low-level runtime symbol `__string_builder_len`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
@returnReturns the operation result as `Int`.
functionstd::__string_builder_free
Signatureextern func __string_builder_free(h: Int) -> Void;
extern func __string_builder_free(h: Int) -> Void;
/*
@brief Binds the low-level runtime symbol `__gc_clear_memory_finalizer`.
@briefBinds the low-level runtime symbol `__string_builder_free`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • hUnderlying runtime handle.
@returnVoid
functionstd::__gc_clear_memory_finalizer
Signatureextern func __gc_clear_memory_finalizer(obj: Any) -> Void;
extern func __gc_clear_memory_finalizer(obj: Any) -> Void;
/*
@brief Binds the low-level runtime symbol `__std_string_alloc_count`.
@briefBinds the low-level runtime symbol `__gc_clear_memory_finalizer`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • objObject instance or encoded object value inspected, converted, or serialized by the operation.
@returnVoid
functionstd::__std_string_alloc_count
Signatureextern func __std_string_alloc_count() -> Int;
extern func __std_string_alloc_count() -> Int;
/*
@brief Binds the low-level runtime symbol `__std_string_alloc_bytes`.
@briefBinds the low-level runtime symbol `__std_string_alloc_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::__std_string_alloc_bytes
Signatureextern func __std_string_alloc_bytes() -> Int;
extern func __std_string_alloc_bytes() -> Int;
/*
@brief Binds the low-level runtime symbol `__std_string_concat_count`.
@briefBinds the low-level runtime symbol `__std_string_alloc_bytes`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::__std_string_concat_count
Signatureextern func __std_string_concat_count() -> Int;
extern func __std_string_concat_count() -> Int;
/*
@brief Binds the low-level runtime symbol `__std_string_substr_count`.
@briefBinds the low-level runtime symbol `__std_string_concat_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::__std_string_substr_count
Signatureextern func __std_string_substr_count() -> Int;
extern func __std_string_substr_count() -> Int;
/*
@brief Binds the low-level runtime symbol `__std_string_cstr_copy_count`.
@briefBinds the low-level runtime symbol `__std_string_substr_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::__std_string_cstr_copy_count
Signatureextern func __std_string_cstr_copy_count() -> Int;
extern func __std_string_cstr_copy_count() -> Int;
/*
@brief Binds the low-level runtime symbol `__std_string_alloc_bucket_count`.
@briefBinds the low-level runtime symbol `__std_string_cstr_copy_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::__std_string_alloc_bucket_count
Signatureextern func __std_string_alloc_bucket_count(bucket: Int) -> Int;
extern func __std_string_alloc_bucket_count(bucket: Int) -> Int;
/*
@brief Binds the low-level runtime symbol `__argv_get`.
@briefBinds the low-level runtime symbol `__std_string_alloc_bucket_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • bucketBucket index or bucket object selected within a hash table.
@returnReturns the operation result as `Int`.
functionstd::__argv_get
Signatureextern func __argv_get(argc: Int, argv: Int, idx: Int) -> String;
extern func __argv_get(argc: Int, argv: Int, idx: Int) -> String;
/*
@brief Binds the low-level runtime symbol `__stdin_read_line`.
@briefBinds the low-level runtime symbol `__argv_get`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@param
  • argcNumber of command-line or native arguments available in `argv`.
  • argvNative pointer or vector containing command-line argument values.
  • idxZero-based index.
@returnReturns the operation result as `String`.
functionstd::__stdin_read_line
Signatureextern func __stdin_read_line() -> String;
extern func __stdin_read_line() -> String;
/*
@brief Binds the low-level runtime symbol `__cpu_count`.
@briefBinds the low-level runtime symbol `__stdin_read_line`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `String`.
functionstd::__cpu_count
Signatureextern func __cpu_count() -> Int;
extern func __cpu_count() -> Int;

/*
@briefBinds the low-level runtime symbol `__cpu_count`.
@detailsThis function is an external entry point used by system modules to access native runtime capabilities such as filesystem, networking, threading, GC, cryptography, or platform operations. Prefer the safe wrapper functions in the same file when available. When calling this entry directly, pass validated arguments that match the signature and handle failures according to the return-value convention.
@returnReturns the operation result as `Int`.
functionstd::err_from_ok
Signaturefunc err_from_ok(ok: Bool) -> ErrCode
func err_from_ok(ok: Bool) -> ErrCode {
    if ok {
        return std.OK;
@briefProvides the system library operation `err_from_ok`.
@detailsExecutes the `err_from_ok` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • okBoolean success value or status flag produced by the operation.
@returnReturns `ErrCode`; on success the error code is `std.OK` or `OK`, and on failure the error code describes the failure while any returned value contains the usable partial result when available.
functionstd::len
Signaturefunc len(s: String) -> Int
func len(s: String) -> Int {
    return __strlen(s);
}
@briefReturns the element count or byte length with `len`.
@detailsExecutes the `len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
@returnReturns the operation result as `Int`.
functionstd::byte_at
Signaturefunc byte_at(s: String, idx: Int) -> Int
func byte_at(s: String, idx: Int) -> Int {
    return __string_byte_at(s, idx);
}
@briefProvides the system library operation `byte_at`.
@detailsExecutes the `byte_at` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
  • idxZero-based index.
@returnReturns the operation result as `Int`.
functionstd::streq
Signaturefunc streq(a: String, b: String) -> Bool
func streq(a: String, b: String) -> Bool {
    return __streq(a, b) == 1;
}
@briefProvides the system library operation `streq`.
@detailsExecutes the `streq` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::strcmp
Signaturefunc strcmp(a: String, b: String) -> Int
func strcmp(a: String, b: String) -> Int {
    return __strcmp(a, b);
}
@briefProvides the system library operation `strcmp`.
@detailsExecutes the `strcmp` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns the operation result as `Int`.
functionstd::concat
Signaturefunc concat(a: String, b: String) -> String
func concat(a: String, b: String) -> String {
    return __concat(a, b);
}
@briefProvides the system library operation `concat`.
@detailsExecutes the `concat` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • aInput value used for comparison, computation, or conversion.
  • bInput value used for comparison, computation, or conversion.
@returnReturns the operation result as `String`.
functionstd::substr
Signaturefunc substr(s: String, start: Int, len: Int) -> String
func substr(s: String, start: Int, len: Int) -> String {
    return __substr(s, start, len);
}
@briefProvides the system library operation `substr`.
@detailsExecutes the `substr` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `String`.
functionstd::char_from_code
Signaturefunc char_from_code(code: Int) -> String
func char_from_code(code: Int) -> String {
    return __char_from_code(code);
}
@briefProvides the system library operation `char_from_code`.
@detailsExecutes the `char_from_code` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • codeNumeric status, error, signal, opcode, or platform code handled by this API.
@returnReturns the operation result as `String`.
functionstd::cstr
Signaturefunc cstr(s: String) -> Ptr
func cstr(s: String) -> Ptr {
    return __string_cstr(s);
}
@briefProvides the system library operation `cstr`.
@detailsExecutes the `cstr` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
@returnReturns the operation result as `Ptr`.
functionstd::string_from_cstr
Signaturefunc string_from_cstr(p: Ptr) -> String
func string_from_cstr(p: Ptr) -> String {
    return __string_from_cstr(p);
}
@briefProvides the system library operation `string_from_cstr`.
@detailsExecutes the `string_from_cstr` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • pNative pointer address passed to the runtime binding.
@returnReturns the operation result as `String`.
functionstd::argv_get
Signaturefunc argv_get(argc: Int, argv: Int, idx: Int) -> String
func argv_get(argc: Int, argv: Int, idx: Int) -> String {
    return __argv_get(argc, argv, idx);
}
@briefProvides the system library operation `argv_get`.
@detailsExecutes the `argv_get` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • argcNumber of command-line or native arguments available in `argv`.
  • argvNative pointer or vector containing command-line argument values.
  • idxZero-based index.
@returnReturns the operation result as `String`.
functionstd::stdin_read_line
Signaturefunc stdin_read_line() -> String
func stdin_read_line() -> String {
    return __stdin_read_line();
}
@briefProvides the system library operation `stdin_read_line`.
@detailsExecutes the `stdin_read_line` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `String`.
functionstd::cpu_count
Signaturefunc cpu_count() -> Int
func cpu_count() -> Int {
    return __cpu_count();
}
@briefProvides the system library operation `cpu_count`.
@detailsExecutes the `cpu_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::StringView.init
Signaturefunc init(self: std.StringView, data: Ptr, length: Int) -> Void
    func init(self: std.StringView, data: Ptr, length: Int) -> Void {
        self.data = data;
        self.length = length;
@briefInitializes a `StringView` instance.
@detailsEstablishes the initial field state for `StringView` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • dataInput or output data buffer.
  • lengthSize or length value that limits how much data the operation processes.
@returnVoid
functionstd::StringView.len
Signaturefunc len(self: std.StringView) -> Int
    func len(self: std.StringView) -> Int {
        return self.length;
    }
@briefReturns the element count or byte length with `StringView.len`.
@detailsExecutes the `len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `Int`.
functionstd::StringView.byte_at
Signaturefunc byte_at(self: std.StringView, idx: Int) -> Int
    func byte_at(self: std.StringView, idx: Int) -> Int {
        return __string_view_byte_at(self.data, self.length, idx);
    }
@briefProvides the system library operation `StringView.byte_at`.
@detailsExecutes the `byte_at` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • idxZero-based index.
@returnReturns the operation result as `Int`.
functionstd::StringView.slice
Signaturefunc slice(self: std.StringView, start: Int, len: Int) -> std.StringView
    func slice(self: std.StringView, start: Int, len: Int) -> std.StringView {
        return new std.StringView(__string_view_slice_ptr(self.data, self.length, start, len), __string_view_slice_len(self.length, start, len));
    }
@briefProvides the system library operation `StringView.slice`.
@detailsExecutes the `slice` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `std.StringView`.
functionstd::StringView.slice_len
Signaturefunc slice_len(self: std.StringView, start: Int, len: Int) -> Int
    func slice_len(self: std.StringView, start: Int, len: Int) -> Int {
        return __string_view_slice_len(self.length, start, len);
    }
@briefProvides the system library operation `StringView.slice_len`.
@detailsExecutes the `slice_len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `Int`.
functionstd::StringView.starts_with
Signaturefunc starts_with(self: std.StringView, prefix: std.StringView) -> Bool
    func starts_with(self: std.StringView, prefix: std.StringView) -> Bool {
        return __string_view_starts_with(self.data, self.length, prefix.data, prefix.length) == 1;
    }
@briefProvides the system library operation `StringView.starts_with`.
@detailsExecutes the `starts_with` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • prefixPrefix string matched, added, stripped, or used to build keys and paths.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringView.ends_with
Signaturefunc ends_with(self: std.StringView, suffix: std.StringView) -> Bool
    func ends_with(self: std.StringView, suffix: std.StringView) -> Bool {
        return __string_view_ends_with(self.data, self.length, suffix.data, suffix.length) == 1;
    }
@briefProvides the system library operation `StringView.ends_with`.
@detailsExecutes the `ends_with` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • suffixSuffix string matched, appended, or removed by the operation.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringView.eq
Signaturefunc eq(self: std.StringView, other: std.StringView) -> Bool
    func eq(self: std.StringView, other: std.StringView) -> Bool {
        return __string_view_eq(self.data, self.length, other.data, other.length) == 1;
    }
@briefTests whether two values are equal with `StringView.eq`.
@detailsExecutes the `eq` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • otherOther instance or comparison operand used by the operation.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringView.find
Signaturefunc find(self: std.StringView, needle: std.StringView, start: Int = 0) -> Int
    func find(self: std.StringView, needle: std.StringView, start: Int = 0) -> Int {
        return __string_view_find(self.data, self.length, needle.data, needle.length, start);
    }
@briefProvides the system library operation `StringView.find`.
@detailsExecutes the `find` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • needleSubstring, byte sequence, or element searched for in the input.
  • startZero-based starting index, byte offset, or range boundary for the operation.
@returnReturns the operation result as `Int`.
functionstd::StringView.to_string
Signaturefunc to_string(self: std.StringView) -> String
    func to_string(self: std.StringView) -> String {
        return __string_view_to_string(self.data, self.length);
    }
@briefConverts to the target representation with `StringView.to_string`.
@detailsExecutes the `to_string` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `String`.
functionstd::StringView.deinit
Signaturefunc deinit(self: std.StringView) -> Void
    func deinit(self: std.StringView) -> Void {
    }
}
@briefReleases fallback resources at the end of the `StringView` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionstd::view
Signaturefunc view(s: String) -> std.StringView
func view(s: String) -> std.StringView {
    return new std.StringView(std.cstr(s), std.len(s));
}
@briefProvides the system library operation `view`.
@detailsExecutes the `view` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
@returnReturns the operation result as `std.StringView`.
functionstd::view_from_cstr
Signaturefunc view_from_cstr(p: Ptr, length: Int) -> std.StringView
func view_from_cstr(p: Ptr, length: Int) -> std.StringView {
    return new std.StringView(p, length);
}
@briefProvides the system library operation `view_from_cstr`.
@detailsExecutes the `view_from_cstr` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • pNative pointer address passed to the runtime binding.
  • lengthSize or length value that limits how much data the operation processes.
@returnReturns the operation result as `std.StringView`.
functionstd::CStringView.init
Signaturefunc init(self: std.CStringView, data: Ptr, length: Int) -> Void
    func init(self: std.CStringView, data: Ptr, length: Int) -> Void {
        self.data = data;
        self.length = length;
@briefInitializes a `CStringView` instance.
@detailsEstablishes the initial field state for `CStringView` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • dataInput or output data buffer.
  • lengthSize or length value that limits how much data the operation processes.
@returnVoid
functionstd::CStringView.len
Signaturefunc len(self: std.CStringView) -> Int
    func len(self: std.CStringView) -> Int {
        return self.length;
    }
@briefReturns the element count or byte length with `CStringView.len`.
@detailsExecutes the `len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `Int`.
functionstd::CStringView.byte_at
Signaturefunc byte_at(self: std.CStringView, idx: Int) -> Int
    func byte_at(self: std.CStringView, idx: Int) -> Int {
        return __string_view_byte_at(self.data, self.length, idx);
    }
@briefProvides the system library operation `CStringView.byte_at`.
@detailsExecutes the `byte_at` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • idxZero-based index.
@returnReturns the operation result as `Int`.
functionstd::CStringView.slice
Signaturefunc slice(self: std.CStringView, start: Int, len: Int) -> std.CStringView
    func slice(self: std.CStringView, start: Int, len: Int) -> std.CStringView {
        return new std.CStringView(__string_view_slice_ptr(self.data, self.length, start, len), __string_view_slice_len(self.length, start, len));
    }
@briefProvides the system library operation `CStringView.slice`.
@detailsExecutes the `slice` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `std.CStringView`.
functionstd::CStringView.slice_len
Signaturefunc slice_len(self: std.CStringView, start: Int, len: Int) -> Int
    func slice_len(self: std.CStringView, start: Int, len: Int) -> Int {
        return __string_view_slice_len(self.length, start, len);
    }
@briefProvides the system library operation `CStringView.slice_len`.
@detailsExecutes the `slice_len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns the operation result as `Int`.
functionstd::CStringView.to_string
Signaturefunc to_string(self: std.CStringView) -> String
    func to_string(self: std.CStringView) -> String {
        return __string_view_to_string(self.data, self.length);
    }
@briefConverts to the target representation with `CStringView.to_string`.
@detailsExecutes the `to_string` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `String`.
functionstd::CStringView.as_view
Signaturefunc as_view(self: std.CStringView) -> std.StringView
    func as_view(self: std.CStringView) -> std.StringView {
        return new std.StringView(self.data, self.length);
    }
@briefProvides the system library operation `CStringView.as_view`.
@detailsExecutes the `as_view` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `std.StringView`.
functionstd::CStringView.deinit
Signaturefunc deinit(self: std.CStringView) -> Void
    func deinit(self: std.CStringView) -> Void {
    }
}
@briefReleases fallback resources at the end of the `CStringView` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionstd::cstr_view
Signaturefunc cstr_view(s: String) -> std.CStringView
func cstr_view(s: String) -> std.CStringView {
    return new std.CStringView(std.cstr(s), std.len(s));
}
@briefProvides the system library operation `cstr_view`.
@detailsExecutes the `cstr_view` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
@returnReturns the operation result as `std.CStringView`.
functionstd::byte_sum_repeat
Signaturefunc byte_sum_repeat(s: String, n: Int) -> Int
func byte_sum_repeat(s: String, n: Int) -> Int {
    return __string_byte_sum_repeat(s, n);
}
@briefProvides the system library operation `byte_sum_repeat`.
@detailsExecutes the `byte_sum_repeat` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • sInput string.
  • nCount, size, or limit value.
@returnReturns the operation result as `Int`.
functionstd::StringBuilder.init
Signaturefunc init(self: std.StringBuilder, cap: Int = 64) -> Void
    func init(self: std.StringBuilder, cap: Int = 64) -> Void {
        self.h = __string_builder_new(cap);
        _ = __string_builder_bind_gc(self);
@briefInitializes a `StringBuilder` instance.
@detailsEstablishes the initial field state for `StringBuilder` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • capInitial or requested storage capacity for the created container or buffer.
@returnVoid
functionstd::StringBuilder.append
Signaturefunc append(self: std.StringBuilder, s: String) -> Bool
    func append(self: std.StringBuilder, s: String) -> Bool {
        return __string_builder_append(self.h, s) == 1;
    }
@briefProvides the system library operation `StringBuilder.append`.
@detailsExecutes the `append` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • sInput string.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringBuilder.append_view
Signaturefunc append_view(self: std.StringBuilder, v: std.StringView) -> Bool
    func append_view(self: std.StringBuilder, v: std.StringView) -> Bool {
        return __string_builder_append_view(self.h, v.data, v.length) == 1;
    }
@briefProvides the system library operation `StringBuilder.append_view`.
@detailsExecutes the `append_view` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • vValue argument consumed, stored, encoded, compared, or forwarded by this API.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringBuilder.append_view_slice
Signaturefunc append_view_slice(self: std.StringBuilder, v: std.StringView, start: Int, len: Int) -> Bool
    func append_view_slice(self: std.StringBuilder, v: std.StringView, start: Int, len: Int) -> Bool {
        return __string_builder_append_view_slice(self.h, v.data, v.length, start, len) == 1;
    }
@briefProvides the system library operation `StringBuilder.append_view_slice`.
@detailsExecutes the `append_view_slice` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • vValue argument consumed, stored, encoded, compared, or forwarded by this API.
  • startZero-based starting index, byte offset, or range boundary for the operation.
  • lenLength in bytes, characters, or elements to read, write, copy, or allocate.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionstd::StringBuilder.len
Signaturefunc len(self: std.StringBuilder) -> Int
    func len(self: std.StringBuilder) -> Int {
        return __string_builder_len(self.h);
    }
@briefReturns the element count or byte length with `StringBuilder.len`.
@detailsExecutes the `len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `Int`.
functionstd::StringBuilder.to_string
Signaturefunc to_string(self: std.StringBuilder) -> String
    func to_string(self: std.StringBuilder) -> String {
        return __string_builder_to_string(self.h);
    }
@briefConverts to the target representation with `StringBuilder.to_string`.
@detailsExecutes the `to_string` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `String`.
functionstd::StringBuilder.free
Signaturefunc free(self: std.StringBuilder) -> Void
    func free(self: std.StringBuilder) -> Void {
        if self.h != 0 {
            _ = __string_builder_free(self.h);
@briefProvides the system library operation `StringBuilder.free`.
@detailsExecutes the `free` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionstd::StringBuilder.dispose
Signaturefunc dispose(self: std.StringBuilder) -> Void
    func dispose(self: std.StringBuilder) -> Void {
        _ = self.free();
    }
@briefExplicitly releases resources owned by `StringBuilder`.
@detailsThis method deterministically cleans up file descriptors, network connections, native handles, buffers, or other external resources. Implementations should be idempotent where possible, and repeated calls must not corrupt object state.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionstd::StringBuilder.deinit
Signaturefunc deinit(self: std.StringBuilder) -> Void
    func deinit(self: std.StringBuilder) -> Void {
        _ = self.free();
    }
@briefReleases fallback resources at the end of the `StringBuilder` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionstd::string_alloc_count
Signaturefunc string_alloc_count() -> Int
func string_alloc_count() -> Int {
    return __std_string_alloc_count();
}
@briefProvides the system library operation `string_alloc_count`.
@detailsExecutes the `string_alloc_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::string_alloc_bytes
Signaturefunc string_alloc_bytes() -> Int
func string_alloc_bytes() -> Int {
    return __std_string_alloc_bytes();
}
@briefProvides the system library operation `string_alloc_bytes`.
@detailsExecutes the `string_alloc_bytes` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::string_concat_count
Signaturefunc string_concat_count() -> Int
func string_concat_count() -> Int {
    return __std_string_concat_count();
}
@briefProvides the system library operation `string_concat_count`.
@detailsExecutes the `string_concat_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::string_substr_count
Signaturefunc string_substr_count() -> Int
func string_substr_count() -> Int {
    return __std_string_substr_count();
}
@briefProvides the system library operation `string_substr_count`.
@detailsExecutes the `string_substr_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::string_cstr_copy_count
Signaturefunc string_cstr_copy_count() -> Int
func string_cstr_copy_count() -> Int {
    return __std_string_cstr_copy_count();
}
@briefProvides the system library operation `string_cstr_copy_count`.
@detailsExecutes the `string_cstr_copy_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@returnReturns the operation result as `Int`.
functionstd::string_alloc_bucket_count
Signaturefunc string_alloc_bucket_count(bucket: Int) -> Int
func string_alloc_bucket_count(bucket: Int) -> Int {
    return __std_string_alloc_bucket_count(bucket);
}
@briefProvides the system library operation `string_alloc_bucket_count`.
@detailsExecutes the `string_alloc_bucket_count` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • bucketBucket index or bucket object selected within a hash table.
@returnReturns the operation result as `Int`.

Variables

Class fields (var).

varstd::StringView.data
TypePtr
@brief`data` field.
@detailsStores the underlying data. The field type is `Ptr`, and it is maintained by the constructors and methods of `StringView`.
    var data: Ptr;
    /*
    @brief `length` field.
varstd::StringView.length
TypeInt
@brief`length` field.
@detailsStores the current length. The field type is `Int`, and it is maintained by the constructors and methods of `StringView`.
    var length: Int;

    /*
varstd::CStringView.data
TypePtr
@brief`data` field.
@detailsStores the underlying data. The field type is `Ptr`, and it is maintained by the constructors and methods of `CStringView`.
    var data: Ptr;
    /*
    @brief `length` field.
varstd::CStringView.length
TypeInt
@brief`length` field.
@detailsStores the current length. The field type is `Int`, and it is maintained by the constructors and methods of `CStringView`.
    var length: Int;

    /*
varstd::StringBuilder.h
TypeInt
@brief`h` field.
@detailsStores the underlying runtime handle. The field type is `Int`, and it is maintained by the constructors and methods of `StringBuilder`.
    var h: Int;

    /*