Enum Value 

pub enum Value {
    Root(Root),
    Raw(Value),
}

Value wraps the native OCaml value type

Variants

Root(Root)

Rooted value

Raw(Value)

Reference to a rooted value NOTE: Value::Raw should NOT be used to convert arbitrary sys::Value into Value

Implementations

impl Value

pub fn raw(&self) -> Raw

Get raw OCaml value

pub fn to<T: FromValue>(&self) -> T

Helper function to convert from Value to T

pub fn into<T: FromValue>(self) -> T

Helper function to convert from Value to T

pub unsafe fn named(name: &str) -> Option<Value>

Returns a named value registered by OCaml

pub unsafe fn alloc(n: usize, tag: Tag) -> Value

Allocate a new value with the given size and tag.

pub unsafe fn alloc_double_array(n: usize) -> Value

Allocate a new float array

pub unsafe fn alloc_tuple(n: usize) -> Value

Allocate a new tuple value

pub unsafe fn alloc_small(n: usize, tag: Tag) -> Value

Allocate a new small value with the given size and tag

pub unsafe fn alloc_final<T>( finalizer: unsafe extern "C" fn(Raw), cfg: Option<(usize, usize)>, ) -> Value

Allocate a new value with a finalizer

This calls caml_alloc_final under-the-hood, which can has less than ideal performance behavior. In most cases you should prefer Pointer::alloc_custom when possible.

pub unsafe fn alloc_custom<T: Custom>() -> Value

Allocate custom value

pub unsafe fn alloc_abstract_ptr<T>(ptr: *mut T) -> Value

Allocate an abstract pointer value, it is best to ensure the value is on the heap using Box::into_raw(Box::from(...)) to create the pointer and Box::from_raw to free it

pub unsafe fn new<T: Into<Value>>(v: T) -> Value

Create a new Value from an existing OCaml value

pub unsafe fn array_length(&self) -> usize

Get array length

pub unsafe fn register_global_root(&mut self)

See caml_register_global_root

pub unsafe fn remove_global_root(&mut self)

Set caml_remove_global_root

pub unsafe fn tag(&self) -> Tag

Get the tag for the underlying OCaml value

pub unsafe fn bool(b: bool) -> Value

Convert a boolean to OCaml value

pub unsafe fn string<S: AsRef<str>>(s: S) -> Value

Allocate and copy a string value

pub unsafe fn bytes<S: AsRef<[u8]>>(s: S) -> Value

Allocate and copy a byte array value

pub unsafe fn of_str(s: &str) -> Value

Convert from a pointer to an OCaml string back to an OCaml value

Safety

This function assumes that the str argument has been allocated by OCaml

pub unsafe fn of_bytes(s: &[u8]) -> Value

Convert from a pointer to an OCaml string back to an OCaml value

Safety

This function assumes that the &[u8] argument has been allocated by OCaml

pub unsafe fn some<V: ToValue>(rt: &Runtime, v: V) -> Value

OCaml Some value

pub fn none() -> Value

OCaml None value

pub fn unit() -> Value

OCaml Unit value

pub unsafe fn variant(rt: &Runtime, tag: u8, value: Option<Value>) -> Value

Create a variant value

pub unsafe fn result_ok<T: ToValue>(rt: &Runtime, value: T) -> Value

Result.Ok value

pub unsafe fn result<A: FromValue, B: FromValue>(&self) -> Result<A, B>

Convert OCaml ('a, 'b) Result.t to Rust Result<Value, Value>

pub unsafe fn result_error<T: ToValue>(rt: &Runtime, value: T) -> Value

Result.Error value

pub unsafe fn int(i: Int) -> Value

Create an OCaml int

pub unsafe fn uint(i: Uint) -> Value

Create an OCaml int

pub unsafe fn int64(i: i64) -> Value

Create an OCaml Int64 from i64

pub unsafe fn int32(i: i32) -> Value

Create an OCaml Int32 from i32

pub unsafe fn nativeint(i: isize) -> Value

Create an OCaml Nativeint from isize

pub unsafe fn double(d: f64) -> Value

Create an OCaml Float from f64

pub unsafe fn is_block(&self) -> bool

Check if a Value is an integer or block, returning true if the underlying value is a block

pub unsafe fn is_long(&self) -> bool

Check if a Value is an integer or block, returning true if the underlying value is an integer

pub unsafe fn field(&self, i: Size) -> Value

Get index of underlying OCaml block value

pub unsafe fn double_field(&self, i: Size) -> f64

Get index of underlying OCaml double array value

pub unsafe fn store_field<V: ToValue>(&mut self, rt: &Runtime, i: Size, val: V)

Set index of underlying OCaml block value

pub unsafe fn store_double_field(&mut self, i: Size, val: f64)

Set index of underlying OCaml double array value

pub unsafe fn int_val(&self) -> isize

Convert an OCaml int to isize

pub unsafe fn double_val(&self) -> f64

Convert an OCaml Float to f64

pub unsafe fn store_double_val(&mut self, val: f64)

Store f64 in OCaml Float

pub unsafe fn int32_val(&self) -> i32

Convert an OCaml Int32 to i32

pub unsafe fn int64_val(&self) -> i64

Convert an OCaml Int64 to i64

pub unsafe fn nativeint_val(&self) -> isize

Convert an OCaml Nativeint to isize

pub unsafe fn custom_ptr_val<T>(&self) -> *const T

Get pointer to data stored in an OCaml custom value

pub unsafe fn custom_ptr_val_mut<T>(&mut self) -> *mut T

Get mutable pointer to data stored in an OCaml custom value

pub unsafe fn abstract_ptr_val<T>(&self) -> *const T

Get pointer to the pointer contained by Value

pub unsafe fn abstract_ptr_val_mut<T>(&self) -> *mut T

Get mutable pointer to the pointer contained by Value

pub unsafe fn string_val(&self) -> &str

Get underlying string pointer

pub unsafe fn bytes_val(&self) -> &[u8]

Get underlying bytes pointer

pub unsafe fn string_val_mut(&mut self) -> &mut str

Get mutable string pointer

pub unsafe fn bytes_val_mut(&mut self) -> &mut [u8]

Get mutable bytes pointer

pub unsafe fn exception(&self) -> Option<Value>

Extract OCaml exception

pub unsafe fn call1<A: ToValue>( &self, rt: &Runtime, arg1: A, ) -> Result<Value, Error>

Call a closure with a single argument, returning an exception result

pub unsafe fn call2<A: ToValue, B: ToValue>( &self, rt: &Runtime, arg1: A, arg2: B, ) -> Result<Value, Error>

Call a closure with two arguments, returning an exception result

pub unsafe fn call3<A: ToValue, B: ToValue, C: ToValue>( &self, rt: &Runtime, arg1: A, arg2: B, arg3: C, ) -> Result<Value, Error>

Call a closure with three arguments, returning an exception result

pub unsafe fn call_n<A: AsRef<[Raw]>>(&self, args: A) -> Result<Value, Error>

Call a closure with n arguments, returning an exception result

pub unsafe fn call<const N: usize, T: FromValue>( &self, rt: &Runtime, args: [impl ToValue; N], ) -> Result<T, Error>

Call a closure with a variable number of arguments, returning and exception Result

pub unsafe fn modify<V: ToValue>(&mut self, rt: &Runtime, v: V)

Modify an OCaml value in place

pub unsafe fn modify_raw(&mut self, v: Raw)

Modify an OCaml value in place using a raw OCaml value as the new value

pub unsafe fn is_exception_result(&self) -> bool

Determines if the current value is an exception

pub unsafe fn hash_variant<S: AsRef<str>>( rt: &Runtime, name: S, a: Option<Value>, ) -> Value

Get hash variant as OCaml value

pub unsafe fn method<S: AsRef<str>>( &self, rt: &Runtime, name: S, ) -> Option<Value>

Get object method

pub unsafe fn seq_next(&self) -> Result<Option<(Value, Value)>, Error>

Returns the next item and the next Seq.t if available, otherwise Ok(None)

pub unsafe fn exception_to_string(&self) -> Result<String, Utf8Error>

Convert an OCaml exception value to the string representation

pub unsafe fn initialize(&mut self, value: Value)

Initialize OCaml value using caml_initialize

pub unsafe fn deep_clone_to_ocaml(self) -> Self

This will recursively clone any OCaml value The new value is allocated inside the OCaml heap, and may end up being moved or garbage collected.

pub unsafe fn deep_clone_to_rust(&self) -> Self

This will recursively clone any OCaml value The new value is allocated outside of the OCaml heap, and should only be used for storage inside Rust structures.

pub fn root(self) -> Value

Ensure a value is rooted

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Raw> for Value

fn from(v: Raw) -> Self

Converts to this type from the input type.

impl From<isize> for Value

fn from(v: Value) -> Self

Converts to this type from the input type.

impl FromValue for Value

fn from_value(v: Value) -> Value

Convert from OCaml value

impl PartialEq for Value

fn eq(&self, other: &Value) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Value

fn partial_cmp(&self, other: &Value) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToValue for Value

fn to_value(&self, _rt: &Runtime) -> Value

Convert to OCaml value

impl Eq for Value

impl StructuralPartialEq for Value