Struct gluon_vm::api::ser::Ser

pub struct Ser<T>(pub T);

Pushable wrapper which pushes T by serializing it.

Struct

use serde::Serialize;

use gluon_vm::{field_decl, record_type};

use gluon::{
    Thread, ThreadExt, new_vm_async,
    base::types::ArcType,
    vm::api::{ser::Ser, FunctionRef, VmType},
};


#[derive(Serialize)]
struct Vec2 {
    x: i32,
    y: i32,
}

impl VmType for Vec2 {
    type Type = Self;

    fn make_type(thread: &Thread) -> ArcType {
        field_decl!{ x, y }
        type T = record_type! {
            x => i32,
            y => i32
        };
        T::make_type(thread)
    }
}


let thread = new_vm_async().await;

let (mut f, _): (FunctionRef<fn (Ser<Vec2>) -> i32>, _) = thread
    .run_expr_async("", r#"let f v: _ -> Int = v.x + v.y in f"#)
    .await
    .unwrap_or_else(|err| panic!("{}", err));
let vec = Vec2 {
    x: 3,
    y: 10
};
let result = f.call_async(Ser(vec)).await.unwrap_or_else(|err| panic!("{}", err));
assert_eq!(result, 13);

Enum

#[macro_use]
extern crate serde_derive;

#[macro_use]
extern crate gluon_vm;

use gluon::{Thread, ThreadExt, new_vm};
use gluon::base::types::ArcType;
use gluon::vm::api::{FunctionRef, VmType};
use gluon::vm::api::ser::Ser;


#[derive(Serialize)]
enum Enum {
    A(i32),
    B(String, i32),
    C { foo: f64, bar: i32 },
}

impl VmType for Enum {
    type Type = Self;

    fn make_type(thread: &Thread) -> ArcType {
        // Use the enum type declared in gluon
        thread.find_type_info("test.Enum").unwrap().into_type()
    }
}


let thread = new_vm();

let expr = r#"
type Enum = | A Int | B String Int | C { foo : Float, bar : Int }

let extract_bar r : { bar : Int | r } -> Int = r.bar

let f e =
    match e with
    | A a -> a
    | B b c -> c
    | C c -> extract_bar c

{ Enum, f }
"#;
thread
    .load_script("test", expr)
    .unwrap_or_else(|err| panic!("{}", err));

let mut f: FunctionRef<fn (Ser<Enum>) -> i32> = thread
    .get_global("test.f")
    .unwrap_or_else(|err| panic!("{}", err));

let result1 = f.call(Ser(Enum::B("".to_string(), 4)))
    .unwrap_or_else(|err| panic!("{}", err));
assert_eq!(result1, 4);

let result2 = f.call(Ser(Enum::C { foo: 3.14, bar: 10 }))
    .unwrap_or_else(|err| panic!("{}", err));
assert_eq!(result2, 10);

Tuple Fields

0: T

Trait Implementations

impl<'vm, T> Pushable<'vm> for Ser<T>

where T: Serialize,

fn vm_push(self, context: &mut ActiveThread<'vm>) -> Result<()>

Pushes self to stack. If the call is successful a single element should have been added to the stack and Ok(()) should be returned. If the call is unsuccessful Status:Error should be returned and the stack should be left intact

fn status_push(self, context: &mut ActiveThread<'vm>) -> Status

where Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value>

where Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>>

where Self: Sized, T: VmRoot<'vm>,

impl<T> VmType for Ser<T>

where T: VmType,

type Type = <T as VmType>::Type

A version of Self which implements Any allowing a TypeId to be retrieved

fn make_type(thread: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

fn make_forall_type(vm: &Thread) -> ArcType

const EXTRA_ARGS: VmIndex = 0u32

How many extra arguments a function returning this type requires. Used for abstract types which when used in return position should act like they still need more arguments before they are called