#![feature(prelude_import)] #[prelude_import] use std::prelude::rust_2021::*; #[macro_use] extern crate std; #[macro_use] extern crate contracts; #[macro_use] extern crate tracing; #[macro_use] extern crate trace; use lalrpop_util::lalrpop_mod; pub mod abstract_data { pub trait Data { fn synthesize() {} } } pub mod bidir { use anyhow::{bail, Result}; use crate::data::{Context, ContextEntry, FreeVar, Monotype, Term, Type}; use crate::gensym::gensym_existential; pub fn app_ctx(ctx: &Context, ty: &Type) -> Result { match ty { Type::Unit => Ok(Type::Unit), Type::Var(s) => Ok(Type::Var(s.clone())), Type::Existential(a) => match ctx.lookup_existential(a) { Some((_, Some(m))) => Ok(m.into_poly()), Some((_, None)) => Ok(Type::Existential(a.clone())), None => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("existential variable {0} doesn\'t exist in context", a)); error }), }, Type::Polytype(a, t) => { Ok(Type::Polytype(a.clone(), Box::new(app_ctx(ctx, t)?))) } Type::Arrow(a, b) => Ok(Type::Arrow(Box::new(app_ctx(ctx, a)?), Box::new(app_ctx(ctx, b)?))), } } /// Under input context ฮ“ , type A is a subtype of B, with output context โˆ† pub fn subtype(ctx: &Context, left: &Type, right: &Type) -> Result { match (left, right) { (Type::Unit, Type::Unit) => Ok(ctx.clone()), (Type::Var(x), Type::Var(y)) if x == y && ctx.lookup_type(x).is_some() => Ok(ctx.clone()), (Type::Existential(x), Type::Existential(y)) if x == y && ctx.lookup_existential(x).is_some() => { Ok(ctx.clone()) } (Type::Existential(a), ty_a) if !ty_a.free_vars().contains(&FreeVar::Existential(a.to_string())) && ctx.lookup_existential(a).is_some() => { let ctx_delta = instantiate_left(ctx, a, ty_a)?; Ok(ctx_delta) } (ty_a, Type::Existential(a)) if !ty_a.free_vars().contains(&FreeVar::Existential(a.to_string())) && ctx.lookup_existential(a).is_some() => { let ctx_delta = instantiate_right(ctx, ty_a, a)?; Ok(ctx_delta) } (Type::Existential(_), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Polytype(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_, _), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_, _), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_, _), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_, _), Type::Polytype(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_, _), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Polytype(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), _ => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("subtyping relation failed between {0:?} and {1:?} (ctx = {2:?})", left, right, ctx)); error }), } } pub fn instantiate_left(ctx: &Context, a: &str, ty_a: &Type) -> Result { match ty_a { Type::Existential(b) if ctx.has_existential(a) && ctx.has_existential(b) => { let mut new_ctx = ctx.clone(); { let b_entry = new_ctx.0.iter_mut().find(|entry| match entry { ContextEntry::ExistentialVar(x) if x == b => true, _ => false, }).expect("should exist"); *b_entry = ContextEntry::ExistentialSolved(b.to_owned(), Monotype::Existential(a.to_owned())); } Ok(new_ctx) } Type::Existential(_b) => ::core::panicking::panic("not yet implemented"), Type::Unit => ::core::panicking::panic("not yet implemented"), Type::Var(_) => ::core::panicking::panic("not yet implemented"), Type::Polytype(_, _) => ::core::panicking::panic("not yet implemented"), Type::Arrow(_, _) => ::core::panicking::panic("not yet implemented"), } } pub fn instantiate_right(ctx: &Context, ty_a: &Type, a: &str) -> Result { match ty_a { Type::Arrow(ty_a1, ty_a2) if ctx.has_existential(a) => { { ::std::io::_print(format_args!("original ctx: {0:?}\n", ctx)); }; let (ex_a1_s, ex_a2_s, ctx_gamma_aug) = ctx.split_existential_function(a)?; let ctx_theta = instantiate_left(&ctx_gamma_aug, &ex_a1_s, &ty_a1)?; let ty_a2_aug = app_ctx(&ctx_theta, &ty_a2)?; let ctx_delta = instantiate_right(&ctx_theta, &ty_a2_aug, &ex_a2_s)?; Ok(ctx_delta) } Type::Polytype(beta, ty_b) if ctx.has_existential(a) => { let ex_b = gensym_existential(); let aug_ctx = ctx.add(<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([ContextEntry::Marker(ex_b.to_owned()), ContextEntry::ExistentialVar(ex_b.to_owned())]))); let aug_b = ty_b.subst(beta, &Type::Existential(ex_b.to_owned())); let out_ctx = instantiate_right(&aug_ctx, &aug_b, a)?; let (before, _after) = out_ctx.split_by(|entry| match entry { ContextEntry::Marker(m) if *m == ex_b => true, _ => false, }).unwrap(); Ok(before) } ty_a if ty_a.is_mono() && ctx.has_existential(a) => { let (before, after) = ctx.split_by(|entry| match entry { ContextEntry::ExistentialVar(n) if n == a => true, _ => false, }).unwrap(); let ty_a_mono = ty_a.into_mono().unwrap(); Ok(Context::unsplit(&before, ContextEntry::ExistentialSolved(a.to_owned(), ty_a_mono), &after)) } Type::Unit => ::core::panicking::panic("not yet implemented"), Type::Var(_) => ::core::panicking::panic("not yet implemented"), Type::Existential(_) => ::core::panicking::panic("not yet implemented"), _ => ::core::panicking::panic("not yet implemented"), } } pub fn typecheck(ctx: &Context, term: &Term, ty: &Type) -> Result { match (term, ty) { (Term::Unit, Type::Unit) => Ok(ctx.clone()), (_e, Type::Polytype(_x, _tyA)) => ::core::panicking::panic("not yet implemented"), (Term::Lam(_x, _e), Type::Arrow(_ty_a, _ty_b)) => { let _aug_ctx = ctx.clone(); ::core::panicking::panic("not yet implemented") } (term, ty) => { let (ty_a, ctx_theta) = synthesize(ctx, term)?; let a = app_ctx(&ctx_theta, &ty_a)?; let b = app_ctx(&ctx_theta, ty)?; let ctx_delta = subtype(&ctx_theta, &a, &b)?; Ok(ctx_delta) } } } pub fn synthesize(ctx: &Context, term: &Term) -> Result<(Type, Context)> { match term { Term::Var(name) if ctx.has_type(name) => { let (_, ty) = ctx.lookup_type(name).unwrap(); Ok((ty, ctx.clone())) } Term::Var(name) => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("could not find name {0}", name)); error }), Term::Unit => Ok((Type::Unit, ctx.clone())), Term::Annot(e, ty_a) => { let ctx_delta = typecheck(ctx, &e, ty_a)?; Ok((ty_a.clone(), ctx_delta)) } Term::Lam(x, e) => { let ex_a_s = gensym_existential(); let ex_b_s = gensym_existential(); let ex_gen = { let res = ::alloc::fmt::format(format_args!("{0}*", ex_a_s)); res }; let ex_a = Type::Existential(ex_a_s.clone()); let ex_b = Type::Existential(ex_b_s.clone()); let aug_ctx = ctx.add(<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([ContextEntry::Marker(ex_a_s.clone()), ContextEntry::ExistentialVar(ex_a_s.clone()), ContextEntry::ExistentialVar(ex_b_s.clone()), ContextEntry::TermAnnot(x.clone(), ex_a.clone())]))); let wtf_ctx = typecheck(&aug_ctx, &e, &ex_b)?; { use ::tracing::__macro_support::Callsite as _; static __CALLSITE: ::tracing::callsite::DefaultCallsite = { static META: ::tracing::Metadata<'static> = { ::tracing_core::metadata::Metadata::new("event bidir/src/bidir.rs:270", "bidir::bidir", ::tracing::Level::INFO, ::core::option::Option::Some("bidir/src/bidir.rs"), ::core::option::Option::Some(270u32), ::core::option::Option::Some("bidir::bidir"), ::tracing_core::field::FieldSet::new(&["message"], ::tracing_core::callsite::Identifier(&__CALLSITE)), ::tracing::metadata::Kind::EVENT) }; ::tracing::callsite::DefaultCallsite::new(&META) }; let enabled = ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL && ::tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current() && { let interest = __CALLSITE.interest(); !interest.is_never() && ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(), interest) }; if enabled { (|value_set: ::tracing::field::ValueSet| { let meta = __CALLSITE.metadata(); ::tracing::Event::dispatch(meta, &value_set); ; })({ #[allow(unused_imports)] use ::tracing::field::{debug, display, Value}; let mut iter = __CALLSITE.metadata().fields().iter(); __CALLSITE.metadata().fields().value_set(&[(&::core::iter::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"), ::core::option::Option::Some(&format_args!("WTF CTX {0:?}", wtf_ctx) as &dyn Value))]) }); } else { ; } }; let (before_marker, after_marker) = wtf_ctx.split_by(|entry| match entry { ContextEntry::Marker(m) if *m == ex_a_s => true, _ => false, }).unwrap(); { use ::tracing::__macro_support::Callsite as _; static __CALLSITE: ::tracing::callsite::DefaultCallsite = { static META: ::tracing::Metadata<'static> = { ::tracing_core::metadata::Metadata::new("event bidir/src/bidir.rs:279", "bidir::bidir", ::tracing::Level::INFO, ::core::option::Option::Some("bidir/src/bidir.rs"), ::core::option::Option::Some(279u32), ::core::option::Option::Some("bidir::bidir"), ::tracing_core::field::FieldSet::new(&["message"], ::tracing_core::callsite::Identifier(&__CALLSITE)), ::tracing::metadata::Kind::EVENT) }; ::tracing::callsite::DefaultCallsite::new(&META) }; let enabled = ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL && ::tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current() && { let interest = __CALLSITE.interest(); !interest.is_never() && ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(), interest) }; if enabled { (|value_set: ::tracing::field::ValueSet| { let meta = __CALLSITE.metadata(); ::tracing::Event::dispatch(meta, &value_set); ; })({ #[allow(unused_imports)] use ::tracing::field::{debug, display, Value}; let mut iter = __CALLSITE.metadata().fields().iter(); __CALLSITE.metadata().fields().value_set(&[(&::core::iter::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"), ::core::option::Option::Some(&format_args!("Unsolved: {0:?}", after_marker.unsolved_existentials()) as &dyn Value))]) }); } else { ; } }; let mut tau = app_ctx(&after_marker, &Type::Arrow(Box::new(ex_a), Box::new(ex_b)))?; for name in after_marker.unsolved_existentials() { { use ::tracing::__macro_support::Callsite as _; static __CALLSITE: ::tracing::callsite::DefaultCallsite = { static META: ::tracing::Metadata<'static> = { ::tracing_core::metadata::Metadata::new("event bidir/src/bidir.rs:284", "bidir::bidir", ::tracing::Level::WARN, ::core::option::Option::Some("bidir/src/bidir.rs"), ::core::option::Option::Some(284u32), ::core::option::Option::Some("bidir::bidir"), ::tracing_core::field::FieldSet::new(&["message"], ::tracing_core::callsite::Identifier(&__CALLSITE)), ::tracing::metadata::Kind::EVENT) }; ::tracing::callsite::DefaultCallsite::new(&META) }; let enabled = ::tracing::Level::WARN <= ::tracing::level_filters::STATIC_MAX_LEVEL && ::tracing::Level::WARN <= ::tracing::level_filters::LevelFilter::current() && { let interest = __CALLSITE.interest(); !interest.is_never() && ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(), interest) }; if enabled { (|value_set: ::tracing::field::ValueSet| { let meta = __CALLSITE.metadata(); ::tracing::Event::dispatch(meta, &value_set); ; })({ #[allow(unused_imports)] use ::tracing::field::{debug, display, Value}; let mut iter = __CALLSITE.metadata().fields().iter(); __CALLSITE.metadata().fields().value_set(&[(&::core::iter::Iterator::next(&mut iter).expect("FieldSet corrupted (this is a bug)"), ::core::option::Option::Some(&format_args!("substituting {0:?} looking for {1}", tau, name) as &dyn Value))]) }); } else { ; } }; tau = tau.subst(&name, &Type::Var(ex_gen.clone())); } Ok((Type::Polytype(ex_gen, Box::new(tau)), before_marker)) } Term::App(e1, e2) => { let (ty_a, ctx_theta) = synthesize(ctx, e1)?; let app_a = app_ctx(&ctx_theta, &ty_a)?; let (ty_c, ctx_delta) = app_synthesize(&ctx_theta, &app_a, &e2)?; Ok((ty_c, ctx_delta)) } } } pub fn app_synthesize(ctx: &Context, fun_ty: &Type, term: &Term) -> Result<(Type, Context)> { match (fun_ty, term) { (Type::Arrow(ty_a, ty_c), e) => { let out_ctx = typecheck(ctx, e, ty_a)?; Ok((*ty_c.clone(), out_ctx)) } (Type::Polytype(a, ty_a), e) => { let ex_s = gensym_existential(); let ex = ContextEntry::ExistentialVar(ex_s.clone()); let aug_ctx = ctx.add(<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([ex.clone()]))); let aug_ty = ty_a.subst(&a, &Type::Existential(ex_s)); let (ty, ctx_delta) = app_synthesize(&aug_ctx, &aug_ty, e)?; Ok((ty, ctx_delta)) } (Type::Existential(a), e) if ctx.has_existential(a) => { let (ex_a1_s, ex_a2_s, ctx_gamma_aug) = ctx.split_existential_function(a)?; let ex_a1 = Type::Existential(ex_a1_s.clone()); let ctx_delta = typecheck(&ctx_gamma_aug, e, &ex_a1)?; let ex_a2 = Type::Existential(ex_a2_s.clone()); Ok((ex_a2, ctx_delta)) } _ => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("trying to appSynthesize with a non-function type")); error }), } } } pub mod data { use std::{fmt, hash::Hash}; use anyhow::{bail, Result}; use im::{HashSet, Vector}; use crate::gensym::gensym_existential; pub enum Term { Unit, Var(String), Lam(String, Box), App(Box, Box), Annot(Box, Type), } #[automatically_derived] impl ::core::clone::Clone for Term { #[inline] fn clone(&self) -> Term { match self { Term::Unit => Term::Unit, Term::Var(__self_0) => Term::Var(::core::clone::Clone::clone(__self_0)), Term::Lam(__self_0, __self_1) => Term::Lam(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), Term::App(__self_0, __self_1) => Term::App(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), Term::Annot(__self_0, __self_1) => Term::Annot(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Term { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("unit")), Self::Var(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::Lam(arg0, arg1) => f.write_fmt(format_args!("(ฮป{0}.{1:?})", arg0, arg1)), Self::App(arg0, arg1) => f.write_fmt(format_args!("({0:?} ยท {1:?})", arg0, arg1)), Self::Annot(arg0, arg1) => f.write_fmt(format_args!("({0:?} : {1:?})", arg0, arg1)), } } } pub enum Type { Unit, Var(String), Existential(String), Polytype(String, Box), Arrow(Box, Box), } #[automatically_derived] impl ::core::clone::Clone for Type { #[inline] fn clone(&self) -> Type { match self { Type::Unit => Type::Unit, Type::Var(__self_0) => Type::Var(::core::clone::Clone::clone(__self_0)), Type::Existential(__self_0) => Type::Existential(::core::clone::Clone::clone(__self_0)), Type::Polytype(__self_0, __self_1) => Type::Polytype(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), Type::Arrow(__self_0, __self_1) => Type::Arrow(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Type { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("๐Ÿ™")), Self::Var(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::Existential(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::Polytype(arg0, arg1) => f.write_fmt(format_args!("(โˆ€ {0} . {1:?})", arg0, arg1)), Self::Arrow(arg0, arg1) => f.write_fmt(format_args!("({0:?} -> {1:?})", arg0, arg1)), } } } impl Type { pub fn into_mono(&self) -> Option { match self { Type::Unit => Some(Monotype::Unit), Type::Var(x) => Some(Monotype::Var(x.clone())), Type::Existential(x) => Some(Monotype::Existential(x.clone())), Type::Polytype(_, _) => None, Type::Arrow(a, b) => Some(Monotype::Arrow(Box::new(a.into_mono()?), Box::new(b.into_mono()?))), } } #[inline] pub fn is_mono(&self) -> bool { self.into_mono().is_some() } } pub enum FreeVar { Var(String), Existential(String), } #[automatically_derived] impl ::core::fmt::Debug for FreeVar { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { match self { FreeVar::Var(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Var", &__self_0), FreeVar::Existential(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Existential", &__self_0), } } } #[automatically_derived] impl ::core::clone::Clone for FreeVar { #[inline] fn clone(&self) -> FreeVar { match self { FreeVar::Var(__self_0) => FreeVar::Var(::core::clone::Clone::clone(__self_0)), FreeVar::Existential(__self_0) => FreeVar::Existential(::core::clone::Clone::clone(__self_0)), } } } #[automatically_derived] impl ::core::marker::StructuralPartialEq for FreeVar { } #[automatically_derived] impl ::core::cmp::PartialEq for FreeVar { #[inline] fn eq(&self, other: &FreeVar) -> bool { let __self_tag = ::core::intrinsics::discriminant_value(self); let __arg1_tag = ::core::intrinsics::discriminant_value(other); __self_tag == __arg1_tag && match (self, other) { (FreeVar::Var(__self_0), FreeVar::Var(__arg1_0)) => *__self_0 == *__arg1_0, (FreeVar::Existential(__self_0), FreeVar::Existential(__arg1_0)) => *__self_0 == *__arg1_0, _ => unsafe { ::core::intrinsics::unreachable() } } } } #[automatically_derived] impl ::core::marker::StructuralEq for FreeVar { } #[automatically_derived] impl ::core::cmp::Eq for FreeVar { #[inline] #[doc(hidden)] #[no_coverage] fn assert_receiver_is_total_eq(&self) -> () { let _: ::core::cmp::AssertParamIsEq; } } #[automatically_derived] impl ::core::hash::Hash for FreeVar { #[inline] fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { let __self_tag = ::core::intrinsics::discriminant_value(self); ::core::hash::Hash::hash(&__self_tag, state); match self { FreeVar::Var(__self_0) => ::core::hash::Hash::hash(__self_0, state), FreeVar::Existential(__self_0) => ::core::hash::Hash::hash(__self_0, state), } } } impl Type { pub fn free_vars(&self) -> HashSet { fn free_vars_with_context(ctx: &Context, ty: &Type) -> HashSet { match ty { Type::Unit => HashSet::default(), Type::Var(x) if ctx.lookup_type(x).is_some() => HashSet::default(), Type::Var(x) => [FreeVar::Var(x.to_owned())].into_iter().collect(), Type::Existential(x) if ctx.lookup_existential(x).is_some() => { HashSet::default() } Type::Existential(x) => { [FreeVar::Existential(x.to_owned())].into_iter().collect() } Type::Polytype(x, ty_a) => { let new_ctx = ctx.add(<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([ContextEntry::ExistentialVar(x.to_owned())]))); free_vars_with_context(&new_ctx, &ty_a) } Type::Arrow(ty_a, ty_b) => { let a_vars = free_vars_with_context(&ctx, &ty_a); let b_vars = free_vars_with_context(&ctx, &ty_b); a_vars.union(b_vars) } } } free_vars_with_context(&Context::default(), self) } pub fn subst(&self, var: &str, replacement: &Type) -> Type { match self { Type::Unit => Type::Unit, Type::Var(n) if n == var => replacement.clone(), Type::Var(n) => Type::Var(n.clone()), Type::Existential(s) if s == var => replacement.clone(), Type::Existential(s) => Type::Existential(s.clone()), Type::Polytype(a, t) => { Type::Polytype(a.clone(), Box::new(t.subst(var, replacement))) } Type::Arrow(a, b) => Type::Arrow(Box::new(a.subst(var, replacement)), Box::new(b.subst(var, replacement))), } } } pub enum Monotype { Unit, Var(String), Existential(String), Arrow(Box, Box), } #[automatically_derived] impl ::core::clone::Clone for Monotype { #[inline] fn clone(&self) -> Monotype { match self { Monotype::Unit => Monotype::Unit, Monotype::Var(__self_0) => Monotype::Var(::core::clone::Clone::clone(__self_0)), Monotype::Existential(__self_0) => Monotype::Existential(::core::clone::Clone::clone(__self_0)), Monotype::Arrow(__self_0, __self_1) => Monotype::Arrow(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Monotype { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("๐Ÿ™")), Self::Var(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::Existential(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::Arrow(arg0, arg1) => f.write_fmt(format_args!("({0:?} -> {1:?})", arg0, arg1)), } } } impl Monotype { pub fn into_poly(&self) -> Type { match self { Monotype::Unit => Type::Unit, Monotype::Var(x) => Type::Var(x.clone()), Monotype::Existential(x) => Type::Existential(x.clone()), Monotype::Arrow(a, b) => { Type::Arrow(Box::new(a.into_poly()), Box::new(b.into_poly())) } } } } pub enum ContextEntry { TypeVar(String), TermAnnot(String, Type), ExistentialVar(String), ExistentialSolved(String, Monotype), Marker(String), } #[automatically_derived] impl ::core::clone::Clone for ContextEntry { #[inline] fn clone(&self) -> ContextEntry { match self { ContextEntry::TypeVar(__self_0) => ContextEntry::TypeVar(::core::clone::Clone::clone(__self_0)), ContextEntry::TermAnnot(__self_0, __self_1) => ContextEntry::TermAnnot(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), ContextEntry::ExistentialVar(__self_0) => ContextEntry::ExistentialVar(::core::clone::Clone::clone(__self_0)), ContextEntry::ExistentialSolved(__self_0, __self_1) => ContextEntry::ExistentialSolved(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), ContextEntry::Marker(__self_0) => ContextEntry::Marker(::core::clone::Clone::clone(__self_0)), } } } impl fmt::Debug for ContextEntry { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::TypeVar(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::TermAnnot(arg0, arg1) => f.write_fmt(format_args!("{0} : {1:?}", arg0, arg1)), Self::ExistentialVar(arg0) => f.write_fmt(format_args!("{0}", arg0)), Self::ExistentialSolved(arg0, arg1) => f.write_fmt(format_args!("{0} โ‰” {1:?}", arg0, arg1)), Self::Marker(arg0) => f.write_fmt(format_args!("โ–ถ{0}", arg0)), } } } pub enum CompleteContextEntry { TypeVar(String), TermAnnot(String, Type), ExistentialSolved(String, Monotype), Marker(String), } #[automatically_derived] impl ::core::fmt::Debug for CompleteContextEntry { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { match self { CompleteContextEntry::TypeVar(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "TypeVar", &__self_0), CompleteContextEntry::TermAnnot(__self_0, __self_1) => ::core::fmt::Formatter::debug_tuple_field2_finish(f, "TermAnnot", __self_0, &__self_1), CompleteContextEntry::ExistentialSolved(__self_0, __self_1) => ::core::fmt::Formatter::debug_tuple_field2_finish(f, "ExistentialSolved", __self_0, &__self_1), CompleteContextEntry::Marker(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Marker", &__self_0), } } } #[automatically_derived] impl ::core::clone::Clone for CompleteContextEntry { #[inline] fn clone(&self) -> CompleteContextEntry { match self { CompleteContextEntry::TypeVar(__self_0) => CompleteContextEntry::TypeVar(::core::clone::Clone::clone(__self_0)), CompleteContextEntry::TermAnnot(__self_0, __self_1) => CompleteContextEntry::TermAnnot(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), CompleteContextEntry::ExistentialSolved(__self_0, __self_1) => CompleteContextEntry::ExistentialSolved(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), CompleteContextEntry::Marker(__self_0) => CompleteContextEntry::Marker(::core::clone::Clone::clone(__self_0)), } } } pub struct Context(pub(crate) Vector); #[automatically_derived] impl ::core::clone::Clone for Context { #[inline] fn clone(&self) -> Context { Context(::core::clone::Clone::clone(&self.0)) } } #[automatically_derived] impl ::core::default::Default for Context { #[inline] fn default() -> Context { Context(::core::default::Default::default()) } } impl fmt::Debug for Context { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("ฮ“")?; for rule in self.0.iter() { f.write_str(", ")?; rule.fmt(f)?; } Ok(()) } } impl Context { pub fn add(&self, entries: Vec) -> Context { let mut new_ctx = self.clone(); for entry in entries { new_ctx.0.push_back(entry); } new_ctx } /// Looks up a polytype by name, also returning an index pub fn lookup_type(&self, name: impl AsRef) -> Option<(usize, Type)> { self.0.iter().enumerate().find_map(|(i, entry)| match entry { ContextEntry::TermAnnot(n, t) if n == name.as_ref() => { Some((i, t.clone())) } _ => None, }) } #[inline] pub fn has_type(&self, name: impl AsRef) -> bool { self.lookup_type(name).is_some() } /// Looks up an existential variable by name /// - Returns Some(Some(t)) if solved /// - Returns Some(None) if exists but unsolved /// - Returns None if not found pub fn lookup_existential(&self, name: impl AsRef) -> Option<(usize, Option)> { self.0.iter().enumerate().find_map(|(i, entry)| match entry { ContextEntry::ExistentialVar(n) if n == name.as_ref() => { Some((i, None)) } ContextEntry::ExistentialSolved(n, t) if n == name.as_ref() => { Some((i, Some(t.clone()))) } _ => None, }) } #[inline] pub fn has_existential(&self, name: impl AsRef) -> bool { self.lookup_existential(name).is_some() } /// Returns a list of names of unsolved existentials pub fn unsolved_existentials(&self) -> HashSet { let mut unsolved = HashSet::new(); for entry in self.0.iter() { match entry { ContextEntry::ExistentialVar(n) => { unsolved.insert(n.clone()); } _ => {} } } unsolved } /// Returns (before, after) pub fn split_by

(&self, p: P) -> Option<(Context, Context)> where P: Fn(&ContextEntry) -> bool { let (before, after) = { let idx = self.0.iter().position(p)?; self.0.clone().split_at(idx) }; Some((Context(before), Context(after))) } pub fn unsplit(left: &Context, center: ContextEntry, right: &Context) -> Context { let mut res = left.clone(); res.0.push_back(center); res.0.extend(right.0.clone().into_iter()); res } pub fn split_existential_function(&self, var: &str) -> Result<(String, String, Context)> { let mut ctx = self.clone(); let idx = match ctx.lookup_existential(var) { Some((idx, _)) => idx, None => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("wtf?")); error }), }; let ex_a1_s = gensym_existential(); let ex_a2_s = gensym_existential(); ctx.0[idx] = ContextEntry::ExistentialSolved(var.to_owned(), Monotype::Arrow(Box::new(Monotype::Existential(ex_a1_s.to_owned())), Box::new(Monotype::Existential(ex_a2_s.to_owned())))); ctx.0.insert(idx, ContextEntry::ExistentialVar(ex_a1_s.to_owned())); ctx.0.insert(idx, ContextEntry::ExistentialVar(ex_a2_s.to_owned())); Ok((ex_a1_s, ex_a2_s, ctx)) } } } pub mod convert_data {} pub mod bidir_debruijn { use anyhow::{bail, Result}; use crate::data_debruijn::{ Context, ContextEntry, ContextIndex, Term, Type, }; use crate::DEPTH; pub fn app_ctx(ctx: &Context, ty: &Type) -> Result { { ::std::io::_print(format_args!("{0:3$}[+] Entering app_ctx(ctx = {1:?}, ty = {2:?})\n", "", ctx, ty, DEPTH.with(|d| d.get()))); }; DEPTH.with(|d| d.set(d.get() + 1)); let fn_return_value = { match ty { Type::Unit => Ok(Type::Unit), Type::Var(s) => Ok(Type::Var(s.clone())), Type::Existential(a) => match ctx.get_existential(a) { Some(Some(m)) => Ok(m.into_poly()), Some(None) => Ok(Type::Existential(a.clone())), None => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("existential variable {0:?} doesn\'t exist in context", a)); error }), }, Type::Polytype(t) => { let t = app_ctx(ctx, t)?; Ok(Type::Polytype(Box::new(t))) } Type::Arrow(a, b) => Ok(Type::Arrow(Box::new(app_ctx(ctx, a)?), Box::new(app_ctx(ctx, b)?))), } }; DEPTH.with(|d| d.set(d.get() - 1)); { ::std::io::_print(format_args!("{0:2$}[-] Exiting app_ctx = {1:?}\n", "", fn_return_value, DEPTH.with(|d| d.get()))); }; fn_return_value } /// Under input context ฮ“ , type A is a subtype of B, with output context โˆ† pub fn subtype(ctx: &Context, left: &Type, right: &Type) -> Result { match (left, right) { (Type::Unit, Type::Unit) => Ok(ctx.clone()), (Type::Var(x), Type::Var(y)) if x == y && ctx.get_type(x).is_some() => { Ok(ctx.clone()) } (Type::Existential(x), Type::Existential(y)) if x == y && ctx.get_existential(x).is_some() => { Ok(ctx.clone()) } (Type::Existential(a), ty_a) if ctx.get_existential(a).is_some() => { instantiate_left(ctx, a, ty_a) } (Type::Unit, Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Type::Polytype(_)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Type::Polytype(_)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Polytype(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Type::Polytype(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Existential(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Polytype(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Type::Arrow(_, _)) => ::core::panicking::panic("not yet implemented"), _ => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("subtyping relation failed between {0:?} and {1:?} (ctx = {2:?})", left, right, ctx)); error }), } } pub fn instantiate_left(ctx: &Context, a: &ContextIndex, ty_a: &Type) -> Result { match ty_a { Type::Existential(b) if ctx.get_existential(a).is_some() && ctx.get_existential(b).is_some() => { ::core::panicking::panic("not yet implemented") } Type::Existential(_b) => ::core::panicking::panic("not yet implemented"), Type::Unit => ::core::panicking::panic("not yet implemented"), Type::Var(_) => ::core::panicking::panic("not yet implemented"), Type::Polytype(_) => ::core::panicking::panic("not yet implemented"), Type::Arrow(_, _) => ::core::panicking::panic("not yet implemented"), } } pub fn typecheck(ctx: &Context, term: &Term, ty: &Type) -> Result { { ::std::io::_print(format_args!("{0:4$}[+] Entering typecheck(ctx = {1:?}, term = {2:?}, ty = {3:?})\n", "", ctx, term, ty, DEPTH.with(|d| d.get()))); }; DEPTH.with(|d| d.set(d.get() + 1)); let fn_return_value = { match (term, ty) { (Term::Unit, Type::Unit) => Ok(ctx.clone()), (_e, Type::Polytype(_t)) => ::core::panicking::panic("not yet implemented"), (Term::Lam(_e), Type::Arrow(_ty_a, _ty_b)) => { ::core::panicking::panic("not yet implemented") } (term, ty) => { { ::std::io::_print(format_args!("SUB RULE: {0:?} || {1:?} ({2:?})\n", term, ty, ctx)); }; let (ty_a, ctx_theta) = synthesize(ctx, term)?; let a = app_ctx(&ctx_theta, &ty_a)?; let b = app_ctx(&ctx_theta, ty)?; let ctx_delta = subtype(&ctx_theta, &a, &b)?; Ok(ctx_delta) } } }; DEPTH.with(|d| d.set(d.get() - 1)); { ::std::io::_print(format_args!("{0:2$}[-] Exiting typecheck = {1:?}\n", "", fn_return_value, DEPTH.with(|d| d.get()))); }; fn_return_value } pub fn synthesize(ctx: &Context, term: &Term) -> Result<(Type, Context)> { { ::std::io::_print(format_args!("{0:3$}[+] Entering synthesize(ctx = {1:?}, term = {2:?})\n", "", ctx, term, DEPTH.with(|d| d.get()))); }; DEPTH.with(|d| d.set(d.get() + 1)); let fn_return_value = { match term { Term::Unit => Ok((Type::Unit, ctx.clone())), Term::Var(index) => { let ty = match ctx.get_type(index) { Some(v) => v, None => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("invalid index {0:?}, context: {1:?}", index, ctx)); error }), }; Ok((ty, ctx.clone())) } Term::App(e1, e2) => { let (ty_a, ctx_theta) = synthesize(ctx, e1)?; let app_a = app_ctx(&ctx_theta, &ty_a)?; let (ty_c, ctx_delta) = app_synthesize(&ctx_theta, &app_a, &e2)?; Ok((ty_c, ctx_delta)) } Term::Lam(e) => { let (aug_ctx, marker_idx) = ctx.add(ContextEntry::Marker); let (aug_ctx, ex_a_idx) = aug_ctx.add(ContextEntry::ExistentialVar); let (aug_ctx, ex_b_idx) = aug_ctx.add(ContextEntry::ExistentialVar); let ex_a = Type::Existential(ex_a_idx.clone()); let ex_b = Type::Existential(ex_b_idx.clone()); let (aug_ctx, _annot_idx) = aug_ctx.add(ContextEntry::TermAnnot(ex_a.clone())); let wtf_ctx = typecheck(&aug_ctx, &e, &ex_b)?; let (before_marker, after_marker) = wtf_ctx.split_at(&marker_idx); { ::std::io::_print(format_args!("Splitting: {0:?}\n", wtf_ctx)); }; let mut tau = app_ctx(&after_marker, &Type::Arrow(Box::new(ex_a), Box::new(ex_b)))?; let (final_ctx, gen_idx) = before_marker.add(ContextEntry::ExistentialVar); for index in after_marker.unsolved_existentials() { tau = tau.subst(&index, Type::Var(gen_idx.clone())); } Ok((Type::Polytype(Box::new(tau)), final_ctx)) } Term::Annot(_, _) => ::core::panicking::panic("not yet implemented"), } }; DEPTH.with(|d| d.set(d.get() - 1)); { ::std::io::_print(format_args!("{0:2$}[-] Exiting synthesize = {1:?}\n", "", fn_return_value, DEPTH.with(|d| d.get()))); }; fn_return_value } pub fn app_synthesize(_ctx: &Context, fun_ty: &Type, term: &Term) -> Result<(Type, Context)> { match (fun_ty, term) { (Type::Unit, Term::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Term::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Term::Lam(_)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Term::App(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Unit, Term::Annot(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Term::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Term::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Term::Lam(_)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Term::App(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Var(_), Term::Annot(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Term::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Term::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Term::Lam(_)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Term::App(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Existential(_), Term::Annot(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Term::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Term::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Term::Lam(_)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Term::App(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Polytype(_), Term::Annot(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Term::Unit) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Term::Var(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Term::Lam(_)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Term::App(_, _)) => ::core::panicking::panic("not yet implemented"), (Type::Arrow(_, _), Term::Annot(_, _)) => ::core::panicking::panic("not yet implemented"), _ => return ::anyhow::__private::Err({ let error = ::anyhow::__private::format_err(format_args!("trying to appSynthesize with a non-function type")); error }), } } } pub mod data_debruijn { use std::{ cell::RefCell, fmt::self, rc::Rc, }; use im::Vector; use crate::{data, gensym::gensym_type}; /// A lambda calculus term. pub enum Term { /// Unit type Unit, /// Variable, with a reference into the context. /// The entry pointed to by this index MUST be a TypeVar. Var(ContextIndex), /// Lambda abstraction. Lam(Box), /// Lambda application. App(Box, Box), /// Type annotation Annot(Box, Type), } #[automatically_derived] impl ::core::clone::Clone for Term { #[inline] fn clone(&self) -> Term { match self { Term::Unit => Term::Unit, Term::Var(__self_0) => Term::Var(::core::clone::Clone::clone(__self_0)), Term::Lam(__self_0) => Term::Lam(::core::clone::Clone::clone(__self_0)), Term::App(__self_0, __self_1) => Term::App(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), Term::Annot(__self_0, __self_1) => Term::Annot(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Term { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("unit")), Self::Var(arg0) => f.write_fmt(format_args!("{0:?}", arg0)), Self::Lam(arg1) => f.write_fmt(format_args!("(ฮป.{0:?})", arg1)), Self::App(arg0, arg1) => f.write_fmt(format_args!("({0:?} ยท {1:?})", arg0, arg1)), Self::Annot(arg0, arg1) => f.write_fmt(format_args!("({0:?} : {1:?})", arg0, arg1)), } } } pub enum Type { Unit, Var(ContextIndex), Existential(ContextIndex), Polytype(Box), Arrow(Box, Box), } #[automatically_derived] impl ::core::clone::Clone for Type { #[inline] fn clone(&self) -> Type { match self { Type::Unit => Type::Unit, Type::Var(__self_0) => Type::Var(::core::clone::Clone::clone(__self_0)), Type::Existential(__self_0) => Type::Existential(::core::clone::Clone::clone(__self_0)), Type::Polytype(__self_0) => Type::Polytype(::core::clone::Clone::clone(__self_0)), Type::Arrow(__self_0, __self_1) => Type::Arrow(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Type { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("๐Ÿ™")), Self::Var(arg0) => f.write_fmt(format_args!("{0:?}", arg0)), Self::Existential(arg0) => f.write_fmt(format_args!("{0:?}", arg0)), Self::Polytype(arg1) => f.write_fmt(format_args!("(โˆ€.{0:?})", arg1)), Self::Arrow(arg0, arg1) => f.write_fmt(format_args!("({0:?} -> {1:?})", arg0, arg1)), } } } impl Type { /// Attempt to turn this polytype into a monotype. /// /// This fails if any sub-expression of this type contains a polytype expression. pub fn try_into_mono(&self) -> Option { match self { Type::Unit => Some(Monotype::Unit), Type::Var(x) => Some(Monotype::Var(x.clone())), Type::Existential(x) => Some(Monotype::Existential(x.clone())), Type::Polytype(_) => None, Type::Arrow(a, b) => Some(Monotype::Arrow(Box::new(a.try_into_mono()?), Box::new(b.try_into_mono()?))), } } #[inline] pub fn is_mono(&self) -> bool { self.try_into_mono().is_some() } } impl Type { pub fn subst(&self, _before: &ContextIndex, _after: Type) -> Type { match self { Type::Unit => Type::Unit, Type::Var(_) => ::core::panicking::panic("not yet implemented"), Type::Existential(_) => ::core::panicking::panic("not yet implemented"), Type::Polytype(_) => ::core::panicking::panic("not yet implemented"), Type::Arrow(_, _) => ::core::panicking::panic("not yet implemented"), } } } pub enum Monotype { Unit, Var(ContextIndex), Existential(ContextIndex), Arrow(Box, Box), } #[automatically_derived] impl ::core::clone::Clone for Monotype { #[inline] fn clone(&self) -> Monotype { match self { Monotype::Unit => Monotype::Unit, Monotype::Var(__self_0) => Monotype::Var(::core::clone::Clone::clone(__self_0)), Monotype::Existential(__self_0) => Monotype::Existential(::core::clone::Clone::clone(__self_0)), Monotype::Arrow(__self_0, __self_1) => Monotype::Arrow(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), } } } impl fmt::Debug for Monotype { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::Unit => f.write_fmt(format_args!("๐Ÿ™")), Self::Var(arg0) => f.write_fmt(format_args!("{0:?}", arg0)), Self::Existential(arg0) => f.write_fmt(format_args!("{0:?}", arg0)), Self::Arrow(arg0, arg1) => f.write_fmt(format_args!("({0:?} -> {1:?})", arg0, arg1)), } } } impl Monotype { pub fn into_poly(&self) -> Type { match self { Monotype::Unit => Type::Unit, Monotype::Var(x) => Type::Var(x.clone()), Monotype::Existential(x) => Type::Existential(x.clone()), Monotype::Arrow(a, b) => { Type::Arrow(Box::new(a.into_poly()), Box::new(b.into_poly())) } } } } pub enum ContextEntry { TypeVar, TermAnnot(Type), ExistentialVar, ExistentialSolved(Monotype), Marker, } #[automatically_derived] impl ::core::fmt::Debug for ContextEntry { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { match self { ContextEntry::TypeVar => ::core::fmt::Formatter::write_str(f, "TypeVar"), ContextEntry::TermAnnot(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "TermAnnot", &__self_0), ContextEntry::ExistentialVar => ::core::fmt::Formatter::write_str(f, "ExistentialVar"), ContextEntry::ExistentialSolved(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "ExistentialSolved", &__self_0), ContextEntry::Marker => ::core::fmt::Formatter::write_str(f, "Marker"), } } } #[automatically_derived] impl ::core::clone::Clone for ContextEntry { #[inline] fn clone(&self) -> ContextEntry { match self { ContextEntry::TypeVar => ContextEntry::TypeVar, ContextEntry::TermAnnot(__self_0) => ContextEntry::TermAnnot(::core::clone::Clone::clone(__self_0)), ContextEntry::ExistentialVar => ContextEntry::ExistentialVar, ContextEntry::ExistentialSolved(__self_0) => ContextEntry::ExistentialSolved(::core::clone::Clone::clone(__self_0)), ContextEntry::Marker => ContextEntry::Marker, } } } pub enum CompleteContextEntry { TypeVar(String), TermAnnot(String, Type), ExistentialSolved(String, Monotype), Marker(String), } #[automatically_derived] impl ::core::fmt::Debug for CompleteContextEntry { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { match self { CompleteContextEntry::TypeVar(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "TypeVar", &__self_0), CompleteContextEntry::TermAnnot(__self_0, __self_1) => ::core::fmt::Formatter::debug_tuple_field2_finish(f, "TermAnnot", __self_0, &__self_1), CompleteContextEntry::ExistentialSolved(__self_0, __self_1) => ::core::fmt::Formatter::debug_tuple_field2_finish(f, "ExistentialSolved", __self_0, &__self_1), CompleteContextEntry::Marker(__self_0) => ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Marker", &__self_0), } } } #[automatically_derived] impl ::core::clone::Clone for CompleteContextEntry { #[inline] fn clone(&self) -> CompleteContextEntry { match self { CompleteContextEntry::TypeVar(__self_0) => CompleteContextEntry::TypeVar(::core::clone::Clone::clone(__self_0)), CompleteContextEntry::TermAnnot(__self_0, __self_1) => CompleteContextEntry::TermAnnot(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), CompleteContextEntry::ExistentialSolved(__self_0, __self_1) => CompleteContextEntry::ExistentialSolved(::core::clone::Clone::clone(__self_0), ::core::clone::Clone::clone(__self_1)), CompleteContextEntry::Marker(__self_0) => CompleteContextEntry::Marker(::core::clone::Clone::clone(__self_0)), } } } pub struct Context { vector: Vector, len: Rc>, } #[automatically_derived] impl ::core::fmt::Debug for Context { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { ::core::fmt::Formatter::debug_struct_field2_finish(f, "Context", "vector", &self.vector, "len", &&self.len) } } #[automatically_derived] impl ::core::clone::Clone for Context { #[inline] fn clone(&self) -> Context { Context { vector: ::core::clone::Clone::clone(&self.vector), len: ::core::clone::Clone::clone(&self.len), } } } impl Default for Context { fn default() -> Self { let vector = Vector::default(); let len = Rc::new(RefCell::new(0)); Context { vector, len } } } impl Context { #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] pub fn add(&self, entry: ContextEntry) -> (Context, ContextIndex) { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of add violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; #[allow(unused_mut)] let mut run = |this: &Self, entry: ContextEntry| -> (Context, ContextIndex) { let context_level = this.vector.len(); let mut new_ctx = this.clone(); new_ctx.vector.push_back(entry); let context_length = this.len.clone(); { *context_length.borrow_mut() += 1; } let idx = ContextIndex { context_level, context_length }; (new_ctx, idx) }; let ret = run(self, entry); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of add violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] #[doc = "Pre-condition: `index.context_length == self.len`"] #[doc = ""] pub fn get(&self, index: &ContextIndex) -> Option<&ContextEntry> { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; if !(index.context_length == self.len) { { ::core::panicking::panic_display(&"Pre-condition of get violated: index.context_length == self.len"); } }; #[allow(unused_mut)] let mut run = |this: &Self, index: &ContextIndex| -> Option<&ContextEntry> { this.vector.get(index.context_level) }; let ret = run(self, index); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] pub fn get_existential(&self, index: &ContextIndex) -> Option> { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get_existential violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; #[allow(unused_mut)] let mut run = |this: &Self, index: &ContextIndex| -> Option> { let entry = this.get(index)?; match entry { ContextEntry::ExistentialSolved(t) => Some(Some(t.clone())), ContextEntry::ExistentialVar => Some(None), _ => None, } }; let ret = run(self, index); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get_existential violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] pub fn get_type(&self, index: &ContextIndex) -> Option { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get_type violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; #[allow(unused_mut)] let mut run = |this: &Self, index: &ContextIndex| -> Option { let entry = this.get(index)?; match entry { ContextEntry::TermAnnot(t) => Some(t.clone()), _ => None, } }; let ret = run(self, index); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of get_type violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] pub fn unsolved_existentials(&self) -> Vec { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of unsolved_existentials violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; #[allow(unused_mut)] let mut run = |this: &Self| -> Vec { let mut unsolved = Vec::new(); let context_length = this.len.clone(); for (context_level, entry) in this.vector.iter().enumerate() { match entry { ContextEntry::ExistentialVar => { let index = ContextIndex { context_length: context_length.clone(), context_level, }; unsolved.push(index) } _ => {} } } unsolved }; let ret = run(self); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of unsolved_existentials violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } #[doc = " Splits the context"] #[doc = "# Contracts"] #[doc = "Invariant: `{ let b = self.vector.len() == * self.len.borrow() ; b }`"] #[doc = ""] pub fn split_at(&self, index: &ContextIndex) -> (Context, Context) { if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of split_at violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; #[allow(unused_mut)] let mut run = |this: &Self, index: &ContextIndex| -> (Context, Context) { let (before, after) = { this.vector.clone().split_at(index.context_level) }; let before_len = Rc::new(RefCell::new(before.len())); let after_len = Rc::new(RefCell::new(after.len())); (Context { vector: before, len: before_len }, Context { vector: after, len: after_len }) }; let ret = run(self, index); if !{ let b = self.vector.len() == *self.len.borrow(); b } { { ::core::panicking::panic_display(&"Invariant of split_at violated: { let b = self.vector.len() == * self.len.borrow() ; b }"); } }; ret } } /// An index into the context. pub struct ContextIndex { context_length: Rc>, context_level: usize, } #[automatically_derived] impl ::core::clone::Clone for ContextIndex { #[inline] fn clone(&self) -> ContextIndex { ContextIndex { context_length: ::core::clone::Clone::clone(&self.context_length), context_level: ::core::clone::Clone::clone(&self.context_level), } } } #[automatically_derived] impl ::core::marker::StructuralPartialEq for ContextIndex { } #[automatically_derived] impl ::core::cmp::PartialEq for ContextIndex { #[inline] fn eq(&self, other: &ContextIndex) -> bool { self.context_length == other.context_length && self.context_level == other.context_level } } #[automatically_derived] impl ::core::marker::StructuralEq for ContextIndex { } #[automatically_derived] impl ::core::cmp::Eq for ContextIndex { #[inline] #[doc(hidden)] #[no_coverage] fn assert_receiver_is_total_eq(&self) -> () { let _: ::core::cmp::AssertParamIsEq>>; let _: ::core::cmp::AssertParamIsEq; } } impl fmt::Debug for ContextIndex { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_fmt(format_args!("#{0}", self.context_index())) } } impl ContextIndex { pub fn context_index(&self) -> usize { *self.context_length.borrow() - self.context_level } } pub fn convert_term(term: &data::Term) -> Term { fn convert_term_with_context(ctx: &data::Context, ctx2: &Context, term: &data::Term) -> Term { match term { data::Term::Unit => Term::Unit, data::Term::Var(name) => { let (idx, _) = ctx.lookup_type(name).unwrap(); let _len = ctx2.len.clone(); let index = ContextIndex { context_length: ctx2.len.clone(), context_level: idx, }; Term::Var(index) } data::Term::Lam(arg, body) => { let ty = gensym_type(); let aug_ctx = ctx.add(<[_]>::into_vec(#[rustc_box] ::alloc::boxed::Box::new([data::ContextEntry::TermAnnot(arg.to_owned(), data::Type::Var(ty.clone()))]))); let body = convert_term_with_context(&aug_ctx, ctx2, body); Term::Lam(Box::new(body)) } data::Term::App(func, arg) => { let func = convert_term_with_context(ctx, ctx2, &func); let arg = convert_term_with_context(ctx, ctx2, &arg); Term::App(Box::new(func), Box::new(arg)) } data::Term::Annot(term, ty) => { let term = convert_term_with_context(ctx, ctx2, &term); let ty = convert_ty_with_context(ctx, ctx2, &ty); Term::Annot(Box::new(term), ty) } } } fn convert_ty_with_context(_ctx: &data::Context, _ctx2: &Context, ty: &data::Type) -> Type { match ty { data::Type::Unit => Type::Unit, data::Type::Var(_) => ::core::panicking::panic("not yet implemented"), data::Type::Existential(_) => ::core::panicking::panic("not yet implemented"), data::Type::Polytype(_, _) => ::core::panicking::panic("not yet implemented"), data::Type::Arrow(_, _) => ::core::panicking::panic("not yet implemented"), } } convert_term_with_context(&data::Context::default(), &Context::default(), term) } } mod gensym { use dashmap::DashMap; const CTRMAP: ::std::thread::LocalKey> = { #[inline] fn __init() -> DashMap<&'static str, usize> { DashMap::new() } #[inline] unsafe fn __getit(init: ::std::option::Option<&mut ::std::option::Option>>) -> ::std::option::Option<&'static DashMap<&'static str, usize>> { #[thread_local] static __KEY: ::std::thread::local_impl::Key> = ::std::thread::local_impl::Key::>::new(); #[allow(unused_unsafe)] unsafe { __KEY.get(move || { if let ::std::option::Option::Some(init) = init { if let ::std::option::Option::Some(value) = init.take() { return value; } else if true { { ::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}", format_args!("missing default value"))); }; } } __init() }) } } unsafe { ::std::thread::LocalKey::new(__getit) } }; const EXISTENTIALS: [&'static str; 24] = ["ฮฑ", "ฮฒ", "ฮณ", "ฮด", "ฮต", "ฮถ", "ฮท", "ฮธ", "ฮน", "ฮบ", "ฮป", "ฮผ", "ฮฝ", "ฮพ", "ฮฟ", "ฯ€", "ฯ", "ฯƒ", "ฯ„", "ฯ…", "ฯ†", "ฯ‡", "ฯˆ", "ฯ‰"]; const TYPEVARS: [&'static str; 26] = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]; pub fn gensym_existential() -> String { let result = idx("existential"); { let res = ::alloc::fmt::format(format_args!("{0}\u{{302}}", EXISTENTIALS[result])); res } } pub fn gensym_type() -> String { let result = idx("existential"); { let res = ::alloc::fmt::format(format_args!("{0}\u{{302}}", TYPEVARS[result])); res } } fn idx(ty: &'static str) -> usize { CTRMAP.with(|ctrmap| { let mut g = ctrmap.entry(ty).or_insert(0); let ctr = *g; *g += 1; ctr }) } } #[rustfmt::skip] #[allow(clippy :: extra_unused_lifetimes)] #[allow(clippy :: needless_lifetimes)] #[allow(clippy :: let_unit_value)] #[allow(clippy :: just_underscores_and_digits)] pub mod parser { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Ident { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, -22, -2]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 1 => 1, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = String; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => __state_machine::SimulatedReduce::Accept, 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct IdentParser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl IdentParser { pub fn new() -> IdentParser { let __builder = super::__intern_token::new_builder(); IdentParser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); return Some(Ok(__nt)); } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Ident::IdentParser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Term { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[3, 18, 0, 0, 0, 0, 4, 0, 5, 19, 0, 3, 18, 0, 0, 0, 0, 4, 0, 5, 19, 0, 3, 18, 0, 0, 0, 0, 4, 0, 5, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 8, 28, 0, 0, 0, 0, 0, 9, 0, 19, 29, 3, 18, -13, 0, 0, 0, 4, 0, 5, 19, 0, 8, 28, 0, 0, 0, 0, 0, 9, 0, 19, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 3, 18, 0, 0, 0, 0, 4, 0, 5, 19, 0, 3, 18, 0, 0, 0, 0, 4, 0, 5, 19, 0, 8, 28, 0, 0, 0, 0, 0, 9, 0, 19, 29, 8, 28, 0, 0, 0, 0, 0, 9, 0, 19, 29, -7, -7, -7, 0, 0, -7, -7, 0, -7, -7, 0, -10, -10, -10, 0, 0, -10, -10, 0, -10, -10, 0, -12, -12, -12, 0, 0, -12, -12, 0, -12, -12, 0, -4, -4, -4, 0, 0, 6, -4, 0, -4, -4, 0, -5, -5, -5, 0, 0, -5, -5, 0, -5, -5, 0, -2, -2, -2, -2, -2, -2, -2, 0, -2, -2, 0, -3, -3, -3, 0, 0, 6, -3, 0, -3, -3, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, -19, -19, -19, -19, 0, -19, -19, 0, -19, -19, 0, -18, -18, -18, -18, 0, -18, -18, 0, -18, -18, 0, -11, -11, -11, 0, 0, -11, -11, 0, -11, -11, 0, -15, -15, -15, 12, 0, -15, -15, 0, -15, -15, 0, -16, -16, -16, -16, 0, -16, -16, 0, -16, -16, 0, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -6, -6, -6, 0, 0, -6, -6, 0, -6, -6, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, -9, -9, -9, 0, 0, -9, -9, 0, -9, -9, 0, -8, -8, -8, 0, 0, -8, -8, 0, -8, -8, 0, -14, -14, -14, 0, 0, -14, -14, 0, -14, -14, 0, -17, -17, -17, -17, 0, -17, -17, 0, -17, -17, 0, -20, -20, -20, -20, 0, -20, -20, 0, -20, -20, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7, -10, -12, -4, -5, -2, -3, 0, 0, 0, -19, -18, -11, -15, -16, -1, -6, 0, 0, 0, -9, -8, -14, -17, -20]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 23, 1 => match state { 3 => 21, 4 => 22, 5 | 7 | 11..=12 => 24, 8 => 32, _ => 13, }, 2 => match state { 2 => 6, _ => 1, }, 3 => 14, 4 => match state { 9 => 33, 10 => 34, _ => 15, }, 5 => match state { 1 | 6 => 19, _ => 16, }, 6 => 20, 7 => match state { 7 => 30, 11 => 35, _ => 25, }, 8 => match state { 12 => 37, _ => 26, }, 9 => 31, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Term; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => __state_machine::SimulatedReduce::Accept, 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct TermParser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl TermParser { pub fn new() -> TermParser { let __builder = super::__intern_token::new_builder(); TermParser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); return Some(Ok(__nt)); } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Term::TermParser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Term1 { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[2, 15, 0, 0, 0, 0, 0, 0, 0, 16, 0, 2, 15, 0, 0, 0, 0, 4, 0, 5, 16, 0, 2, 15, -13, 0, 0, 0, 4, 0, 5, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 7, 29, 0, 0, 0, 0, 0, 8, 0, 16, 30, 7, 29, 0, 0, 0, 0, 0, 8, 0, 16, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 2, 15, 0, 0, 0, 0, 4, 0, 5, 16, 0, 2, 15, 0, 0, 0, 0, 4, 0, 5, 16, 0, 7, 29, 0, 0, 0, 0, 0, 8, 0, 16, 30, 7, 29, 0, 0, 0, 0, 0, 8, 0, 16, 30, -7, -7, -7, 0, 0, -7, -7, 0, -7, -7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -5, -5, -5, 0, 0, -5, -5, 0, -5, -5, 0, -2, -2, -2, -2, -2, -2, -2, 0, -2, -2, 0, -10, -10, -10, 0, 0, -10, -10, 0, -10, -10, 0, -12, -12, -12, 0, 0, -12, -12, 0, -12, -12, 0, -4, -4, -4, 0, 0, 6, -4, 0, -4, -4, 0, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, -3, -3, -3, 0, 0, 6, -3, 0, -3, -3, 0, -6, -6, -6, 0, 0, -6, -6, 0, -6, -6, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, -19, -19, -19, -19, 0, -19, -19, 0, -19, -19, 0, -18, -18, -18, -18, 0, -18, -18, 0, -18, -18, 0, -11, -11, -11, 0, 0, -11, -11, 0, -11, -11, 0, -15, -15, -15, 11, 0, -15, -15, 0, -15, -15, 0, -16, -16, -16, -16, 0, -16, -16, 0, -16, -16, 0, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, -9, -9, -9, 0, 0, -9, -9, 0, -9, -9, 0, -8, -8, -8, 0, 0, -8, -8, 0, -8, -8, 0, -14, -14, -14, 0, 0, -14, -14, 0, -14, -14, 0, -17, -17, -17, -17, 0, -17, -17, 0, -17, -17, 0, -20, -20, -20, -20, 0, -20, -20, 0, -20, -20, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7, -24, -5, -2, 0, 0, 0, 0, 0, -6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 24, 1 => match state { 3 => 22, 4 => 23, 5..=6 | 10..=11 => 25, 7 => 32, _ => 12, }, 2 => 2, 3 => match state { 0 => 13, _ => 16, }, 4 => match state { 8 => 33, 9 => 34, _ => 17, }, 5 => match state { 2 => 20, _ => 18, }, 6 => 19, 7 => match state { 6 => 30, 10 => 35, _ => 26, }, 8 => match state { 11 => 37, _ => 27, }, 9 => 31, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Term; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => __state_machine::SimulatedReduce::Accept, 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct Term1Parser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl Term1Parser { pub fn new() -> Term1Parser { let __builder = super::__intern_token::new_builder(); Term1Parser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); return Some(Ok(__nt)); } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Term1::Term1Parser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Term2 { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[2, 16, 0, 0, 0, 0, 3, 0, 4, 17, 0, 2, 16, 0, 0, 0, 0, 3, 0, 4, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 2, 16, -13, 0, 0, 0, 3, 0, 4, 17, 0, 9, 29, 0, 0, 0, 0, 0, 10, 0, 17, 30, 2, 16, 0, 0, 0, 0, 3, 0, 4, 17, 0, 2, 16, 0, 0, 0, 0, 3, 0, 4, 17, 0, 9, 29, 0, 0, 0, 0, 0, 10, 0, 17, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 9, 29, 0, 0, 0, 0, 0, 10, 0, 17, 30, 9, 29, 0, 0, 0, 0, 0, 10, 0, 17, 30, -7, -7, -7, 0, 0, -7, -7, 0, -7, -7, 0, -10, -10, -10, 0, 0, -10, -10, 0, -10, -10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -5, -5, -5, 0, 0, -5, -5, 0, -5, -5, 0, -2, -2, -2, -2, -2, -2, -2, 0, -2, -2, 0, -12, -12, -12, 0, 0, -12, -12, 0, -12, -12, 0, -4, -4, -4, 0, 0, 6, -4, 0, -4, -4, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, -3, -3, -3, 0, 0, 6, -3, 0, -3, -3, 0, -6, -6, -6, 0, 0, -6, -6, 0, -6, -6, 0, -19, -19, -19, -19, 0, -19, -19, 0, -19, -19, 0, -18, -18, -18, -18, 0, -18, -18, 0, -18, -18, 0, -11, -11, -11, 0, 0, -11, -11, 0, -11, -11, 0, -15, -15, -15, 11, 0, -15, -15, 0, -15, -15, 0, -16, -16, -16, -16, 0, -16, -16, 0, -16, -16, 0, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -9, -9, -9, 0, 0, -9, -9, 0, -9, -9, 0, -8, -8, -8, 0, 0, -8, -8, 0, -8, -8, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, -14, -14, -14, 0, 0, -14, -14, 0, -14, -14, 0, -17, -17, -17, -17, 0, -17, -17, 0, -17, -17, 0, -20, -20, -20, -20, 0, -20, -20, 0, -20, -20, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7, -10, -25, -5, -2, 0, 0, 0, 0, 0, 0, -6, 0, 0, 0, 0, 0, 0, -9, -8, 0, 0, 0, 0, 0, 0]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 24, 1 => match state { 2 => 20, 3 => 21, 5 | 8 | 10..=11 => 25, 9 => 34, _ => 12, }, 2 => 4, 3 => 13, 4 => match state { 0 => 14, 6 => 30, 7 => 31, _ => 17, }, 5 => match state { 4 => 22, _ => 18, }, 6 => 19, 7 => match state { 8 => 32, 10 => 35, _ => 26, }, 8 => match state { 11 => 37, _ => 27, }, 9 => 33, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Term; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => __state_machine::SimulatedReduce::Accept, 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct Term2Parser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl Term2Parser { pub fn new() -> Term2Parser { let __builder = super::__intern_token::new_builder(); Term2Parser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); return Some(Ok(__nt)); } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Term2::Term2Parser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Term4 { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[2, 17, 0, 0, 0, 0, 3, 0, 4, 18, 0, 2, 17, 0, 0, 0, 0, 3, 0, 4, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 7, 27, 0, 0, 0, 0, 0, 8, 0, 18, 28, 2, 17, -13, 0, 0, 0, 3, 0, 4, 18, 0, 7, 27, 0, 0, 0, 0, 0, 8, 0, 18, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 2, 17, 0, 0, 0, 0, 3, 0, 4, 18, 0, 2, 17, 0, 0, 0, 0, 3, 0, 4, 18, 0, 7, 27, 0, 0, 0, 0, 0, 8, 0, 18, 28, 7, 27, 0, 0, 0, 0, 0, 8, 0, 18, 28, -7, -7, -7, 0, 0, -7, -7, 0, -7, -7, 0, -10, -10, -10, 0, 0, -10, -10, 0, -10, -10, 0, -12, -12, -12, 0, 0, -12, -12, 0, -12, -12, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, -5, -5, -5, 0, 0, -5, -5, 0, -5, -5, 0, -2, -2, -2, -2, -2, -2, -2, 0, -2, -2, 0, -4, -4, -4, 0, 0, 5, -4, 0, -4, -4, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, -19, -19, -19, -19, 0, -19, -19, 0, -19, -19, 0, -18, -18, -18, -18, 0, -18, -18, 0, -18, -18, 0, -11, -11, -11, 0, 0, -11, -11, 0, -11, -11, 0, -15, -15, -15, 11, 0, -15, -15, 0, -15, -15, 0, -16, -16, -16, -16, 0, -16, -16, 0, -16, -16, 0, -1, -1, -1, -1, 0, -1, -1, 0, -1, -1, 0, -3, -3, -3, 0, 0, 5, -3, 0, -3, -3, 0, -6, -6, -6, 0, 0, -6, -6, 0, -6, -6, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, -9, -9, -9, 0, 0, -9, -9, 0, -9, -9, 0, -8, -8, -8, 0, 0, -8, -8, 0, -8, -8, 0, -14, -14, -14, 0, 0, -14, -14, 0, -14, -14, 0, -17, -17, -17, -17, 0, -17, -17, 0, -17, -17, 0, -20, -20, -20, -20, 0, -20, -20, 0, -20, -20, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7, -10, -12, -26, -5, -2, 0, 0, 0, 0, -19, -18, -11, -15, -16, -1, 0, -6, 0, 0, 0, -9, -8, -14, -17, -20]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 22, 1 => match state { 2 => 20, 3 => 21, 4 | 6 | 10..=11 => 23, 7 => 32, _ => 12, }, 2 => 5, 3 => 13, 4 => match state { 8 => 33, 9 => 34, _ => 14, }, 5 => match state { 1 => 18, 5 => 28, _ => 15, }, 6 => 19, 7 => match state { 6 => 30, 10 => 35, _ => 24, }, 8 => match state { 11 => 37, _ => 25, }, 9 => 31, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Term; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => __state_machine::SimulatedReduce::Accept, 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct Term4Parser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl Term4Parser { pub fn new() -> Term4Parser { let __builder = super::__intern_token::new_builder(); Term4Parser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); return Some(Ok(__nt)); } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Term4::Term4Parser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Type { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[2, 10, 0, 0, 0, 0, 0, 3, 0, 11, 12, 2, 10, 0, 0, 0, 0, 0, 3, 0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 2, 10, 0, 0, 0, 0, 0, 3, 0, 11, 12, 2, 10, 0, 0, 0, 0, 0, 3, 0, 11, 12, 0, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, -20, -20, 0, 0, 0, 0, 0, 0, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, 0, 0, 0, 0, -19, -18, -27, -15, -16, -2, -1, 0, 0, 0, -14, -17, -20]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 5, 1 => match state { 2 => 14, _ => 6, }, 7 => match state { 1 => 12, 3 => 15, _ => 7, }, 8 => match state { 4 => 17, _ => 8, }, 9 => 13, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Type; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => __state_machine::SimulatedReduce::Accept, 27 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct TypeParser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl TypeParser { pub fn new() -> TypeParser { let __builder = super::__intern_token::new_builder(); TypeParser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); return Some(Ok(__nt)); } 27 => { __reduce27(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce27<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 16) } } pub use self::__parse__Type::TypeParser; #[rustfmt::skip] #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy :: all)] mod __parse__Type0 { use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; use self::__lalrpop_util::lexer::Token; #[allow(dead_code)] pub(crate) enum __Symbol<'input> { Variant0(&'input str), Variant1(String), Variant2(Term), Variant3(Type), } const __ACTION: &[i8] = &[2, 9, 0, 0, 0, 0, 0, 3, 0, 10, 11, 2, 9, 0, 0, 0, 0, 0, 3, 0, 10, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 2, 9, 0, 0, 0, 0, 0, 3, 0, 10, 11, 2, 9, 0, 0, 0, 0, 0, 3, 0, 10, 11, 0, 0, -19, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, -18, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, -17, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -20, -20, 0, 0, 0, 0, 0, 0, 0]; fn __action(state: i8, integer: usize) -> i8 { __ACTION[(state as usize) * 11 + integer] } const __EOF_ACTION: &[i8] = &[0, 0, 0, 0, 0, -19, -18, -28, -16, -2, -1, 0, 0, 0, 0, -17, 0, -20]; fn __goto(state: i8, nt: usize) -> i8 { match nt { 0 => 5, 1 => match state { 2 => 14, _ => 6, }, 7 => match state { 3 => 16, _ => 11, }, 8 => match state { 0 => 7, 4 => 17, _ => 12, }, 9 => 13, _ => 0, } } const __TERMINAL: &[&str] = &[r###""(""###, r###""()""###, r###"")""###, r###""->""###, r###"".""###, r###"":""###, r###""\\""###, r###""forall""###, r###""ฮป""###, r###"r#"[A-Za-z_]+"#"###, r###"r#"\\^[A-Za-z_]+"#"###]; fn __expected_tokens(__state: i8) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { let next_state = __action(__state, index); if next_state == 0 { None } else { Some(alloc::string::ToString::to_string(terminal)) } }).collect() } fn __expected_tokens_from_states<'input>(__states: &[i8], _: core::marker::PhantomData<(&'input ())>) -> alloc::vec::Vec { __TERMINAL.iter().enumerate().filter_map(|(index, terminal)| { if __accepts(None, __states, Some(index), core::marker::PhantomData::<(&())>) { Some(alloc::string::ToString::to_string(terminal)) } else { None } }).collect() } pub(crate) struct __StateMachine<'input> where { input: &'input str, __phantom: core::marker::PhantomData<(&'input ())>, } impl<'input> __state_machine::ParserDefinition for __StateMachine<'input> where { type Location = usize; type Error = &'static str; type Token = Token<'input>; type TokenIndex = usize; type Symbol = __Symbol<'input>; type Success = Type; type StateIndex = i8; type Action = i8; type ReduceIndex = i8; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { __token_to_integer(token, core::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i8, integer: usize) -> i8 { __action(state, integer) } #[inline] fn error_action(&self, state: i8) -> i8 { __action(state, 11 - 1) } #[inline] fn eof_action(&self, state: i8) -> i8 { __EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i8, nt: usize) -> i8 { __goto(state, nt) } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { __token_to_symbol(token_index, token, core::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i8) -> alloc::vec::Vec { __expected_tokens(state) } fn expected_tokens_from_states(&self, states: &[i8]) -> alloc::vec::Vec { __expected_tokens_from_states(states, core::marker::PhantomData::<(&())>) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol(&self, recovery: __state_machine::ErrorRecovery) -> Self::Symbol { { ::core::panicking::panic_fmt(format_args!("error recovery not enabled for this grammar")); } } fn reduce(&mut self, action: i8, start_location: Option<&Self::Location>, states: &mut alloc::vec::Vec, symbols: &mut alloc::vec::Vec<__state_machine::SymbolTriple>) -> Option<__state_machine::ParseResult> { __reduce(self.input, action, start_location, states, symbols, core::marker::PhantomData::<(&())>) } fn simulate_reduce(&self, action: i8) -> __state_machine::SimulatedReduce { __simulate_reduce(action, core::marker::PhantomData::<(&())>) } } fn __token_to_integer<'input>(__token: &Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> Option { match *__token { Token(2, _) if true => Some(0), Token(3, _) if true => Some(1), Token(4, _) if true => Some(2), Token(5, _) if true => Some(3), Token(6, _) if true => Some(4), Token(7, _) if true => Some(5), Token(8, _) if true => Some(6), Token(9, _) if true => Some(7), Token(10, _) if true => Some(8), Token(0, _) if true => Some(9), Token(1, _) if true => Some(10), _ => None, } } fn __token_to_symbol<'input>(__token_index: usize, __token: Token<'input>, _: core::marker::PhantomData<(&'input ())>) -> __Symbol<'input> { match __token_index { 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => match __token { Token(2, __tok0) | Token(3, __tok0) | Token(4, __tok0) | Token(5, __tok0) | Token(6, __tok0) | Token(7, __tok0) | Token(8, __tok0) | Token(9, __tok0) | Token(10, __tok0) | Token(0, __tok0) | Token(1, __tok0) if true => __Symbol::Variant0(__tok0), _ => ::core::panicking::panic("internal error: entered unreachable code"), }, _ => ::core::panicking::panic("internal error: entered unreachable code"), } } fn __simulate_reduce<'input>(__reduce_index: i8, _: core::marker::PhantomData<(&'input ())>) -> __state_machine::SimulatedReduce<__StateMachine<'input>> { match __reduce_index { 0 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 2 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 2, } } 3 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 4 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 5 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 3, } } 6 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 3, } } 7 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 8 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 4, } } 9 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 4, } } 10 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 5, } } 11 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 5, } } 12 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 6, } } 13 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 14 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 7, } } 15 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 16 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 17 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 18 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 8, } } 19 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 8, } } 20 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 9, } } 21 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 10, } } 22 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 11, } } 23 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 12, } } 24 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 25 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 14, } } 26 => { __state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 15, } } 27 => __state_machine::SimulatedReduce::Accept, _ => { ::core::panicking::panic_fmt(format_args!("invalid reduction index {0}", __reduce_index)); } } } pub struct Type0Parser { builder: __lalrpop_util::lexer::MatcherBuilder, _priv: (), } impl Type0Parser { pub fn new() -> Type0Parser { let __builder = super::__intern_token::new_builder(); Type0Parser { builder: __builder, _priv: () } } #[allow(dead_code)] pub fn parse<'input>(&self, input: &'input str) -> Result, &'static str>> { let mut __tokens = self.builder.matcher(input); __state_machine::Parser::drive(__StateMachine { input, __phantom: core::marker::PhantomData::<(&())>, }, __tokens) } } fn __accepts<'input>(__error_state: Option, __states: &[i8], __opt_integer: Option, _: core::marker::PhantomData<(&'input ())>) -> bool { let mut __states = __states.to_vec(); __states.extend(__error_state); loop { let mut __states_len = __states.len(); let __top = __states[__states_len - 1]; let __action = match __opt_integer { None => __EOF_ACTION[__top as usize], Some(__integer) => __action(__top, __integer), }; if __action == 0 { return false; } if __action > 0 { return true; } let (__to_pop, __nt) = match __simulate_reduce(-(__action + 1), core::marker::PhantomData::<(&())>) { __state_machine::SimulatedReduce::Reduce { states_to_pop, nonterminal_produced } => (states_to_pop, nonterminal_produced), __state_machine::SimulatedReduce::Accept => return true, }; __states_len -= __to_pop; __states.truncate(__states_len); let __top = __states[__states_len - 1]; let __next_state = __goto(__top, __nt); __states.push(__next_state); } } pub(crate) fn __reduce<'input>(input: &'input str, __action: i8, __lookahead_start: Option<&usize>, __states: &mut alloc::vec::Vec, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> Option, &'static str>>> { let (__pop_states, __nonterminal) = match __action { 0 => { __reduce0(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 1 => { __reduce1(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 2 => { __reduce2(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 3 => { __reduce3(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 4 => { __reduce4(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 5 => { __reduce5(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 6 => { __reduce6(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 7 => { __reduce7(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 8 => { __reduce8(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 9 => { __reduce9(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 10 => { __reduce10(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 11 => { __reduce11(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 12 => { __reduce12(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 13 => { __reduce13(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 14 => { __reduce14(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 15 => { __reduce15(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 16 => { __reduce16(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 17 => { __reduce17(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 18 => { __reduce18(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 19 => { __reduce19(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 20 => { __reduce20(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 21 => { __reduce21(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 22 => { __reduce22(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 23 => { __reduce23(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 24 => { __reduce24(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 25 => { __reduce25(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 26 => { __reduce26(input, __lookahead_start, __symbols, core::marker::PhantomData::<(&())>) } 27 => { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action4::<>(input, __sym0); return Some(Ok(__nt)); } _ => { ::core::panicking::panic_fmt(format_args!("invalid action code {0}", __action)); } }; let __states_len = __states.len(); __states.truncate(__states_len - __pop_states); let __state = *__states.last().unwrap(); let __next_state = __goto(__state, __nonterminal); __states.push(__next_state); None } #[inline(never)] fn __symbol_type_mismatch() -> ! { { ::core::panicking::panic_fmt(format_args!("symbol type mismatch")); } } fn __pop_Variant1<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, String, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant1(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant2<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Term, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant2(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant3<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, Type, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant3(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } fn __pop_Variant0<'input>(__symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>) -> (usize, &'input str, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant0(__v), __r)) => (__l, __v, __r), _ => __symbol_type_mismatch(), } } pub(crate) fn __reduce0<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action26::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 0) } pub(crate) fn __reduce1<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action27::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 1) } pub(crate) fn __reduce2<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 2) { ::core::panicking::panic("assertion failed: __symbols.len() >= 2") }; let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym1.2; let __nt = super::__action15::<>(input, __sym0, __sym1); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (2, 2) } pub(crate) fn __reduce3<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action16::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 2) } pub(crate) fn __reduce4<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action7::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce5<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant2(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action8::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 3) } pub(crate) fn __reduce6<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action9::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 3) } pub(crate) fn __reduce7<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action10::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce8<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant2(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action11::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (4, 4) } pub(crate) fn __reduce9<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action12::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 4) } pub(crate) fn __reduce10<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action13::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (3, 5) } pub(crate) fn __reduce11<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action14::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 5) } pub(crate) fn __reduce12<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action17::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 6) } pub(crate) fn __reduce13<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant3(__symbols); let __sym1 = __pop_Variant0(__symbols); let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action23::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 7) } pub(crate) fn __reduce14<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action24::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 7) } pub(crate) fn __reduce15<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action18::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce16<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 3) { ::core::panicking::panic("assertion failed: __symbols.len() >= 3") }; let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant3(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym2.2; let __nt = super::__action19::<>(input, __sym0, __sym1, __sym2); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (3, 8) } pub(crate) fn __reduce17<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action20::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce18<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action21::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 8) } pub(crate) fn __reduce19<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { if !(__symbols.len() >= 4) { ::core::panicking::panic("assertion failed: __symbols.len() >= 4") }; let __sym3 = __pop_Variant3(__symbols); let __sym2 = __pop_Variant0(__symbols); let __sym1 = __pop_Variant1(__symbols); let __sym0 = __pop_Variant0(__symbols); let __start = __sym0.0; let __end = __sym3.2; let __nt = super::__action22::<>(input, __sym0, __sym1, __sym2, __sym3); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (4, 8) } pub(crate) fn __reduce20<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action25::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 9) } pub(crate) fn __reduce21<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant1(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action6::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant1(__nt), __end)); (1, 10) } pub(crate) fn __reduce22<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action3::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 11) } pub(crate) fn __reduce23<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action0::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 12) } pub(crate) fn __reduce24<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action1::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 13) } pub(crate) fn __reduce25<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant2(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action2::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant2(__nt), __end)); (1, 14) } pub(crate) fn __reduce26<'input>(input: &'input str, __lookahead_start: Option<&usize>, __symbols: &mut alloc::vec::Vec<(usize, __Symbol<'input>, usize)>, _: core::marker::PhantomData<(&'input ())>) -> (usize, usize) { let __sym0 = __pop_Variant3(__symbols); let __start = __sym0.0; let __end = __sym0.2; let __nt = super::__action5::<>(input, __sym0); __symbols.push((__start, __Symbol::Variant3(__nt), __end)); (1, 15) } } pub use self::__parse__Type0::Type0Parser; mod __intern_token { #![allow(unused_imports)] use crate::data::*; #[allow(unused_extern_crates)] extern crate lalrpop_util as __lalrpop_util; #[allow(unused_imports)] use self::__lalrpop_util::state_machine as __state_machine; extern crate core; extern crate alloc; pub fn new_builder() -> __lalrpop_util::lexer::MatcherBuilder { let __strs: &[(&str, bool)] = &[("^([A-Z_a-z]+)", false), ("^((?:\\^[A-Z_a-z]+))", false), ("^(\\()", false), ("^((?:\\(\\)))", false), ("^(\\))", false), ("^((?:\\->))", false), ("^(\\.)", false), ("^(:)", false), ("^(\\\\)", false), ("^((?:forall))", false), ("^(ฮป)", false), (r"^(\s*)", true)]; __lalrpop_util::lexer::MatcherBuilder::new(__strs.iter().copied()).unwrap() } } pub(crate) use self::__lalrpop_util::lexer::Token; #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action0<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action1<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action2<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action3<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action4<'input>(input: &'input str, (_, __0, _): (usize, Type, usize)) -> Type { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action5<'input>(input: &'input str, (_, __0, _): (usize, Type, usize)) -> Type { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action6<'input>(input: &'input str, (_, __0, _): (usize, String, usize)) -> String { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action7<'input>(input: &'input str, (_, __0, _): (usize, &'input str, usize)) -> Term { Term::Unit } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action8<'input>(input: &'input str, (_, _, _): (usize, &'input str, usize), (_, term, _): (usize, Term, usize), (_, _, _): (usize, &'input str, usize)) -> Term { term } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action9<'input>(input: &'input str, (_, __0, _): (usize, String, usize)) -> Term { Term::Var(__0) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action10<'input>(input: &'input str, (_, _, _): (usize, &'input str, usize), (_, name, _): (usize, String, usize), (_, _, _): (usize, &'input str, usize), (_, term, _): (usize, Term, usize)) -> Term { Term::Lam(name, Box::new(term)) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action11<'input>(input: &'input str, (_, _, _): (usize, &'input str, usize), (_, name, _): (usize, String, usize), (_, _, _): (usize, &'input str, usize), (_, term, _): (usize, Term, usize)) -> Term { Term::Lam(name, Box::new(term)) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action12<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action13<'input>(input: &'input str, (_, term, _): (usize, Term, usize), (_, _, _): (usize, &'input str, usize), (_, ty, _): (usize, Type, usize)) -> Term { Term::Annot(Box::new(term), ty) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action14<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action15<'input>(input: &'input str, (_, func, _): (usize, Term, usize), (_, arg, _): (usize, Term, usize)) -> Term { Term::App(Box::new(func), Box::new(arg)) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action16<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action17<'input>(input: &'input str, (_, __0, _): (usize, Term, usize)) -> Term { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action18<'input>(input: &'input str, (_, __0, _): (usize, &'input str, usize)) -> Type { Type::Unit } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action19<'input>(input: &'input str, (_, _, _): (usize, &'input str, usize), (_, ty, _): (usize, Type, usize), (_, _, _): (usize, &'input str, usize)) -> Type { ty } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action20<'input>(input: &'input str, (_, __0, _): (usize, String, usize)) -> Type { Type::Var(__0) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action21<'input>(input: &'input str, (_, __0, _): (usize, String, usize)) -> Type { Type::Existential(__0) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action22<'input>(input: &'input str, (_, _, _): (usize, &'input str, usize), (_, name, _): (usize, String, usize), (_, _, _): (usize, &'input str, usize), (_, ty, _): (usize, Type, usize)) -> Type { Type::Polytype(name, Box::new(ty)) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action23<'input>(input: &'input str, (_, a, _): (usize, Type, usize), (_, _, _): (usize, &'input str, usize), (_, b, _): (usize, Type, usize)) -> Type { Type::Arrow(Box::new(a), Box::new(b)) } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action24<'input>(input: &'input str, (_, __0, _): (usize, Type, usize)) -> Type { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action25<'input>(input: &'input str, (_, __0, _): (usize, Type, usize)) -> Type { __0 } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action26<'input>(input: &'input str, (_, __0, _): (usize, &'input str, usize)) -> String { __0.to_string() } #[allow(unused_variables)] #[allow(clippy :: too_many_arguments)] fn __action27<'input>(input: &'input str, (_, __0, _): (usize, &'input str, usize)) -> String { __0.to_string() } #[allow(clippy :: type_complexity)] pub trait __ToTriple<'input> { fn to_triple(value: Self) -> Result<(usize, Token<'input>, usize), __lalrpop_util::ParseError, &'static str>>; } impl<'input> __ToTriple<'input> for (usize, Token<'input>, usize) { fn to_triple(value: Self) -> Result<(usize, Token<'input>, usize), __lalrpop_util::ParseError, &'static str>> { Ok(value) } } impl<'input> __ToTriple<'input> for Result<(usize, Token<'input>, usize), &'static str> { fn to_triple(value: Self) -> Result<(usize, Token<'input>, usize), __lalrpop_util::ParseError, &'static str>> { match value { Ok(v) => Ok(v), Err(error) => Err(__lalrpop_util::ParseError::User { error }), } } } } const DEPTH: ::std::thread::LocalKey<::std::cell::Cell> = { #[inline] fn __init() -> ::std::cell::Cell { ::std::cell::Cell::new(0) } #[inline] unsafe fn __getit(init: ::std::option::Option<&mut ::std::option::Option<::std::cell::Cell>>) -> ::std::option::Option<&'static ::std::cell::Cell> { #[thread_local] static __KEY: ::std::thread::local_impl::Key<::std::cell::Cell> = ::std::thread::local_impl::Key::<::std::cell::Cell>::new(); #[allow(unused_unsafe)] unsafe { __KEY.get(move || { if let ::std::option::Option::Some(init) = init { if let ::std::option::Option::Some(value) = init.take() { return value; } else if true { { ::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}", format_args!("missing default value"))); }; } } __init() }) } } unsafe { ::std::thread::LocalKey::new(__getit) } };