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".

Implementations on Foreign Types

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 FromEure<'_> for String

type Error = ParseError

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

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<'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, 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, 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> FromEure<'doc, Option<T>> for Option<M>

where M: FromEure<'doc, T>, M::Error: UnionParseError,

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, 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: UnionParseError,

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>

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>

Implementors

impl FromEure<'_> for Form

type Error = ParseError

impl FromEure<'_> for Identifier

type Error = ParseError

impl FromEure<'_> for PrimitiveValue

type Error = ParseError

impl FromEure<'_> for Text

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<'doc> FromEure<'doc> for &'doc NodeArray

type Error = ParseError

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

type Error = ParseError

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

type Error = ParseError

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

type Error = ParseError

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

type Error = ParseError