-version = 3

-name = "ahash"

-version = "0.8.7"

-checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"

- "cfg-if",

- "once_cell",

- "version_check",

- "zerocopy",

-name = "cfg-if"

-version = "1.0.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

-

-[[package]]

-version = "1.0.0-alpha.6"

-source = "git+https://github.com/zesterer/chumsky#8b8cf0a04b157df30799d4f385ddedc1dca85014"

-version = "0.14.3"

-checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"

- "ahash",

-version = "0.13.0"

-checksum = "c000ca4d908ff18ac99b93a062cb8958d331c3220719c52e77cb19cc6ac5d2c1"

-version = "0.13.0"

-checksum = "dc487311295e0002e452025d6b580b77bb17286de87b57138f3b5db711cded68"

-version = "0.13.0"

-checksum = "dbfc0d229f1f42d790440136d941afd806bc9e949e2bcb8faa813b0f00d1267e"

-name = "once_cell"

-version = "1.19.0"

-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"

-version = "0.6.29"

-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"

-name = "version_check"

-version = "0.9.4"

-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

-name = "zerocopy"

-version = "0.7.32"

-checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"

- "zerocopy-derive",

-name = "zerocopy-derive"

-version = "0.7.32"

-checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"

- "proc-macro2",

- "quote",

- "syn 2.0.48",

-chumsky = { git = "https://github.com/zesterer/chumsky", version = "1.0.0-alpha.6", features = [

- "label",

-logos = "0.13.0"

-use chumsky::span::SimpleSpan;

-

- #[regex(r"[^\s\(\)\[\]\{\}0-9λ'\-←→=≢≡🐢🦆✊🪣🔓🐘🍴🐈↖⤵️☎️🔭+×*√≠<≤>≥⏪⏩\-¯∧∨⊻÷%🔎🚧⬅➡⏭️➡️↘️🐋🐳][^\(\)\[\]\{\}λ←→=≢≡'🐢🐘🍴✊🐈↖⤵️+🪣×🔓*√🦆≠<≤>≥☎️🔭⏪⏩¯∧∨⊻÷%🔎🚧⬅➡⏭️➡️↘️🐋🐳\s]*", priority = 7)]

- "←" => Place,

- "→" => Ret,

- "🐢" => Dup,

- "🐘" => Both,

- "🍴" => Fork,

- "🪣" => Gap,

- "✊" => Hold,

- "🐈" => Flip,

- "🦆" => Duck,

- "↖" => Reverse,

- "≢" => Ne,

- "≤" => Le,

- "∧" => And,

- "⊻" => Xor,

- "🔓" => Keep,

- "⏭️" => Each,

- "➡️" => Reduce,

- "↘️" => ReduceStack,

- "⬆️" => Range,

- "🐳" => Else,

- "☎️" => Call,

- self.inner.find_map(|(x, s)| match x.ok()? {

- Token::Comment(_) => None,

- x => Some((x, SimpleSpan::new(s.start, s.end))),

- })

- 🐢≠'\n'🚧

- / run function on all values, pushing to the stack /

- ⏭️line

- / reduce the stack /

- ↘️+

-

- true 🐋 (+ 🐳 -)

- test! [String("1abc25hriwm4") Ident("line") Place Lambda OpeningBracket('(') Char('0') Gt Keep Char('9') Lt Keep Char('9') Sub Both First Last Int(10u64) Mul Add ClosingBracket(')') Dup Ne Ident("\\n") Split Each Ident("line") ReduceStack Add Ident("true") If OpeningBracket('(') Add Else Sub ClosingBracket(')') ]

-#![feature(iter_intersperse)]

- println!("Hello, world!");

-use chumsky::{

- input::{SpannedInput, Stream},

- prelude::*,

- Parser,

-};

- let inline_expr = recursive(|inline_expr| {

- let val = select! {

- Token::Int(x) => Expr::Value(Value::Int(x)),

- Token::Float(x) => Expr::Value(Value::Float(x)),

- Token::String(s) => Expr::Value(Value::String(s)),

- }

- .labelled("value");

-

- choice((t![ident].map(Expr::Ident), val)).boxed()

- });

- let decl = t![ident]

- .then_ignore(t![<-])

- .then(inline_expr.clone().or(λ.clone().map(Expr::Lambda)))

- .map(|(name, body)| Expr::Let {

- name,

- rhs: Box::new(body),

- })

- .labelled("declare")

- .boxed();

-

- let r#if = t![if]

- .ignore_then(

- expr.clone()

- .then(t![else].or_not().ignore_then(expr.clone().or_not()))

- .delimited_by(t!['('], t![')']),

- )

- .map(|(a, b)| Expr::If {

- then: Box::new(a),

- or: Box::new(b.unwrap_or_else(|| Expr::Value(Value::Unit))),

- })

- .labelled("🐋")

- .boxed();

- decl,

- r#if,

- λ.clone().map(Expr::Lambda),

- Function::parse(λ).map(Expr::Function),

- parse_s("a ← λ ( +- 🍴 )", Expr::parse());

- // dbg!(Expr::parse().parse(code("a ← λ ( +- 🍴 )")).unwrap());

-pub fn stream(lexer: Lexer<'_>, len: usize) -> SpannedInput<Token<'_>, Span, Stream<Lexer<'_>>> {

- Stream::from_iter(lexer).spanned((len..len).into())

-#[cfg(test)]

-pub fn code<'s>(x: &'s str) -> SpannedInput<Token<'s>, Span, Stream<Lexer<'s>>> {

-#[cfg(test)]

-

-pub fn parse(tokens: Lexer<'_>, len: usize) -> Result<Ast<'_>, Vec<Error<'_>>> {

- parser().parse(stream(tokens, len)).into_result()

-}

-

-fn parser<'s>() -> parser![Ast<'s>] {

- Expr::parse().repeated().collect().map(Ast::Module)

-}

- Both(Λ<'s>, Λ<'s>),

- Fork(Λ<'s>, Λ<'s>),

- Gap(Λ<'s>),

- Hold(Λ<'s>),

- Duck(Λ<'s>),

- Ne,

- Le,

- And,

- Keep,

- Each(Λ<'s>),

- ReduceStack(Λ<'s>),

- let mut λ = Recursive::declare();

- λ.define(choice((

- t![λ]

- .ignore_then(exp.repeated().collect().delimited_by(t!['('], t![')']))

- .map(|x| Self(x)),

- Function::parse(λ.clone()).map(|x| Λ(vec![Expr::Function(x)])),

- )));

- λ.labelled("λ")

- Token::Reverse => Reverse,

- Token::Ne => Ne,

- Token::Le => Le,

- Token::Gt => Gt,

- Token::Ge => Ge,

- Token::And => And,

- Token::Keep => Keep,

- };

- ($name:ident) => {{

- let mut p = Recursive::declare();

- p.define(

- λ.clone()

- .then(λ.clone())

- .then_ignore(just(Token::$name))

- .map(|(a, b)| $name(a, b)),

- );

- p

- }};

- choice((basic, two![Both], two![Fork]))

-use std::ops::Deref;

- input::{SpannedInput, Stream},

-use match_deref::match_deref;

-pub type Input<'s> = SpannedInput<Token<'s>, SimpleSpan, Stream<crate::lexer::Lexer<'s>>>;

-

-#[derive(Clone, Debug)]

- Self::Float(x) => write!(f, "{x}f"),

- Self::Int(x) => write!(f, "{x}i"),

-#[derive(Clone, Debug)]

- Let {

- name: &'s str,

- rhs: Box<Expr<'s>>,

- },

- If {

- then: Box<Expr<'s>>,

- or: Box<Expr<'s>>,

- },

- span: SimpleSpan::new(0, 0),

- just(Token::ThinArrow)

- let mut o = lerr::Error::new(code);

- o.label((e.span().into_range(), "here"));

- o.message(cmt!("{red}error{reset}: {x}"));

- o.message(cmt!("{red}error{reset}: {e}"));

- }

- RichReason::Many(x) => {

- match &x[..] {

- [x, rest @ ..] => {

- o.message(cmt!("{red}error{reset}: {x}"));

- for elem in rest {

- o.note(cmt!("{yellow}also{reset}: {elem}"));

- }

- }

- _ => unreachable!(),

- };

- }

- o.label((

- span.into_range(),

- cmt!("{yellow}while parsing this{reset}: {l}"),

- ));

- eprintln!("{o}");

-// usage: 0 🐢 λ(<5) λ(1+) 🐬☎️

-🐬 ← λ (

- / evaluate the condition /

- λ(🐢🪣☎️)✊✊

- 🐋 (

- / evaluate the body /

- 🐢☎️

- / recurse /

- 🐬☎️

- )

-)

-// { str → int }

-line ← λ (

- '0'>🔓'9'<🔓

- '9'-

- ⬅➡🍴

- 10×+

-)

-🐢≢'\n'🚧

-↘️+