Struct ocaml::Value

#[repr(transparent)]pub struct Value(pub Value);

Value wraps the native OCaml value type transparently, this means it has the same representation as an ocaml_sys::Value

Methods

impl Value

pub fn named<T: FromValue>(name: &str) -> Option<T>

Returns a named value registered by OCaml

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

Allocate a new value with the given size and tag.

pub fn alloc_tuple(n: usize) -> Value

Allocate a new tuple value

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

Allocate a new small value with the given size and tag

pub fn alloc_final<T>(
    finalizer: unsafe extern "C" fn(_: Value),
    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 Poiner::alloc_custom when possible.

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

Allocate custom value

pub const fn new(v: Value) -> Value

Create a new Value from an existing OCaml value

pub fn array_length(self) -> usize

Get array length

pub fn register_global_root(&mut self)

See caml_register_global_root

pub fn remove_global_root(&mut self)

Set caml_remove_global_root

pub fn tag(self) -> Tag

Get the tag for the underlying OCaml value

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

Convert a boolean to OCaml value

pub fn some<V: ToValue>(v: V) -> Value

OCaml Some value

pub const fn none() -> Value

OCaml None value

pub const fn unit() -> Value

OCaml Unit value

pub fn variant(tag: u8, value: Option<Value>) -> Value

Create a variant value

pub fn ptr<T>(p: *const T) -> Value

Create a new opaque pointer Value

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

Create an OCaml int

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

Create an OCaml int

pub fn int64(i: i64) -> Value

Create an OCaml Int64 from i64

pub fn int32(i: i32) -> Value

Create an OCaml Int32 from i32

pub fn nativeint(i: isize) -> Value

Create an OCaml Nativeint from isize

pub fn float(d: f64) -> Value

Create an OCaml Float from f64

pub fn is_block(self) -> bool

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

pub fn is_long(self) -> bool

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

pub fn field<T: FromValue>(self, i: Size) -> T

Get index of underlying OCaml block value

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

Set index of underlying OCaml block value

pub const fn int_val(self) -> isize

Convert an OCaml int to isize

pub fn float_val(self) -> f64

Convert an OCaml Float to f64

pub fn int32_val(self) -> i32

Convert an OCaml Int32 to i32

pub fn int64_val(self) -> i64

Convert an OCaml Int64 to i64

pub fn nativeint_val(self) -> isize

Convert an OCaml Nativeint to isize

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

Get pointer to data stored in an OCaml custom value

pub fn custom_mut_ptr_val<T>(self) -> *mut T

Get mutable pointer to data stored in an OCaml custom value

pub fn ptr_val<T>(self) -> *const T

Get pointer to data stored in an opaque value

pub fn mut_ptr_val<T>(self) -> *mut T

Get mutable pointer to data stored in an opaque value

pub fn exception<A: FromValue>(self) -> Option<A>

Extract OCaml exception

pub fn call<A: ToValue>(self, arg: A) -> Result<Value, Error>

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

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

Call a closure with two arguments, returning an exception value

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

Call a closure with three arguments, returning an exception value

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

Call a closure with n arguments, returning an exception value

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

Modify an OCaml value in place

pub fn is_exception_result(self) -> bool

Determines if the current value is an exception

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

Get hash variant as OCaml value

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

Get object method

pub 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.

Requires the deep-clone feature

pub 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.

Requires the deep-clone feature

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Value

impl Debug for Value

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

Formats the value using the given formatter.

impl FromValue for Value

fn from_value(v: Value) -> Value

Convert from OCaml value

impl PartialEq<Value> for Value

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Value> 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: &Value) -> bool

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl StructuralPartialEq for Value

impl<'_> ToValue for &'_ Value

fn to_value(self) -> Value

Convert to OCaml value

impl ToValue for Value

fn to_value(self) -> Value

Convert to OCaml value