🥮 mooncakes.io
README

tonyfettes/c/pointer does not have a README file

#
Borrow

source
trait Borrow

Trait for types that support safe borrowing as pointers.

Types implementing this trait can be safely converted to and from pointers, enabling temporary pointer access to their internal data.
impl Borrow for FixedArray[T]
impl Borrow for Bytes
impl Borrow for Ref[T]

#
From

source
pub(open) trait From {
  fn from(Self) -> Pointer[Unit]
}

#
Into

source
pub(open) trait Into {
  fn into(Pointer[Unit]) -> Self
}

#
Load

source
pub(open) trait Load {
  fn load(Pointer[Self]) -> Self
}

impl Load for Bool
impl Load for Byte
impl Load for Int
impl Load for Int16
impl Load for Int64
impl Load for UInt
impl Load for UInt16
impl Load for UInt64
impl Load for Float
impl Load for Double
impl Load for Ptrdiff
impl Load for Size

#
Store

source
pub(open) trait Store {
  fn store(Pointer[Self], Self) -> Unit
}

impl Store for Bool
impl Store for Byte
impl Store for Int
impl Store for Int16
impl Store for Int64
impl Store for UInt
impl Store for UInt16
impl Store for UInt64
impl Store for Float
impl Store for Double
impl Store for Ptrdiff
impl Store for Size

#
Pointer

source
#alias(Ptr)
#external
pub(all) type Pointer[_]

A generic pointer type that wraps the underlying platform pointer type.

Pointer[T] represents a pointer to a value of type T. This type is used for low-level memory operations and interoperability with C code.
impl Compare for Pointer[T]
impl Eq for Pointer[T]
impl Borrow for Pointer[T]
impl From for Pointer[T]
impl Into for Pointer[T]
impl Load for Pointer[T]
impl Store for Pointer[T]
impl Sized for Pointer[T]

#
Pointer::add

source

Adds an offset to a pointer and returns a new pointer.

Parameters:

  • pointer: The original pointer.
  • offset: The offset to add, in number of elements of type T.

Returns a new pointer that is offset from the original pointer by the specified number of elements.

#
Pointer::align

source
fn Pointer::align(self : Pointer[Unit], alignment : 
Size) -> Pointer[Unit]

#
Pointer::byte_add

source
fn[T] Pointer::byte_add(self : Pointer[T], offset : 
Size) -> Pointer[T]

#
Pointer::byte_offset

source
fn[T] Pointer::byte_offset(self : Pointer[T], offset : 
Ptrdiff) -> Pointer[T]

Adds a byte offset to a pointer and returns a new pointer.

This function interprets the pointer as a byte pointer, adds the specified byte offset, and returns the result cast back to the original type.

Parameters:
  • offset: The byte offset to add

Returns a new pointer that is offset from the original pointer by the specified number of bytes.

#
Pointer::byte_offset_from

source
fn[T] Pointer::byte_offset_from(self : Pointer[T], other : Pointer[T]) -> 
Ptrdiff

Calculates the byte offset between two pointers.

Subtracts other from self to determine how many bytes are between the two pointers.

Parameters:
  • other: The pointer to subtract from this pointer

Returns the number of bytes between the two pointers.

#
Pointer::byte_sub

source
fn[T] Pointer::byte_sub(self : Pointer[T], offset : 
Size) -> Pointer[T]

#
Pointer::cast

source
fn[T, U] Pointer::cast(self : Pointer[T]) -> Pointer[U]

Casts a pointer from one type to another.

This is an unsafe operation that reinterprets the pointer without any type checking.

Parameters:
  • self: The pointer to cast

Returns a pointer to type U

#
Pointer::cast_to_byte

source
fn[T] Pointer::cast_to_byte(self : Pointer[T]) -> Pointer[Byte]

#
Pointer::cast_to_unit

source
fn[T] Pointer::cast_to_unit(self : Pointer[T]) -> Pointer[Unit]

#
Pointer::from

source
#as_free_fn
fn[T : From] Pointer::from(value : T) -> Pointer[Unit]

#
Pointer::into

source
fn[T : Into] Pointer::into(ptr : Pointer[Unit]) -> T

#
Pointer::is_not_null

source
fn[T] Pointer::is_not_null(self : Pointer[T]) -> Bool

Checks if the pointer is not null.

Returns true if the pointer is not null, false otherwise.

#
Pointer::is_null

source
fn[T] Pointer::is_null(self : Pointer[T]) -> Bool

Checks if the pointer is null.

Returns true if the pointer is null, false otherwise.

#
Pointer::load

source
fn[T : Load] Pointer::load(self : Pointer[T]) -> T

Loads a value from the memory location pointed to by this pointer.

This is equivalent to dereferencing the pointer in C (*pointer).

Returns the value stored at this memory location.

#
Pointer::null

source
#as_free_fn
fn[T] Pointer::null() -> Pointer[T]

Creates a null pointer of type T.

Returns a null pointer that points to no valid memory location.

#
Pointer::offset

source

#
Pointer::offset_from

source

Calculates the offset between two pointers in elements.

Subtracts other from self to determine how many elements of type T are between the two pointers.

Parameters:
  • other: The pointer to subtract from this pointer

Returns the number of elements between the two pointers.

#
Pointer::op_get

source
fn[T : 
Sized + Load] Pointer::op_get(self : Pointer[T], index : Int) -> T

Reads a value from the pointer at the specified index.

This is equivalent to the C operation pointer[index].

Parameters:
  • index: The index to read from

Returns the value at the specified index.

#
Pointer::op_set

source
fn[T : 
Sized + Store] Pointer::op_set(self : Pointer[T], index : Int, value : T) -> Unit

Writes a value to the pointer at the specified index.

This is equivalent to the C operation pointer[index] = value.

Parameters:
  • index: The index to write to
  • value: The value to write

#
Pointer::sizeof

source
#as_free_fn
fn Pointer::sizeof() -> 
Size

Returns the size of a pointer in bytes.

On most platforms, this returns 8 for 64-bit systems or 4 for 32-bit systems.

#
Pointer::store

source
fn[T : Store] Pointer::store(self : Pointer[T], value : T) -> Unit

Stores a value to the memory location pointed to by this pointer.

This is equivalent to the C operation *pointer = value.

Parameters:
  • value: The value to store

#
Pointer::sub

source

#
Pointer::to_size

source
fn[T] Pointer::to_size(self : Pointer[T]) -> 
Size

#
Pointer::to_uint64

source
fn[T] Pointer::to_uint64(self : Pointer[T]) -> UInt64

Converts the pointer to a 64-bit unsigned integer.

This returns the numeric value of the pointer's address.

Returns the memory address as a UInt64.

#
Pointer::unsafe_from

source
#as_free_fn
fn[T] Pointer::unsafe_from(value : T) -> Pointer[Unit]

Unsafely extracts a pointer from any value.

Warning: This is an unsafe operation that should be used with extreme caution. The value is not consumed, and using the pointer may lead to undefined behavior if the value is moved or deallocated.

Parameters:

  • value: The value to extract a pointer from

Returns a Pointer[Unit] pointing to the value's memory location.

#
Pointer::unsafe_from_array

source
#as_free_fn
fn[T] Pointer::unsafe_from_array(value : FixedArray[T]) -> Pointer[T]

Extracts a pointer from a fixed array.

Parameters:

  • value: The fixed array to extract a pointer from

Returns a Pointer[T] pointing to the first element of the array.

#
Pointer::unsafe_from_bytes

source
#as_free_fn
fn Pointer::unsafe_from_bytes(value : Bytes) -> Pointer[Byte]

Extracts a pointer from a bytes buffer.

Parameters:

  • value: The bytes buffer to extract a pointer from

Returns a Pointer[Byte] pointing to the first byte of the buffer.

#
Pointer::unsafe_from_ref

source
#as_free_fn
fn[T] Pointer::unsafe_from_ref(value : 
Ref[T]) -> Pointer[T]

Extracts a pointer from a reference.

Parameters:

  • value: The reference to extract a pointer from

Returns a Pointer[T] pointing to the referenced value.

#
Pointer::unsafe_into

source
#as_free_fn
fn[T] Pointer::unsafe_into(ptr : Pointer[Unit]) -> T

Unsafely converts a pointer back into a value.

Warning: This is an unsafe operation that should be used with extreme caution. The pointer must point to valid memory of type T, or undefined behavior will occur.

Parameters:

  • pointer: The pointer to convert

Returns a value of type T.

#
Pointer::unsafe_into_array

source
#as_free_fn
fn[T] Pointer::unsafe_into_array(ptr : Pointer[T]) -> FixedArray[T]

Converts a pointer into a fixed array.

Parameters:

  • pointer: The pointer to convert

Returns a FixedArray[T] starting at the pointer's memory location.

#
Pointer::unsafe_into_bytes

source
#as_free_fn
fn Pointer::unsafe_into_bytes(ptr : Pointer[Byte]) -> Bytes

Converts a pointer into a bytes buffer.

Parameters:

  • pointer: The pointer to convert

Returns a Bytes buffer starting at the pointer's memory location.

#
Pointer::unsafe_into_ref

source
#as_free_fn
fn[T] Pointer::unsafe_into_ref(ptr : Pointer[T]) -> 
Ref[T]

Converts a pointer into a reference.

Parameters:

  • pointer: The pointer to convert

Returns a Ref[T] referencing the memory location.

#
borrow

source
fn[T : Borrow, R] borrow(value : T, f : (Pointer[Unit]) -> R raise?) -> R raise?

Borrows a pointer from a value that implements the Borrow trait.

The value is temporarily converted to a pointer, passed to the function, and then restored. This ensures the value remains valid after the operation.

Parameters:

  • value: The value to borrow from (must implement Borrow)
  • f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_2

source
fn[A : Borrow, B : Borrow, R] borrow_2(a : A, b : B, f : (Pointer[Unit], Pointer[Unit]) -> R raise?) -> R raise?

#
borrow_array

source
fn[T, R] borrow_array(array : FixedArray[T], f : (Pointer[T]) -> R raise?) -> R raise?

Borrows a pointer from a fixed array for the duration of a function call.

The array is temporarily converted to a pointer, passed to the function, and then restored. This ensures the array remains valid after the operation.

Parameters:

  • array: The fixed array to borrow from
  • f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_bytes

source
fn[R] borrow_bytes(bytes : Bytes, f : (Pointer[Byte]) -> R raise?) -> R raise?

Borrows a pointer from a bytes buffer for the duration of a function call.

The bytes buffer is temporarily converted to a pointer, passed to the function, and then restored. This ensures the buffer remains valid after the operation.

Parameters:

  • bytes: The bytes buffer to borrow from
  • f: The function to call with the borrowed pointer

Returns the result of calling f.

#
borrow_ref

source
fn[T, R] borrow_ref(ref_ : 
Ref[T], f : (Pointer[T]) -> R raise?) -> R raise?

Borrows a pointer from a reference for the duration of a function call.

The reference is temporarily converted to a pointer, passed to the function, and then restored. This ensures the reference remains valid after the operation.

Parameters:

  • ref_: The reference to borrow from
  • f: The function to call with the borrowed pointer

Returns the result of calling f.

#
unsafe_borrow

source
fn[T, R] unsafe_borrow(value : T, f : (Pointer[Unit]) -> R raise?) -> R raise?

Unsafely borrows a pointer from any value for the duration of a function call.

Warning: This is an unsafe operation. The value is temporarily converted to a pointer and restored after the function call, but this may lead to undefined behavior if not used carefully.

Parameters:

  • value: The value to borrow from
  • f: The function to call with the borrowed pointer

Returns the result of calling f.

#
unsafe_decref

source
fn[T] unsafe_decref(value : T) -> Unit

Decrements the reference count of a value.

This function manipulates the internal reference count by converting the value to a pointer and back twice, effectively decrementing its reference count.

Warning: This is a low-level operation that should be used with caution.

Parameters:

  • value: The value whose reference count should be decremented

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io