Pointer

(Fn [(Ptr a), Long] (Ptr a))

adds a long integer value to a pointer.

(Fn [(Ref a b)] (Ptr a))

returns the memory address of a reference. Equivalent to the & operator when placed before a variable in C.

(Fn [(Ptr a)] (Ptr a))

                        (blit x)
                    

(Fn [(Ref (Ptr a) b)] (Ptr a))

copies a pointer p.

(Fn [(Ptr a)] (Ptr a))

                        (dec a)
                    

(Fn [(Ptr a), (Ptr a)] Bool)

checks two pointer references for equality.

(Fn [(Ptr a)] ())

Free a pointer, deallocating the memory associated with it. Carp's borrow checker handles deallocation automatically for managed types. The Ptr type is unmanaged, so pointers allocated with functions such as Pointer.unsafe-alloc need to be deallocated manually using this function. Users need to manually verify that this operation is safe.

(let-do [x (Pointer.unsafe-alloc @"c")]
  (Pointer.set x @"carp")
  (println* (Pointer.to-value x))
  (Pointer.free x))

(Fn [Long] (Ptr a))

converts a long integer to a pointer.

(Fn [(Ptr a)] (Ptr a))

                        (inc a)
                    

(Fn [(Ptr a)] String)

                        (prn a)
                    

(Fn [(Ref (Ptr a) b), (Ref (Ptr a) c)] Bool)

(Fn [(Ptr a), a] ())

Sets the value of a pointer.

(Fn [(Ptr a)] String)

                        (str a)
                    

(Fn [(Ptr a)] String)

(Fn [(Ptr a), Long] (Ptr a))

subtracts a long integer value from a pointer.

(Fn [(Ptr a)] Long)

converts a pointer to a long integer.

(Fn [(Ptr a)] (Ref a b))

converts a pointer to a reference type.

The user will have to ensure themselves that this is a safe operation.

(Fn [(Ptr a)] a)

converts a pointer to a value.

The user will have to ensure themselves that this is a safe operation.

(Fn [a] (Ptr a))

Allocate a new pointer to the value a. This pointer won't be managed by Carp's borrow checker and will cause memory leaks unless explicitly freed using Pointer.free.

See Unsafe.leak if you want to prevent Carp's automatic memory management from deallocating a value without performing an allocation.

(let-do [x (Pointer.unsafe-alloc @"c")]
  (Pointer.set x @"carp")
  (println* (Pointer.to-value x))
  (Pointer.free x))

(Fn [(Ptr a), b] ())

Sets the value of a pointer to a value of any type. The user will have to ensure this operation is safe.

(Fn [(Ptr a)] Long)

gets the byte size of a pointer.