Trait FromEure 

pub trait FromEure<'doc, T = Self>: Sized {
    type Error;

    // Required method
    fn parse(ctx: &ParseContext<'doc>) -> Result<T, Self::Error>;
}

Trait for parsing Rust types from Eure documents.

Types implementing this trait can be constructed from EureDocument via ParseContext.

Type Parameters

• 'doc: The document lifetime, allowing zero-copy parsing for references
• T: The target type to parse (defaults to Self)

When T = Self (the default), this is standard parsing. When T != Self, Self acts as a “strategy” type for parsing remote types. This follows the same pattern as PartialEq<Rhs = Self>.

Remote Type Support

The T parameter enables parsing external crate types that can’t implement FromEure directly (due to Rust’s orphan rule). Define a marker type and implement FromEure<'doc, RemoteType> for it:

struct DurationDef;

impl<'doc> FromEure<'doc, std::time::Duration> for DurationDef {
    type Error = ParseError;
    fn parse(ctx: &ParseContext<'doc>) -> Result<std::time::Duration, Self::Error> {
        let rec = ctx.parse_record()?;
        let secs: u64 = rec.parse_field("secs")?;
        let nanos: u32 = rec.parse_field("nanos")?;
        rec.deny_unknown_fields()?;
        Ok(std::time::Duration::new(secs, nanos))
    }
}

Container types (Option<M>, Vec<M>, etc.) automatically support remote types: if M: FromEure<'doc, T>, then Option<M>: FromEure<'doc, Option<T>>.

Examples

// Reference type - borrows from document
impl<'doc> FromEure<'doc> for &'doc str { ... }

// Owned type - no lifetime dependency
impl FromEure<'_> for String { ... }

Required Associated Types

type Error

The error type returned by parsing.

Required Methods

fn parse(ctx: &ParseContext<'doc>) -> Result<T, Self::Error>

Parse a value of type T from the given parse context.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FromEure<'_> for bool

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for f32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for f64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for i8

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for i16

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for i32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for i64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for i128

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for isize

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for u8

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for u16

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for u32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for u64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for u128

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for usize

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for String

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for BigInt

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl FromEure<'_> for Regex

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<Self, Self::Error>

impl<'doc> FromEure<'doc> for &'doc str

type Error = ParseError

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc> FromEure<'doc> for ()

type Error = ParseError

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, Err> FromEure<'doc> for (A, B, C, D, E)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, Err> FromEure<'doc> for (A, B, C, D, E, F)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, Err> FromEure<'doc> for (A, B, C, D, E, F, G)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, O: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, O: FromEure<'doc, Error = Err>, P: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, D, Err> FromEure<'doc> for (A, B, C, D)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, C, Err> FromEure<'doc> for (A, B, C)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, B, Err> FromEure<'doc> for (A, B)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, A, Err> FromEure<'doc> for (A,)

where A: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

impl<'doc, K, M, T> FromEure<'doc, BTreeMap<K, T>> for BTreeMap<K, M>

where K: ParseObjectKey<'doc>, M: FromEure<'doc, T>, M::Error: From<ParseError>,

BTreeMap<K, M> parses BTreeMap<K, T> using M’s FromEure implementation.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<BTreeMap<K, T>, Self::Error>

impl<'doc, K, M, T> FromEure<'doc, HashMap<K, T>> for HashMap<K, M>

where K: ParseObjectKey<'doc>, M: FromEure<'doc, T>, M::Error: From<ParseError>,

HashMap<K, M> parses HashMap<K, T> using M’s FromEure implementation.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<HashMap<K, T>, Self::Error>

impl<'doc, K, M, T> FromEure<'doc, IndexMap<K, T>> for IndexMap<K, M>

where K: ParseObjectKey<'doc>, M: FromEure<'doc, T>, M::Error: From<ParseError>,

IndexMap<K, M> parses IndexMap<K, T> using M’s FromEure implementation.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<IndexMap<K, T>, Self::Error>

impl<'doc, M, T> FromEure<'doc, Option<T>> for Option<M>

where M: FromEure<'doc, T>, M::Error: From<ParseError>,

Option<M> parses Option<T> using M’s FromEure implementation.

When M = T (same type), this is standard Option<T> parsing. When M ≠ T, M acts as a strategy type for parsing remote type T.

• $variant: some -> parse T via M
• $variant: none -> None
• No $variant and value is null -> None
• No $variant and value is not null -> try parsing as T (Some)

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<Option<T>, Self::Error>

impl<'doc, M, T> FromEure<'doc, Vec<T>> for Vec<M>

where M: FromEure<'doc, T>, M::Error: From<ParseError>,

Vec<M> parses Vec<T> using M’s FromEure implementation.

When M = T, this is standard Vec<T> parsing. When M ≠ T, M acts as a strategy type for parsing remote type T.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<Vec<T>, Self::Error>

impl<'doc, M, T> FromEure<'doc, IndexSet<T>> for IndexSet<M>

where M: FromEure<'doc, T>, T: Eq + Hash, M::Error: From<ParseError>,

IndexSet<M> parses IndexSet<T> using M’s FromEure implementation.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<IndexSet<T>, Self::Error>

impl<'doc, M, T, const N: usize> FromEure<'doc, [T; N]> for [M; N]

where M: FromEure<'doc, T>, M::Error: From<ParseError>,

[M; N] parses [T; N] using M’s FromEure implementation.

When M = T, this is standard fixed-size array parsing. When M ≠ T, M acts as a strategy type for parsing remote type T.

type Error = <M as FromEure<'doc, T>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<[T; N], Self::Error>

impl<'doc, MT, T, ME, E, Err> FromEure<'doc, Result<T, E>> for Result<MT, ME>

where MT: FromEure<'doc, T, Error = Err>, ME: FromEure<'doc, E, Error = Err>, Err: From<ParseError>,

Result<MT, ME> parses Result<T, E> using MT and ME’s FromEure implementations.

When MT = T and ME = E (same types), this is standard Result parsing. When different, MT and ME act as strategy types for parsing remote types.

• $variant: ok -> parse T via MT
• $variant: err -> parse E via ME
• No $variant -> try Ok first, then Err (priority-based)

type Error = Err

fn parse(ctx: &ParseContext<'doc>) -> Result<Result<T, E>, Self::Error>

impl<'doc, T> FromEure<'doc> for Cow<'static, T>

where T: ToOwned + ?Sized, T::Owned: FromEure<'doc>,

type Error = <<T as ToOwned>::Owned as FromEure<'doc>>::Error

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

Implementors

impl FromEure<'_> for VariantRepr

type Error = ParseError

impl FromEure<'_> for PrimitiveValue

type Error = ParseError

impl FromEure<'_> for Identifier

type Error = ParseError

impl FromEure<'_> for Text

type Error = ParseError

impl<'doc> FromEure<'doc> for &'doc PrimitiveValue

type Error = ParseError

impl<'doc> FromEure<'doc> for &'doc NodeArray

type Error = ParseError

impl<'doc> FromEure<'doc> for EureDocument

type Error = ParseError

impl<'doc> FromEure<'doc> for NodeId

type Error = ParseError

impl<'doc, K, M, T> FromEure<'doc, Map<K, T>> for Map<K, M>

where K: ParseObjectKey<'doc>, M: FromEure<'doc, T>, M::Error: From<ParseError>,

Map<K, M> parses Map<K, T> using M’s FromEure implementation.

type Error = <M as FromEure<'doc, T>>::Error

impl<'doc, T> FromEure<'doc, Cow<'doc, T>> for BorrowedCow

where T: ToOwned + ?Sized, for<'a> &'a T: FromEure<'a>, for<'a> <&'a T as FromEure<'a>>::Error: Into<ParseError>,

type Error = ParseError

impl<M: MustBeTextMarker> FromEure<'_> for MustBeText<M>

type Error = ParseError