Struct ocaml::value::Value

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

Value wraps the native OCaml value type

Methods

impl Value

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

Allocate a new value with the given size and tag

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

Allocate a new small value with the given size and tag

pub fn alloc_custom<T>(value: T, finalizer: extern "C" fn(_: Value)) -> Value

Allocate a new value with a custom finalizer

pub fn set_custom<T>(&mut self, value: T) -> T

pub fn new(v: Value) -> Value

Create a new Value from an existing OCaml value

pub fn register_global_root(&self)

See caml_register_global_root

pub fn remove_global_root(&self)

Set caml_remove_global_root

pub fn value(&self) -> Value

Get the underlying OCaml value

pub fn tag(&self) -> Tag

Get the tag for the underlying OCaml value

pub fn bool(b: bool) -> Value

Convert a boolean to OCaml value

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

OCaml Some value

pub fn none() -> Value

OCaml None value

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

Create a variant value

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

Create a new opaque pointer Value

pub fn i32(i: i32) -> Value

Create an integer Value from i32

pub fn i64(i: i64) -> Value

Create an integer Value from i64

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 native int from isize

pub fn isize(i: isize) -> Value

Create a long Value from isize

pub fn usize(u: usize) -> Value

Create a value from usize

pub fn f64(d: f64) -> Value

Create a value 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(&self, i: Size) -> Value

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 fn i32_val(&self) -> i32

Convert an OCaml integer to i32

pub fn i64_val(&self) -> i64

Convert an OCaml integer to i64

pub fn isize_val(&self) -> isize

Convert an OCaml integer to isize

pub fn usize_val(&self) -> usize

Convert an OCaml integer to usize

pub fn f64_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 integer to isize

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

Get pointer to data stored in an OCaml custom value

pub fn custom_ptr_val_mut<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 call<A: ToValue>(&self, arg: A) -> Result<Value, Error>

Call a closure with a single argument

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

Call a closure with two arguments

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

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

Call a closure with n arguments

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

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

pub fn call2_exn<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_exn<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_exn<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 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.

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.

Trait Implementations

impl ToValue for Value

fn to_value(&self) -> Value

impl FromValue for Value

fn from_value(v: Value) -> Value

impl From<Tuple> for Value

fn from(t: Tuple) -> Value

Performs the conversion.

impl From<Array> for Value

fn from(t: Array) -> Value

Performs the conversion.

impl From<Value> for Array

fn from(v: Value) -> Array

Performs the conversion.

impl From<List> for Value

fn from(t: List) -> Value

Performs the conversion.

impl From<Value> for List

fn from(v: Value) -> List

Performs the conversion.

impl From<Str> for Value

fn from(t: Str) -> Value

Performs the conversion.

impl From<Value> for Str

fn from(v: Value) -> Str

Performs the conversion.

impl<T: BigarrayKind> From<Array1<T>> for Value

fn from(t: Array1<T>) -> Value

Performs the conversion.

impl<T: BigarrayKind> From<Value> for Array1<T>

fn from(v: Value) -> Array1<T>

Performs the conversion.

impl From<Value> for Value

fn from(v: Value) -> Value

Performs the conversion.

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 Debug for Value

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

Formats the value using the given formatter.