25 releases

0.18.0 Oct 3, 2021
0.17.2 Oct 25, 2020
0.17.1 Aug 15, 2020
0.16.1 Jul 5, 2020
0.8.1 Jul 1, 2018

#11 in #type-inference

Download history 81/week @ 2022-10-08 38/week @ 2022-10-15 60/week @ 2022-10-22 117/week @ 2022-10-29 113/week @ 2022-11-05 76/week @ 2022-11-12 96/week @ 2022-11-19 84/week @ 2022-11-26 79/week @ 2022-12-03 98/week @ 2022-12-10 81/week @ 2022-12-17 72/week @ 2022-12-24 28/week @ 2022-12-31 64/week @ 2023-01-07 22/week @ 2023-01-14 106/week @ 2023-01-21

224 downloads per month
Used in 14 crates (5 directly)

MIT license

72KB
2K SLoC

Various macros for integrating with the gluon vm.

Derive Macros

Custom derives for the following gluon-Traits are available:

Getable

Derives Getable for any enum or struct as long as all fields also implement Getable (generic type parameters included). If the type is generic over a lifetime, the lifetime will be constrained to that of the 'vm lifetime in the trait definition.

Note: Newtype structs are expected to be their inner type on the Gluon side.

Examples

Marhalling this gluon type:

type Comment =
    | Normal String
    | Multiline String
    | Doc String

To this rust enum:

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;

enum Comment {
    Normal(String),
    Multiline(String),
    Doc(String),
}
# fn main() {}

Pushable

Derives Pushable for any enum or struct as long as all fields also implement Pushable (generic type parameters included).

Note: Newtype structs are pushed as their inner type.

Examples

Allowing the User struct to be marshalled to gluon code:

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;

#[derive(Pushable)]
struct User {
    name: String,
    age: u32,
}
# fn main() {}

As this compatible Record:

type User = { name: String, age: Int }

VmType

Derives VmType for a rust type, mapping it to a gluon type.

Alternatively, you can specify the corresponding gluon type with the #[gluon(vm_type = "<gluon_type>")] attribute, where the gluon type is the fully qualified type name. The gluon type must be registered before a binding using the mapped rust type is first loaded.

If the rust type has type parameters, they have to implement VmType as well. All lifetimes have to be 'static.

Note: Newtype structs are mapped to their inner type.

Examples

Deriving VmType for a struct:

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;

// will map to: `{ string: String, number: Int, vec: Array Float }`
#[derive(VmType)]
struct Struct {
    string: String,
    number: u32,
    vec: Vec<f64>,
}
# fn main() {}

Mapping to an existing type, assuming the following gluon type in the module types:

type Either l r = | Left l | Right r

Requires the additional vm_type attribute:

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;

#[derive(VmType)]
#[gluon(vm_type = "types.Either")]
enum Either<L, R> {
    Left(L),
    Right(R),
}
# fn main() {}

Userdata

Derives Userdata and the required Trace and VmType for a rust type. Note that you will still have to use Thread::register_type to register the rust type with the vm before it is used.

Examples

Deriving Userdata for a type that will be opaque for the gluon code:

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;

use std::sync::Arc;

// Userdata requires Trace + Debug + Send + Sync
#[derive(Userdata, Trace, Debug)]
struct Ident {
    group: Arc<str>,
    name: Arc<str>,
}
# fn main() {}

Dependencies

~195–590KB
~14K SLoC