+version = "0.2.21"

+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"

+source = "git+https://codeberg.org/zesterer/chumsky?rev=ba2122d298639b9ecbf3289392b90dae70a4b0ef#ba2122d298639b9ecbf3289392b90dae70a4b0ef"

+source = "git+https://github.com/brendanzab/codespan?rev=b563293#b56329354ce0ecbe4afe7c85f7b76417678a5ef8"

+version = "1.17.0"

+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"

+version = "0.1.5"

+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"

+version = "0.15.5"

+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"

+version = "0.2.189"

+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"

+version = "1.15.0"

+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"

+version = "1.13.3"

+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"

+version = "0.1.14"

+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"

+version = "0.1.11"

+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"

+name = "windows-link"

+version = "0.2.1"

+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

+name = "windows-sys"

+version = "0.61.2"

+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"

+ "windows-link",

+license = "MIT"

+description = "small interpreted stack-based array programming language"

+authors = ["bendn <[email protected]>"]

+repository = "https://git.bendn.org/kale"

+categories = ["compilers", "parser-implementations"]

+keywords = ["stack", "language", "array"]

+chumsky = { git = "https://codeberg.org/zesterer/chumsky", rev = "ba2122d298639b9ecbf3289392b90dae70a4b0ef", features = [

+codespan-reporting = { git = "https://github.com/brendanzab/codespan", rev = "b563293" }

+[package.metadata.docs.rs]

+rustdoc-args = ["--generate-link-to-definition"]

+MIT License

+

+Copyright (c) 2026 bendn

+

+Permission is hereby granted, free of charge, to any person obtaining a copy

+of this software and associated documentation files (the "Software"), to deal

+in the Software without restriction, including without limitation the rights

+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+copies of the Software, and to permit persons to whom the Software is

+furnished to do so, subject to the following conditions:

+

+The above copyright notice and this permission notice shall be included in all

+copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+SOFTWARE.

+# `kale`

+

+kale is a stack based left-to-right interpreted array programming language

+

+this means every value is immediately pushed to the stack

+and every function will pop items off of the stack

+there are a few functions for stack manipulation.

+

+kale operates with a inferred "type"ing system, as in each function declares it's "signature" (items popped off stack -> items pushed to stack) and it goes from there

+

+most arithmetic / basic operations is pervasive, meaning that when running an operation over an array, it will compare them by each individual value.

+

+so when comparing arrays to arrays you get an array of booleans; same for arrays and values. comparing a value to a value you will get a single value.

+

+comparisons are reversed, for intuition sake.

+[toolchain]

+channel = "nightly"

+use std::ops::{Add, Deref, DerefMut};

+ Val::from(array.get(0).ok_or_else(|| Error {

+ name: format!("array is empty"),

+ message: "here".to_string().spun(span),

+ ..Default::default()

+ })?)

+ .spun(span),

+ Val::from(array.get(array.len() - 1).ok_or_else(

+ || Error {

+ },

+ )?)

+ .spun(span),

+ assert_eq!(n, argc.output);

+ // .skip(n.saturating_sub(argc.output))

+#![allow(unexpected_cfgs, rustdoc::invalid_rust_codeblocks)]

+

+use crate::exec::Argc;

+use crate::parser::types::{Λ, *};

+

+ ($(

+ $(#[$attr:ident = $attrval:expr])*

+ $z:literal $( | $y:literal)? => $v:ident $($eq:literal @)? $(_ $expr:tt)?,)+

+ //&

+

+ //$(

+ //$(#[$fattr:ident = $fattrval:expr])*

+ //$fname:ident $expr:tt),* $(,)?

+ ) => {

+ pub enum Token<'strings> {

+ #[regex(r"[^\s\(\)\[\]\{\}⎬0-9@'\-←→=≢≡+×\|*√<\-¯∧∨⊻÷%]", priority = 7, callback = |lex| {

+ $(

+ $(#[$attr = $attrval])*

+ $(#[doc = concat!("link", stringify!($eq), " [`Function::" , stringify!($v), "`]\n")])?

+ #[doc=concat!("character: `", $z, "`")]

+ #[token($z, priority = 8)]

+ $(#[token($y, priority = 8)])?

+ $v,)+

+ impl <'s> Function<'s> {

+ pub(crate) fn basic() -> crate::parser::util::parser![Self] {

+ use chumsky::Parser;

+ chumsky::select! {

+ Token::Zap => Self::Zap(None),

+ Token::ClosingBracket('}') => Self::Setify,

+ Token::Ident(x) => Self::Ident(x),

+ $($(Token::$v => {stringify!($eq); Self::$v },)?)+

+ }.labelled("token")

+ }

+ }

+

+#[derive(Debug, Clone)]

+pub enum Function<'s> {

+ #[doc(hidden)]

+ Setify,

+ #[allow(dead_code)]

+ #[doc(hidden)]

+ If { then: Λ<'s>, or: Λ<'s> },

+ #[doc(hidden)]

+ Ident(&'s str),

+ #[doc(hidden)]

+ Define(&'s str),

+ // $($(#[$fattr = $fattrval])* $fname $expr,)*

+ $(

+ $(#[$attr = $attrval])*

+ $(#[doc = concat!("<h1>", $z, "</h1>")] #[cfg(not(target_family = $eq))] $v,)?

+ $(#[doc = concat!("<h1>", $z, "</h1>")] $v $expr,)?

+ )+

+ /// [n = drops n items.

+ ///

+ /// <h1>[</h1>

+ Take(u64),

+}

+

+ /// Create an array from n items off the stack:

+ /// ```

+ /// 1 2 3 4 ⎦4

+ /// ```

+ /// Produces an array of [1, 2, 3, 4]

+ "⎦" => Array _ (Option<u64>),

+ /// Array contains.

+ "∈" => In "0" @,

+

+

+ /// Duplicates the top value of the stack.

+ "^" => Dup "0" @,

+ /// Runs n functions on the same values in the stack, pulling y items where y is the maximum arguments of any of the functions.

+ "&" => And _ (Vec<Spanned<Λ<'s>>>),

+ /// Runs one function n times, with new stack items every time, where n is the number of instances of this symbol.

+ /// ```kale

+ /// 1 2 3 4 +|

+ /// / results in 7 3

+ /// ```

+ "|" => Both _ (Spanned<Λ<'s>>, usize),

+ /// Flips the top two values on the stack.

+ "🔀" => Flip "0" @,

+ /// Zaps the top value on the stack, or the nth value, if followed by a number.

+ "⤵️" | "⤵" => Zap _ (Option<u64>),

+ /// Pops an array off of the stack to use it as a stack.

+ "⬇️" | "⬇" => With _ (Spanned<Λ<'s>>),

+ /// Pops a number, creates an array from 0-n

+ "⏫" => Range "0" @,

+ // "🪪" => Type "0" @,

+ /// Pops an array, gets the length.

+ "📏" => Length "0" @,

+ /// Groups an array by a mask, grouping by the ones in the mask array.

+ /// ```kale

+ /// 5⏫^2≢👩‍👩‍👧‍👧

+ /// ```

+ /// Would split by two, producing [0, 1] and [3, 4].

+ "👩‍👩‍👧‍👧" => Group "0" @,

+ /// Pops a string, opens that file, producing an array of utf8 integers.

+ "📂" => Open "0" @,

+ "⏪" => Shl "0" @,

+ "⏩" => Shr "0" @,

+ /// Takes an array, index, removes the element in the array at that index.

+ "❎" => Del "0" @,

+ /// Sorts an array.

+ "📶" => Sort "0" @,

+ /// Given an array, and a mask, masks the array by the mask.

+ /// In other words, picks only the values for which are one in the mask.

+ /// ```

+ /// 10⏫^5<

+ /// 🔓

+ /// ```

+ /// Produces [0, 1, 2, 3, 4],

+ "🔓" => Mask "0" @,

+ /// Given an array of indexes, and an array, indexes the array by those indices.

+ "🔒" => Index "0" @,

+ "#️⃣🗺" => HashMap "0" @,

+ "≣#️⃣" => IndexHashMap "0" @,

+ "∅" => EmptySet "0" @,

+ /// Places a value in an array.

+ "💽" => Append "0" @,

+ /// Get first item in array.

+ "⬅️" | "⬅" => First "0" @,

+ /// Get last item in array.

+ "➡️" | "➡" => Last "0" @,

+ /// Reduce an array by a function.

+ "↘️" | "↘" => Reduce _ (Spanned<Λ<'s>>),

+ /// Scan an array by a function. So it reduces, keeping the product.

+ "↖️" | "↖" => Scan _ (Spanned<Λ<'s>>),

+ /// Fold an array by a function (note that the accumulator is taken after the array).

+ "⏭️" | "⏭" => Fold _ (Spanned<Λ<'s>>),

+ /// Map an array by a function.

+ "🗺" => Map _ (Spanned<Λ<'s>>),

+ /// Zip two arrays together.

+ "🇳🇿" => Zip "0" @,

+ /// Get the windows of an array.

+ "🪟" => Windows "0" @,

+ /// Debugs the stack at the current point in time.

+ "🧐" => Debug "0" @,

+ /// Takes one value, pushes one value.

+ "." => Identity "0" @,

+ /// Invoke python. Requires specifying the signature. In python land, the executor will be able to access a `s` variable, containing the stack. If the python does not satisfy the signature, an error will occur.

+ /// ```

+ /// 5 "s.append(s.pop()+1)"🐍1 → 1

+ /// ```

+ /// Produces six.

+ "🐍" => Python _ (Argc),

+

+

+ "≡" => Eq "0" @,

+ "≣" => Matches "0" @,

+ "≢" => Ne "0" @,

+ "+" => Add "0" @,

+ "-" => Sub "0" @,

+ "×" => Mul "0" @,

+ "ⁿ" => Pow "0" @,

+ "<" => Lt "0" @,

+ ">" => Gt "0" @,

+ "≤" => Le "0" @,

+ "≥" => Ge "0" @,

+ "÷" => Div "0" @,

+ "%" => Mod "0" @,

+ "∧" => BitAnd "0" @,

+ "∨" => Or "0" @,

+ "⊕" => Xor "0" @,

+ "!" => Not "0" @,

+ "¯" => Neg "0" @,

+ "√" => Sqrt "0" @,

+pub struct Lexer<'s> {

+ line ← "0" @(

+#![doc = include_str!("../README.md")]

+

+pub use lexer::Function;

+ pub(crate) fn parse(

+ pub(crate) fn parse(λ: parser![Λ<'s>]) -> parser![Self] {

+ Self::basic()

+ just(Token::Array)

+ Self::basic(),

+pub use crate::lexer::Function;

+ Function(Function<'s>),

+ impl chumsky::Parser<'s, crate::parser::types::Input<'s>, $t, chumsky::extra::Err<$crate::parser::types::Error<'s>>> + Clone + 's

+pub(crate) use parser;

+pub(crate) use spanned;

+pub(crate) use t;