Trait ocaml_interop::FromOCaml

pub unsafe trait FromOCaml<T> {
    // Required method
    fn from_ocaml(v: OCaml<'_, T>) -> Self;
}

Implements conversion from OCaml values into Rust values.

Safety

Implementing this trait involves unsafe code that interacts with the OCaml runtime. Implementors must adhere to the following safety guidelines:

• Valid OCaml Values: The OCaml value passed to the from_ocaml function must be valid. The implementor is responsible for ensuring that the value is a correct and valid representation of the type T in OCaml. Passing an invalid or unrelated value may lead to undefined behavior.

• Handling of OCaml Exceptions: If the OCaml code can raise exceptions, the implementor must ensure these are appropriately handled. Uncaught OCaml exceptions should not be allowed to propagate into the Rust code, as they are not compatible with Rust’s error handling mechanisms.

Implementors of this trait need to have a thorough understanding of the OCaml runtime, especially regarding value representation and memory management, to ensure safe and correct conversions from OCaml to Rust.

Required Methods

fn from_ocaml(v: OCaml<'_, T>) -> Self

Convert from OCaml value.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl FromOCaml<bool> for bool

fn from_ocaml(v: OCaml<'_, bool>) -> Self

impl FromOCaml<isize> for i32

fn from_ocaml(v: OCaml<'_, OCamlInt>) -> Self

impl FromOCaml<isize> for i64

fn from_ocaml(v: OCaml<'_, OCamlInt>) -> Self

impl FromOCaml<()> for ()

fn from_ocaml(_v: OCaml<'_, ()>) -> Self

impl FromOCaml<String> for String

fn from_ocaml(v: OCaml<'_, String>) -> Self

impl FromOCaml<String> for Vec<u8>

fn from_ocaml(v: OCaml<'_, String>) -> Self

impl FromOCaml<OCamlBytes> for Box<[u8]>

fn from_ocaml(v: OCaml<'_, OCamlBytes>) -> Self

impl FromOCaml<OCamlBytes> for String

fn from_ocaml(v: OCaml<'_, OCamlBytes>) -> Self

impl FromOCaml<OCamlBytes> for Vec<u8>

fn from_ocaml(v: OCaml<'_, OCamlBytes>) -> Self

impl FromOCaml<OCamlFloat> for f64

fn from_ocaml(v: OCaml<'_, OCamlFloat>) -> Self

impl FromOCaml<OCamlFloatArray> for Vec<f64>

fn from_ocaml(v: OCaml<'_, OCamlFloatArray>) -> Self

impl FromOCaml<OCamlInt32> for i32

fn from_ocaml(v: OCaml<'_, OCamlInt32>) -> Self

impl FromOCaml<OCamlInt64> for i64

fn from_ocaml(v: OCaml<'_, OCamlInt64>) -> Self

impl<A, OCamlA> FromOCaml<Option<OCamlA>> for Option<A>

where A: FromOCaml<OCamlA>,

fn from_ocaml(v: OCaml<'_, Option<OCamlA>>) -> Self

impl<A, OCamlA> FromOCaml<OCamlList<OCamlA>> for Vec<A>

where A: FromOCaml<OCamlA>,

fn from_ocaml(v: OCaml<'_, OCamlList<OCamlA>>) -> Self

impl<A, OCamlA> FromOCaml<OCamlUniformArray<OCamlA>> for Vec<A>

where A: FromOCaml<OCamlA>,

fn from_ocaml(v: OCaml<'_, OCamlUniformArray<OCamlA>>) -> Self

impl<A, OCamlA, Err, OCamlErr> FromOCaml<Result<OCamlA, OCamlErr>> for Result<A, Err>

where A: FromOCaml<OCamlA>, Err: FromOCaml<OCamlErr>,

fn from_ocaml(v: OCaml<'_, Result<OCamlA, OCamlErr>>) -> Self

impl<OCamlA, OCamlB, A: 'static, B: 'static> FromOCaml<(A, B)> for (OCamlA, OCamlB)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>,

fn from_ocaml(v: OCaml<'_, (A, B)>) -> Self

impl<OCamlA, OCamlB, OCamlC, A: 'static, B: 'static, C: 'static> FromOCaml<(A, B, C)> for (OCamlA, OCamlB, OCamlC)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>,

fn from_ocaml(v: OCaml<'_, (A, B, C)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, A: 'static, B: 'static, C: 'static, D: 'static> FromOCaml<(A, B, C, D)> for (OCamlA, OCamlB, OCamlC, OCamlD)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> FromOCaml<(A, B, C, D, E)> for (OCamlA, OCamlB, OCamlC, OCamlD, OCamlE)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>, OCamlE: FromOCaml<E>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D, E)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> FromOCaml<(A, B, C, D, E, F)> for (OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>, OCamlE: FromOCaml<E>, OCamlF: FromOCaml<F>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D, E, F)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> FromOCaml<(A, B, C, D, E, F, G)> for (OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>, OCamlE: FromOCaml<E>, OCamlF: FromOCaml<F>, OCamlG: FromOCaml<G>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D, E, F, G)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG, OCamlH, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> FromOCaml<(A, B, C, D, E, F, G, H)> for (OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG, OCamlH)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>, OCamlE: FromOCaml<E>, OCamlF: FromOCaml<F>, OCamlG: FromOCaml<G>, OCamlH: FromOCaml<H>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D, E, F, G, H)>) -> Self

impl<OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG, OCamlH, OCamlI, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> FromOCaml<(A, B, C, D, E, F, G, H, I)> for (OCamlA, OCamlB, OCamlC, OCamlD, OCamlE, OCamlF, OCamlG, OCamlH, OCamlI)

where OCamlA: FromOCaml<A>, OCamlB: FromOCaml<B>, OCamlC: FromOCaml<C>, OCamlD: FromOCaml<D>, OCamlE: FromOCaml<E>, OCamlF: FromOCaml<F>, OCamlG: FromOCaml<G>, OCamlH: FromOCaml<H>, OCamlI: FromOCaml<I>,

fn from_ocaml(v: OCaml<'_, (A, B, C, D, E, F, G, H, I)>) -> Self

impl<OCamlT, T: FromOCaml<OCamlT>> FromOCaml<OCamlT> for Box<T>

fn from_ocaml(v: OCaml<'_, OCamlT>) -> Self

Implementors