1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
//! Parts for "combiners". Combiners are custom user-defined macros for our //! notation/format/language. use crate::{ Datum, Error, TextBase, parser::DatumAllocator, }; /// A macro function, bound to an operator sub-form, which is called with the /// operands sub-form(s) to determine what should be substituted for the whole /// form. The `OperativeRef` and `ApplicativeRef` type parameters determine the /// types used to refer to the functions. /// /// While these parameters as defined here can allow possibly inconsistent /// types, further bounds on these are required by a `Parser`'s /// [`OperatorBindings`](trait.OperatorBindings.html) which ensures that only /// consistent ones can be used with it, which is the only intended use of this /// type. #[derive(Debug)] pub enum Combiner<OperativeRef, ApplicativeRef> { /// An "operative" combiner, which is given unparsed operands text. Operative(OperativeRef), /// An "applicative" combiner, which is given parsed operands list. Applicative(ApplicativeRef), } /// The type of "operative" functions. First argument is the "operator" /// sub-form as a `Datum`; and the second argument is the "operands" sub-form as /// the `Text` type containing the unparsed operands text; and the third /// argument is the `Parser`'s `DatumAllocator`. See /// [`combiner::Result`](type.Result.html) for the description of the return /// value. pub type OpFn<DA, CE> = dyn Fn(DADatum<DA>, <DA as DatumAllocator>::TT, &mut DA) -> Result<DA, CE>; /// The type of "applicative" functions. First argument is the "operator" /// sub-form as a `Datum`; and the second argument is the "operands" sub-forms /// as a `Datum::List` containing the recursively parsed operands as separate /// `Datum`s, or it is a `Datum::EmptyList` if the operands text was empty; and /// the third argument is the `Parser`'s `DatumAllocator`. See /// [`combiner::Result`](type.Result.html) for the description of the return /// value. pub type ApFn<DA, CE> = dyn Fn(DADatum<DA>, DADatum<DA>, &mut DA) -> Result<DA, CE>; /// The type returned by "operative" and "applicative" functions. For a /// successful `Some` return, the returned `Datum` is substituted for the /// original form by the parser in the AST it yields. For a successful `None` /// return, the original form is removed from the AST. An /// [`Error`](../enum.Error.html) is returned if the combiner fails for any /// reason. pub type Result<DA, CE> = core::result::Result<Option<DADatum<DA>>, Error<<<DA as DatumAllocator>::TT as TextBase>::Pos, CE>>; type DADatum<DA> = Datum<<DA as DatumAllocator>::TT, <DA as DatumAllocator>::ET, <DA as DatumAllocator>::DR>;