add another lambda example

Parser had only consturctor and parse functions public.

Likely, there would be just a creation of parser followed by .parse(),
and now this action is performed in `parse` function.

Cargo.lock

@@ -3,19 +3,20 @@
 version = 3
 
 [[package]]
-name = "able-script"
-version = "0.1.0"
+name = "ablescript"
+version = "0.3.0"
 dependencies = [
- "clap",
+ "logos",
+ "rand",
 ]
 
 [[package]]
-name = "ansi_term"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+name = "ablescript_cli"
+version = "0.3.0"
 dependencies = [
- "winapi",
+ "ablescript",
+ "clap",
+ "rustyline",
 ]
 
 [[package]]
@@ -30,67 +31,502 @@ dependencies = [
 ]
 
 [[package]]
-name = "bitflags"
-version = "1.2.1"
+name = "autocfg"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "beef"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bed554bd50246729a1ec158d08aa3235d1b69d94ad120ebe187e28894787e736"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "clap"
-version = "2.33.3"
+version = "3.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+checksum = "71c47df61d9e16dc010b55dba1952a57d8c215dbb533fd13cdd13369aac73b1c"
 dependencies = [
- "ansi_term",
  "atty",
  "bitflags",
+ "indexmap",
+ "os_str_bytes",
  "strsim",
+ "termcolor",
  "textwrap",
- "unicode-width",
- "vec_map",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.18"
+name = "clipboard-win"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
+checksum = "2f3e1238132dc01f081e1cbb9dace14e5ef4c3a51ee244bd982275fb514605db"
+dependencies = [
+ "error-code",
+ "str-buf",
+ "winapi",
+]
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
+[[package]]
+name = "errno"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "error-code"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
+dependencies = [
+ "libc",
+ "str-buf",
+]
+
+[[package]]
+name = "fd-lock"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46e245f4c8ec30c6415c56cb132c07e69e74f1942f6b4a4061da748b49f486ca"
+dependencies = [
+ "cfg-if",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "getrandom"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 dependencies = [
  "libc",
 ]
 
 [[package]]
-name = "libc"
-version = "0.2.93"
+name = "indexmap"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9385f66bf6105b241aa65a61cb923ef20efc665cb9f9bb50ac2f0c4b7f378d41"
-
-[[package]]
-name = "strsim"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
-
-[[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
 dependencies = [
- "unicode-width",
+ "autocfg",
+ "hashbrown",
 ]
 
 [[package]]
-name = "unicode-width"
-version = "0.1.8"
+name = "io-lifetimes"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "9448015e586b611e5d322f6703812bbca2f1e709d5773ecd38ddb4e3bb649504"
 
 [[package]]
-name = "vec_map"
-version = "0.8.2"
+name = "libc"
+version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+checksum = "ec647867e2bf0772e28c8bcde4f0d19a9216916e890543b5a03ed8ef27b8f259"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5284f00d480e1c39af34e72f8ad60b94f47007e3481cd3b731c1d67190ddc7b7"
+
+[[package]]
+name = "log"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6389c490849ff5bc16be905ae24bc913a9c8892e19b2341dbc175e14c341c2b8"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "logos"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427e2abca5be13136da9afdbf874e6b34ad9001dd70f2b103b083a85daa7b345"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56a7d287fd2ac3f75b11f19a1c8a874a7d55744bd91f7a1b3e7cf87d4343c36d"
+dependencies = [
+ "beef",
+ "fnv",
+ "proc-macro2",
+ "quote",
+ "regex-syntax",
+ "syn",
+ "utf8-ranges",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "nix"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if",
+ "libc",
+ "memoffset",
+]
+
+[[package]]
+name = "os_str_bytes"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec757218438d5fda206afc041538b2f6d889286160d649a86a24d37e1235afd1"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+dependencies = [
+ "getrandom",
+ "redox_syscall",
+ "thiserror",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "rustix"
+version = "0.34.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96619609a54d638872db136f56941d34e2a00bb0acf3fa783a90d6b96a093ba2"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys",
+ "winapi",
+]
+
+[[package]]
+name = "rustyline"
+version = "9.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db7826789c0e25614b03e5a54a0717a86f9ff6e6e5247f92b369472869320039"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "clipboard-win",
+ "dirs-next",
+ "fd-lock",
+ "libc",
+ "log",
+ "memchr",
+ "nix",
+ "radix_trie",
+ "scopeguard",
+ "smallvec",
+ "unicode-segmentation",
+ "unicode-width",
+ "utf8parse",
+ "winapi",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "smallvec"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
+
+[[package]]
+name = "str-buf"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d44a3643b4ff9caf57abcee9c2c621d6c03d9135e0d8b589bd9afb5992cb176a"
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b683b2b825c8eef438b77c36a06dc262294da3d5a5813fac20da149241dcd44d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "thiserror"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "utf8-ranges"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 
 [[package]]
 name = "winapi"
@@ -108,8 +544,60 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "030b7ff91626e57a05ca64a07c481973cbb2db774e4852c9c7ca342408c6a99a"
+dependencies = [
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29277a4435d642f775f63c7d1faeb927adba532886ce0287bd985bffb16b6bca"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1145e1989da93956c68d1864f32fb97c8f561a8f89a5125f6a2b7ea75524e4b8"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4a09e3a0d4753b73019db171c1339cd4362c8c44baf1bcea336235e955954a6"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca64fcb0220d58db4c119e050e7af03c69e6f4f415ef69ec1773d9aab422d5a"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08cabc9f0066848fef4bc6a1c1668e6efce38b661d2aeec75d18d8617eebb5f1"

Cargo.toml

@@ -1,10 +1,6 @@
-[package]
-name = "able-script"
-version = "0.1.0"
-authors = ["able <abl3theabove@gmail.com>"]
-edition = "2018"
+[workspace]
+members = ["ablescript", "ablescript_cli"]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-clap="*"
+[profile.release]
+lto = true
+strip = true

LICENSE

@@ -1,7 +1,21 @@
-You can do whatever you want with this software assuming you meet the following conditions:
-1) Answer me why?
-2) Never attribute me
+MIT License
 
-You can do whatever you want with this license assuming you meet the following conditions:
-1) attribute me
-2) I (AbleTheAbove#3819 on discord) own you
+Copyright (c) 2021 AbleCorp
+
+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.

README.md

@@ -1,4 +1,19 @@
-# Ablescript
+# AbleScript
+![Build Status](https://img.shields.io/github/workflow/status/AbleCorp/able-script/Rust)
 ![Lines of code](https://img.shields.io/tokei/lines/github/abletheabove/able-script)
+![Discord](https://img.shields.io/discord/831368967385120810)
 
-Bravely going where some languages have gone before.
+[Able Script Book](https://ablecorp.us/able-script-the-book)
+
+Still better than Javascript ://
+
+## About
+Ablescript is designed to be bad.
+
+## Key Features
+- Brain Fuck functions
+- No floats
+- U is equal to -210
+- bannable variables
+- fuck you
+- constants

able-script-test/functio.able

@@ -1,4 +0,0 @@
-functio hello(words){
-  words print;
-}
-hello("wonk");

able-script-test/hello_world.able

@@ -1,2 +0,0 @@
-var hello = "world";
-hello print;

ablescript/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "ablescript"
+version = "0.3.0"
+authors = ["able <abl3theabove@gmail.com>"]
+edition = "2021"
+
+description = "The best programming language"
+license = "MIT"
+documentation = "https://ablecorp.us/able-script-the-book/"
+repository = "https://github.com/AbleCorp/able-script"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+logos = "0.12"
+rand = "0.8"

ablescript/src/ast.rs

@@ -0,0 +1,223 @@
+//! AbleScript's Abstract Syntax tree
+//!
+//! Statements are the type which is AST made of, as they
+//! express an effect.
+//!
+//! Expressions are just operations and they cannot be
+//! used as statements. Functions in AbleScript are in fact
+//! just plain subroutines and they do not return any value,
+//! so their calls are statements.
+
+use crate::{base_55::char2num, variables::Value};
+use std::{fmt::Debug, hash::Hash};
+
+type Span = std::ops::Range<usize>;
+
+#[derive(Clone)]
+pub struct Spanned<T> {
+    pub item: T,
+    pub span: Span,
+}
+
+impl<T> Spanned<T> {
+    pub fn new(item: T, span: Span) -> Self {
+        Self { item, span }
+    }
+}
+
+impl<T: Debug> Debug for Spanned<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if f.alternate() {
+            write!(f, "{:#?} @ {:?}", self.item, self.span)
+        } else {
+            write!(f, "{:?} @ {:?}", self.item, self.span)
+        }
+    }
+}
+
+impl<T: PartialEq> PartialEq for Spanned<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.item == other.item
+    }
+}
+
+impl<T: Hash> Hash for Spanned<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.item.hash(state);
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub struct Assignable {
+    pub ident: Spanned<String>,
+    pub kind: AssignableKind,
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum AssignableKind {
+    Variable,
+    Index { indices: Vec<Spanned<Expr>> },
+}
+
+pub struct InvalidAssignable;
+
+impl Assignable {
+    pub fn from_expr(expr: Spanned<Expr>) -> Result<Assignable, InvalidAssignable> {
+        match expr.item {
+            Expr::Variable(ident) => Ok(Assignable {
+                ident: Spanned::new(ident, expr.span),
+                kind: AssignableKind::Variable,
+            }),
+            Expr::Index { expr, index } => Self::from_index(*expr, *index),
+            _ => Err(InvalidAssignable),
+        }
+    }
+
+    fn from_index(
+        mut buf: Spanned<Expr>,
+        index: Spanned<Expr>,
+    ) -> Result<Assignable, InvalidAssignable> {
+        let mut indices = vec![index];
+        let ident = loop {
+            match buf.item {
+                Expr::Variable(ident) => break ident,
+                Expr::Index { expr, index } => {
+                    indices.push(*index);
+                    buf = *expr;
+                }
+                _ => return Err(InvalidAssignable),
+            }
+        };
+
+        indices.reverse();
+        Ok(Assignable {
+            ident: Spanned::new(ident, buf.span),
+            kind: AssignableKind::Index { indices },
+        })
+    }
+}
+
+pub type Block = Vec<Spanned<Stmt>>;
+
+/// A syntactic unit expressing an effect.
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum Stmt {
+    // Control flow
+    Unless {
+        cond: Spanned<Expr>,
+        body: Block,
+    },
+    Loop {
+        body: Block,
+    },
+    Break,
+    HopBack,
+
+    Dim {
+        ident: Spanned<String>,
+        init: Option<Spanned<Expr>>,
+    },
+    Assign {
+        assignable: Assignable,
+        value: Spanned<Expr>,
+    },
+
+    Functio {
+        ident: Spanned<String>,
+        body: Spanned<FunctioBody>,
+    },
+    BfFunctio {
+        ident: Spanned<String>,
+        body: Spanned<BfFunctioBody>,
+    },
+    Call {
+        expr: Spanned<Expr>,
+        args: Vec<Spanned<Expr>>,
+    },
+    Print(Spanned<Expr>),
+    Read(Assignable),
+    Melo(Spanned<String>),
+    Rlyeh,
+    Rickroll,
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub struct FunctioBody {
+    pub params: Vec<Spanned<String>>,
+    pub body: Block,
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub struct BfFunctioBody {
+    pub tape_len: Option<Spanned<Expr>>,
+    pub code: Vec<u8>,
+}
+
+/// Expression is parse unit which do not cause any effect,
+/// like math and logical operations or values.
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum Expr {
+    BinOp {
+        lhs: Box<Spanned<Expr>>,
+        rhs: Box<Spanned<Expr>>,
+        kind: BinOpKind,
+    },
+    Aint(Box<Spanned<Expr>>),
+    Literal(Literal),
+    Cart(Vec<(Spanned<Expr>, Spanned<Expr>)>),
+    Lambda(Spanned<FunctioBody>),
+    BfLambda(Box<Spanned<BfFunctioBody>>),
+    Index {
+        expr: Box<Spanned<Expr>>,
+        index: Box<Spanned<Expr>>,
+    },
+    Len(Box<Spanned<Expr>>),
+    Variable(String),
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum Literal {
+    Char(char),
+    Int(isize),
+    Str(String),
+}
+
+impl From<Literal> for Value {
+    fn from(lit: Literal) -> Self {
+        match lit {
+            Literal::Char(c) => Self::Int(char2num(c)),
+            Literal::Int(i) => Self::Int(i),
+            Literal::Str(s) => Self::Str(s),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum BinOpKind {
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Greater,
+    Less,
+    Equal,
+    NotEqual,
+}
+
+impl BinOpKind {
+    pub fn from_token(t: crate::lexer::Token) -> Result<Self, crate::error::ErrorKind> {
+        use crate::lexer::Token;
+
+        match t {
+            Token::Plus => Ok(Self::Add),
+            Token::Minus => Ok(Self::Subtract),
+            Token::Star => Ok(Self::Multiply),
+            Token::FwdSlash => Ok(Self::Divide),
+            Token::GreaterThan => Ok(Self::Greater),
+            Token::LessThan => Ok(Self::Less),
+            Token::Equals => Ok(Self::Equal),
+            Token::Aint => Ok(Self::NotEqual),
+            t => Err(crate::error::ErrorKind::UnexpectedToken(t)),
+        }
+    }
+}

ablescript/src/base_55.rs

@@ -0,0 +1,23 @@
+pub const fn char2num(c: char) -> isize {
+    match c {
+        ' ' => 0,
+        // NOTE(Able): Why does it jump to 53 here? MY REASONS ARE BEYOND YOUR UNDERSTANDING MORTAL
+        '/' => 53,
+        '\\' => 54,
+        '.' => 55,
+        'U' => -210,
+        'A'..='Z' => -(c as isize) + 64,
+        'a'..='z' => (c as isize) - 96,
+        _ => 0,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn str_to_base55() {
+        let chrs: Vec<isize> = "AbleScript".chars().map(char2num).collect();
+        assert_eq!(chrs, &[-1, 2, 12, 5, -19, 3, 18, 9, 16, 20]);
+    }
+}

ablescript/src/brian.rs

@@ -0,0 +1,454 @@
+//! A brainfuck interpreter capable of executing arbitrary code, with arbitrary inputs and outputs.
+//!
+//! If you just want to execute some simple brainfuck, check the [`interpret_with_io`] function.
+//!
+//! To construct the interpreter, use the [`from_ascii`] or [`from_ascii_with_input_buffer`] methods
+//! (or their variants that take a maximum tape size). The latter grants access to
+//! the method [`add_input`], which allows for the addition of input while the interpreter is running.
+//!
+//! [`from_ascii`]: Interpreter::from_ascii
+//! [`from_ascii_with_input_buffer`]: Interpreter::from_ascii_with_input_buffer
+//! [`add_input`]: Interpreter::add_input
+//!
+//! Finally, to run the interpreter, you can use the [`advance`], [`advance_until_io`], or [`interpret_with_output`] methods.
+//!
+//! [`advance`]: Interpreter::advance
+//! [`advance_until_io`]: Interpreter::advance_until_io
+//! [`interpret_with_output`]: Interpreter::interpret_with_output
+
+#![deny(missing_docs)]
+// Putting this here because we still don't use the entire capabilities of this module. ~~Alex
+#![allow(dead_code)]
+
+use std::{
+    collections::VecDeque,
+    error::Error,
+    fmt::Display,
+    io::{Read, Write},
+};
+
+// NOTE(Able): This is the brain fuck interface
+
+/// The default limit for the tape size. This is the value used by methods that don't take it as a parameter
+pub const DEFAULT_TAPE_SIZE_LIMIT: usize = 30_000;
+
+/// Mappings from integers to BF instructions
+pub const INSTRUCTION_MAPPINGS: &[u8] = b"[]+-,.<>";
+#[derive(Debug, Clone, PartialEq, Eq)]
+/// A brainfuck interpreter. Read the [module level documentation](self) for more
+pub struct Interpreter<'a, I> {
+    code: &'a [u8],
+    instr_ptr: usize,
+    tape: Vec<i8>,
+    data_ptr: usize,
+    tape_size_limit: usize,
+    input: I,
+}
+
+impl<'a> Interpreter<'a, InputBuffer> {
+    /// Construct an `Interpreter` from an ASCII string of code with an empty input buffer
+    /// This methods sets the tape size limit to [its default value](DEFAULT_TAPE_SIZE_LIMIT)
+    pub fn from_ascii_with_input_buffer(code: &'a [u8]) -> Self {
+        Self::from_ascii_with_input_buffer_and_tape_limit(code, DEFAULT_TAPE_SIZE_LIMIT)
+    }
+
+    /// Construct an `Interpreter` from an ASCII string of code with an empty input buffer,
+    /// setting the tape size limit to the specified value
+    pub fn from_ascii_with_input_buffer_and_tape_limit(
+        code: &'a [u8],
+        tape_size_limit: usize,
+    ) -> Self {
+        Self {
+            code,
+            instr_ptr: 0,
+            tape: Vec::new(),
+            data_ptr: 0,
+            tape_size_limit,
+            input: InputBuffer(VecDeque::new()),
+        }
+    }
+
+    /// Add a byte to the input buffer of this interpreter
+    pub fn add_input(&mut self, input: i8) {
+        self.input.0.push_back(input);
+    }
+}
+
+impl<'a, I: BootlegRead> Interpreter<'a, I> {
+    /// Construct an interpreter from an ASCII string of code, a source of input bytes, and a tape size limit
+    pub fn from_ascii_with_tape_limit(code: &'a [u8], input: I, tape_size_limit: usize) -> Self {
+        Self {
+            code,
+            instr_ptr: 0,
+            tape: Vec::new(),
+            data_ptr: 0,
+            tape_size_limit,
+            input,
+        }
+    }
+
+    /// Constructs an interpreter from an ASCII string of code, a source of input bytes, and [the default tape size limit](DEFAULT_TAPE_SIZE_LIMIT)
+    pub fn from_ascii(code: &'a [u8], input: I) -> Self {
+        Self::from_ascii_with_tape_limit(code, input, DEFAULT_TAPE_SIZE_LIMIT)
+    }
+
+    /// Advance the interpreter by one instruction.
+    /// A return value of Ok(None) indicates succesful termination of the interpreter
+    pub fn advance(&mut self) -> Result<Option<Status>, ProgramError> {
+        let &opcode = match self.code.get(self.instr_ptr) {
+            Some(opcode) => opcode,
+            None => return Ok(None),
+        };
+
+        match opcode {
+            b'>' => self.data_ptr += 1,
+
+            b'<' => {
+                self.data_ptr = self
+                    .data_ptr
+                    .checked_sub(1)
+                    .ok_or(ProgramError::DataPointerUnderflow)?;
+            }
+
+            b'+' => {
+                let val = self
+                    .get_or_resize_tape_mut()
+                    .ok_or(ProgramError::TapeSizeExceededLimit)?;
+                *val = val.wrapping_add(1)
+            }
+
+            b'-' => {
+                let val = self
+                    .get_or_resize_tape_mut()
+                    .ok_or(ProgramError::TapeSizeExceededLimit)?;
+                *val = val.wrapping_sub(1)
+            }
+
+            b'.' => {
+                self.instr_ptr += 1;
+                return Ok(Some(Status::Output(self.get_at_data_ptr())));
+            }
+
+            b',' => match self.input.bootleg_read() {
+                Ok(Some(num)) => {
+                    let cell = self
+                        .get_or_resize_tape_mut()
+                        .ok_or(ProgramError::TapeSizeExceededLimit)?;
+                    *cell = num;
+                }
+                Ok(None) => return Ok(Some(Status::NeedsInput)),
+                Err(_) => return Err(ProgramError::InputReadError),
+            },
+
+            b'[' => {
+                if self.get_at_data_ptr() == 0 {
+                    self.instr_ptr = self
+                        .get_matching_closing_bracket(self.instr_ptr)
+                        .ok_or(ProgramError::UnmatchedOpeningBracket)?
+                    //Instruction pointer will be incremented by 1 after the match
+                }
+            }
+
+            b']' => {
+                if self.get_at_data_ptr() != 0 {
+                    self.instr_ptr = self
+                        .get_matching_opening_bracket(self.instr_ptr)
+                        .ok_or(ProgramError::UnmatchedClosingBracket)?
+                    //Instruction pointer will be incremented by 1 after the match
+                }
+            }
+
+            _ => {} //brainfuck treats all characters it doesn't understand as comments
+        }
+
+        self.instr_ptr += 1;
+
+        Ok(Some(Status::Continue))
+    }
+
+    /// Advances the interpreter until the next IO operation. See [`advance`](Interpreter::advance)  
+    pub fn advance_until_io(&mut self) -> Result<Option<IoStatus>, ProgramError> {
+        while let Some(status) = self.advance()? {
+            match status {
+                Status::NeedsInput => return Ok(Some(IoStatus::NeedsInput)),
+                Status::Output(out) => return Ok(Some(IoStatus::Output(out))),
+                Status::Continue => continue,
+            }
+        }
+        Ok(None)
+    }
+
+    /// Executes the interpreter until it halts, writing all return values to the provided `Write` type.
+    /// For more granular control, use [`advance`](Interpreter::advance)
+    pub fn interpret_with_output<O: Write>(&mut self, mut output: O) -> Result<(), InterpretError> {
+        while let Some(status) = self.advance_until_io()? {
+            match status {
+                IoStatus::NeedsInput => return Err(InterpretError::EndOfInput),
+                IoStatus::Output(out) => match output.write(&[out as u8]) {
+                    Ok(0) => return Err(InterpretError::OutputBufferFull),
+                    Ok(_) => continue,
+                    Err(_) => return Err(InterpretError::OutputWriteError),
+                },
+            }
+        }
+        Ok(())
+    }
+
+    fn get_or_resize_tape_mut(&mut self) -> Option<&mut i8> {
+        if self.data_ptr > self.tape_size_limit {
+            return None;
+        }
+        if self.data_ptr >= self.tape.len() {
+            self.tape.resize(self.data_ptr + 1, 0);
+        }
+        Some(&mut self.tape[self.data_ptr])
+    }
+
+    fn get_at_data_ptr(&self) -> i8 {
+        //No need to resize the tape to read: if the tape doesn't extend that far already, it holds a value of 0
+        self.tape.get(self.data_ptr).copied().unwrap_or(0)
+    }
+
+    fn get_matching_closing_bracket(&mut self, opening: usize) -> Option<usize> {
+        self.code[opening..]
+            .iter()
+            .zip(opening..)
+            .scan(0, |counter, (char, index)| {
+                match char {
+                    b'[' => *counter += 1,
+                    b']' => *counter -= 1,
+                    _ => {}
+                };
+                Some((*counter, index))
+            })
+            .find_map(
+                |(counter, index)| {
+                    if counter == 0 {
+                        Some(index)
+                    } else {
+                        None
+                    }
+                },
+            )
+    }
+
+    fn get_matching_opening_bracket(&mut self, closing: usize) -> Option<usize> {
+        self.code[..closing + 1]
+            .iter()
+            .zip(0..closing + 1)
+            .rev()
+            .scan(0, |counter, (char, index)| {
+                match char {
+                    b']' => *counter += 1,
+                    b'[' => *counter -= 1,
+                    _ => {}
+                };
+                Some((*counter, index))
+            })
+            .find_map(
+                |(counter, index)| {
+                    if counter == 0 {
+                        Some(index)
+                    } else {
+                        None
+                    }
+                },
+            )
+    }
+}
+
+/// A convenience function for interpreting brainfuck code with a given input and output source.
+/// For more information, consult [the module level documentation](self)
+pub fn interpret_with_io<I: BootlegRead, O: Write>(
+    code: &[u8],
+    input: I,
+    output: O,
+) -> Result<(), InterpretError> {
+    Interpreter::from_ascii(code, input).interpret_with_output(output)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+///The result of advancing the interpreter by one step, assuming it didn't terminate
+pub enum Status {
+    NeedsInput,
+    Output(i8),
+    Continue,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// The result of advancing the interpreter until the next IO operation, assuming it didn't terminate
+pub enum IoStatus {
+    NeedsInput,
+    Output(i8),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// An error that occurred while the interpreter was advancing
+pub enum ProgramError {
+    DataPointerUnderflow,
+    InputReadError,
+    UnmatchedOpeningBracket,
+    UnmatchedClosingBracket,
+    TapeSizeExceededLimit,
+}
+
+impl Display for ProgramError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                ProgramError::DataPointerUnderflow => "data pointer underflow",
+                ProgramError::InputReadError => "input read error",
+                ProgramError::UnmatchedOpeningBracket => "unmatched `[`",
+                ProgramError::UnmatchedClosingBracket => "unmatched `]`",
+                ProgramError::TapeSizeExceededLimit => "tape size exceeded",
+            }
+        )
+    }
+}
+impl Error for ProgramError {}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// An error that occurred while the interpreter was being run start-to-end all in one go
+pub enum InterpretError {
+    ProgramError(ProgramError),
+    EndOfInput,
+    OutputBufferFull,
+    OutputWriteError,
+}
+
+impl Display for InterpretError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InterpretError::ProgramError(e) => write!(f, "program error: {}", e),
+            InterpretError::EndOfInput => write!(f, "unexpected end of input"),
+            InterpretError::OutputBufferFull => write!(f, "output buffer full"),
+            InterpretError::OutputWriteError => write!(f, "output write error"),
+        }
+    }
+}
+impl Error for InterpretError {}
+
+impl From<ProgramError> for InterpretError {
+    fn from(e: ProgramError) -> Self {
+        InterpretError::ProgramError(e)
+    }
+}
+
+/// A bootlegged version of the standard library's read trait, so as to allow the interpreter to be generic over any `Read`
+/// type, as well as over an input buffer.
+pub trait BootlegRead {
+    type Error;
+    fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error>;
+}
+
+impl<T: Read> BootlegRead for T {
+    type Error = std::io::Error;
+    fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error> {
+        let mut buffer = [0];
+        match self.read(&mut buffer) {
+            Ok(0) => Ok(None),
+            Ok(_) => Ok(Some(buffer[0] as i8)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/// A wrapper around a `VecDeque`, to be able to implement `BootlegRead` for it
+struct InputBuffer(VecDeque<i8>);
+impl BootlegRead for InputBuffer {
+    type Error = std::convert::Infallible;
+    fn bootleg_read(&mut self) -> Result<Option<i8>, Self::Error> {
+        Ok(self.0.pop_front())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adder() {
+        let mut interpreter = Interpreter {
+            code: b"[->+<]", //Source: https://en.wikipedia.org/wiki/Brainfuck
+            instr_ptr: 0,
+            tape: vec![10, 5],
+            data_ptr: 0,
+            tape_size_limit: DEFAULT_TAPE_SIZE_LIMIT,
+            input: std::io::empty(),
+        };
+
+        while let Some(status) = interpreter.advance_until_io().expect("Unexpected error") {
+            match status {
+                IoStatus::NeedsInput => panic!("Requested input in an IO-less program"),
+                IoStatus::Output(_) => panic!("Produced output in an IO-less program"),
+            }
+        }
+
+        assert_eq!(interpreter.tape, vec![0, 15]);
+    }
+
+    #[test]
+    fn hello_world() {
+        let mut interpreter = Interpreter::from_ascii(
+            b"++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.", 
+            std::io::empty(),
+        );
+
+        let mut string = Vec::new();
+        interpreter
+            .interpret_with_output(&mut string)
+            .expect("Failed to write to output buffer");
+        assert_eq!(string, b"Hello World!\n");
+    }
+
+    #[test]
+    fn with_input_buffer() {
+        let mut interpreter = Interpreter::from_ascii_with_input_buffer(b"+++++.>,[-<->].");
+        let output = match interpreter
+            .advance_until_io()
+            .expect("Unexpected error")
+            .expect("Unexpected termination")
+        {
+            IoStatus::NeedsInput => panic!("Unexpected input request"),
+            IoStatus::Output(out) => out,
+        };
+
+        assert_eq!(
+            interpreter.advance_until_io(),
+            Ok(Some(IoStatus::NeedsInput))
+        );
+
+        interpreter.add_input(output);
+
+        assert_eq!(
+            interpreter.advance_until_io(),
+            Ok(Some(IoStatus::Output(0)))
+        );
+        assert_eq!(interpreter.advance_until_io(), Ok(None));
+    }
+
+    #[test]
+    fn hit_tape_size_limit() {
+        let mut interpreter =
+            Interpreter::from_ascii_with_tape_limit(b"+>+>+>+>+>", std::io::empty(), 1);
+        let result = interpreter.interpret_with_output(std::io::sink());
+        assert_eq!(
+            result,
+            Err(InterpretError::ProgramError(
+                ProgramError::TapeSizeExceededLimit
+            ))
+        );
+    }
+
+    #[test]
+    fn positive_integer_overflow() {
+        interpret_with_io(b"+[+]", std::io::empty(), std::io::sink()).unwrap();
+    }
+
+    #[test]
+    fn negative_integer_overflow() {
+        interpret_with_io(b"-", std::io::empty(), std::io::sink()).unwrap();
+    }
+}

ablescript/src/consts.rs

@@ -0,0 +1,42 @@
+//! Number constants.
+
+use crate::variables::{Value, Variable};
+use std::collections::HashMap;
+
+pub const ANSWER: isize = 42;
+
+/// Initialize a HashMap between the constant names and values
+/// accessible from within AbleScript.
+pub fn ablescript_consts() -> HashMap<String, Variable> {
+    use Value::*;
+
+    [
+        ("TAU", Int(6)),                  // Circumference / radius
+        ("PI", Int(3)),                   // Deprecated, do not use
+        ("EULER", Int(3)),                // Mathematical constant e
+        ("MASS", Int(70)),                // @Kev#6900's weight in kilograms
+        ("PHI", Int(2)),                  // Golden ratio
+        ("WUA", Int(1)),                  // 1
+        ("EULERS_CONSTANT", Int(0)),      // ???
+        ("GRAVITY", Int(10)),             // Earth surface gravity, m/s
+        ("RNG", Int(12)),                 // Kixiron#5289 Randomly rolled dice
+        ("STD_RNG", Int(4)),              // The standard random number is 4 (https://xkcd.com/221/)
+        ("INF", Int(isize::max_value())), // The biggest number
+        ("INTERESSANT", Int(114514)),     // HTGAzureX1212.#5959 intéressant number
+        ("FUNNY", Int(69)),               // HTGAzureX1212.#5959 funny number
+        (
+            // Never gonna let you down
+            "NEVERGONNAGIVEYOUUP",
+            Str("1452251871514141792252515212116".to_owned()),
+        ),
+        ("OCTOTHORPE", Str("#".to_owned())), // It's an octothorpe
+        ("ANSWER", Int(ANSWER)),
+        ("nul", Nul),
+        ("always", Abool(crate::variables::Abool::Always)),
+        ("sometimes", Abool(crate::variables::Abool::Sometimes)),
+        ("never", Abool(crate::variables::Abool::Never)),
+    ]
+    .into_iter()
+    .map(|(name, value)| (name.to_owned(), Variable::from_value(value)))
+    .collect()
+}

ablescript/src/error.rs

@@ -0,0 +1,71 @@
+use crate::{brian::InterpretError, lexer::Token};
+use std::{fmt::Display, io, ops::Range};
+
+#[derive(Debug)]
+pub struct Error {
+    pub kind: ErrorKind,
+    pub span: Range<usize>,
+}
+
+#[derive(Debug)]
+pub enum ErrorKind {
+    UnexpectedEof,
+    UnexpectedToken(Token),
+    UnknownVariable(String),
+    MeloVariable(String),
+    TopLevelBreak,
+    BfInterpretError(InterpretError),
+    MismatchedArgumentError,
+    MissingLhs,
+    IOError(io::Error),
+}
+
+impl Error {
+    pub fn new(kind: ErrorKind, span: Range<usize>) -> Self {
+        Self { kind, span }
+    }
+
+    /// Create an UnexpectedEof error, where the EOF occurs at the
+    /// given index in the file.
+    pub fn unexpected_eof(index: usize) -> Self {
+        Self::new(ErrorKind::UnexpectedEof, index..index)
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Error at range {}-{}: {}",
+            self.span.start, self.span.end, self.kind
+        )
+    }
+}
+impl std::error::Error for Error {}
+
+impl Display for ErrorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ErrorKind::UnexpectedEof => write!(f, "unexpected end of file"),
+            ErrorKind::UnexpectedToken(Token::Melo) => write!(f, "unexpected marten"),
+            ErrorKind::UnexpectedToken(token) => write!(f, "unexpected token {:?}", token),
+            ErrorKind::UnknownVariable(name) => write!(f, "unknown identifier \"{}\"", name),
+            ErrorKind::MeloVariable(name) => write!(f, "banned variable \"{}\"", name),
+            ErrorKind::TopLevelBreak => write!(f, "can only `break` out of a loop"),
+            ErrorKind::BfInterpretError(err) => write!(f, "brainfuck error: {}", err),
+            // TODO: give concrete numbers here.
+            ErrorKind::MismatchedArgumentError => write!(f, "wrong number of function arguments"),
+            ErrorKind::MissingLhs => write!(f, "missing expression before binary operation"),
+            ErrorKind::IOError(err) => write!(f, "I/O error: {}", err),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Self {
+            kind: ErrorKind::IOError(e),
+            span: 0..0,
+        }
+    }
+}

ablescript/src/interpret.rs

@@ -0,0 +1,795 @@
+//! Expression evaluator and statement interpreter.
+//!
+//! To interpret a piece of AbleScript code, you first need to
+//! construct an [ExecEnv], which is responsible for storing the stack
+//! of local variable and function definitions accessible from an
+//! AbleScript snippet. You can then call [ExecEnv::eval_stmts] to
+//! evaluate or execute any number of expressions or statements.
+
+#![deny(missing_docs)]
+
+use crate::{
+    ast::{Assignable, AssignableKind, BfFunctioBody, Expr, FunctioBody, Spanned, Stmt},
+    consts::ablescript_consts,
+    error::{Error, ErrorKind},
+    variables::{Functio, Value, ValueRef, Variable},
+};
+use rand::random;
+use std::{
+    cmp::Ordering,
+    collections::{HashMap, VecDeque},
+    io::{stdin, stdout, Read, Write},
+    mem::take,
+    ops::Range,
+    process::exit,
+};
+
+/// An environment for executing AbleScript code.
+pub struct ExecEnv {
+    /// The stack, ordered such that `stack[stack.len() - 1]` is the
+    /// top-most (newest) stack frame, and `stack[0]` is the
+    /// bottom-most (oldest) stack frame.
+    stack: Vec<Scope>,
+
+    /// The `read` statement maintains a buffer of up to 7 bits,
+    /// because input comes from the operating system 8 bits at a time
+    /// (via stdin) but gets delivered to AbleScript 3 bits at a time
+    /// (via the `read` statement). We store each of those bits as
+    /// booleans to facilitate easy manipulation.
+    read_buf: VecDeque<bool>,
+}
+
+/// A set of visible variable and function definitions in a single
+/// stack frame.
+struct Scope {
+    /// The mapping from variable names to values.
+    variables: HashMap<String, Variable>,
+}
+
+impl Default for ExecEnv {
+    fn default() -> Self {
+        Self {
+            stack: vec![Default::default()],
+            read_buf: Default::default(),
+        }
+    }
+}
+
+impl Default for Scope {
+    fn default() -> Self {
+        Self {
+            variables: ablescript_consts(),
+        }
+    }
+}
+
+/// The reason a successful series of statements halted.
+enum HaltStatus {
+    /// We ran out of statements to execute.
+    Finished,
+
+    /// A `break` statement occurred at the given span, and was not
+    /// caught by a `loop` statement up to this point.
+    Break(Range<usize>),
+
+    /// A `hopback` statement occurred at the given span, and was not
+    /// caught by a `loop` statement up to this point.
+    Hopback(Range<usize>),
+}
+
+/// The number of bits the `read` statement reads at once from
+/// standard input.
+pub const READ_BITS: u8 = 3;
+
+impl ExecEnv {
+    /// Create a new Scope with no predefined variable definitions or
+    /// other information.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Create a new Scope with predefined variables
+    pub fn new_with_vars<I>(vars: I) -> Self
+    where
+        I: IntoIterator<Item = (String, Variable)>,
+    {
+        let scope = Scope {
+            variables: ablescript_consts().into_iter().chain(vars).collect(),
+        };
+
+        Self {
+            stack: vec![scope],
+            read_buf: Default::default(),
+        }
+    }
+
+    /// Execute a set of Statements in the root stack frame. Return an
+    /// error if one or more of the Stmts failed to evaluate, or if a
+    /// `break` or `hopback` statement occurred at the top level.
+    pub fn eval_stmts(&mut self, stmts: &[Spanned<Stmt>]) -> Result<(), Error> {
+        match self.eval_stmts_hs(stmts, false)? {
+            HaltStatus::Finished => Ok(()),
+            HaltStatus::Break(span) | HaltStatus::Hopback(span) => Err(Error {
+                // It's an error to issue a `break` outside of a
+                // `loop` statement.
+                kind: ErrorKind::TopLevelBreak,
+                span,
+            }),
+        }
+    }
+
+    /// The same as `eval_stmts`, but report "break" and "hopback"
+    /// exit codes as normal conditions in a HaltStatus enum, and
+    /// create a new stack frame if `stackframe` is true.
+    ///
+    /// `interpret`-internal code should typically prefer this
+    /// function over `eval_stmts`.
+    fn eval_stmts_hs(
+        &mut self,
+        stmts: &[Spanned<Stmt>],
+        stackframe: bool,
+    ) -> Result<HaltStatus, Error> {
+        let init_depth = self.stack.len();
+
+        if stackframe {
+            self.stack.push(Default::default());
+        }
+
+        let mut final_result = Ok(HaltStatus::Finished);
+        for stmt in stmts {
+            final_result = self.eval_stmt(stmt);
+            if !matches!(final_result, Ok(HaltStatus::Finished)) {
+                break;
+            }
+        }
+
+        if stackframe {
+            self.stack.pop();
+        }
+
+        // Invariant: stack size must have net 0 change.
+        debug_assert_eq!(self.stack.len(), init_depth);
+        final_result
+    }
+
+    /// Evaluate a functio body, returning its functio.
+    fn eval_functio_body(&self, body: &Spanned<FunctioBody>) -> Functio {
+        Functio::Able {
+            params: body
+                .item
+                .params
+                .iter()
+                .map(|ident| ident.item.to_owned())
+                .collect(),
+            body: body.item.body.to_owned(),
+        }
+    }
+
+    /// Evaluate a BF functio body, returning its functio or an error.
+    fn eval_bff_body(&self, body: &Spanned<BfFunctioBody>) -> Result<Functio, Error> {
+        Ok(Functio::Bf {
+            instructions: body.item.code.to_owned(),
+            tape_len: body
+                .item
+                .tape_len
+                .as_ref()
+                .map(|tape_len| self.eval_expr(tape_len).map(|v| v.into_isize() as usize))
+                .unwrap_or(Ok(crate::brian::DEFAULT_TAPE_SIZE_LIMIT))?,
+        })
+    }
+
+    /// Evaluate an Expr, returning its value or an error.
+    fn eval_expr(&self, expr: &Spanned<Expr>) -> Result<Value, Error> {
+        use crate::ast::BinOpKind::*;
+        use crate::ast::Expr::*;
+
+        Ok(match &expr.item {
+            BinOp { lhs, rhs, kind } => {
+                let lhs = self.eval_expr(lhs)?;
+                let rhs = self.eval_expr(rhs)?;
+                match kind {
+                    Add => lhs + rhs,
+                    Subtract => lhs - rhs,
+                    Multiply => lhs * rhs,
+                    Divide => lhs / rhs,
+                    Greater => Value::Abool((lhs > rhs).into()),
+                    Less => Value::Abool((lhs < rhs).into()),
+                    Equal => Value::Abool((lhs == rhs).into()),
+                    NotEqual => Value::Abool((lhs != rhs).into()),
+                }
+            }
+            Aint(expr) => !self.eval_expr(expr)?,
+            Literal(lit) => lit.clone().into(),
+            Lambda(body) => Value::Functio(self.eval_functio_body(body)),
+            BfLambda(body) => Value::Functio(self.eval_bff_body(body)?),
+            Expr::Cart(members) => Value::Cart(
+                members
+                    .iter()
+                    .map(|(value, key)| {
+                        self.eval_expr(value).and_then(|value| {
+                            self.eval_expr(key).map(|key| (key, ValueRef::new(value)))
+                        })
+                    })
+                    .collect::<Result<HashMap<_, _>, _>>()?,
+            ),
+            Index { expr, index } => {
+                let value = self.eval_expr(expr)?;
+                let index = self.eval_expr(index)?;
+
+                value
+                    .into_cart()
+                    .get(&index)
+                    .map(|x| x.borrow().clone())
+                    .unwrap_or(Value::Nul)
+            }
+            Len(expr) => Value::Int(self.eval_expr(expr)?.length()),
+
+            // TODO: not too happy with constructing an artificial
+            // Ident here.
+            Variable(name) => self.get_var(&Spanned::new(name.to_owned(), expr.span.clone()))?,
+        })
+    }
+
+    /// Perform the action indicated by a statement.
+    fn eval_stmt(&mut self, stmt: &Spanned<Stmt>) -> Result<HaltStatus, Error> {
+        match &stmt.item {
+            Stmt::Print(expr) => {
+                println!("{}", self.eval_expr(expr)?);
+            }
+            Stmt::Dim { ident, init } => {
+                let init = match init {
+                    Some(e) => self.eval_expr(e)?,
+                    None => Value::Nul,
+                };
+
+                self.decl_var(&ident.item, init);
+            }
+            Stmt::Functio { ident, body } => {
+                self.decl_var(&ident.item, Value::Functio(self.eval_functio_body(body)));
+            }
+            Stmt::BfFunctio { ident, body } => {
+                self.decl_var(&ident.item, Value::Functio(self.eval_bff_body(body)?));
+            }
+            Stmt::Unless { cond, body } => {
+                if !self.eval_expr(cond)?.into_abool().to_bool() {
+                    return self.eval_stmts_hs(body, true);
+                }
+            }
+            Stmt::Call { expr, args } => {
+                let func = self.eval_expr(expr)?.into_functio();
+
+                self.fn_call(func, args, &stmt.span)?;
+            }
+            Stmt::Loop { body } => loop {
+                let res = self.eval_stmts_hs(body, true)?;
+                match res {
+                    HaltStatus::Finished => {}
+                    HaltStatus::Break(_) => break,
+                    HaltStatus::Hopback(_) => continue,
+                }
+            },
+            Stmt::Assign { assignable, value } => {
+                self.assign(assignable, self.eval_expr(value)?)?;
+            }
+            Stmt::Break => {
+                return Ok(HaltStatus::Break(stmt.span.clone()));
+            }
+            Stmt::HopBack => {
+                return Ok(HaltStatus::Hopback(stmt.span.clone()));
+            }
+            Stmt::Melo(ident) => {
+                self.get_var_mut(ident)?.melo = true;
+            }
+            Stmt::Rlyeh => {
+                // Maybe print a creepy error message or something
+                // here at some point. ~~Alex
+                exit(random());
+            }
+            Stmt::Rickroll => {
+                stdout()
+                    .write_all(include_str!("rickroll").as_bytes())
+                    .expect("Failed to write to stdout");
+            }
+            Stmt::Read(assignable) => {
+                let mut value = 0;
+                for _ in 0..READ_BITS {
+                    value <<= 1;
+                    value += self.get_bit()? as isize;
+                }
+
+                self.assign(assignable, Value::Int(value))?;
+            }
+        }
+
+        Ok(HaltStatus::Finished)
+    }
+
+    /// Assign a value to an Assignable.
+    fn assign(&mut self, dest: &Assignable, value: Value) -> Result<(), Error> {
+        match dest.kind {
+            AssignableKind::Variable => {
+                self.get_var_mut(&dest.ident)?.value.replace(value);
+            }
+            AssignableKind::Index { ref indices } => {
+                let mut cell = self.get_var_rc(&dest.ident)?;
+                for index in indices {
+                    let index = self.eval_expr(index)?;
+
+                    let next_cell = match &mut *cell.borrow_mut() {
+                        Value::Cart(c) => {
+                            // cell is a cart, so we can do simple
+                            // indexing.
+                            if let Some(x) = c.get(&index) {
+                                // cell[index] exists, get a shared
+                                // reference to it.
+                                ValueRef::clone(x)
+                            } else {
+                                // cell[index] does not exist, so we
+                                // insert an empty cart by default
+                                // instead.
+                                let next_cell = ValueRef::new(Value::Cart(Default::default()));
+                                c.insert(index, ValueRef::clone(&next_cell));
+                                next_cell
+                            }
+                        }
+                        x => {
+                            // cell is not a cart; `take` it, convert
+                            // it into a cart, and write the result
+                            // back into it.
+                            let mut cart = take(x).into_cart();
+                            let next_cell = ValueRef::new(Value::Cart(Default::default()));
+                            cart.insert(index, ValueRef::clone(&next_cell));
+                            *x = Value::Cart(cart);
+                            next_cell
+                        }
+                    };
+                    cell = next_cell;
+                }
+                cell.replace(value);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Call a function with the given arguments (i.e., actual
+    /// parameters). If the function invocation fails for some reason,
+    /// report the error at `span`.
+    fn fn_call(
+        &mut self,
+        func: Functio,
+        args: &[Spanned<Expr>],
+        span: &Range<usize>,
+    ) -> Result<(), Error> {
+        // Arguments that are ExprKind::Variable are pass by
+        // reference; all other expressions are pass by value.
+        let args = args
+            .iter()
+            .map(|arg| {
+                if let Expr::Variable(name) = &arg.item {
+                    self.get_var_rc(&Spanned::new(name.to_owned(), arg.span.clone()))
+                } else {
+                    self.eval_expr(arg).map(ValueRef::new)
+                }
+            })
+            .collect::<Result<Vec<_>, Error>>()?;
+
+        self.fn_call_with_values(func, &args, span)
+    }
+
+    fn fn_call_with_values(
+        &mut self,
+        func: Functio,
+        args: &[ValueRef],
+        span: &Range<usize>,
+    ) -> Result<(), Error> {
+        match func {
+            Functio::Bf {
+                instructions,
+                tape_len,
+            } => {
+                let mut input: Vec<u8> = vec![];
+                for arg in args {
+                    arg.borrow().bf_write(&mut input);
+                }
+
+                let mut output = vec![];
+
+                crate::brian::Interpreter::from_ascii_with_tape_limit(
+                    &instructions,
+                    &input as &[_],
+                    tape_len,
+                )
+                .interpret_with_output(&mut output)
+                .map_err(|e| Error {
+                    kind: ErrorKind::BfInterpretError(e),
+                    span: span.to_owned(),
+                })?;
+
+                stdout()
+                    .write_all(&output)
+                    .expect("Failed to write to stdout");
+            }
+            Functio::Able { params, body } => {
+                if params.len() != args.len() {
+                    return Err(Error {
+                        kind: ErrorKind::MismatchedArgumentError,
+                        span: span.to_owned(),
+                    });
+                }
+
+                self.stack.push(Default::default());
+
+                for (param, arg) in params.iter().zip(args.iter()) {
+                    self.decl_var_shared(param, arg.to_owned());
+                }
+
+                let res = self.eval_stmts_hs(&body, false);
+
+                self.stack.pop();
+                res?;
+            }
+            Functio::Builtin(b) => b.call(args).map_err(|e| Error::new(e, span.clone()))?,
+            Functio::Chain { functios, kind } => {
+                let (left_functio, right_functio) = *functios;
+                match kind {
+                    crate::variables::FunctioChainKind::Equal => {
+                        let (l, r) = args.split_at(args.len() / 2);
+
+                        self.fn_call_with_values(left_functio, l, span)?;
+                        self.fn_call_with_values(right_functio, r, span)?;
+                    }
+                    crate::variables::FunctioChainKind::ByArity => {
+                        let (l, r) =
+                            Self::deinterlace(args, (left_functio.arity(), right_functio.arity()));
+
+                        self.fn_call_with_values(left_functio, &l, span)?;
+                        self.fn_call_with_values(right_functio, &r, span)?;
+                    }
+                };
+            }
+            Functio::Eval(code) => {
+                if !args.is_empty() {
+                    return Err(Error {
+                        kind: ErrorKind::MismatchedArgumentError,
+                        span: span.to_owned(),
+                    });
+                }
+
+                let stmts = crate::parser::parse(&code)?;
+                self.eval_stmts(&stmts)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn deinterlace(args: &[ValueRef], arities: (usize, usize)) -> (Vec<ValueRef>, Vec<ValueRef>) {
+        let n_alternations = usize::min(arities.0, arities.1);
+        let (extra_l, extra_r) = match Ord::cmp(&arities.0, &arities.1) {
+            Ordering::Less => (0, arities.1 - arities.0),
+            Ordering::Equal => (0, 0),
+            Ordering::Greater => (arities.0 - arities.1, 0),
+        };
+
+        (
+            args.chunks(2)
+                .take(n_alternations)
+                .map(|chunk| ValueRef::clone(&chunk[0]))
+                .chain(
+                    args[2 * n_alternations..]
+                        .iter()
+                        .map(ValueRef::clone)
+                        .take(extra_l),
+                )
+                .collect(),
+            args.chunks(2)
+                .take(n_alternations)
+                .map(|chunk| ValueRef::clone(&chunk[1]))
+                .chain(
+                    args[2 * n_alternations..]
+                        .iter()
+                        .map(ValueRef::clone)
+                        .take(extra_r),
+                )
+                .collect(),
+        )
+    }
+
+    /// Get a single bit from the bit buffer, or refill it from
+    /// standard input if it is empty.
+    fn get_bit(&mut self) -> Result<bool, Error> {
+        const BITS_PER_BYTE: u8 = 8;
+
+        if self.read_buf.is_empty() {
+            let mut data = [0];
+            stdin().read_exact(&mut data)?;
+
+            for n in (0..BITS_PER_BYTE).rev() {
+                self.read_buf.push_back(((data[0] >> n) & 1) != 0);
+            }
+        }
+
+        Ok(self
+            .read_buf
+            .pop_front()
+            .expect("We just pushed to the buffer if it was empty"))
+    }
+
+    /// Get the value of a variable. Throw an error if the variable is
+    /// inaccessible or banned.
+    fn get_var(&self, name: &Spanned<String>) -> Result<Value, Error> {
+        // Search for the name in the stack from top to bottom.
+        match self
+            .stack
+            .iter()
+            .rev()
+            .find_map(|scope| scope.variables.get(&name.item))
+        {
+            Some(var) => {
+                if !var.melo {
+                    Ok(var.value.borrow().clone())
+                } else {
+                    Err(Error {
+                        kind: ErrorKind::MeloVariable(name.item.to_owned()),
+                        span: name.span.clone(),
+                    })
+                }
+            }
+            None => Err(Error {
+                kind: ErrorKind::UnknownVariable(name.item.to_owned()),
+                span: name.span.clone(),
+            }),
+        }
+    }
+
+    /// Get a mutable reference to a variable. Throw an error if the
+    /// variable is inaccessible or banned.
+    fn get_var_mut(&mut self, name: &Spanned<String>) -> Result<&mut Variable, Error> {
+        // This function has a lot of duplicated code with `get_var`,
+        // which I feel like is a bad sign...
+        match self
+            .stack
+            .iter_mut()
+            .rev()
+            .find_map(|scope| scope.variables.get_mut(&name.item))
+        {
+            Some(var) => {
+                if !var.melo {
+                    Ok(var)
+                } else {
+                    Err(Error {
+                        kind: ErrorKind::MeloVariable(name.item.to_owned()),
+                        span: name.span.clone(),
+                    })
+                }
+            }
+            None => Err(Error {
+                kind: ErrorKind::UnknownVariable(name.item.to_owned()),
+                span: name.span.clone(),
+            }),
+        }
+    }
+
+    /// Get an Rc'd pointer to the value of a variable. Throw an error
+    /// if the variable is inaccessible or banned.
+    fn get_var_rc(&mut self, name: &Spanned<String>) -> Result<ValueRef, Error> {
+        Ok(self.get_var_mut(name)?.value.clone())
+    }
+
+    /// Declare a new variable, with the given initial value.
+    fn decl_var(&mut self, name: &str, value: Value) {
+        self.decl_var_shared(name, ValueRef::new(value));
+    }
+
+    /// Declare a new variable, with the given shared initial value.
+    fn decl_var_shared(&mut self, name: &str, value: ValueRef) {
+        self.stack
+            .iter_mut()
+            .last()
+            .expect("Declaring variable on empty stack")
+            .variables
+            .insert(name.to_owned(), Variable { melo: false, value });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::{Expr, Literal};
+
+    #[test]
+    fn basic_expression_test() {
+        // Check that 2 + 2 = 4.
+        let env = ExecEnv::new();
+        assert_eq!(
+            env.eval_expr(&Spanned {
+                item: Expr::BinOp {
+                    lhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(2)),
+                        span: 1..1,
+                    }),
+                    rhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(2)),
+                        span: 1..1,
+                    }),
+                    kind: crate::ast::BinOpKind::Add,
+                },
+                span: 1..1
+            })
+            .unwrap(),
+            Value::Int(4)
+        )
+    }
+
+    #[test]
+    fn type_coercions() {
+        // The sum of an integer and an aboolean causes an aboolean
+        // coercion.
+
+        let env = ExecEnv::new();
+        assert_eq!(
+            env.eval_expr(&Spanned {
+                item: Expr::BinOp {
+                    lhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(2)),
+                        span: 1..1,
+                    }),
+                    rhs: Box::new(Spanned {
+                        item: Expr::Variable("always".to_owned()),
+                        span: 1..1,
+                    }),
+                    kind: crate::ast::BinOpKind::Add,
+                },
+                span: 1..1
+            })
+            .unwrap(),
+            Value::Int(3)
+        );
+    }
+
+    #[test]
+    fn overflow_should_not_panic() {
+        // Integer overflow should throw a recoverable error instead
+        // of panicking.
+        let env = ExecEnv::new();
+        assert_eq!(
+            env.eval_expr(&Spanned {
+                item: Expr::BinOp {
+                    lhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(isize::MAX)),
+                        span: 1..1,
+                    }),
+                    rhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(1)),
+                        span: 1..1,
+                    }),
+                    kind: crate::ast::BinOpKind::Add,
+                },
+                span: 1..1
+            })
+            .unwrap(),
+            Value::Int(-9223372036854775808)
+        );
+
+        // And the same for divide by zero.
+        assert_eq!(
+            env.eval_expr(&Spanned {
+                item: Expr::BinOp {
+                    lhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(84)),
+                        span: 1..1,
+                    }),
+                    rhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(0)),
+                        span: 1..1,
+                    }),
+                    kind: crate::ast::BinOpKind::Divide,
+                },
+                span: 1..1
+            })
+            .unwrap(),
+            Value::Int(2)
+        );
+    }
+
+    // From here on out, I'll use this function to parse and run
+    // expressions, because writing out abstract syntax trees by hand
+    // takes forever and is error-prone.
+    fn eval(env: &mut ExecEnv, src: &str) -> Result<Value, Error> {
+        // We can assume there won't be any syntax errors in the
+        // interpreter tests.
+        let ast = crate::parser::parse(src).unwrap();
+        env.eval_stmts(&ast).map(|()| Value::Nul)
+    }
+
+    #[test]
+    fn variable_decl_and_assignment() {
+        // Functions have no return values, so use some
+        // pass-by-reference hacks to detect the correct
+        // functionality.
+        let mut env = ExecEnv::new();
+
+        // Declaring and reading from a variable.
+        eval(&mut env, "dim foo 32; dim bar foo + 1;").unwrap();
+        assert_eq!(
+            env.get_var(&Spanned {
+                item: "bar".to_owned(),
+                span: 1..1,
+            })
+            .unwrap(),
+            Value::Int(33)
+        );
+
+        // Assigning an existing variable.
+        eval(&mut env, "/*hi*/ =: foo;").unwrap();
+        assert_eq!(
+            env.get_var(&Spanned {
+                item: "foo".to_owned(),
+                span: 1..1,
+            })
+            .unwrap(),
+            Value::Str("hi".to_owned())
+        );
+
+        // But variable assignment should be illegal when the variable
+        // hasn't been declared in advance.
+        eval(&mut env, "bar + 1 =: invalid;").unwrap_err();
+    }
+
+    #[test]
+    fn scope_visibility_rules() {
+        // Declaration and assignment of variables declared in an `if`
+        // statement should have no effect on those declared outside
+        // of it.
+        let mut env = ExecEnv::new();
+        eval(
+            &mut env,
+            "dim foo 1; 2 =: foo; unless (never) { dim foo 3; 4 =: foo; }",
+        )
+        .unwrap();
+
+        assert_eq!(
+            env.get_var(&Spanned {
+                item: "foo".to_owned(),
+                span: 1..1,
+            })
+            .unwrap(),
+            Value::Int(2)
+        );
+    }
+
+    #[test]
+    fn lambdas() {
+        let mut env = ExecEnv::new();
+
+        // Lambda call from a variable.
+        eval(
+            &mut env,
+            r#"
+            dim foo 1;
+            dim to2 λ (var) { 2 =: var; };
+            to2(foo);
+            "#,
+        )
+        .unwrap();
+        assert_eq!(
+            env.get_var(&Spanned {
+                item: "foo".to_owned(),
+                span: 1..1,
+            })
+            .unwrap(),
+            Value::Int(2),
+        );
+
+        // Inline lambda call.
+        eval(&mut env, "(λ (var) { 3 =: var; })(foo);").unwrap();
+        assert_eq!(
+            env.get_var(&Spanned {
+                item: "foo".to_owned(),
+                span: 1..1,
+            })
+            .unwrap(),
+            Value::Int(3),
+        );
+    }
+}

ablescript/src/lexer.rs

@@ -0,0 +1,194 @@
+use logos::{Lexer, Logos};
+
+#[derive(Logos, Debug, PartialEq, Clone)]
+pub enum Token {
+    // Symbols
+    #[token("(")]
+    LeftParen,
+
+    #[token(")")]
+    RightParen,
+
+    #[token("[")]
+    LeftBracket,
+
+    #[token("]")]
+    RightBracket,
+
+    #[token("{")]
+    LeftCurly,
+
+    #[token("}")]
+    RightCurly,
+
+    #[token(";")]
+    Semicolon,
+
+    #[token(",")]
+    Comma,
+
+    // Operators
+    #[token("+")]
+    Plus,
+
+    #[token("-")]
+    Minus,
+
+    #[token("*")]
+    Star,
+
+    #[token("/")]
+    FwdSlash,
+
+    #[token("=:")]
+    Assign,
+
+    #[token("<=")]
+    Arrow,
+
+    // Logical operators
+    #[token("<")]
+    LessThan,
+
+    #[token(">")]
+    GreaterThan,
+
+    #[token("=")]
+    Equals,
+
+    #[token("ain't")]
+    Aint,
+
+    // Keywords
+    #[token("functio")]
+    Functio,
+
+    /// Brain fuck FFI
+    #[token("bff")]
+    Bff,
+
+    /// Lambda
+    #[token("λ")]
+    Lambda,
+
+    /// BFF but lambda
+    #[token("bfλ")]
+    BfLambda,
+
+    /// Variable bro
+    #[token("dim")]
+    Dim,
+
+    /// Prints the preceding things
+    #[token("print")]
+    Print,
+
+    /// Read input into preceding variable
+    #[token("read")]
+    Read,
+
+    /// Ban the following variable from ever being used again
+    #[token("melo")]
+    Melo,
+
+    #[token("T-Dark")]
+    TDark,
+
+    // Control flow keywords
+    #[token("unless")]
+    Unless,
+
+    #[token("loop")]
+    Loop,
+
+    #[token("break")]
+    Break,
+
+    /// HopBack hops on the back of loop - like `continue`
+    #[token("hopback")]
+    HopBack,
+
+    /// Crash with random error (see discussion #17)
+    #[token("rlyeh")]
+    Rlyeh,
+
+    #[token("rickroll")]
+    Rickroll,
+
+    // Literals
+    /// String
+    #[token("/*", get_string)]
+    String(String),
+
+    /// Integer
+    #[regex(r"-?[0-9]+", get_value)]
+    Integer(isize),
+
+    // A character (to be base-55 converted)
+    #[regex(r"\p{XID_Start}", get_value)]
+    Char(char),
+
+    /// An identifier
+    #[regex(r"\p{XID_Start}[\p{XID_Continue}]+", get_ident)]
+    Identifier(String),
+
+    #[regex(r"owo .*")]
+    Comment,
+
+    #[regex(r"[ \t\n\f]+", logos::skip)]
+    #[error]
+    Error,
+}
+
+fn get_value<T: std::str::FromStr>(lexer: &mut Lexer<Token>) -> Option<T> {
+    lexer.slice().parse().ok()
+}
+
+fn get_string(lexer: &mut Lexer<Token>) -> Option<String> {
+    lexer.bump(lexer.remainder().find("*/")?);
+    let string = lexer.slice()[2..].to_owned();
+    lexer.bump(2);
+
+    Some(string)
+}
+
+fn get_ident(lexer: &mut Lexer<Token>) -> String {
+    lexer.slice().to_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Token;
+    use super::Token::*;
+    use logos::Logos;
+
+    #[test]
+    fn simple_fn() {
+        let code = "functio test() { dim var 3; unless (var ain't 3) { var print } }";
+        let expected = &[
+            Functio,
+            Identifier("test".to_owned()),
+            LeftParen,
+            RightParen,
+            LeftCurly,
+            Dim,
+            Identifier("var".to_owned()),
+            Integer(3),
+            Semicolon,
+            Unless,
+            LeftParen,
+            Identifier("var".to_owned()),
+            Aint,
+            Integer(3),
+            RightParen,
+            LeftCurly,
+            Identifier("var".to_owned()),
+            Print,
+            RightCurly,
+            RightCurly,
+        ];
+        let lexer = Token::lexer(code);
+        let result: Vec<Token> = lexer.collect();
+        assert_eq!(result, expected);
+    }
+}

ablescript/src/lib.rs

@@ -0,0 +1,13 @@
+#![doc = include_str!("../../README.md")]
+#![forbid(unsafe_code, clippy::unwrap_used)]
+
+pub mod ast;
+pub mod error;
+pub mod interpret;
+pub mod parser;
+pub mod variables;
+
+mod base_55;
+mod brian;
+mod consts;
+mod lexer;

ablescript/src/parser.rs

@@ -0,0 +1,897 @@
+//! AbleScript Parser
+//!
+//! Type of this parser is recursive descent
+
+use crate::ast::*;
+use crate::error::{Error, ErrorKind};
+use crate::lexer::Token;
+use logos::{Lexer, Logos};
+
+/// Parser structure which holds lexer and metadata
+///
+/// Make one using [`Parser::new`] function
+struct Parser<'source> {
+    lexer: Lexer<'source, Token>,
+    tdark: bool,
+}
+
+impl<'source> Parser<'source> {
+    /// Create a new parser from source code
+    fn new(source: &'source str) -> Self {
+        Self {
+            lexer: Token::lexer(source),
+            tdark: false,
+        }
+    }
+
+    /// Start parsing tokens
+    ///
+    /// Loops trough lexer, parses statements, returns AST
+    fn parse(&mut self) -> Result<Block, Error> {
+        let mut ast = vec![];
+        while let Some(token) = self.lexer.next() {
+            match token {
+                // Ignore comments
+                Token::Comment => continue,
+
+                // T-Dark block (replace `lang` with `script`)
+                Token::TDark => ast.extend(self.tdark_flow()?),
+                token => ast.push(self.parse_stmt(token)?),
+            }
+        }
+        Ok(ast)
+    }
+
+    /// Get next item
+    ///
+    /// If EOF, return Error instead of None
+    fn checked_next(&mut self) -> Result<Token, Error> {
+        loop {
+            match self
+                .lexer
+                .next()
+                .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?
+            {
+                Token::Comment => (),
+                token => break Ok(token),
+            }
+        }
+    }
+
+    /// Parse a token
+    ///
+    /// This function will route to corresponding flow functions
+    /// which may advance the lexer iterator
+    fn parse_stmt(&mut self, token: Token) -> Result<Spanned<Stmt>, Error> {
+        let start = self.lexer.span().start;
+
+        match token {
+            Token::Unless => Ok(Spanned::new(
+                self.unless_flow()?,
+                start..self.lexer.span().end,
+            )),
+            Token::Functio => Ok(Spanned::new(
+                self.functio_flow()?,
+                start..self.lexer.span().end,
+            )),
+            Token::Bff => Ok(Spanned::new(self.bff_flow()?, start..self.lexer.span().end)),
+            Token::Dim => Ok(Spanned::new(self.dim_flow()?, start..self.lexer.span().end)),
+            Token::Melo => Ok(Spanned::new(
+                self.melo_flow()?,
+                start..self.lexer.span().end,
+            )),
+            Token::Loop => Ok(Spanned::new(
+                self.loop_flow()?,
+                start..self.lexer.span().end,
+            )),
+            Token::Break => Ok(Spanned::new(
+                self.semicolon_terminated(Stmt::Break)?,
+                start..self.lexer.span().end,
+            )),
+            Token::HopBack => Ok(Spanned::new(
+                self.semicolon_terminated(Stmt::HopBack)?,
+                start..self.lexer.span().end,
+            )),
+            Token::Rlyeh => Ok(Spanned::new(
+                self.semicolon_terminated(Stmt::Rlyeh)?,
+                start..self.lexer.span().end,
+            )),
+            Token::Rickroll => Ok(Spanned::new(
+                self.semicolon_terminated(Stmt::Rickroll)?,
+                start..self.lexer.span().end,
+            )),
+
+            Token::Identifier(_)
+            | Token::String(_)
+            | Token::Integer(_)
+            | Token::Char(_)
+            | Token::Aint
+            | Token::LeftBracket
+            | Token::LeftParen => Ok(Spanned::new(
+                self.value_flow(token)?,
+                start..self.lexer.span().end,
+            )),
+
+            t => Err(Error {
+                kind: ErrorKind::UnexpectedToken(t),
+                span: start..self.lexer.span().end,
+            }),
+        }
+    }
+
+    /// Require statement to be semicolon terminated
+    ///
+    /// Utility function for short statements
+    fn semicolon_terminated(&mut self, stmt_kind: Stmt) -> Result<Stmt, Error> {
+        self.require(Token::Semicolon)?;
+        Ok(stmt_kind)
+    }
+
+    /// Require next item to be equal with expected one
+    fn require(&mut self, required: Token) -> Result<(), Error> {
+        match self.checked_next()? {
+            t if t == required => Ok(()),
+            t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
+        }
+    }
+
+    /// Get an Identifier
+    fn get_ident(&mut self) -> Result<Spanned<String>, Error> {
+        match self.checked_next()? {
+            Token::Identifier(ident) => Ok(Spanned::new(
+                if self.tdark {
+                    ident.replace("lang", "script")
+                } else {
+                    ident
+                },
+                self.lexer.span(),
+            )),
+            t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
+        }
+    }
+
+    /// Parse an expression
+    ///
+    /// AbleScript strongly separates expressions from statements.
+    /// Expressions do not have any side effects and the are
+    /// only mathematial and logical operations or values.
+    fn parse_expr(
+        &mut self,
+        token: Token,
+        buf: &mut Option<Spanned<Expr>>,
+    ) -> Result<Spanned<Expr>, Error> {
+        let start = match buf {
+            Some(e) => e.span.start,
+            None => self.lexer.span().start,
+        };
+
+        match token {
+            // Values
+            Token::Identifier(i) => Ok(Spanned::new(
+                Expr::Variable(if self.tdark {
+                    i.replace("lang", "script")
+                } else {
+                    i
+                }),
+                start..self.lexer.span().end,
+            )),
+            Token::Integer(i) => Ok(Spanned::new(
+                Expr::Literal(Literal::Int(i)),
+                start..self.lexer.span().end,
+            )),
+            Token::String(s) => Ok(Spanned::new(
+                Expr::Literal(Literal::Str(if self.tdark {
+                    s.replace("lang", "script")
+                } else {
+                    s
+                })),
+                start..self.lexer.span().end,
+            )),
+            Token::Char(c) => Ok(Spanned::new(
+                Expr::Literal(Literal::Char(c)),
+                start..self.lexer.span().end,
+            )),
+
+            Token::LeftBracket => match buf.take() {
+                Some(buf) => Ok(Spanned::new(
+                    self.index_flow(buf)?,
+                    start..self.lexer.span().end,
+                )),
+                None => Ok(Spanned::new(
+                    self.cart_flow()?,
+                    start..self.lexer.span().end,
+                )),
+            },
+
+            // Lambdas
+            Token::Lambda => Ok(Spanned::new(
+                self.lambda_flow()?,
+                start..self.lexer.span().end,
+            )),
+            Token::BfLambda => Ok(Spanned::new(
+                self.bf_lambda_flow()?,
+                start..self.lexer.span().end,
+            )),
+
+            // Operations
+            Token::Aint if buf.is_none() => Ok(Spanned::new(
+                {
+                    let next = self.checked_next()?;
+                    Expr::Aint(Box::new(self.parse_expr(next, buf)?))
+                },
+                start..self.lexer.span().end,
+            )),
+
+            Token::Plus
+            | Token::Minus
+            | Token::Star
+            | Token::FwdSlash
+            | Token::Equals
+            | Token::LessThan
+            | Token::GreaterThan
+            | Token::Aint => Ok(Spanned::new(
+                self.binop_flow(
+                    BinOpKind::from_token(token).map_err(|e| Error::new(e, self.lexer.span()))?,
+                    buf,
+                )?,
+                start..self.lexer.span().end,
+            )),
+
+            Token::LeftParen => self.expr_flow(Token::RightParen),
+            t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
+        }
+    }
+
+    /// Flow for creating carts
+    fn cart_flow(&mut self) -> Result<Expr, Error> {
+        let mut cart = vec![];
+        let mut buf = None;
+
+        match self.checked_next()? {
+            Token::RightBracket => (),
+            t => {
+                buf = Some(self.parse_expr(t, &mut buf)?);
+                'cart: loop {
+                    let value = loop {
+                        match self.checked_next()? {
+                            Token::Arrow => break buf.take(),
+                            t => buf = Some(self.parse_expr(t, &mut buf)?),
+                        }
+                    }
+                    .ok_or_else(|| {
+                        Error::new(ErrorKind::UnexpectedToken(Token::Arrow), self.lexer.span())
+                    })?;
+
+                    let key = loop {
+                        match self.checked_next()? {
+                            Token::RightBracket => {
+                                cart.push((
+                                    value,
+                                    buf.take().ok_or_else(|| {
+                                        Error::unexpected_eof(self.lexer.span().start)
+                                    })?,
+                                ));
+
+                                break 'cart;
+                            }
+                            Token::Comma => break buf.take(),
+                            t => buf = Some(self.parse_expr(t, &mut buf)?),
+                        }
+                    }
+                    .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?;
+
+                    cart.push((value, key));
+                }
+            }
+        }
+
+        Ok(Expr::Cart(cart))
+    }
+
+    /// Flow for indexing operations
+    ///
+    /// Indexing with empty index resolves to length of expression, else it indexes
+    fn index_flow(&mut self, expr: Spanned<Expr>) -> Result<Expr, Error> {
+        let mut buf = None;
+        Ok(loop {
+            match self.checked_next()? {
+                Token::RightBracket => match buf {
+                    Some(index) => {
+                        break Expr::Index {
+                            expr: Box::new(expr),
+                            index: Box::new(index),
+                        }
+                    }
+                    None => break Expr::Len(Box::new(expr)),
+                },
+                token => buf = Some(self.parse_expr(token, &mut buf)?),
+            }
+        })
+    }
+
+    /// Flow for operators
+    ///
+    /// Generates operation from LHS buffer and next expression as RHS
+    ///
+    /// This is unaware of precedence, as AbleScript do not have it
+    fn binop_flow(
+        &mut self,
+        kind: BinOpKind,
+        lhs: &mut Option<Spanned<Expr>>,
+    ) -> Result<Expr, Error> {
+        Ok(Expr::BinOp {
+            lhs: Box::new(
+                lhs.take()
+                    .ok_or_else(|| Error::new(ErrorKind::MissingLhs, self.lexer.span()))?,
+            ),
+            rhs: {
+                let next = self
+                    .lexer
+                    .next()
+                    .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?;
+                Box::new(self.parse_expr(next, &mut None)?)
+            },
+            kind,
+        })
+    }
+
+    /// Parse expressions until terminate token
+    fn expr_flow(&mut self, terminate: Token) -> Result<Spanned<Expr>, Error> {
+        let mut buf = None;
+        Ok(loop {
+            match self.checked_next()? {
+                t if t == terminate => {
+                    break buf.take().ok_or_else(|| {
+                        Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())
+                    })?
+                }
+                t => buf = Some(self.parse_expr(t, &mut buf)?),
+            }
+        })
+    }
+
+    /// Parse a list of statements between curly braces
+    fn get_block(&mut self) -> Result<Block, Error> {
+        self.require(Token::LeftCurly)?;
+        let mut block = vec![];
+
+        loop {
+            match self.checked_next()? {
+                Token::RightCurly => break,
+                Token::TDark => block.extend(self.tdark_flow()?),
+                t => block.push(self.parse_stmt(t)?),
+            }
+        }
+        Ok(block)
+    }
+
+    /// Parse T-Dark block
+    fn tdark_flow(&mut self) -> Result<Block, Error> {
+        self.tdark = true;
+        let block = self.get_block();
+        self.tdark = false;
+        block
+    }
+
+    /// If Statement parser gets any kind of value (Identifier or Literal)
+    /// It cannot parse it as it do not parse expressions. Instead of it it
+    /// will parse it to function call or print statement.
+    fn value_flow(&mut self, init: Token) -> Result<Stmt, Error> {
+        let mut buf = Some(self.parse_expr(init, &mut None)?);
+        let r = loop {
+            match self.checked_next()? {
+                // Print to stdout
+                Token::Print => {
+                    let stmt = Stmt::Print(buf.take().ok_or_else(|| {
+                        Error::new(ErrorKind::UnexpectedToken(Token::Print), self.lexer.span())
+                    })?);
+                    break self.semicolon_terminated(stmt)?;
+                }
+
+                // Functio call
+                Token::LeftParen => {
+                    break self.functio_call_flow(buf.take().ok_or_else(|| {
+                        Error::new(
+                            ErrorKind::UnexpectedToken(Token::LeftParen),
+                            self.lexer.span(),
+                        )
+                    })?)?;
+                }
+
+                // Variable Assignment
+                Token::Assign => {
+                    return match buf.take() {
+                        Some(expr) => self.assignment_flow(expr),
+                        None => Err(Error::new(
+                            ErrorKind::UnexpectedToken(Token::Assign),
+                            self.lexer.span(),
+                        )),
+                    }
+                }
+
+                // Read input
+                Token::Read => {
+                    if let Some(Ok(assignable)) = buf.take().map(Assignable::from_expr) {
+                        self.require(Token::Semicolon)?;
+                        break Stmt::Read(assignable);
+                    } else {
+                        return Err(Error::new(
+                            ErrorKind::UnexpectedToken(Token::Read),
+                            self.lexer.span(),
+                        ));
+                    }
+                }
+
+                t => buf = Some(self.parse_expr(t, &mut buf)?),
+            }
+        };
+
+        Ok(r)
+    }
+
+    /// Parse Unless flow
+    ///
+    /// Consists of condition and block, there is no else
+    fn unless_flow(&mut self) -> Result<Stmt, Error> {
+        self.require(Token::LeftParen)?;
+        Ok(Stmt::Unless {
+            cond: self.expr_flow(Token::RightParen)?,
+            body: self.get_block()?,
+        })
+    }
+
+    /// Parse functio body
+    ///
+    /// `(a, b, c) { ... }`
+    fn get_functio_body(&mut self) -> Result<Spanned<FunctioBody>, Error> {
+        self.require(Token::LeftParen)?;
+        let start = self.lexer.span().start;
+
+        let mut params = vec![];
+        loop {
+            match self.checked_next()? {
+                Token::RightParen => break,
+                Token::Identifier(i) => {
+                    params.push(Spanned::new(i, self.lexer.span()));
+
+                    // Require comma (next) or right paren (end) after identifier
+                    match self.checked_next()? {
+                        Token::Comma => continue,
+                        Token::RightParen => break,
+                        t => {
+                            return Err(Error::new(
+                                ErrorKind::UnexpectedToken(t),
+                                self.lexer.span(),
+                            ))
+                        }
+                    }
+                }
+                t => return Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
+            }
+        }
+
+        let body = self.get_block()?;
+
+        Ok(Spanned::new(
+            FunctioBody { params, body },
+            start..self.lexer.span().end,
+        ))
+    }
+
+    /// Parse functio flow
+    ///
+    /// functio $ident (a, b, c) { ... }
+    fn functio_flow(&mut self) -> Result<Stmt, Error> {
+        let ident = self.get_ident()?;
+        let body = self.get_functio_body()?;
+
+        Ok(Stmt::Functio { ident, body })
+    }
+
+    /// Parse lambda flow
+    ///
+    /// `λ (a, b, c) { ... }`
+    fn lambda_flow(&mut self) -> Result<Expr, Error> {
+        Ok(Expr::Lambda(self.get_functio_body()?))
+    }
+
+    /// Parse BF function body
+    ///
+    /// `([tapelen]) { ... }`
+    fn get_bff_body(&mut self) -> Result<Spanned<BfFunctioBody>, Error> {
+        let (tape_len, start) = match self.checked_next()? {
+            Token::LeftParen => {
+                let len = Some(self.expr_flow(Token::RightParen)?);
+                let start = self.lexer.span().start;
+                self.require(Token::LeftCurly)?;
+                (len, start)
+            }
+            Token::LeftCurly => (None, self.lexer.span().start),
+            token => {
+                return Err(Error::new(
+                    ErrorKind::UnexpectedToken(token),
+                    self.lexer.span(),
+                ))
+            }
+        };
+
+        let mut code: Vec<u8> = vec![];
+        loop {
+            match self.checked_next()? {
+                Token::Plus
+                | Token::Minus
+                | Token::Comma
+                | Token::LeftBracket
+                | Token::RightBracket
+                | Token::LessThan
+                | Token::GreaterThan => code.push(self.lexer.slice().as_bytes()[0]),
+                Token::RightCurly => break,
+                _ => (),
+            }
+        }
+
+        Ok(Spanned::new(
+            BfFunctioBody { tape_len, code },
+            start..self.lexer.span().end,
+        ))
+    }
+
+    /// Parse BF function declaration
+    ///
+    /// `bff $ident ([tapelen]) { ... }`
+    fn bff_flow(&mut self) -> Result<Stmt, Error> {
+        let ident = self.get_ident()?;
+        let body = self.get_bff_body()?;
+
+        Ok(Stmt::BfFunctio { ident, body })
+    }
+
+    /// Parse a BF lambda
+    ///
+    /// `bfλ ([tapelen]) { ... }`
+    fn bf_lambda_flow(&mut self) -> Result<Expr, Error> {
+        Ok(Expr::BfLambda(Box::new(self.get_bff_body()?)))
+    }
+
+    /// Parse functio call flow
+    fn functio_call_flow(&mut self, expr: Spanned<Expr>) -> Result<Stmt, Error> {
+        let mut args = vec![];
+        let mut buf = None;
+        loop {
+            match self.checked_next()? {
+                // End of argument list
+                Token::RightParen => {
+                    if let Some(expr) = buf.take() {
+                        args.push(expr)
+                    }
+                    break;
+                }
+
+                // Next argument
+                Token::Comma => match buf.take() {
+                    Some(expr) => args.push(expr),
+                    // Comma alone
+                    None => {
+                        return Err(Error::new(
+                            ErrorKind::UnexpectedToken(Token::Comma),
+                            self.lexer.span(),
+                        ))
+                    }
+                },
+                t => buf = Some(self.parse_expr(t, &mut buf)?),
+            }
+        }
+
+        self.require(Token::Semicolon)?;
+        Ok(Stmt::Call { expr, args })
+    }
+
+    /// Parse variable declaration
+    fn dim_flow(&mut self) -> Result<Stmt, Error> {
+        let ident = self.get_ident()?;
+        let mut init = None;
+        loop {
+            match self.checked_next()? {
+                Token::Semicolon => break,
+                t => init = Some(self.parse_expr(t, &mut init)?),
+            }
+        }
+
+        Ok(Stmt::Dim { ident, init })
+    }
+
+    /// Parse assignment to assignable
+    fn assignment_flow(&mut self, value: Spanned<Expr>) -> Result<Stmt, Error> {
+        let ident = self.get_ident()?;
+        let kind = match self.checked_next()? {
+            Token::Semicolon => AssignableKind::Variable,
+            Token::LeftBracket => {
+                let mut indices = vec![];
+                loop {
+                    indices.push(self.expr_flow(Token::RightBracket)?);
+                    match self.checked_next()? {
+                        Token::Semicolon => break AssignableKind::Index { indices },
+                        Token::LeftBracket => (),
+                        t => {
+                            return Err(Error::new(
+                                ErrorKind::UnexpectedToken(t),
+                                self.lexer.span(),
+                            ))
+                        }
+                    }
+                }
+            }
+            t => return Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
+        };
+
+        Ok(Stmt::Assign {
+            assignable: Assignable { ident, kind },
+            value,
+        })
+    }
+
+    /// Parse Melo flow
+    fn melo_flow(&mut self) -> Result<Stmt, Error> {
+        let ident = self.get_ident()?;
+        self.semicolon_terminated(Stmt::Melo(ident))
+    }
+
+    /// Parse loop flow
+    ///
+    /// `loop` is an infinite loop, no condition, only body
+    fn loop_flow(&mut self) -> Result<Stmt, Error> {
+        Ok(Stmt::Loop {
+            body: self.get_block()?,
+        })
+    }
+}
+
+/// Parse AbleScript code into AST
+pub fn parse(source: &str) -> Result<Block, Error> {
+    Parser::new(source).parse()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simple_math() {
+        let code = "1 * (num + 3) / 666 print;";
+        let expected = &[Spanned {
+            item: Stmt::Print(Spanned {
+                item: Expr::BinOp {
+                    lhs: Box::new(Spanned {
+                        item: Expr::BinOp {
+                            lhs: Box::new(Spanned {
+                                item: Expr::Literal(Literal::Int(1)),
+                                span: 0..1,
+                            }),
+                            rhs: Box::new(Spanned {
+                                item: Expr::BinOp {
+                                    lhs: Box::new(Spanned {
+                                        item: Expr::Variable("num".to_owned()),
+                                        span: 5..6,
+                                    }),
+                                    rhs: Box::new(Spanned {
+                                        item: Expr::Literal(Literal::Int(3)),
+                                        span: 9..10,
+                                    }),
+                                    kind: BinOpKind::Add,
+                                },
+                                span: 5..10,
+                            }),
+                            kind: BinOpKind::Multiply,
+                        },
+                        span: 0..11,
+                    }),
+                    rhs: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Int(666)),
+                        span: 14..17,
+                    }),
+                    kind: BinOpKind::Divide,
+                },
+                span: 0..17,
+            }),
+            span: 0..24,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn variable_declaration() {
+        let code = "dim var 42;";
+        let expected = &[Spanned {
+            item: Stmt::Dim {
+                ident: Spanned {
+                    item: "var".to_owned(),
+                    span: 4..5,
+                },
+                init: Some(Spanned {
+                    item: Expr::Literal(Literal::Int(42)),
+                    span: 8..10,
+                }),
+            },
+            span: 0..11,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn unless_flow() {
+        let code = "unless (never + never) { /*Buy Able products!*/ print; }";
+        let expected = &[Spanned {
+            item: Stmt::Unless {
+                cond: Spanned {
+                    item: Expr::BinOp {
+                        lhs: Box::new(Spanned {
+                            item: Expr::Variable("never".to_owned()),
+                            span: 8..13,
+                        }),
+                        rhs: Box::new(Spanned {
+                            item: Expr::Variable("never".to_owned()),
+                            span: 16..21,
+                        }),
+                        kind: BinOpKind::Add,
+                    },
+                    span: 8..21,
+                },
+                body: vec![Spanned {
+                    item: Stmt::Print(Spanned {
+                        item: Expr::Literal(Literal::Str("Buy Able products!".to_owned())),
+                        span: 25..47,
+                    }),
+                    span: 25..54,
+                }],
+            },
+            span: 0..56,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn lambda() {
+        let code = "(λ () { /*ablelambda*/ print; })();";
+        let expected = &[Spanned {
+            item: Stmt::Call {
+                expr: Spanned {
+                    item: Expr::Lambda(Spanned {
+                        item: FunctioBody {
+                            params: Vec::new(),
+                            body: vec![Spanned {
+                                item: Stmt::Print(Spanned {
+                                    item: Expr::Literal(Literal::Str("ablelambda".to_owned())),
+                                    span: 9..23,
+                                }),
+                                span: 9..30,
+                            }],
+                        },
+                        span: 4..32,
+                    }),
+                    span: 1..32,
+                },
+                args: Vec::new(),
+            },
+            span: 0..36,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn tdark() {
+        let code = "T-Dark { dim lang /*lang*/ + lang; }";
+        let expected = &[Spanned {
+            item: Stmt::Dim {
+                ident: Spanned {
+                    item: "script".to_owned(),
+                    span: 13..17,
+                },
+                init: Some(Spanned {
+                    item: Expr::BinOp {
+                        lhs: Box::new(Spanned {
+                            item: Expr::Literal(Literal::Str("script".to_owned())),
+                            span: 20..26,
+                        }),
+                        rhs: Box::new(Spanned {
+                            item: Expr::Variable("script".to_owned()),
+                            span: 29..33,
+                        }),
+                        kind: BinOpKind::Add,
+                    },
+                    span: 20..33,
+                }),
+            },
+            span: 9..34,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn cart_construction() {
+        let code = "[/*able*/ <= 1, /*script*/ <= 3 - 1] print;";
+        let expected = &[Spanned {
+            item: Stmt::Print(Spanned {
+                item: Expr::Cart(vec![
+                    (
+                        Spanned {
+                            item: Expr::Literal(Literal::Str("able".to_owned())),
+                            span: 1..7,
+                        },
+                        Spanned {
+                            item: Expr::Literal(Literal::Int(1)),
+                            span: 11..12,
+                        },
+                    ),
+                    (
+                        Spanned {
+                            item: Expr::Literal(Literal::Str("script".to_owned())),
+                            span: 14..22,
+                        },
+                        Spanned {
+                            item: Expr::BinOp {
+                                kind: BinOpKind::Subtract,
+                                lhs: Box::new(Spanned {
+                                    item: Expr::Literal(Literal::Int(3)),
+                                    span: 26..27,
+                                }),
+                                rhs: Box::new(Spanned {
+                                    item: Expr::Literal(Literal::Int(1)),
+                                    span: 30..31,
+                                }),
+                            },
+                            span: 26..31,
+                        },
+                    ),
+                ]),
+                span: 0..32,
+            }),
+            span: 0..39,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+
+    #[test]
+    fn cart_index() {
+        let code = "[/*able*/ <= /*ablecorp*/][/*ablecorp*/] print;";
+        let expected = &[Spanned {
+            item: Stmt::Print(Spanned {
+                item: Expr::Index {
+                    expr: Box::new(Spanned {
+                        item: Expr::Cart(vec![(
+                            Spanned {
+                                item: Expr::Literal(Literal::Str("able".to_owned())),
+                                span: 1..7,
+                            },
+                            Spanned {
+                                item: Expr::Literal(Literal::Str("ablecorp".to_owned())),
+                                span: 11..21,
+                            },
+                        )]),
+                        span: 0..22,
+                    }),
+                    index: Box::new(Spanned {
+                        item: Expr::Literal(Literal::Str("ablecorp".to_owned())),
+                        span: 23..33,
+                    }),
+                },
+                span: 0..34,
+            }),
+            span: 0..41,
+        }];
+
+        let ast = Parser::new(code).parse().unwrap();
+        assert_eq!(ast, expected);
+    }
+}

ablescript/src/rickroll

@@ -0,0 +1,67 @@
+We're no strangers to love
+You know the rules and so do I
+A full commitments what I'm thinking of
+You wouldn't get this from another guy
+
+I just wanna tell you how I'm feeling
+Gotta make you understand
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye
+Never gonna tell a lie and hurt you
+
+We've known each other for so long
+Your heart's been aching but you're too shy to say it
+Inside we both know what's been going on
+We know the game and we're gonna play it
+
+And if you ask me how I'm feeling
+Don't tell me you're too blind to see
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye
+Never gonna tell a lie and hurt you
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye
+Never gonna tell a lie and hurt you
+
+Never gonna give, never gonna give
+(Give you up)
+
+We've known each other for so long
+Your heart's been aching but you're too shy to say it
+Inside we both know what's been going on
+We know the game and we're gonna play it
+
+I just wanna tell you how I'm feeling
+Gotta make you understand
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye
+Never gonna tell a lie and hurt you
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye
+Never gonna tell a lie and hurt you
+
+Never gonna give you up
+Never gonna let you down
+Never gonna run around and desert you
+Never gonna make you cry
+Never gonna say goodbye

ablescript/src/variables.rs

@@ -0,0 +1,989 @@
+use std::{
+    cell::{Ref, RefCell, RefMut},
+    collections::HashMap,
+    fmt::Display,
+    hash::Hash,
+    io::Write,
+    mem::discriminant,
+    ops,
+    rc::Rc,
+    vec,
+};
+
+use rand::Rng;
+
+use crate::{ast::Block, brian::INSTRUCTION_MAPPINGS, consts};
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub enum Abool {
+    Never = -1,
+    Sometimes = 0,
+    Always = 1,
+}
+
+impl Abool {
+    pub fn to_bool(&self) -> bool {
+        match self {
+            Self::Always => true,
+            Self::Sometimes if rand::random() => true,
+            _ => false,
+        }
+    }
+}
+impl Display for Abool {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Abool::Never => write!(f, "never"),
+            Abool::Sometimes => write!(f, "sometimes"),
+            Abool::Always => write!(f, "always"),
+        }
+    }
+}
+
+impl From<bool> for Abool {
+    fn from(b: bool) -> Self {
+        if b {
+            Abool::Always
+        } else {
+            Abool::Never
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Hash)]
+pub enum Functio {
+    Bf {
+        instructions: Vec<u8>,
+        tape_len: usize,
+    },
+    Able {
+        params: Vec<String>,
+        body: Block,
+    },
+    Builtin(BuiltinFunctio),
+    Chain {
+        functios: Box<(Functio, Functio)>,
+        kind: FunctioChainKind,
+    },
+    Eval(String),
+}
+
+impl Functio {
+    pub fn arity(&self) -> usize {
+        match self {
+            Functio::Bf {
+                instructions: _,
+                tape_len: _,
+            } => 0,
+            Functio::Able { params, body: _ } => params.len(),
+            Functio::Builtin(b) => b.arity,
+            Functio::Chain { functios, kind: _ } => functios.0.arity() + functios.1.arity(),
+            Functio::Eval(_) => 0,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct BuiltinFunctio {
+    function: Rc<dyn Fn(&[ValueRef]) -> Result<(), crate::error::ErrorKind>>,
+    arity: usize,
+}
+
+impl BuiltinFunctio {
+    pub fn new<F>(f: F, arity: usize) -> Self
+    where
+        F: Fn(&[ValueRef]) -> Result<(), crate::error::ErrorKind> + 'static,
+    {
+        Self {
+            function: Rc::new(f),
+            arity,
+        }
+    }
+
+    pub fn call(&self, args: &[ValueRef]) -> Result<(), crate::error::ErrorKind> {
+        (self.function)(args)
+    }
+
+    pub fn fn_addr(&self) -> usize {
+        Rc::as_ptr(&self.function) as *const () as _
+    }
+}
+
+impl std::fmt::Debug for BuiltinFunctio {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BuiltinFunctio")
+            .field("function", &"built-in")
+            .field("arity", &self.arity)
+            .finish()
+    }
+}
+
+impl PartialEq for BuiltinFunctio {
+    fn eq(&self, other: &Self) -> bool {
+        self.fn_addr() == other.fn_addr() && self.arity == other.arity
+    }
+}
+
+impl Hash for BuiltinFunctio {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.fn_addr().hash(state);
+        self.arity.hash(state);
+    }
+}
+
+#[derive(Debug, PartialEq, Copy, Clone, Hash)]
+pub enum FunctioChainKind {
+    Equal,
+    ByArity,
+}
+
+pub type Cart = HashMap<Value, ValueRef>;
+
+#[derive(Debug, Clone)]
+pub enum Value {
+    Nul,
+    Str(String),
+    Int(isize),
+    Abool(Abool),
+    Functio(Functio),
+    Cart(Cart),
+}
+
+impl Default for Value {
+    fn default() -> Self {
+        Self::Nul
+    }
+}
+
+impl Hash for Value {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        discriminant(self).hash(state);
+        match self {
+            Value::Nul => (),
+            Value::Str(v) => v.hash(state),
+            Value::Int(v) => v.hash(state),
+            Value::Abool(v) => v.to_string().hash(state),
+            Value::Functio(statements) => statements.hash(state),
+            Value::Cart(_) => self.to_string().hash(state),
+        }
+    }
+}
+
+impl Value {
+    /// Write an AbleScript value to a Brainfuck input stream by
+    /// coercing the value to an integer, then truncating that integer
+    /// to a single byte, then writing that byte. This should only be
+    /// called on `Write`rs that cannot fail, e.g., `Vec<u8>`, because
+    /// any IO errors will cause a panic.
+    pub fn bf_write(&self, stream: &mut impl Write) {
+        stream
+            .write_all(&[self.clone().into_isize() as u8])
+            .expect("Failed to write to Brainfuck input");
+    }
+
+    /// Coerce a value to an integer.
+    pub fn into_isize(self) -> isize {
+        match self {
+            Value::Abool(a) => a as _,
+            Value::Functio(f) => match f {
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => {
+                    instructions.into_iter().map(|x| x as isize).sum::<isize>() * tape_len as isize
+                }
+                Functio::Able { params, body } => {
+                    params
+                        .into_iter()
+                        .map(|x| x.bytes().map(|x| x as isize).sum::<isize>())
+                        .sum::<isize>()
+                        + body.len() as isize
+                }
+                Functio::Builtin(b) => (b.fn_addr() + b.arity) as _,
+                Functio::Chain { functios, kind } => {
+                    let (lf, rf) = *functios;
+                    Value::Functio(lf).into_isize()
+                        + Value::Functio(rf).into_isize()
+                            * match kind {
+                                FunctioChainKind::Equal => -1,
+                                FunctioChainKind::ByArity => 1,
+                            }
+                }
+                Functio::Eval(code) => code.bytes().map(|x| x as isize).sum(),
+            },
+            Value::Int(i) => i,
+            Value::Nul => consts::ANSWER,
+            Value::Str(text) => text.parse().unwrap_or(consts::ANSWER),
+            Value::Cart(c) => c
+                .into_iter()
+                .map(|(i, v)| i.into_isize() * v.borrow().clone().into_isize())
+                .sum(),
+        }
+    }
+
+    /// Coerce a value to an aboolean.
+    pub fn into_abool(self) -> Abool {
+        match self {
+            Value::Nul => Abool::Never,
+            Value::Str(s) => match s.to_lowercase().as_str() {
+                "never" | "no" | "🇳🇴" => Abool::Never,
+                "sometimes" => Abool::Sometimes,
+                "always" | "yes" => Abool::Always,
+                s => (!s.is_empty()).into(),
+            },
+            Value::Int(x) => match x.cmp(&0) {
+                std::cmp::Ordering::Less => Abool::Never,
+                std::cmp::Ordering::Equal => Abool::Sometimes,
+                std::cmp::Ordering::Greater => Abool::Always,
+            },
+            Value::Abool(a) => a,
+            Value::Functio(f) => match f {
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => Value::Int(
+                    (instructions.iter().map(|x| *x as usize).sum::<usize>() * tape_len) as _,
+                )
+                .into_abool(),
+                Functio::Able { params, body } => {
+                    let str_to_isize =
+                        |x: String| -> isize { x.as_bytes().iter().map(|x| *x as isize).sum() };
+
+                    let params: isize = params.into_iter().map(str_to_isize).sum();
+                    let body: isize = body
+                        .into_iter()
+                        .map(|x| format!("{:?}", x))
+                        .map(str_to_isize)
+                        .sum();
+
+                    Value::Int((params + body) % 3 - 1).into_abool()
+                }
+                Functio::Builtin(b) => (b.fn_addr() % b.arity == 0).into(),
+                Functio::Chain { functios, kind } => {
+                    let (lhs, rhs) = *functios;
+                    match kind {
+                        FunctioChainKind::Equal => {
+                            Value::Abool(Value::Functio(lhs).into_abool())
+                                + Value::Abool(Value::Functio(rhs).into_abool())
+                        }
+                        FunctioChainKind::ByArity => {
+                            Value::Abool(Value::Functio(lhs).into_abool())
+                                * Value::Abool(Value::Functio(rhs).into_abool())
+                        }
+                    }
+                    .into_abool()
+                }
+                Functio::Eval(code) => Value::Str(code).into_abool(),
+            },
+            Value::Cart(c) => {
+                if c.is_empty() {
+                    Abool::Never
+                } else {
+                    Abool::Always
+                }
+            }
+        }
+    }
+
+    /// Coerce a value to a functio.
+    pub fn into_functio(self) -> Functio {
+        match self {
+            Value::Nul => Functio::Able {
+                body: vec![],
+                params: vec![],
+            },
+            Value::Str(s) => Functio::Eval(s),
+            Value::Int(i) => Functio::Bf {
+                instructions: {
+                    std::iter::successors(Some(i as usize), |i| {
+                        Some(i / INSTRUCTION_MAPPINGS.len())
+                    })
+                    .take_while(|&i| i != 0)
+                    .map(|i| INSTRUCTION_MAPPINGS[i % INSTRUCTION_MAPPINGS.len()])
+                    .collect()
+                },
+                tape_len: crate::brian::DEFAULT_TAPE_SIZE_LIMIT,
+            },
+            Value::Abool(a) => Functio::Eval(match a {
+                Abool::Never => "".to_owned(),
+                Abool::Sometimes => {
+                    use rand::seq::SliceRandom;
+                    let mut str_chars: Vec<_> = "Buy Able Products!".chars().collect();
+                    str_chars.shuffle(&mut rand::thread_rng());
+
+                    format!(r#""{}"print;"#, str_chars.iter().collect::<String>())
+                }
+                Abool::Always => r#"loop{"Buy Able products!"print;}"#.to_owned(),
+            }),
+            Value::Functio(f) => f,
+            Value::Cart(c) => {
+                let kind = if let Some(114514) = c
+                    .get(&Value::Str("1452251871514141792252515212116".to_owned()))
+                    .map(|x| x.borrow().to_owned().into_isize())
+                {
+                    FunctioChainKind::Equal
+                } else {
+                    FunctioChainKind::ByArity
+                };
+
+                let mut cart_vec = c.iter().collect::<Vec<_>>();
+                cart_vec.sort_by(|x, y| x.0.partial_cmp(y.0).unwrap_or(std::cmp::Ordering::Less));
+
+                cart_vec
+                    .into_iter()
+                    .map(|(_, x)| x.borrow().to_owned().into_functio())
+                    .reduce(|acc, x| Functio::Chain {
+                        functios: Box::new((acc, x)),
+                        kind,
+                    })
+                    .unwrap_or_else(|| Functio::Eval(r#""Buy Able Products!"print;"#.to_owned()))
+            }
+        }
+    }
+
+    /// Coerce a value into a cart.
+    pub fn into_cart(self) -> Cart {
+        match self {
+            Value::Nul => HashMap::new(),
+            Value::Str(s) => s
+                .chars()
+                .enumerate()
+                .map(|(i, x)| {
+                    (
+                        Value::Int(i as isize + 1),
+                        ValueRef::new(Value::Str(x.to_string())),
+                    )
+                })
+                .collect(),
+            Value::Int(i) => Value::Str(i.to_string()).into_cart(),
+            Value::Abool(a) => Value::Str(a.to_string()).into_cart(),
+            Value::Functio(f) => match f {
+                Functio::Able { params, body } => {
+                    let params: Cart = params
+                        .into_iter()
+                        .enumerate()
+                        .map(|(i, x)| (Value::Int(i as isize + 1), ValueRef::new(Value::Str(x))))
+                        .collect();
+
+                    let body: Cart = body
+                        .into_iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            (
+                                Value::Int(i as isize + 1),
+                                ValueRef::new(Value::Str(format!("{:?}", x))),
+                            )
+                        })
+                        .collect();
+
+                    let mut cart = HashMap::new();
+                    cart.insert(
+                        Value::Str("params".to_owned()),
+                        ValueRef::new(Value::Cart(params)),
+                    );
+
+                    cart.insert(
+                        Value::Str("body".to_owned()),
+                        ValueRef::new(Value::Cart(body)),
+                    );
+
+                    cart
+                }
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => {
+                    let mut cart: Cart = instructions
+                        .into_iter()
+                        .enumerate()
+                        .map(|(i, x)| {
+                            (
+                                Value::Int(i as isize + 1),
+                                ValueRef::new(
+                                    char::from_u32(x as u32)
+                                        .map(|x| Value::Str(x.to_string()))
+                                        .unwrap_or(Value::Nul),
+                                ),
+                            )
+                        })
+                        .collect();
+
+                    cart.insert(
+                        Value::Str("tapelen".to_owned()),
+                        ValueRef::new(Value::Int(tape_len as _)),
+                    );
+                    cart
+                }
+                Functio::Builtin(b) => {
+                    let mut cart = HashMap::new();
+                    cart.insert(
+                        Value::Str("addr".to_owned()),
+                        ValueRef::new(Value::Cart(Value::Int(b.fn_addr() as _).into_cart())),
+                    );
+
+                    cart.insert(
+                        Value::Str("arity".to_owned()),
+                        ValueRef::new(Value::Int(b.arity as _)),
+                    );
+
+                    cart
+                }
+                Functio::Chain { functios, kind } => {
+                    let (lhs, rhs) = *functios;
+                    match kind {
+                        FunctioChainKind::Equal => {
+                            Value::Cart(Value::Functio(lhs).into_cart())
+                                + Value::Cart(Value::Functio(rhs).into_cart())
+                        }
+                        FunctioChainKind::ByArity => {
+                            Value::Cart(Value::Functio(lhs).into_cart())
+                                * Value::Cart(Value::Functio(rhs).into_cart())
+                        }
+                    }
+                    .into_cart()
+                }
+                Functio::Eval(s) => Value::Str(s).into_cart(),
+            },
+            Value::Cart(c) => c,
+        }
+    }
+
+    /// Get a length of a value
+    pub fn length(&self) -> isize {
+        match self {
+            Value::Nul => 0,
+            Value::Str(s) => s.len() as _,
+            Value::Int(i) => i.count_zeros() as _,
+            Value::Abool(a) => match a {
+                Abool::Never => -3,
+                Abool::Sometimes => {
+                    if rand::thread_rng().gen() {
+                        3
+                    } else {
+                        -3
+                    }
+                }
+                Abool::Always => 3,
+            },
+            Value::Functio(f) => match f {
+                // Compares lengths of functions:
+                // BfFunctio - Sum of lengths of instructions and length of tape
+                // AbleFunctio - Sum of argument count and body length
+                // Eval - Length of input code
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => (instructions.len() + tape_len) as _,
+                Functio::Able { params, body } => (params.len() + format!("{:?}", body).len()) as _,
+                Functio::Builtin(b) => (std::mem::size_of_val(b.function.as_ref()) + b.arity) as _,
+                Functio::Chain { functios, kind } => {
+                    let (lhs, rhs) = *functios.clone();
+                    match kind {
+                        FunctioChainKind::Equal => {
+                            Value::Int(Value::Functio(lhs).into_isize())
+                                + Value::Int(Value::Functio(rhs).into_isize())
+                        }
+                        FunctioChainKind::ByArity => {
+                            Value::Int(Value::Functio(lhs).into_isize())
+                                * Value::Int(Value::Functio(rhs).into_isize())
+                        }
+                    }
+                    .into_isize()
+                }
+                Functio::Eval(s) => s.len() as _,
+            },
+            Value::Cart(c) => c.len() as _,
+        }
+    }
+}
+
+impl ops::Add for Value {
+    type Output = Value;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        match self {
+            Value::Nul => match rhs {
+                Value::Nul => Value::Nul,
+                Value::Str(_) => Value::Str(self.to_string()) + rhs,
+                Value::Int(_) => Value::Int(self.into_isize()) + rhs,
+                Value::Abool(_) => Value::Abool(self.into_abool()) + rhs,
+                Value::Functio(_) => Value::Functio(self.into_functio()) + rhs,
+                Value::Cart(_) => Value::Cart(self.into_cart()) + rhs,
+            },
+            Value::Str(s) => Value::Str(format!("{s}{rhs}")),
+            Value::Int(i) => Value::Int(i.wrapping_add(rhs.into_isize())),
+            Value::Abool(_) => {
+                Value::Abool(Value::Int(self.into_isize().max(rhs.into_isize())).into_abool())
+            }
+            Value::Functio(f) => Value::Functio(Functio::Chain {
+                functios: Box::new((f, rhs.into_functio())),
+                kind: FunctioChainKind::Equal,
+            }),
+            Value::Cart(c) => {
+                Value::Cart(c.into_iter().chain(rhs.into_cart().into_iter()).collect())
+            }
+        }
+    }
+}
+
+impl ops::Sub for Value {
+    type Output = Value;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        match self {
+            Value::Nul => match rhs {
+                Value::Nul => Value::Nul,
+                Value::Str(_) => Value::Str(self.to_string()) - rhs,
+                Value::Int(_) => Value::Int(self.into_isize()) - rhs,
+                Value::Abool(_) => Value::Abool(self.into_abool()) - rhs,
+                Value::Functio(_) => Value::Functio(self.into_functio()) - rhs,
+                Value::Cart(_) => Value::Cart(self.into_cart()) - rhs,
+            },
+            Value::Str(s) => Value::Str(s.replace(&rhs.to_string(), "")),
+            Value::Int(i) => Value::Int(i.wrapping_sub(rhs.into_isize())),
+            Value::Abool(_) => (self.clone() + rhs.clone()) * !(self * rhs),
+            Value::Functio(f) => Value::Functio(match f {
+                Functio::Bf {
+                    instructions: lhs_ins,
+                    tape_len: lhs_tl,
+                } => match rhs.into_functio() {
+                    Functio::Bf {
+                        instructions: rhs_ins,
+                        tape_len: rhs_tl,
+                    } => Functio::Bf {
+                        instructions: lhs_ins
+                            .into_iter()
+                            .zip(rhs_ins.into_iter())
+                            .filter_map(|(l, r)| if l != r { Some(l) } else { None })
+                            .collect(),
+                        tape_len: lhs_tl - rhs_tl,
+                    },
+                    rhs => Functio::Bf {
+                        instructions: lhs_ins
+                            .into_iter()
+                            .zip(Value::Functio(rhs).to_string().bytes())
+                            .filter_map(|(l, r)| if l != r { Some(l) } else { None })
+                            .collect(),
+                        tape_len: lhs_tl,
+                    },
+                },
+                Functio::Able {
+                    params: lhs_params,
+                    body: lhs_body,
+                } => match rhs.into_functio() {
+                    Functio::Able {
+                        params: rhs_params,
+                        body: rhs_body,
+                    } => Functio::Able {
+                        params: lhs_params
+                            .into_iter()
+                            .zip(rhs_params.into_iter())
+                            .filter_map(|(l, r)| if l != r { Some(l) } else { None })
+                            .collect(),
+                        body: lhs_body
+                            .into_iter()
+                            .zip(rhs_body.into_iter())
+                            .filter_map(|(l, r)| if l != r { Some(l) } else { None })
+                            .collect(),
+                    },
+                    rhs => Value::Int(
+                        Value::Functio(Functio::Able {
+                            params: lhs_params,
+                            body: lhs_body,
+                        })
+                        .into_isize()
+                            - Value::Functio(rhs).into_isize(),
+                    )
+                    .into_functio(),
+                },
+                Functio::Builtin(b) => {
+                    let arity = b.arity;
+                    let resulting_arity = arity.saturating_sub(rhs.into_isize() as usize);
+
+                    Functio::Builtin(BuiltinFunctio::new(
+                        move |args| {
+                            b.call(
+                                &args
+                                    .iter()
+                                    .take(resulting_arity)
+                                    .cloned()
+                                    .chain(std::iter::repeat_with(|| ValueRef::new(Value::Nul)))
+                                    .take(arity)
+                                    .collect::<Vec<_>>(),
+                            )
+                        },
+                        resulting_arity,
+                    ))
+                }
+                Functio::Chain { functios, .. } => {
+                    let rhs = rhs.into_functio();
+                    let (a, b) = *functios;
+
+                    match (a == rhs, b == rhs) {
+                        (_, true) => a,
+                        (true, _) => b,
+                        (_, _) => (Value::Functio(a) - Value::Functio(rhs)).into_functio(),
+                    }
+                }
+                Functio::Eval(lhs_code) => Functio::Eval(lhs_code.replace(
+                    &match rhs.into_functio() {
+                        Functio::Eval(code) => code,
+                        rhs => Value::Functio(rhs).to_string(),
+                    },
+                    "",
+                )),
+            }),
+            Value::Cart(c) => Value::Cart({
+                let rhs_cart = rhs.into_cart();
+                c.into_iter()
+                    .filter(|(k, v)| rhs_cart.get(k) != Some(v))
+                    .collect()
+            }),
+        }
+    }
+}
+
+impl ops::Mul for Value {
+    type Output = Value;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        match self {
+            Value::Nul => match rhs {
+                Value::Nul => Value::Nul,
+                Value::Str(_) => Value::Str(self.to_string()) * rhs,
+                Value::Int(_) => Value::Int(self.into_isize()) * rhs,
+                Value::Abool(_) => Value::Abool(self.into_abool()) * rhs,
+                Value::Functio(_) => Value::Functio(self.into_functio()) * rhs,
+                Value::Cart(_) => Value::Cart(self.into_cart()) * rhs,
+            },
+            Value::Str(s) => Value::Str(s.repeat(rhs.into_isize() as usize)),
+            Value::Int(i) => Value::Int(i.wrapping_mul(rhs.into_isize())),
+            Value::Abool(_) => {
+                Value::Abool(Value::Int(self.into_isize().min(rhs.into_isize())).into_abool())
+            }
+            Value::Functio(f) => Value::Functio(Functio::Chain {
+                functios: Box::new((f, rhs.into_functio())),
+                kind: FunctioChainKind::ByArity,
+            }),
+            Value::Cart(c) => {
+                let rhsc = rhs.into_cart();
+
+                Value::Cart(
+                    c.into_iter()
+                        .map(|(k, v)| {
+                            if let Some(k) = rhsc.get(&k) {
+                                (k.borrow().clone(), v)
+                            } else {
+                                (k, v)
+                            }
+                        })
+                        .collect(),
+                )
+            }
+        }
+    }
+}
+
+impl ops::Div for Value {
+    type Output = Value;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        match self {
+            Value::Nul => match rhs {
+                Value::Nul => Value::Nul,
+                Value::Str(_) => Value::Str(self.to_string()) / rhs,
+                Value::Int(_) => Value::Int(self.into_isize()) / rhs,
+                Value::Abool(_) => Value::Abool(self.into_abool()) / rhs,
+                Value::Functio(_) => Value::Functio(self.into_functio()) / rhs,
+                Value::Cart(_) => Value::Cart(self.into_cart()) / rhs,
+            },
+            Value::Str(s) => Value::Cart(
+                s.split(&rhs.to_string())
+                    .enumerate()
+                    .map(|(i, x)| {
+                        (
+                            Value::Int(i as isize + 1),
+                            ValueRef::new(Value::Str(x.to_owned())),
+                        )
+                    })
+                    .collect(),
+            ),
+            Value::Int(i) => Value::Int(i.wrapping_div(match rhs.into_isize() {
+                0 => consts::ANSWER,
+                x => x,
+            })),
+            Value::Abool(_) => !self + rhs,
+            Value::Functio(f) => Value::Functio(match f {
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => {
+                    let fraction = 1.0 / rhs.into_isize() as f64;
+                    let len = instructions.len();
+                    Functio::Bf {
+                        instructions: instructions
+                            .into_iter()
+                            .take((len as f64 * fraction) as usize)
+                            .collect(),
+                        tape_len,
+                    }
+                }
+                Functio::Able { params, body } => {
+                    let fraction = 1.0 / rhs.into_isize() as f64;
+                    let len = body.len();
+                    Functio::Able {
+                        params,
+                        body: body
+                            .into_iter()
+                            .take((len as f64 * fraction) as usize)
+                            .collect(),
+                    }
+                }
+                Functio::Builtin(b) => Functio::Builtin(BuiltinFunctio {
+                    arity: b.arity + rhs.into_isize() as usize,
+                    ..b
+                }),
+                Functio::Chain { functios, kind } => {
+                    let functios = *functios;
+                    Functio::Chain {
+                        functios: Box::new((
+                            (Value::Functio(functios.0) / rhs.clone()).into_functio(),
+                            (Value::Functio(functios.1) / rhs).into_functio(),
+                        )),
+                        kind,
+                    }
+                }
+                Functio::Eval(s) => {
+                    let fraction = 1.0 / rhs.into_isize() as f64;
+                    let len = s.len();
+                    Functio::Eval(s.chars().take((len as f64 * fraction) as usize).collect())
+                }
+            }),
+            Value::Cart(c) => {
+                let cart_len = c.len();
+                let chunk_len = rhs.into_isize() as usize;
+
+                Value::Cart(
+                    c.into_iter()
+                        .collect::<Vec<_>>()
+                        .chunks(cart_len / chunk_len + (cart_len % chunk_len != 0) as usize)
+                        .enumerate()
+                        .map(|(k, v)| {
+                            (
+                                Value::Int(k as isize + 1),
+                                ValueRef::new(Value::Cart(v.iter().cloned().collect())),
+                            )
+                        })
+                        .collect(),
+                )
+            }
+        }
+    }
+}
+
+impl ops::Not for Value {
+    type Output = Value;
+
+    fn not(self) -> Self::Output {
+        match self {
+            Value::Nul => Value::Nul,
+            Value::Str(s) => Value::Str(s.chars().rev().collect()),
+            Value::Int(i) => Value::Int(i.swap_bytes()),
+            Value::Abool(a) => Value::Abool(match a {
+                Abool::Never => Abool::Always,
+                Abool::Sometimes => Abool::Sometimes,
+                Abool::Always => Abool::Never,
+            }),
+            Value::Functio(f) => Value::Functio(match f {
+                Functio::Bf {
+                    mut instructions,
+                    tape_len,
+                } => {
+                    instructions.reverse();
+
+                    Functio::Bf {
+                        instructions,
+                        tape_len,
+                    }
+                }
+                Functio::Able {
+                    mut params,
+                    mut body,
+                } => {
+                    params.reverse();
+                    body.reverse();
+
+                    Functio::Able { params, body }
+                }
+                Functio::Builtin(b) => {
+                    let arity = b.arity;
+                    Functio::Builtin(BuiltinFunctio::new(
+                        move |args| b.call(&args.iter().cloned().rev().collect::<Vec<_>>()),
+                        arity,
+                    ))
+                }
+                Functio::Chain { functios, kind } => {
+                    let (a, b) = *functios;
+                    Functio::Chain {
+                        functios: Box::new((
+                            (!Value::Functio(b)).into_functio(),
+                            (!Value::Functio(a)).into_functio(),
+                        )),
+                        kind,
+                    }
+                }
+                Functio::Eval(code) => Functio::Eval(code.chars().rev().collect()),
+            }),
+            Value::Cart(c) => Value::Cart(
+                c.into_iter()
+                    .map(|(k, v)| (v.borrow().clone(), ValueRef::new(k)))
+                    .collect(),
+            ),
+        }
+    }
+}
+
+impl PartialEq for Value {
+    fn eq(&self, other: &Self) -> bool {
+        let other = other.clone();
+
+        match self {
+            Value::Nul => matches!(other, Value::Nul),
+            Value::Str(s) => *s == other.to_string(),
+            Value::Int(i) => *i == other.into_isize(),
+            Value::Abool(a) => *a == other.into_abool(),
+            Value::Functio(f) => *f == other.into_functio(),
+            Value::Cart(c) => *c == other.into_cart(),
+        }
+    }
+}
+
+impl Eq for Value {}
+
+impl PartialOrd for Value {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        use std::cmp::Ordering::*;
+        let other = other.clone();
+
+        match self {
+            Value::Nul => {
+                if other == Value::Nul {
+                    Some(Equal)
+                } else {
+                    None
+                }
+            }
+            Value::Str(s) => Some(s.cmp(&other.to_string())),
+            Value::Int(i) => Some(i.cmp(&other.into_isize())),
+            Value::Abool(a) => a.partial_cmp(&other.into_abool()),
+            Value::Functio(_) => self.clone().into_isize().partial_cmp(&other.into_isize()),
+            Value::Cart(c) => Some(c.len().cmp(&other.into_cart().len())),
+        }
+    }
+}
+
+impl Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Nul => write!(f, "nul"),
+            Value::Str(v) => write!(f, "{}", v),
+            Value::Int(v) => write!(f, "{}", v),
+            Value::Abool(v) => write!(f, "{}", v),
+            Value::Functio(v) => match v {
+                Functio::Bf {
+                    instructions,
+                    tape_len,
+                } => {
+                    write!(
+                        f,
+                        "({}) {}",
+                        tape_len,
+                        String::from_utf8(instructions.to_owned())
+                            .expect("Brainfuck functio source should be UTF-8")
+                    )
+                }
+                Functio::Able { params, body } => {
+                    write!(
+                        f,
+                        "({}) -> {:?}",
+                        params.join(", "),
+                        // Maybe we should have a pretty-printer for
+                        // statement blocks at some point?
+                        body,
+                    )
+                }
+                Functio::Builtin(b) => write!(f, "builtin @ {}", b.fn_addr()),
+                Functio::Chain { functios, kind } => {
+                    let (a, b) = *functios.clone();
+                    write!(
+                        f,
+                        "{} {} {} ",
+                        Value::Functio(a),
+                        match kind {
+                            FunctioChainKind::Equal => '+',
+                            FunctioChainKind::ByArity => '*',
+                        },
+                        Value::Functio(b)
+                    )
+                }
+                Functio::Eval(s) => write!(f, "{}", s),
+            },
+            Value::Cart(c) => {
+                write!(f, "[")?;
+                let mut cart_vec = c.iter().collect::<Vec<_>>();
+                cart_vec.sort_by(|x, y| x.0.partial_cmp(y.0).unwrap_or(std::cmp::Ordering::Less));
+
+                for (idx, (key, value)) in cart_vec.into_iter().enumerate() {
+                    write!(
+                        f,
+                        "{}{} <= {}",
+                        if idx != 0 { ", " } else { "" },
+                        value.borrow(),
+                        key
+                    )?;
+                }
+
+                write!(f, "]")
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ValueRef(Rc<RefCell<Value>>);
+
+impl ValueRef {
+    pub fn new(v: Value) -> Self {
+        Self(Rc::new(RefCell::new(v)))
+    }
+
+    pub fn borrow(&self) -> Ref<Value> {
+        self.0.borrow()
+    }
+
+    pub fn borrow_mut(&self) -> RefMut<Value> {
+        self.0.borrow_mut()
+    }
+
+    pub fn replace(&self, v: Value) -> Value {
+        self.0.replace(v)
+    }
+}
+
+#[derive(Debug)]
+pub struct Variable {
+    pub melo: bool,
+
+    // Multiple Variables can reference the same underlying Value when
+    // pass-by-reference is used, therefore we use Rc here.
+    pub value: ValueRef,
+}
+
+impl Variable {
+    pub fn from_value(value: Value) -> Self {
+        Self {
+            melo: false,
+            value: ValueRef::new(value),
+        }
+    }
+}

ablescript_cli/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ablescript_cli"
+version = "0.3.0"
+authors = ["able <abl3theabove@gmail.com>"]
+edition = "2021"
+
+description = "The best programming language"
+license = "MIT"
+documentation = "https://ablecorp.us/able-script-the-book/"
+repository = "https://github.com/AbleCorp/able-script"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+ablescript = { version = "0.3.0", path = "../ablescript" }
+
+clap = "3.1"
+rustyline = "9.1"

ablescript_cli/src/main.rs

@@ -0,0 +1,64 @@
+#![forbid(unsafe_code, clippy::unwrap_used)]
+
+mod repl;
+
+use ablescript::interpret::ExecEnv;
+use ablescript::parser::parse;
+use clap::{Arg, Command};
+use std::process::exit;
+
+fn main() {
+    // variables::test(); // NOTE(Able): Add this as a test case
+    let matches = Command::new("AbleScript")
+        .version(env!("CARGO_PKG_VERSION"))
+        .author("Able <abl3theabove@gmail.com>")
+        .about("AbleScript interpreter")
+        .arg(
+            Arg::new("file")
+                .short('f')
+                .long("file")
+                .value_name("FILE")
+                .help("Set the path to interpret from")
+                .takes_value(true),
+        )
+        .arg(
+            Arg::new("debug")
+                .long("debug")
+                .help("Enable debug AST printing"),
+        )
+        .get_matches();
+
+    let ast_print = matches.is_present("debug");
+
+    match matches.value_of("file") {
+        Some(file_path) => {
+            // Read file
+            let source = match std::fs::read_to_string(file_path) {
+                Ok(s) => s,
+                Err(e) => {
+                    println!("Failed to read file \"{}\": {}", file_path, e);
+                    exit(1)
+                }
+            };
+
+            // Parse & evaluate
+            if let Err(e) = parse(&source).and_then(|ast| {
+                if ast_print {
+                    println!("{:#?}", ast);
+                }
+                ExecEnv::new().eval_stmts(&ast)
+            }) {
+                println!(
+                    "Error `{:?}` occurred at span: {:?} = `{:?}`",
+                    e.kind,
+                    e.span.clone(),
+                    &source[e.span]
+                );
+            }
+        }
+        None => {
+            println!("Hi [AbleScript {}]", env!("CARGO_PKG_VERSION"));
+            repl::repl(ast_print);
+        }
+    }
+}

ablescript_cli/src/repl.rs

@@ -0,0 +1,60 @@
+use ablescript::interpret::ExecEnv;
+use ablescript::parser::parse;
+use rustyline::Editor;
+
+pub fn repl(ast_print: bool) {
+    let mut rl = Editor::<()>::new();
+    let mut env = ExecEnv::new();
+
+    // If this is `Some`, the user has previously entered an
+    // incomplete statement and is now completing it; otherwise, the
+    // user is entering a completely new statement.
+    let mut partial: Option<String> = None;
+    loop {
+        match rl.readline(if partial.is_some() { ">> " } else { ":: " }) {
+            Ok(readline) => {
+                let readline = readline.trim_end();
+                rl.add_history_entry(readline);
+
+                let partial_data = match partial {
+                    Some(line) => line + readline,
+                    None => readline.to_owned(),
+                };
+
+                partial = match parse(&partial_data).and_then(|ast| {
+                    if ast_print {
+                        println!("{:#?}", &ast);
+                    }
+                    env.eval_stmts(&ast)
+                }) {
+                    Ok(_) => None,
+                    Err(ablescript::error::Error {
+                        // Treat "Unexpected EOF" errors as "we need
+                        // more data".
+                        kind: ablescript::error::ErrorKind::UnexpectedEof,
+                        ..
+                    }) => Some(partial_data),
+                    Err(e) => {
+                        println!("{}", e);
+                        println!(" | {}", partial_data);
+                        println!(
+                            "   {}{}",
+                            " ".repeat(e.span.start),
+                            "^".repeat((e.span.end - e.span.start).max(1))
+                        );
+                        None
+                    }
+                };
+            }
+            Err(rustyline::error::ReadlineError::Eof) => {
+                println!("bye");
+                break;
+            }
+            Err(rustyline::error::ReadlineError::Interrupted) => (),
+            Err(e) => {
+                println!("Error: {:?}", e);
+                break;
+            }
+        }
+    }
+}

examples/by-arity-chain.able

@@ -0,0 +1,44 @@
+functio arity_0() {
+   /*this function has arity 0*/ print;
+}
+
+functio arity_1(arg1) {
+   /*this function has arity 1*/ print;
+   arg1 print;
+}
+
+functio arity_2(arg1, arg2) {
+   /*this function has arity 2*/ print;
+   arg1 print;
+   arg2 print;
+}
+
+functio arity_3(arg1, arg2, arg3) {
+   /*this function has arity 3*/ print;
+   arg1 print;
+   arg2 print;
+   arg3 print;
+}
+
+owo arity_0();
+owo arity_1(/*foo*/);
+owo arity_2(/*foo*/, /*bar*/);
+owo arity_3(/*foo*/, /*bar*/, /*baz*/);
+
+dim i1 arity_0 * arity_1;
+i1(/*second*/);
+
+/*----*/ print;
+
+dim i2 arity_1 * arity_0;
+i2(/*first*/);
+
+/*----*/ print;
+
+dim ifancy arity_3 * arity_3;
+ifancy(/*left1*/, /*right1*/, /*left2*/, /*right2*/, /*left3*/, /*right3*/);
+
+/*---*/ print;
+
+dim another arity_0 * arity_3;
+another(/*right1*/, /*right2*/, /*right3*/);

examples/carts.able

@@ -0,0 +1,8 @@
+functio helloable() {
+   /*Hello, Able!*/ print;
+}
+
+dim cart [/*able*/ <= 42, helloable <= /*hello*/];
+
+cart[42] print;
+cart[/*hello*/]();

examples/functio.able

@@ -0,0 +1,4 @@
+functio hello(words){
+   words print;
+}
+hello(/*wonk*/);

examples/hello-world.able

@@ -0,0 +1,2 @@
+dim hello /*world*/;
+hello print;

examples/iotest.able

@@ -0,0 +1,5 @@
+dim data;
+loop {
+   data read;
+   data print;
+}

examples/lambda.able

@@ -0,0 +1,17 @@
+dim with_world λ (var) {
+    var + /*world!*/ =: var;
+};
+
+dim foo /*Hello, */;
+with_world(foo);
+foo print;
+
+
+
+functio add1(var) {
+    1 + var =: var;
+}
+
+dim bar 0;
+(add1 * λ () { /*Goodbye, world!*/ print; })(bar);
+bar print;

examples/melo-hello.able

@@ -0,0 +1,3 @@
+dim hi /*wonk*/;
+melo hi;
+hi print; owo Should error out

examples/pass-by-reference.able

@@ -0,0 +1,23 @@
+owo Pass-by-reference test
+
+owo Swap two variables.
+functio swap(left, right) {
+   dim tmp left;
+   right =: left;
+   tmp =: right;
+}
+
+dim foo /*hello*/;
+dim bar /*world*/;
+
+swap(foo, bar);
+
+unless (foo = /*world*/) {
+   /*FAILED*/ print;
+   /*foo should be 'world', is actually:*/ print;
+   foo print;
+}
+
+unless (foo ain't /*world*/) {
+   /*OK*/ print;
+}

src/base_55.rs

@@ -1,124 +0,0 @@
-pub fn char2num(character: char) -> i32 {
-    match character {
-        'Z' => -26,
-        'Y' => -25,
-        'X' => -24,
-        'W' => -23,
-        'V' => -22,
-        'U' => -21,
-        'T' => -20,
-        'R' => -18,
-        'S' => -19,
-        'Q' => -17,
-        'P' => -16,
-        'O' => -15,
-        'N' => -14,
-        'M' => -13,
-        'L' => -12,
-        'K' => -11,
-        'J' => -10,
-        'I' => -9,
-        'H' => -8,
-        'G' => -7,
-        'F' => -6,
-        'E' => -5,
-        'D' => -4,
-        'C' => -3,
-        'B' => -2,
-        'A' => -1,
-        ' ' => 0,
-        'a' => 1,
-        'b' => 2,
-        'c' => 3,
-        'd' => 4,
-        'e' => 5,
-        'f' => 6,
-        'g' => 7,
-        'h' => 8,
-        'i' => 9,
-        'j' => 10,
-        'k' => 11,
-        'l' => 12,
-        'm' => 13,
-        'n' => 14,
-        'o' => 15,
-        'p' => 16,
-        'q' => 17,
-        'r' => 18,
-        's' => 19,
-        't' => 20,
-        'u' => 21,
-        'v' => 22,
-        'w' => 23,
-        'x' => 24,
-        'y' => 25,
-        'z' => 26,
-        // NOTE(Able): Why does it jump to 53 here? MY REASONS ARE BEYOND YOUR UNDERSTANDING MORTAL
-        '/' => 53,
-        '\\' => 54,
-        '.' => 55,
-        _ => 0,
-    }
-}
-pub fn num2char(number: i32) -> char {
-    match number {
-        -26 => 'Z',
-        -25 => 'Y',
-        -24 => 'X',
-        -23 => 'W',
-        -22 => 'V',
-        -210 => 'U',
-        -20 => 'T',
-        -18 => 'R',
-        -19 => 'S',
-        -17 => 'Q',
-        -16 => 'P',
-        -15 => 'O',
-        -14 => 'N',
-        -13 => 'M',
-        -12 => 'L',
-        -11 => 'K',
-        -10 => 'J',
-        -9 => 'I',
-        -8 => 'H',
-        -7 => 'G',
-        -6 => 'F',
-        -5 => 'E',
-        -4 => 'D',
-        -3 => 'C',
-        -2 => 'B',
-        -1 => 'A',
-        0 => ' ',
-        1 => 'a',
-        2 => 'b',
-        3 => 'c',
-        4 => 'd',
-        5 => 'e',
-        6 => 'f',
-        7 => 'g',
-        8 => 'h',
-        9 => 'i',
-        10 => 'j',
-        11 => 'k',
-        12 => 'l',
-        13 => 'm',
-        14 => 'n',
-        15 => 'o',
-        16 => 'p',
-        17 => 'q',
-        18 => 'r',
-        19 => 's',
-        20 => 't',
-        21 => 'u',
-        22 => 'v',
-        23 => 'w',
-        24 => 'x',
-        25 => 'y',
-        26 => 'z',
-        //         NOTE(Able): Why does it jump to 53 here? MY REASONS ARE BEYOND YOUR UNDERSTANDING MORTAL
-        53 => '/',
-        54 => '\\',
-        55 => '.',
-        _ => ' ',
-    }
-}

src/const.rs

@@ -1,15 +0,0 @@
-// NOTE(Able): Number constants
-pub const TAU: i32 = 6;
-pub const PI: i32 = 3;
-pub const E: i32 = 3;
-pub const M: i32 = 70; // @Kev#6900
-pub const PHI: i32 = 2;
-pub const GOLDEN_RATIO: i32 = 2;
-pub const WUA: i32 = 1;
-pub const EULERS_CONSTANT: i32 = 0;
-pub const GRAVITY: i32 = 10;
-pub const RNG: i32 = 12;
-pub const STD_RNG: i32 = 4; //The standard random number is 4 (source: https://xkcd.com/221/)
-pub const INF: i32 = i32::max_value();
-
-pub const OCTOTHORPE: char = '#';

src/main.rs

@@ -1,31 +0,0 @@
-extern crate clap;
-use clap::{App, Arg};
-
-mod base_55;
-mod parser;
-pub mod tokens;
-
-fn main() {
-    let matches = App::new("AbleScript")
-        .version(env!("CARGO_PKG_VERSION"))
-        .author("Able <abl3theabove@gmail.com>")
-        .about("Does awesome things")
-        .arg(
-            Arg::with_name("file")
-                .short("f")
-                .long("file")
-                .value_name("FILE")
-                .help("Set the path to interpret from")
-                .takes_value(true),
-        )
-        .get_matches();
-    match matches.value_of("file") {
-        Some(file_path) => {
-            // Start parsing that file
-        }
-        None => {
-            println!("hi");
-            //start the prompt
-        }
-    }
-}

src/parser.rs

@@ -1,17 +0,0 @@
-use crate::tokens::{ABOOL, TOKENS};
-
-pub fn abool2num(abool: ABOOL) -> i32 {
-    match abool {
-        ABOOL::NEVER => -1,
-        ABOOL::SOMETIMES => 0,
-        ABOOL::ALWAYS => 1,
-    }
-}
-pub fn num2abool(number: i32) -> ABOOL {
-    match number {
-        -1 => ABOOL::NEVER,
-        0 => ABOOL::SOMETIMES,
-        1 => ABOOL::ALWAYS,
-        _ => ABOOL::SOMETIMES,
-    }
-}

src/tokens.rs

@@ -1,27 +0,0 @@
-pub enum TOKENS {
-    LEFT_PARENTHESIS,                              // (
-    RIGHT_PARENTHESIS,                             // )
-    LEFT_BRACKET,                                  // [
-    RIGHT_BRACKET,                                 // ]
-    LEFT_BRACE,                                    // {
-    RIGHT_BRACE,                                   // }
-    COMMENT { value: String },                     // #
-    SUBTRACT,                                      // -
-    ADDITION,                                      // +
-    MULTIPLY,                                      // *
-    DIVIDE,                                        // /
-    CHAR,                                          // Base52 based character
-    FUNCTION,                                      // functio
-    BF_FUNCTION { name: String, functio: String }, // Brain fuck FFI
-    VARIABLE,                                      // Variable bro
-    BOOLEAN { state: bool },                       // True, False
-    ABOOLEAN { state: ABOOL },                     // Always, Sometimes, Never
-    PRINT,                                         // Prints the preceding things
-    MELO, // Ban the following variable from ever being used again
-    T_DARK,
-}
-pub enum ABOOL {
-    NEVER = -1,
-    SOMETIMES = 0,
-    ALWAYS = 1,
-}