Crate valuable

Valuable provides object-safe value inspection. Use cases include passing structured data to trait objects and object-safe serialization.

Getting started

First, derive Valuable on your types.

use valuable::Valuable;

#[derive(Valuable)]
struct HelloWorld {
    message: Message,
}

#[derive(Valuable)]
enum Message {
    HelloWorld,
    Custom(String),
}

Then, implement a visitor to inspect the data.

use valuable::{NamedValues, Value, Valuable, Visit};

struct Print;

impl Visit for Print {
    fn visit_value(&mut self, value: Value<'_>) {
        match value {
            Value::Structable(v) => {
                println!("struct {}", v.definition().name());
                v.visit(self);
            }
            Value::Enumerable(v) => {
                println!("enum {}::{}", v.definition().name(), v.variant().name());
                v.visit(self);
            }
            Value::Listable(v) => {
                println!("list");
                v.visit(self);
            }
            Value::Mappable(v) => {
                println!("map");
                v.visit(self);
            }
            _ => {
                println!("value {:?}", value);
            }
        }
    }

    fn visit_named_fields(&mut self, named_fields: &NamedValues<'_>) {
        for (field, value) in named_fields.iter() {
            println!("named field {}", field.name());
            value.visit(self);
        }
    }

    fn visit_unnamed_fields(&mut self, values: &[Value<'_>]) {
        for value in values {
            value.visit(self);
        }
    }

    fn visit_entry(&mut self, key: Value<'_>, value: Value<'_>) {
        println!("key / value");
        key.visit(self);
        value.visit(self);
    }
}

Then, use the visitor to visit the value.

let hello_world = HelloWorld { message: Message::HelloWorld };
hello_world.visit(&mut Print);

Related Crates

• valuable-serde provides a bridge between valuable and the serde serialization ecosystem. Using valuable_serde::Serializable allows any type that implements Valuable to be serialized by any serde::ser::Serializer.

Structs

NamedField

A named field

NamedValues

Set of values from a Structable or Enumerable with named fields.

VariantDef

An enum variant definition.

Enums

EnumDef

An enum’s variants, variant fields, and other enum-level information.

Fields

Data stored within a Structable or an Enumerable.

Slice

A slice containing primitive values.

StructDef

A struct’s name, fields, and other struct-level information.

TupleDef

The number of fields and other tuple-level information.

Value

Any Rust value

Variant

An enum variant

Traits

Enumerable

An enum-like Valuable sub-type.

Listable

A list-like Valuable sub-type.

Mappable

A map-like Valuable sub-type.

Structable

A struct-like Valuable sub-type.

Tuplable

A tuple-like Valuable sub-type.

Valuable

A type that can be converted to a Value.

Visit

Traverse a value’s fields and variants.

Functions

visit

Inspects a value by calling the relevant Visit methods with value’s data.

Derive Macros

Valuablederive

Derive a Valuable implementation for a struct or enum.