clearer comment

Made Parser private and made parse function
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.
2022-04-18 22:09:56 +02:00 · 2022-04-18 22:09:41 +02:00 · 2022-04-18 22:01:35 +02:00 · 2022-04-18 21:59:57 +02:00 · 2022-04-18 21:43:32 +02:00 · 2022-04-18 21:43:19 +02:00
26 changed files with 1836 additions and 2036 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -4,7 +4,7 @@ version = 3
 [[package]]
 name = "ablescript"
-version = "0.5.4"
+version = "0.3.0"
 dependencies = [
 "logos",
 "rand",
@ -12,7 +12,7 @@ dependencies = [
 [[package]]
 name = "ablescript_cli"
-version = "0.5.4"
+version = "0.3.0"
 dependencies = [
 "ablescript",
 "clap",
@ -20,58 +20,27 @@ dependencies = [
 ]
 [[package]]
-name = "anstream"
+name = "atty"
-version = "0.6.4"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "anstyle",
+ "hermit-abi",
- "anstyle-parse",
+ "libc",
- "anstyle-query",
+ "winapi",
 "anstyle-wincon",
 "colorchoice",
 "utf8parse",
 ]
 [[package]]
-name = "anstyle"
+name = "autocfg"
-version = "1.0.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 [[package]]
 name = "anstyle-parse"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140"
 dependencies = [
 "utf8parse",
 ]
 [[package]]
 name = "anstyle-query"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
 dependencies = [
 "windows-sys 0.48.0",
 ]
 [[package]]
 name = "anstyle-wincon"
 version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
 dependencies = [
 "anstyle",
 "windows-sys 0.48.0",
 ]
 [[package]]
 name = "beef"
-version = "0.5.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+checksum = "bed554bd50246729a1ec158d08aa3235d1b69d94ad120ebe187e28894787e736"
 [[package]]
 name = "bitflags"
@ -80,10 +49,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 [[package]]
-name = "bitflags"
+name = "cc"
-version = "2.4.1"
+version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
 [[package]]
 name = "cfg-if"
@ -93,61 +62,30 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "clap"
-version = "4.4.10"
+version = "3.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fffed7514f420abec6d183b1d3acfd9099c79c3a10a06ade4f8203f1411272"
+checksum = "71c47df61d9e16dc010b55dba1952a57d8c215dbb533fd13cdd13369aac73b1c"
 dependencies = [
- "clap_builder",
+ "atty",
- "clap_derive",
+ "bitflags",
-]
+ "indexmap",
-
+ "os_str_bytes",
 [[package]]
 name = "clap_builder"
 version = "4.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63361bae7eef3771745f02d8d892bec2fee5f6e34af316ba556e7f97a7069ff1"
 dependencies = [
 "anstream",
 "anstyle",
 "clap_lex",
 "strsim",
 "termcolor",
 "textwrap",
 ]
 [[package]]
 name = "clap_derive"
 version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "clap_lex"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
 [[package]]
 name = "clipboard-win"
-version = "4.5.0"
+version = "4.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
+checksum = "2f3e1238132dc01f081e1cbb9dace14e5ef4c3a51ee244bd982275fb514605db"
 dependencies = [
 "error-code",
 "str-buf",
 "winapi",
 ]
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 [[package]]
 name = "dirs-next"
 version = "2.0.0"
@ -177,12 +115,23 @@ checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 [[package]]
 name = "errno"
-version = "0.3.8"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+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",
 "windows-sys 0.52.0",
 ]
 [[package]]
@ -197,13 +146,13 @@ dependencies = [
 [[package]]
 name = "fd-lock"
-version = "3.0.13"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5"
+checksum = "46e245f4c8ec30c6415c56cb132c07e69e74f1942f6b4a4061da748b49f486ca"
 dependencies = [
 "cfg-if",
 "rustix",
- "windows-sys 0.48.0",
+ "windows-sys",
 ]
 [[package]]
@ -214,9 +163,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 [[package]]
 name = "getrandom"
-version = "0.2.11"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f"
+checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad"
 dependencies = [
 "cfg-if",
 "libc",
@ -224,54 +173,71 @@ dependencies = [
 ]
 [[package]]
-name = "heck"
+name = "hashbrown"
-version = "0.4.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 [[package]]
-name = "libc"
+name = "hermit-abi"
-version = "0.2.150"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 [[package]]
 name = "libredox"
 version = "0.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
 dependencies = [
 "bitflags 2.4.1",
 "libc",
 "redox_syscall",
 ]
 [[package]]
-name = "linux-raw-sys"
+name = "indexmap"
-version = "0.4.11"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "969488b55f8ac402214f3f5fd243ebb7206cf82de60d3172994707a4bcc2b829"
+checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee"
 dependencies = [
 "autocfg",
 "hashbrown",
 ]
 [[package]]
 name = "io-lifetimes"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9448015e586b611e5d322f6703812bbca2f1e709d5773ecd38ddb4e3bb649504"
 [[package]]
 name = "libc"
 version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 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.20"
+version = "0.4.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+checksum = "6389c490849ff5bc16be905ae24bc913a9c8892e19b2341dbc175e14c341c2b8"
 dependencies = [
 "cfg-if",
 ]
 [[package]]
 name = "logos"
-version = "0.13.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c000ca4d908ff18ac99b93a062cb8958d331c3220719c52e77cb19cc6ac5d2c1"
+checksum = "427e2abca5be13136da9afdbf874e6b34ad9001dd70f2b103b083a85daa7b345"
 dependencies = [
 "logos-derive",
 ]
 [[package]]
-name = "logos-codegen"
+name = "logos-derive"
-version = "0.13.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc487311295e0002e452025d6b580b77bb17286de87b57138f3b5db711cded68"
+checksum = "56a7d287fd2ac3f75b11f19a1c8a874a7d55744bd91f7a1b3e7cf87d4343c36d"
 dependencies = [
 "beef",
 "fnv",
@ -279,22 +245,23 @@ dependencies = [
 "quote",
 "regex-syntax",
 "syn",
-]
+ "utf8-ranges",
 [[package]]
 name = "logos-derive"
 version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbfc0d229f1f42d790440136d941afd806bc9e949e2bcb8faa813b0f00d1267e"
 dependencies = [
 "logos-codegen",
 ]
 [[package]]
 name = "memchr"
-version = "2.6.4"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
+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"
@ -307,35 +274,46 @@ dependencies = [
 [[package]]
 name = "nix"
-version = "0.26.4"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+checksum = "9f866317acbd3a240710c63f065ffb1e4fd466259045ccb504130b7f668f35c6"
 dependencies = [
- "bitflags 1.3.2",
+ "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.17"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 [[package]]
 name = "proc-macro2"
-version = "1.0.70"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39278fbbf5fb4f646ce651690877f89d1c5811a3d4acb27700c1cb3cdb78fd3b"
+checksum = "ec757218438d5fda206afc041538b2f6d889286160d649a86a24d37e1235afd1"
 dependencies = [
- "unicode-ident",
+ "unicode-xid",
 ]
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
 dependencies = [
 "proc-macro2",
 ]
@ -373,59 +351,60 @@ dependencies = [
 [[package]]
 name = "rand_core"
-version = "0.6.4"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
 dependencies = [
 "getrandom",
 ]
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 ]
 [[package]]
 name = "redox_users"
-version = "0.4.4"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
 "getrandom",
- "libredox",
+ "redox_syscall",
 "thiserror",
 ]
 [[package]]
 name = "regex-syntax"
-version = "0.6.29"
+version = "0.6.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 [[package]]
 name = "rustix"
-version = "0.38.25"
+version = "0.34.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc99bc2d4f1fed22595588a013687477aedf3cdcfb26558c559edb67b4d9b22e"
+checksum = "96619609a54d638872db136f56941d34e2a00bb0acf3fa783a90d6b96a093ba2"
 dependencies = [
- "bitflags 2.4.1",
+ "bitflags",
 "errno",
 "io-lifetimes",
 "libc",
 "linux-raw-sys",
- "windows-sys 0.48.0",
+ "winapi",
 ]
 [[package]]
 name = "rustyline"
-version = "11.0.0"
+version = "9.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dfc8644681285d1fb67a467fb3021bfea306b99b4146b166a1fe3ada965eece"
+checksum = "db7826789c0e25614b03e5a54a0717a86f9ff6e6e5247f92b369472869320039"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 "cfg-if",
 "clipboard-win",
 "dirs-next",
@ -436,6 +415,7 @@ dependencies = [
 "nix",
 "radix_trie",
 "scopeguard",
 "smallvec",
 "unicode-segmentation",
 "unicode-width",
 "utf8parse",
@ -444,21 +424,21 @@ dependencies = [
 [[package]]
 name = "scopeguard"
-version = "1.2.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 [[package]]
 name = "smallvec"
-version = "1.11.2"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"
 [[package]]
 name = "str-buf"
-version = "1.0.6"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
+checksum = "d44a3643b4ff9caf57abcee9c2c621d6c03d9135e0d8b589bd9afb5992cb176a"
 [[package]]
 name = "strsim"
@ -468,64 +448,85 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 [[package]]
 name = "syn"
-version = "2.0.39"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
+checksum = "b683b2b825c8eef438b77c36a06dc262294da3d5a5813fac20da149241dcd44d"
 dependencies = [
 "proc-macro2",
 "quote",
- "unicode-ident",
+ "unicode-xid",
 ]
 [[package]]
-name = "thiserror"
+name = "termcolor"
-version = "1.0.50"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
+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.50"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
+checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.1"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
+checksum = "7e8820f5d777f6224dc4be3632222971ac30164d4a258d595640799554ebfd99"
 [[package]]
 name = "unicode-width"
-version = "0.1.11"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+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.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.10.2+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 [[package]]
 name = "winapi"
@ -543,6 +544,15 @@ 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"
@ -551,132 +561,43 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows-sys"
-version = "0.48.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+checksum = "030b7ff91626e57a05ca64a07c481973cbb2db774e4852c9c7ca342408c6a99a"
 dependencies = [
- "windows-targets 0.48.5",
+ "windows_aarch64_msvc",
 "windows_i686_gnu",
 "windows_i686_msvc",
 "windows_x86_64_gnu",
 "windows_x86_64_msvc",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
 "windows-targets 0.52.0",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
 "windows_aarch64_gnullvm 0.48.5",
 "windows_aarch64_msvc 0.48.5",
 "windows_i686_gnu 0.48.5",
 "windows_i686_msvc 0.48.5",
 "windows_x86_64_gnu 0.48.5",
 "windows_x86_64_gnullvm 0.48.5",
 "windows_x86_64_msvc 0.48.5",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
 dependencies = [
 "windows_aarch64_gnullvm 0.52.0",
 "windows_aarch64_msvc 0.52.0",
 "windows_i686_gnu 0.52.0",
 "windows_i686_msvc 0.52.0",
 "windows_x86_64_gnu 0.52.0",
 "windows_x86_64_gnullvm 0.52.0",
 "windows_x86_64_msvc 0.52.0",
 ]
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.5"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+checksum = "29277a4435d642f775f63c7d1faeb927adba532886ce0287bd985bffb16b6bca"
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.5"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+checksum = "1145e1989da93956c68d1864f32fb97c8f561a8f89a5125f6a2b7ea75524e4b8"
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.5"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+checksum = "d4a09e3a0d4753b73019db171c1339cd4362c8c44baf1bcea336235e955954a6"
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.5"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+checksum = "8ca64fcb0220d58db4c119e050e7af03c69e6f4f415ef69ec1773d9aab422d5a"
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.5"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+checksum = "08cabc9f0066848fef4bc6a1c1668e6efce38b661d2aeec75d18d8617eebb5f1"
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
--- a/ablescript/Cargo.toml
+++ b/ablescript/Cargo.toml
@ -1,14 +1,16 @@
 [package]
 name = "ablescript"
-version = "0.5.4"
+version = "0.3.0"
-authors = ["AbleScript Developers"]
+authors = ["able <abl3theabove@gmail.com>"]
 edition = "2021"
 description = "The best programming language"
 license = "MIT"
 documentation = "https://ablecorp.us/able-script-the-book/"
-repository    = "https://git.ablecorp.us/AbleScript/able-script"
+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.13"
+logos = "0.12"
 rand = "0.8"
--- a/ablescript/src/ast.rs
+++ b/ablescript/src/ast.rs
@ -8,7 +8,7 @@
 //! just plain subroutines and they do not return any value,
 //! so their calls are statements.
-use crate::{base_55::char2num, value::Value};
+use crate::{base_55::char2num, variables::Value};
 use std::{fmt::Debug, hash::Hash};
 type Span = std::ops::Range<usize>;
@ -110,8 +110,8 @@ pub enum Stmt {
    Loop {
        body: Block,
    },
-    Enough,
+    Break,
-    AndAgain,
+    HopBack,
    Dim {
        ident: Spanned<String>,
@ -136,13 +136,9 @@ pub enum Stmt {
        expr: Spanned<Expr>,
        args: Vec<Spanned<Expr>>,
    },
-    Print {
+    Print(Spanned<Expr>),
        expr: Spanned<Expr>,
        newline: bool,
    },
    Read(Assignable),
    Melo(Spanned<String>),
    Finally(Block),
    Rlyeh,
    Rickroll,
 }
@ -164,11 +160,10 @@ pub enum Expr {
        index: Box<Spanned<Expr>>,
    },
    Len(Box<Spanned<Expr>>),
    Keys(Box<Spanned<Expr>>),
    Variable(String),
 }
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+#[derive(Debug, PartialEq, Clone, Hash)]
 pub enum Literal {
    Char(char),
    Int(isize),
@ -185,7 +180,7 @@ impl From<Literal> for Value {
    }
 }
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+#[derive(Debug, PartialEq, Clone, Hash)]
 pub enum BinOpKind {
    Add,
    Subtract,
--- a/ablescript/src/base_55.rs
+++ b/ablescript/src/base_55.rs
@ -5,7 +5,7 @@ pub const fn char2num(c: char) -> isize {
        '/' => 53,
        '\\' => 54,
        '.' => 55,
-        'U' => -210, // Backwards compatibility
+        'U' => -210,
        'A'..='Z' => -(c as isize) + 64,
        'a'..='z' => (c as isize) - 96,
        _ => 0,
--- a/ablescript/src/brian.rs
+++ b/ablescript/src/brian.rs
@ -221,7 +221,15 @@ impl<'a, I: BootlegRead> Interpreter<'a, I> {
                };
                Some((*counter, index))
            })
-            .find_map(|(counter, index)| (counter == 0).then_some(index))
+            .find_map(
                |(counter, index)| {
                    if counter == 0 {
                        Some(index)
                    } else {
                        None
                    }
                },
            )
    }
    fn get_matching_opening_bracket(&mut self, closing: usize) -> Option<usize> {
@ -237,7 +245,15 @@ impl<'a, I: BootlegRead> Interpreter<'a, I> {
                };
                Some((*counter, index))
            })
-            .find_map(|(counter, index)| (counter == 0).then_some(index))
+            .find_map(
                |(counter, index)| {
                    if counter == 0 {
                        Some(index)
                    } else {
                        None
                    }
                },
            )
    }
 }
--- a/ablescript/src/consts.rs
+++ b/ablescript/src/consts.rs
@ -1,6 +1,6 @@
 //! Number constants.
-use crate::value::{Value, Variable};
+use crate::variables::{Value, Variable};
 use std::collections::HashMap;
 pub const ANSWER: isize = 42;
@ -30,12 +30,11 @@ pub fn ablescript_consts() -> HashMap<String, Variable> {
            Str("1452251871514141792252515212116".to_owned()),
        ),
        ("OCTOTHORPE", Str("#".to_owned())), // It's an octothorpe
        ("AMOGUS", Str("ඞ".to_owned())),   // Amogus
        ("ANSWER", Int(ANSWER)),
        ("nul", Nul),
-        ("always", Abool(crate::value::Abool::Always)),
+        ("always", Abool(crate::variables::Abool::Always)),
-        ("sometimes", Abool(crate::value::Abool::Sometimes)),
+        ("sometimes", Abool(crate::variables::Abool::Sometimes)),
-        ("never", Abool(crate::value::Abool::Never)),
+        ("never", Abool(crate::variables::Abool::Never)),
    ]
    .into_iter()
    .map(|(name, value)| (name.to_owned(), Variable::from_value(value)))
--- a/ablescript/src/error.rs
+++ b/ablescript/src/error.rs
@ -9,36 +9,15 @@ pub struct Error {
 #[derive(Debug)]
 pub enum ErrorKind {
-    /// Parser expected token, but none was available
+    UnexpectedEof,
    UnexpectedEoi,
    /// Parser encountered unknown token
    InvalidToken,
    /// Parser expected certain token, but other one appeared
    UnexpectedToken(Token),
    /// Attempted to assign to undefined variable
    UnknownVariable(String),
    /// Attempted to access banned variable
    MeloVariable(String),
-
+    TopLevelBreak,
-    /// Breaking / re-starting loop outside loop
+    BfInterpretError(InterpretError),
-    LoopOpOutsideLoop,
+    MismatchedArgumentError,
    /// Rlyeh was executed but host interface's exit
    /// doesn't exit the program
    NonExitingRlyeh(i32),
    /// Missing left-hand side expression in binary expression
    MissingLhs,
-
+    IOError(io::Error),
    /// Error when executing BF code
    Brian(InterpretError),
    /// IO Error
    Io(io::Error),
 }
 impl Error {
@ -46,10 +25,10 @@ impl Error {
        Self { kind, span }
    }
-    /// Create an UnexpectedEoi error, where the EOI occurs at the
+    /// Create an UnexpectedEof error, where the EOF occurs at the
-    /// given index in the input.
+    /// given index in the file.
-    pub fn unexpected_eoi(index: usize) -> Self {
+    pub fn unexpected_eof(index: usize) -> Self {
-        Self::new(ErrorKind::UnexpectedEoi, index..index)
+        Self::new(ErrorKind::UnexpectedEof, index..index)
    }
 }
@ -67,27 +46,26 @@ impl std::error::Error for Error {}
 impl Display for ErrorKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
-            ErrorKind::UnexpectedEoi => write!(f, "unexpected end of input"),
+            ErrorKind::UnexpectedEof => write!(f, "unexpected end of file"),
            ErrorKind::InvalidToken => write!(f, "invalid token"),
            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::LoopOpOutsideLoop => write!(
+            ErrorKind::TopLevelBreak => write!(f, "can only `break` out of a loop"),
-                f,
+            ErrorKind::BfInterpretError(err) => write!(f, "brainfuck error: {}", err),
                "unable to perform loop operation (enough or and enough) outside a loop"
            ),
            &ErrorKind::NonExitingRlyeh(code) => write!(f, "program exited with code {code}"),
            ErrorKind::Brian(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::Io(err) => write!(f, "I/O error: {}", err),
+            ErrorKind::IOError(err) => write!(f, "I/O error: {}", err),
        }
    }
 }
-impl From<io::Error> for ErrorKind {
+impl From<io::Error> for Error {
    fn from(e: io::Error) -> Self {
-        Self::Io(e)
+        Self {
            kind: ErrorKind::IOError(e),
            span: 0..0,
        }
    }
 }
--- a/ablescript/src/host_interface.rs
+++ b/ablescript/src/host_interface.rs
@ -1,53 +0,0 @@
 use crate::value::Variable;
 use std::collections::HashMap;
 /// Host Environment Interface
 pub trait HostInterface {
    /// Initial variables for a stack frame
    fn initial_vars(&mut self) -> HashMap<String, Variable>;
    /// Print a string
    fn print(&mut self, string: &str, new_line: bool) -> std::io::Result<()>;
    /// Read a byte
    fn read_byte(&mut self) -> std::io::Result<u8>;
    /// This function should exit the program with specified code.
    ///
    /// For cases where exit is not desired, just let the function return
    /// and interpreter will terminate with an error.
    fn exit(&mut self, code: i32);
 }
 /// Standard [HostInterface] implementation
 #[derive(Clone, Copy, Default)]
 pub struct Standard;
 impl HostInterface for Standard {
    fn initial_vars(&mut self) -> HashMap<String, Variable> {
        HashMap::default()
    }
    fn print(&mut self, string: &str, new_line: bool) -> std::io::Result<()> {
        use std::io::Write;
        let mut stdout = std::io::stdout();
        stdout.write_all(string.as_bytes())?;
        if new_line {
            stdout.write_all(b"\n")?;
        }
        Ok(())
    }
    fn read_byte(&mut self) -> std::io::Result<u8> {
        use std::io::Read;
        let mut buf = [0];
        std::io::stdin().read_exact(&mut buf)?;
        Ok(buf[0])
    }
    fn exit(&mut self, code: i32) {
        std::process::exit(code);
    }
 }
--- a/ablescript/src/interpret.rs
+++ b/ablescript/src/interpret.rs
@ -9,22 +9,23 @@
 #![deny(missing_docs)]
 use crate::{
-    ast::{Assignable, AssignableKind, Block, Expr, Spanned, Stmt},
+    ast::{Assignable, AssignableKind, Expr, Spanned, Stmt},
    consts::ablescript_consts,
    error::{Error, ErrorKind},
-    host_interface::HostInterface,
+    variables::{Functio, Value, ValueRef, Variable},
    value::{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<H> {
+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.
@ -36,12 +37,6 @@ pub struct ExecEnv<H> {
    /// (via the `read` statement). We store each of those bits as
    /// booleans to facilitate easy manipulation.
    read_buf: VecDeque<bool>,
    /// Interface to interact with the host interface
    host_interface: H,
    /// Vector of blocks to be executed at the end of the program
    finalisers: Vec<Block>,
 }
 /// A set of visible variable and function definitions in a single
@ -51,12 +46,12 @@ struct Scope {
    variables: HashMap<String, Variable>,
 }
-impl<H> Default for ExecEnv<H>
+impl Default for ExecEnv {
 where
    H: Default + HostInterface,
 {
    fn default() -> Self {
-        Self::with_host_interface(H::default())
+        Self {
            stack: vec![Default::default()],
            read_buf: Default::default(),
        }
    }
 }
@ -73,80 +68,57 @@ enum HaltStatus {
    /// We ran out of statements to execute.
    Finished,
-    /// An `enough` statement occurred at the given span, and was not
+    /// A `break` statement occurred at the given span, and was not
    /// caught by a `loop` statement up to this point.
-    Enough(Range<usize>),
+    Break(Range<usize>),
-    /// A `and again` statement occurred at the given span, and was not
+    /// A `hopback` statement occurred at the given span, and was not
    /// caught by a `loop` statement up to this point.
-    AndAgain(Range<usize>),
+    Hopback(Range<usize>),
 }
 /// The number of bits the `read` statement reads at once from
 /// standard input.
 pub const READ_BITS: u8 = 3;
-impl<H: HostInterface> ExecEnv<H> {
+impl ExecEnv {
    /// Create a new Scope with no predefined variable definitions or
    /// other information.
-    pub fn with_host_interface(mut host_interface: H) -> Self {
+    pub fn new() -> Self {
-        Self {
+        Self::default()
            stack: vec![
                Default::default(),
                Scope {
                    variables: host_interface.initial_vars(),
                },
            ],
            read_buf: Default::default(),
            finalisers: vec![],
            host_interface,
        }
    }
    /// Create a new Scope with predefined variables
-    pub fn new_with_vars<I>(mut host_interface: H, vars: I) -> Self
+    pub fn new_with_vars<I>(vars: I) -> Self
    where
        I: IntoIterator<Item = (String, Variable)>,
    {
-        Self {
+        let scope = Scope {
            stack: vec![
                Scope {
            variables: ablescript_consts().into_iter().chain(vars).collect(),
-                },
+        };
-                Scope {
+
-                    variables: host_interface.initial_vars(),
+        Self {
-                },
+            stack: vec![scope],
            ],
            read_buf: Default::default(),
            finalisers: vec![],
            host_interface,
        }
    }
    /// 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
-    /// `enough` or `and again` statement occurred at the top level.
+    /// `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::Enough(span) | HaltStatus::AndAgain(span) => Err(Error {
+            HaltStatus::Break(span) | HaltStatus::Hopback(span) => Err(Error {
-                // It's an error to issue a `enough` outside of a
+                // It's an error to issue a `break` outside of a
                // `loop` statement.
-                kind: ErrorKind::LoopOpOutsideLoop,
+                kind: ErrorKind::TopLevelBreak,
                span,
            }),
        }?;
        while !self.finalisers.is_empty() {
            for block in std::mem::take(&mut self.finalisers) {
                self.eval_stmts_hs(&block, true)?;
        }
    }
-        Ok(())
+    /// The same as `eval_stmts`, but report "break" and "hopback"
    }
    /// The same as `eval_stmts`, but report "enough" and "and again"
    /// exit codes as normal conditions in a HaltStatus enum, and
    /// create a new stack frame if `stackframe` is true.
    ///
@ -223,30 +195,18 @@ impl<H: HostInterface> ExecEnv<H> {
                    .unwrap_or(Value::Nul)
            }
            Len(expr) => Value::Int(self.eval_expr(expr)?.length()),
-            Keys(expr) => Value::Cart(
+
                self.eval_expr(expr)?
                    .into_cart()
                    .into_keys()
                    .enumerate()
                    .map(|(i, k)| (Value::Int(i as isize + 1), ValueRef::new(k)))
                    .collect(),
            ),
            // TODO: not too happy with constructing an artificial
            // Ident here.
-            Variable(name) => {
+            Variable(name) => self.get_var(&Spanned::new(name.to_owned(), expr.span.clone()))?,
                self.get_var_value(&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, newline } => {
+            Stmt::Print(expr) => {
-                let value = self.eval_expr(expr)?;
+                println!("{}", self.eval_expr(expr)?);
                self.host_interface
                    .print(&value.to_string(), *newline)
                    .map_err(|e| Error::new(e.into(), stmt.span.clone()))?;
            }
            Stmt::Dim { ident, init } => {
                let init = match init {
@ -294,59 +254,44 @@ impl<H: HostInterface> ExecEnv<H> {
            }
            Stmt::Call { expr, args } => {
                let func = self.eval_expr(expr)?.into_functio();
-                return self.fn_call(func, args, &stmt.span);
+
                self.fn_call(func, args, &stmt.span)?;
            }
            Stmt::Loop { body } => loop {
                let res = self.eval_stmts_hs(body, true)?;
                match res {
-                    HaltStatus::Finished => (),
+                    HaltStatus::Finished => {}
-                    HaltStatus::Enough(_) => break,
+                    HaltStatus::Break(_) => break,
-                    HaltStatus::AndAgain(_) => continue,
+                    HaltStatus::Hopback(_) => continue,
                }
            },
            Stmt::Assign { assignable, value } => {
                self.assign(assignable, self.eval_expr(value)?)?;
            }
-            Stmt::Enough => {
+            Stmt::Break => {
-                return Ok(HaltStatus::Enough(stmt.span.clone()));
+                return Ok(HaltStatus::Break(stmt.span.clone()));
            }
-            Stmt::AndAgain => {
+            Stmt::HopBack => {
-                return Ok(HaltStatus::AndAgain(stmt.span.clone()));
+                return Ok(HaltStatus::Hopback(stmt.span.clone()));
            }
-            Stmt::Melo(ident) => match self.get_var_mut(ident)? {
+            Stmt::Melo(ident) => {
-                var @ Variable::Ref(_) => *var = Variable::Melo,
+                self.get_var_mut(ident)?.melo = true;
                Variable::Melo => {
                    for s in &mut self.stack {
                        if s.variables.remove(&ident.item).is_some() {
                            break;
            }
                    }
                }
            },
            Stmt::Finally(block) => self.finalisers.push(block.clone()),
            Stmt::Rlyeh => {
                // Maybe print a creepy error message or something
                // here at some point. ~~Alex
-                let code = random();
+                exit(random());
                self.host_interface.exit(code);
                return Err(Error::new(
                    ErrorKind::NonExitingRlyeh(code),
                    stmt.span.clone(),
                ));
            }
            Stmt::Rickroll => {
-                self.host_interface
+                stdout()
-                    .print(include_str!("rickroll"), false)
+                    .write_all(include_str!("rickroll").as_bytes())
-                    .map_err(|e| Error::new(e.into(), stmt.span.clone()))?;
+                    .expect("Failed to write to stdout");
            }
            Stmt::Read(assignable) => {
                let mut value = 0;
                for _ in 0..READ_BITS {
                    value <<= 1;
-                    value += self
+                    value += self.get_bit()? as isize;
                        .get_bit()
                        .map_err(|e| Error::new(e, stmt.span.clone()))?
                        as isize;
                }
                self.assign(assignable, Value::Int(value))?;
@ -360,10 +305,10 @@ impl<H: HostInterface> ExecEnv<H> {
    fn assign(&mut self, dest: &Assignable, value: Value) -> Result<(), Error> {
        match dest.kind {
            AssignableKind::Variable => {
-                self.get_var_rc_mut(&dest.ident)?.replace(value);
+                self.get_var_mut(&dest.ident)?.value.replace(value);
            }
            AssignableKind::Index { ref indices } => {
-                let mut cell = self.get_var_rc_mut(&dest.ident)?.clone();
+                let mut cell = self.get_var_rc(&dest.ident)?;
                for index in indices {
                    let index = self.eval_expr(index)?;
@ -412,15 +357,14 @@ impl<H: HostInterface> ExecEnv<H> {
        func: Functio,
        args: &[Spanned<Expr>],
        span: &Range<usize>,
-    ) -> Result<HaltStatus, Error> {
+    ) -> 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_mut(&Spanned::new(name.to_owned(), arg.span.clone()))
+                    self.get_var_rc(&Spanned::new(name.to_owned(), arg.span.clone()))
                        .cloned()
                } else {
                    self.eval_expr(arg).map(ValueRef::new)
                }
@ -435,7 +379,7 @@ impl<H: HostInterface> ExecEnv<H> {
        func: Functio,
        args: &[ValueRef],
        span: &Range<usize>,
-    ) -> Result<HaltStatus, Error> {
+    ) -> Result<(), Error> {
        match func {
            Functio::Bf {
                instructions,
@ -455,21 +399,22 @@ impl<H: HostInterface> ExecEnv<H> {
                )
                .interpret_with_output(&mut output)
                .map_err(|e| Error {
-                    kind: ErrorKind::Brian(e),
+                    kind: ErrorKind::BfInterpretError(e),
                    span: span.to_owned(),
                })?;
-                match String::from_utf8(output) {
+                stdout()
-                    Ok(string) => self.host_interface.print(&string, false),
+                    .write_all(&output)
-                    Err(e) => self
+                    .expect("Failed to write to stdout");
                        .host_interface
                        .print(&format!("{:?}", e.as_bytes()), true),
                }
                .map_err(|e| Error::new(e.into(), span.clone()))?;
                Ok(HaltStatus::Finished)
            }
            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()) {
@ -479,45 +424,40 @@ impl<H: HostInterface> ExecEnv<H> {
                let res = self.eval_stmts_hs(&body, false);
                self.stack.pop();
-                res
+                res?;
            }
            Functio::Builtin(b) => {
                b.call(args).map_err(|e| Error::new(e, span.clone()))?;
                Ok(HaltStatus::Finished)
            }
            Functio::Builtin(b) => b.call(args).map_err(|e| Error::new(e, span.clone()))?,
            Functio::Chain { functios, kind } => {
                use crate::value::functio::FunctioChainKind;
                let (left_functio, right_functio) = *functios;
-                Ok(
+                match kind {
-                    match match kind {
+                    crate::variables::FunctioChainKind::Equal => {
                        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(left_functio, l, span)?,
+                        self.fn_call_with_values(right_functio, r, span)?;
                                self.fn_call_with_values(right_functio, r, span)?,
                            )
                    }
-                        FunctioChainKind::ByArity => {
+                    crate::variables::FunctioChainKind::ByArity => {
-                            let (l, r) = Self::deinterlace(
+                        let (l, r) =
-                                args,
+                            Self::deinterlace(args, (left_functio.arity(), right_functio.arity()));
                                (left_functio.arity(), right_functio.arity()),
                            );
-                            (
+                        self.fn_call_with_values(left_functio, &l, span)?;
-                                self.fn_call_with_values(left_functio, &l, span)?,
+                        self.fn_call_with_values(right_functio, &r, span)?;
                                self.fn_call_with_values(right_functio, &r, span)?,
                            )
                    }
-                    } {
+                };
                        (s, HaltStatus::Finished) => s,
                        (HaltStatus::Finished, s) => s,
                        (_, r) => r,
                    },
                )
            }
-            Functio::Eval(code) => self.eval_stmts_hs(&crate::parser::parse(&code)?, false),
+            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>) {
@ -533,23 +473,18 @@ impl<H: HostInterface> ExecEnv<H> {
                .take(n_alternations)
                .map(|chunk| ValueRef::clone(&chunk[0]))
                .chain(
-                    args.get(2 * n_alternations..)
+                    args[2 * n_alternations..]
                        .iter()
                        .copied()
                        .flatten()
                        .map(ValueRef::clone)
                        .take(extra_l),
                )
                .collect(),
            args.chunks(2)
                .take(n_alternations)
-                .flat_map(|chunk| chunk.get(1))
+                .map(|chunk| ValueRef::clone(&chunk[1]))
                .map(ValueRef::clone)
                .chain(
-                    args.get(2 * n_alternations..)
+                    args[2 * n_alternations..]
                        .iter()
                        .copied()
                        .flatten()
                        .map(ValueRef::clone)
                        .take(extra_r),
                )
@ -559,14 +494,15 @@ impl<H: HostInterface> ExecEnv<H> {
    /// 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, ErrorKind> {
+    fn get_bit(&mut self) -> Result<bool, Error> {
        const BITS_PER_BYTE: u8 = 8;
        if self.read_buf.is_empty() {
-            let byte = self.host_interface.read_byte()?;
+            let mut data = [0];
            stdin().read_exact(&mut data)?;
            for n in (0..BITS_PER_BYTE).rev() {
-                self.read_buf.push_back(((byte >> n) & 1) != 0);
+                self.read_buf.push_back(((data[0] >> n) & 1) != 0);
            }
        }
@ -578,7 +514,7 @@ impl<H: HostInterface> ExecEnv<H> {
    /// Get the value of a variable. Throw an error if the variable is
    /// inaccessible or banned.
-    fn get_var_value(&self, name: &Spanned<String>) -> Result<Value, Error> {
+    fn get_var(&self, name: &Spanned<String>) -> Result<Value, Error> {
        // Search for the name in the stack from top to bottom.
        match self
            .stack
@ -586,16 +522,25 @@ impl<H: HostInterface> ExecEnv<H> {
            .rev()
            .find_map(|scope| scope.variables.get(&name.item))
        {
-            Some(Variable::Ref(r)) => Ok(r.borrow().clone()),
+            Some(var) => {
-            Some(Variable::Melo) => Err(Error {
+                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(),
            }),
            None => Ok(Value::Undefined),
        }
    }
-    /// Get a mutable reference to a variable.
+    /// 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...
@ -605,7 +550,16 @@ impl<H: HostInterface> ExecEnv<H> {
            .rev()
            .find_map(|scope| scope.variables.get_mut(&name.item))
        {
-            Some(var) => Ok(var),
+            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(),
@ -613,16 +567,10 @@ impl<H: HostInterface> ExecEnv<H> {
        }
    }
-    /// Get an reference to an Rc'd pointer to the value of a variable. Throw an error
+    /// 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(&mut self, name: &Spanned<String>) -> Result<&mut ValueRef, Error> {
+    fn get_var_rc(&mut self, name: &Spanned<String>) -> Result<ValueRef, Error> {
-        match self.get_var_mut(name)? {
+        Ok(self.get_var_mut(name)?.value.clone())
            Variable::Ref(r) => Ok(r),
            Variable::Melo => Err(Error {
                kind: ErrorKind::MeloVariable(name.item.to_owned()),
                span: name.span.clone(),
            }),
        }
    }
    /// Declare a new variable, with the given initial value.
@ -637,22 +585,19 @@ impl<H: HostInterface> ExecEnv<H> {
            .last()
            .expect("Declaring variable on empty stack")
            .variables
-            .insert(name.to_owned(), Variable::Ref(value));
+            .insert(name.to_owned(), Variable { melo: false, value });
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{
+    use crate::ast::{Expr, Literal};
        ast::{Expr, Literal},
        host_interface::Standard,
    };
    #[test]
    fn basic_expression_test() {
        // Check that 2 + 2 = 4.
-        let env = ExecEnv::<Standard>::default();
+        let env = ExecEnv::new();
        assert_eq!(
            env.eval_expr(&Spanned {
                item: Expr::BinOp {
@ -678,7 +623,7 @@ mod tests {
        // The sum of an integer and an aboolean causes an aboolean
        // coercion.
-        let env = ExecEnv::<Standard>::default();
+        let env = ExecEnv::new();
        assert_eq!(
            env.eval_expr(&Spanned {
                item: Expr::BinOp {
@ -703,7 +648,7 @@ mod tests {
    fn overflow_should_not_panic() {
        // Integer overflow should throw a recoverable error instead
        // of panicking.
-        let env = ExecEnv::<Standard>::default();
+        let env = ExecEnv::new();
        assert_eq!(
            env.eval_expr(&Spanned {
                item: Expr::BinOp {
@ -747,7 +692,7 @@ mod tests {
    // 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<Standard>, src: &str) -> Result<Value, Error> {
+    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();
@ -759,12 +704,12 @@ mod tests {
        // Functions have no return values, so use some
        // pass-by-reference hacks to detect the correct
        // functionality.
-        let mut env = ExecEnv::<Standard>::default();
+        let mut env = ExecEnv::new();
        // Declaring and reading from a variable.
-        eval(&mut env, "foo dim 32; bar dim foo + 1;").unwrap();
+        eval(&mut env, "dim foo 32; dim bar foo + 1;").unwrap();
        assert_eq!(
-            env.get_var_value(&Spanned {
+            env.get_var(&Spanned {
                item: "bar".to_owned(),
                span: 1..1,
            })
@ -775,7 +720,7 @@ mod tests {
        // Assigning an existing variable.
        eval(&mut env, "/*hi*/ =: foo;").unwrap();
        assert_eq!(
-            env.get_var_value(&Spanned {
+            env.get_var(&Spanned {
                item: "foo".to_owned(),
                span: 1..1,
            })
@ -793,15 +738,15 @@ mod tests {
        // Declaration and assignment of variables declared in an `if`
        // statement should have no effect on those declared outside
        // of it.
-        let mut env = ExecEnv::<Standard>::default();
+        let mut env = ExecEnv::new();
        eval(
            &mut env,
-            "foo dim 1; 2 =: foo; unless (never) { foo dim 3; 4 =: foo; }",
+            "dim foo 1; 2 =: foo; unless (never) { dim foo 3; 4 =: foo; }",
        )
        .unwrap();
        assert_eq!(
-            env.get_var_value(&Spanned {
+            env.get_var(&Spanned {
                item: "foo".to_owned(),
                span: 1..1,
            })
--- a/ablescript/src/lexer.rs
+++ b/ablescript/src/lexer.rs
@ -1,60 +1,135 @@
 use logos::{Lexer, Logos};
-#[derive(Logos, Debug, PartialEq, Eq, Clone)]
+#[derive(Logos, Debug, PartialEq, Clone)]
 #[logos(skip r"[ \t\n\f]+")]
 #[logos(skip r"owo .*")]
 #[rustfmt::skip]
 pub enum Token {
    // Symbols
-    #[token("(")] LeftParen,
+    #[token("(")]
-    #[token(")")] RightParen,
+    LeftParen,
-    #[token("[")] LeftBracket,
+
-    #[token("]")] RightBracket,
+    #[token(")")]
-    #[token("{")] LeftCurly,
+    RightParen,
-    #[token("}")] RightCurly,
+
-    #[token(";")] Semicolon,
+    #[token("[")]
-    #[token(",")] Comma,
+    LeftBracket,
    #[token("]")]
    RightBracket,
    #[token("{")]
    LeftCurly,
    #[token("}")]
    RightCurly,
    #[token(";")]
    Semicolon,
    #[token(",")]
    Comma,
    // Operators
-    #[token("+")] Plus,
+    #[token("+")]
-    #[token("-")] Minus,
+    Plus,
-    #[token("*")] Star,
+
-    #[token("/")] FwdSlash,
+    #[token("-")]
-    #[token("=:")] Assign,
+    Minus,
-    #[token("<=")] Arrow,
+
    #[token("*")]
    Star,
    #[token("/")]
    FwdSlash,
    #[token("=:")]
    Assign,
    #[token("<=")]
    Arrow,
    // Logical operators
-    #[token("<")] LessThan,
+    #[token("<")]
-    #[token(">")] GreaterThan,
+    LessThan,
-    #[token("=")] Equals,
+
-    #[token("ain't")] Aint,
+    #[token(">")]
    GreaterThan,
    #[token("=")]
    Equals,
    #[token("ain't")]
    Aint,
    // Keywords
-    #[token("functio")] Functio,
+    #[token("functio")]
-    #[token("bff")] Bff,
+    Functio,
-    #[token("dim")] Dim,
+
-    #[token("print")] Print,
+    /// Brain fuck FFI
-    #[token("read")] Read,
+    #[token("bff")]
-    #[token("melo")] Melo,
+    Bff,
-    #[token("T-Dark")] TDark,
+
    /// 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("unless")]
-    #[token("loop")] Loop,
+    Unless,
    #[token("enough")] Enough,
    #[token("and again")] AndAgain,
    #[token("finally")] Finally,
    #[token("rlyeh")] Rlyeh,
-    #[token("rickroll")] Rickroll,
+    #[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
-    #[token("/*", get_string)] String(String),
+    /// String
-    #[regex(r"-?[0-9]+", get_value)] Integer(isize),
+    #[token("/*", get_string)]
-    #[regex(r"\p{XID_Start}", get_value)] Char(char),
+    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)]
    #[token("and ", |_| "and".to_owned())]
    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> {
@ -63,31 +138,7 @@ fn get_value<T: std::str::FromStr>(lexer: &mut Lexer<Token>) -> Option<T> {
 fn get_string(lexer: &mut Lexer<Token>) -> Option<String> {
    lexer.bump(lexer.remainder().find("*/")?);
-
+    let string = lexer.slice()[2..].to_owned();
    let mut string = String::new();
    let mut slice = &lexer.slice()[2..];
    while let Some(escape_start) = slice.find('"') {
        // Push predeceasing string
        string.push_str(slice.get(..escape_start)?);
        // Move slice behind escape start delimiter
        slice = slice.get(escape_start + 1..)?;
        // Get escape end delimiter position and parse string before it to
        // a character from it's unicode value (base-12) and push it to string
        let escape_end = slice.find('"')?;
        string.push(
            u32::from_str_radix(slice.get(..escape_end)?, 12)
                .ok()
                .and_then(char::from_u32)?,
        );
        // Move slice behind escape end delimiter
        slice = slice.get(escape_end + 1..)?;
    }
    // Push remaining string
    string.push_str(slice);
    lexer.bump(2);
    Some(string)
@ -128,17 +179,8 @@ mod tests {
            RightCurly,
            RightCurly,
        ];
-
+        let lexer = Token::lexer(code);
-        let result: Vec<_> = Token::lexer(code).collect::<Result<_, _>>().unwrap();
+        let result: Vec<Token> = lexer.collect();
        assert_eq!(result, expected);
    }
    #[test]
    fn escapes() {
        let code = r#"/*»"720B""722B""7195"«*/"#;
        let expected = &[Token::String("»にゃぁ«".to_owned())];
        let result: Vec<_> = Token::lexer(code).collect::<Result<_, _>>().unwrap();
        assert_eq!(result, expected);
    }
 }
--- a/ablescript/src/lib.rs
+++ b/ablescript/src/lib.rs
@ -1,16 +1,11 @@
-//! The AbleScript language reference implementation. See
+#![doc = include_str!("../../README.md")]
-//! <https://git.ablecorp.us/AbleScript/able-script> for more
+#![forbid(unsafe_code, clippy::unwrap_used)]
 //! information.
 #![forbid(unsafe_code)]
 #![cfg_attr(not(test), forbid(clippy::unwrap_used))]
 pub mod ast;
 pub mod error;
 pub mod host_interface;
 pub mod interpret;
 pub mod parser;
-pub mod value;
+pub mod variables;
 mod base_55;
 mod brian;
--- a/ablescript/src/parser.rs
+++ b/ablescript/src/parser.rs
@ -31,12 +31,12 @@ impl<'source> Parser<'source> {
        let mut ast = vec![];
        while let Some(token) = self.lexer.next() {
            match token {
-                // T-Dark block (replace `lang` with `script`)
+                // Ignore comments
-                Ok(Token::TDark) => ast.extend(self.tdark_flow()?),
+                Token::Comment => continue,
                Ok(token) => ast.push(self.parse_stmt(token)?),
-                // Invalid token
+                // T-Dark block (replace `lang` with `script`)
-                Err(()) => return Err(Error::new(ErrorKind::InvalidToken, self.lexer.span())),
+                Token::TDark => ast.extend(self.tdark_flow()?),
                token => ast.push(self.parse_stmt(token)?),
            }
        }
        Ok(ast)
@ -46,10 +46,15 @@ impl<'source> Parser<'source> {
    ///
    /// If EOF, return Error instead of None
    fn checked_next(&mut self) -> Result<Token, Error> {
-        match self.lexer.next() {
+        loop {
-            Some(Ok(t)) => Ok(t),
+            match self
-            Some(Err(())) => Err(Error::new(ErrorKind::InvalidToken, self.lexer.span())),
+                .lexer
-            None => Err(Error::unexpected_eoi(self.lexer.span().start)),
+                .next()
                .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?
            {
                Token::Comment => (),
                token => break Ok(token),
            }
        }
    }
@ -61,16 +66,40 @@ impl<'source> Parser<'source> {
        let start = self.lexer.span().start;
        match token {
-            Token::Unless => self.unless_flow(),
+            Token::Unless => Ok(Spanned::new(
-            Token::Functio => self.functio_flow(),
+                self.unless_flow()?,
-            Token::Bff => self.bff_flow(),
+                start..self.lexer.span().end,
-            Token::Melo => self.melo_flow(),
+            )),
-            Token::Loop => self.get_block().map(|body| Stmt::Loop { body }),
+            Token::Functio => Ok(Spanned::new(
-            Token::Enough => self.semicolon_terminated(Stmt::Enough),
+                self.functio_flow()?,
-            Token::AndAgain => self.semicolon_terminated(Stmt::AndAgain),
+                start..self.lexer.span().end,
-            Token::Finally => self.get_block().map(Stmt::Finally),
+            )),
-            Token::Rlyeh => self.semicolon_terminated(Stmt::Rlyeh),
+            Token::Bff => Ok(Spanned::new(self.bff_flow()?, start..self.lexer.span().end)),
-            Token::Rickroll => self.semicolon_terminated(Stmt::Rickroll),
+            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(_)
@ -78,14 +107,16 @@ impl<'source> Parser<'source> {
            | Token::Char(_)
            | Token::Aint
            | Token::LeftBracket
-            | Token::LeftParen => self.value_flow(token),
+            | 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,
            }),
        }
        .map(|stmt| Spanned::new(stmt, start..self.lexer.span().end))
    }
    /// Require statement to be semicolon terminated
@ -107,9 +138,14 @@ impl<'source> Parser<'source> {
    /// Get an Identifier
    fn get_ident(&mut self) -> Result<Spanned<String>, Error> {
        match self.checked_next()? {
-            Token::Identifier(ident) => {
+            Token::Identifier(ident) => Ok(Spanned::new(
-                Ok(Spanned::new(self.tdark_subst(ident), self.lexer.span()))
+                if self.tdark {
-            }
+                    ident.replace("lang", "script")
                } else {
                    ident
                },
                self.lexer.span(),
            )),
            t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
        }
    }
@ -131,20 +167,50 @@ impl<'source> Parser<'source> {
        match token {
            // Values
-            Token::Identifier(i) => Ok(Expr::Variable(self.tdark_subst(i))),
+            Token::Identifier(i) => Ok(Spanned::new(
-            Token::Integer(i) => Ok(Expr::Literal(Literal::Int(i))),
+                Expr::Variable(if self.tdark {
-            Token::String(s) => Ok(Expr::Literal(Literal::Str(self.tdark_subst(s)))),
+                    i.replace("lang", "script")
-            Token::Char(c) => Ok(Expr::Literal(Literal::Char(c))),
+                } 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) => self.index_flow(buf),
+                Some(buf) => Ok(Spanned::new(
-                None => self.cart_flow(),
+                    self.index_flow(buf)?,
                    start..self.lexer.span().end,
                )),
                None => Ok(Spanned::new(
                    self.cart_flow()?,
                    start..self.lexer.span().end,
                )),
            },
            // Operations
-            Token::Aint if buf.is_none() => {
+            Token::Aint if buf.is_none() => Ok(Spanned::new(
                {
                    let next = self.checked_next()?;
-                Ok(Expr::Aint(Box::new(self.parse_expr(next, buf)?)))
+                    Expr::Aint(Box::new(self.parse_expr(next, buf)?))
-            }
+                },
                start..self.lexer.span().end,
            )),
            Token::Plus
            | Token::Minus
@ -153,15 +219,17 @@ impl<'source> Parser<'source> {
            | Token::Equals
            | Token::LessThan
            | Token::GreaterThan
-            | Token::Aint => self.binop_flow(
+            | 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 => return self.expr_flow(Token::RightParen),
+            Token::LeftParen => self.expr_flow(Token::RightParen),
            t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
        }
        .map(|expr| Spanned::new(expr, start..self.lexer.span().end))
    }
    /// Flow for creating carts
@ -190,7 +258,7 @@ impl<'source> Parser<'source> {
                                cart.push((
                                    value,
                                    buf.take().ok_or_else(|| {
-                                        Error::unexpected_eoi(self.lexer.span().start)
+                                        Error::unexpected_eof(self.lexer.span().start)
                                    })?,
                                ));
@ -200,7 +268,7 @@ impl<'source> Parser<'source> {
                            t => buf = Some(self.parse_expr(t, &mut buf)?),
                        }
                    }
-                    .ok_or_else(|| Error::unexpected_eoi(self.lexer.span().start))?;
+                    .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?;
                    cart.push((value, key));
                }
@ -226,10 +294,6 @@ impl<'source> Parser<'source> {
                    }
                    None => break Expr::Len(Box::new(expr)),
                },
                Token::GreaterThan if buf.is_none() => {
                    self.require(Token::RightBracket)?;
                    break Expr::Keys(Box::new(expr));
                }
                token => buf = Some(self.parse_expr(token, &mut buf)?),
            }
        })
@ -251,7 +315,10 @@ impl<'source> Parser<'source> {
                    .ok_or_else(|| Error::new(ErrorKind::MissingLhs, self.lexer.span()))?,
            ),
            rhs: {
-                let next = self.checked_next()?;
+                let next = self
                    .lexer
                    .next()
                    .ok_or_else(|| Error::unexpected_eof(self.lexer.span().start))?;
                Box::new(self.parse_expr(next, &mut None)?)
            },
            kind,
@ -301,28 +368,14 @@ impl<'source> Parser<'source> {
    /// 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)?);
-        Ok(loop {
+        let r = loop {
            match self.checked_next()? {
                // Print to stdout
                Token::Print => {
-                    break Stmt::Print {
+                    let stmt = Stmt::Print(buf.take().ok_or_else(|| {
                        expr: buf.take().ok_or_else(|| {
                        Error::new(ErrorKind::UnexpectedToken(Token::Print), self.lexer.span())
-                        })?,
+                    })?);
-                        newline: match self.checked_next()? {
+                    break self.semicolon_terminated(stmt)?;
                            Token::Semicolon => true,
                            Token::Minus => {
                                self.require(Token::Semicolon)?;
                                false
                            }
                            token => {
                                return Err(Error::new(
                                    ErrorKind::UnexpectedToken(token),
                                    self.lexer.span(),
                                ));
                            }
                        },
                    };
                }
                // Functio call
@ -335,32 +388,7 @@ impl<'source> Parser<'source> {
                    })?)?;
                }
-                // Variable declaration
+                // Variable Assignment
                Token::Dim => {
                    return match buf.take() {
                        Some(Spanned {
                            item: Expr::Variable(ident),
                            span,
                        }) => Ok(Stmt::Dim {
                            ident: Spanned::new(ident, span),
                            init: {
                                let mut init = None;
                                loop {
                                    match self.checked_next()? {
                                        Token::Semicolon => break init,
                                        token => init = Some(self.parse_expr(token, &mut init)?),
                                    }
                                }
                            },
                        }),
                        _ => Err(Error::new(
                            ErrorKind::UnexpectedToken(Token::Dim),
                            self.lexer.span(),
                        )),
                    }
                }
                // Variable assignment
                Token::Assign => {
                    return match buf.take() {
                        Some(expr) => self.assignment_flow(expr),
@ -386,7 +414,9 @@ impl<'source> Parser<'source> {
                t => buf = Some(self.parse_expr(t, &mut buf)?),
            }
-        })
+        };
        Ok(r)
    }
    /// Parse Unless flow
@ -462,10 +492,16 @@ impl<'source> Parser<'source> {
        let mut code: Vec<u8> = vec![];
        loop {
-            match self.lexer.next() {
+            match self.checked_next()? {
-                Some(Ok(Token::RightCurly)) => break,
+                Token::Plus
-                Some(_) => code.push(self.lexer.slice().as_bytes()[0]),
+                | Token::Minus
-                None => return Err(Error::unexpected_eoi(self.lexer.span().start)),
+                | Token::Comma
                | Token::LeftBracket
                | Token::RightBracket
                | Token::LessThan
                | Token::GreaterThan => code.push(self.lexer.slice().as_bytes()[0]),
                Token::RightCurly => break,
                _ => (),
            }
        }
@ -509,6 +545,20 @@ impl<'source> Parser<'source> {
        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()?;
@ -545,37 +595,13 @@ impl<'source> Parser<'source> {
        self.semicolon_terminated(Stmt::Melo(ident))
    }
-    /// Perform lang -> script substitution if in T-Dark block
+    /// Parse loop flow
-    fn tdark_subst(&self, mut string: String) -> String {
+    ///
-        if self.tdark {
+    /// `loop` is an infinite loop, no condition, only body
-            if let Some(pos) = string.to_lowercase().find("lang") {
+    fn loop_flow(&mut self) -> Result<Stmt, Error> {
-                let range = pos..pos + 4;
+        Ok(Stmt::Loop {
-                let mut count_upper = 0_u8;
+            body: self.get_block()?,
                string.replace_range(
                    range.clone(),
                    &(string[range]
                        .chars()
                        .zip("scri".chars())
                        .map(|(lc, sc)| {
                            if lc.is_uppercase() {
                                count_upper += 1;
                                sc.to_ascii_uppercase()
                            } else {
                                sc.to_ascii_lowercase()
                            }
        })
                        .collect::<String>()
                        + match count_upper {
                            0 | 1 => "pt",
                            2 if rand::random() => "Pt",
                            2 => "pT",
                            _ => "PT",
                        }),
                )
            }
        }
        string
    }
 }
@ -592,8 +618,7 @@ mod tests {
    fn simple_math() {
        let code = "1 * (num + 3) / 666 print;";
        let expected = &[Spanned {
-            item: Stmt::Print {
+            item: Stmt::Print(Spanned {
                expr: Spanned {
                item: Expr::BinOp {
                    lhs: Box::new(Spanned {
                        item: Expr::BinOp {
@ -626,9 +651,7 @@ mod tests {
                    kind: BinOpKind::Divide,
                },
                span: 0..17,
-                },
+            }),
                newline: true,
            },
            span: 0..24,
        }];
@ -638,16 +661,16 @@ mod tests {
    #[test]
    fn variable_declaration() {
-        let code = "var dim 42;";
+        let code = "dim var 42;";
        let expected = &[Spanned {
            item: Stmt::Dim {
                ident: Spanned {
                    item: "var".to_owned(),
-                    span: 0..3,
+                    span: 4..5,
                },
                init: Some(Spanned {
                    item: Expr::Literal(Literal::Int(42)),
-                    span: 4..6,
+                    span: 8..10,
                }),
            },
            span: 0..11,
@ -677,13 +700,10 @@ mod tests {
                    span: 8..21,
                },
                body: vec![Spanned {
-                    item: Stmt::Print {
+                    item: Stmt::Print(Spanned {
                        expr: Spanned {
                        item: Expr::Literal(Literal::Str("Buy Able products!".to_owned())),
                        span: 25..47,
-                        },
+                    }),
                        newline: true,
                    },
                    span: 25..54,
                }],
            },
@ -696,12 +716,12 @@ mod tests {
    #[test]
    fn tdark() {
-        let code = "T-Dark { lang dim /*lang*/ + lang; }";
+        let code = "T-Dark { dim lang /*lang*/ + lang; }";
        let expected = &[Spanned {
            item: Stmt::Dim {
                ident: Spanned {
                    item: "script".to_owned(),
-                    span: 9..15,
+                    span: 13..17,
                },
                init: Some(Spanned {
                    item: Expr::BinOp {
@ -729,8 +749,7 @@ mod tests {
    fn cart_construction() {
        let code = "[/*able*/ <= 1, /*script*/ <= 3 - 1] print;";
        let expected = &[Spanned {
-            item: Stmt::Print {
+            item: Stmt::Print(Spanned {
                expr: Spanned {
                item: Expr::Cart(vec![
                    (
                        Spanned {
@ -764,9 +783,7 @@ mod tests {
                    ),
                ]),
                span: 0..32,
-                },
+            }),
                newline: true,
            },
            span: 0..39,
        }];
@ -778,8 +795,7 @@ mod tests {
    fn cart_index() {
        let code = "[/*able*/ <= /*ablecorp*/][/*ablecorp*/] print;";
        let expected = &[Spanned {
-            item: Stmt::Print {
+            item: Stmt::Print(Spanned {
                expr: Spanned {
                item: Expr::Index {
                    expr: Box::new(Spanned {
                        item: Expr::Cart(vec![(
@ -800,9 +816,7 @@ mod tests {
                    }),
                },
                span: 0..34,
-                },
+            }),
                newline: true,
            },
            span: 0..41,
        }];
--- a/ablescript/src/value/coercions.rs
+++ b/ablescript/src/value/coercions.rs
@ -1,279 +0,0 @@
 use super::{functio::FunctioChainKind, Abool, Cart, Functio, Value, ValueRef};
 use crate::{brian::INSTRUCTION_MAPPINGS, consts};
 use std::collections::HashMap;
 impl Value {
    /// Coerce a value to an integer.
    pub fn into_isize(self) -> isize {
        match self {
            Value::Nul => consts::ANSWER,
            Value::Undefined => rand::random(),
            Value::Str(text) => text
                .parse()
                .unwrap_or_else(|_| text.chars().map(|cr| cr as isize).sum()),
            Value::Int(i) => i,
            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::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::Undefined => Abool::Sometimes,
            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 | Value::Undefined => 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::Undefined => [(Value::Undefined, ValueRef::new(Value::Undefined))]
                .into_iter()
                .collect(),
            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,
        }
    }
 }
--- a/ablescript/src/value/functio.rs
+++ b/ablescript/src/value/functio.rs
@ -1,113 +0,0 @@
 use super::ValueRef;
 use crate::ast::Block;
 use std::{hash::Hash, rc::Rc};
 type BuiltinRc = Rc<dyn Fn(&[ValueRef]) -> Result<(), crate::error::ErrorKind>>;
 /// AbleScript Function
 #[derive(Debug, PartialEq, Clone, Hash)]
 pub enum Functio {
    /// BF instructions and a length of the type
    ///
    /// Takes input bytes as parameters
    Bf {
        instructions: Vec<u8>,
        tape_len: usize,
    },
    /// Regular AbleScript functio
    ///
    /// Consists of parameter name mapping and AST
    Able { params: Vec<String>, body: Block },
    /// Builtin Rust functio
    Builtin(BuiltinFunctio),
    /// Chained functio pair
    Chain {
        functios: Box<(Functio, Functio)>,
        kind: FunctioChainKind,
    },
    /// Code to be parsed and then executed in current scope
    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,
        }
    }
 }
 /// Built-in Rust functio
 #[derive(Clone)]
 pub struct BuiltinFunctio {
    pub(super) function: BuiltinRc,
    pub(super) arity: usize,
 }
 impl BuiltinFunctio {
    /// Wrap a Rust function into AbleScript's built-in functio
    ///
    /// Arity used for functio chaining, recommend value for variadic
    /// functions is the accepted minimum.
    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);
    }
 }
 /// A method of distributting parameters across functio chain
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub enum FunctioChainKind {
    /// All parameters are equally distributed
    Equal,
    /// Parameters are distributed to members of chain
    /// by their arity
    ByArity,
 }
--- a/ablescript/src/value/mod.rs
+++ b/ablescript/src/value/mod.rs
@ -1,202 +0,0 @@
 pub mod functio;
 mod coercions;
 mod ops;
 pub use functio::Functio;
 use std::{
    cell::{Ref, RefCell, RefMut},
    collections::HashMap,
    fmt::Display,
    hash::Hash,
    io::Write,
    mem::discriminant,
    rc::Rc,
 };
 pub type Cart = HashMap<Value, ValueRef>;
 /// AbleScript Value
 #[derive(Debug, Default, Clone)]
 pub enum Value {
    #[default]
    Nul,
    Undefined,
    Str(String),
    Int(isize),
    Abool(Abool),
    Functio(Functio),
    Cart(Cart),
 }
 impl Hash for Value {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        discriminant(self).hash(state);
        match self {
            Value::Nul | Value::Undefined => (),
            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");
    }
 }
 /// Three-state logic value
 #[derive(Debug, Clone, Copy, PartialEq, Eq, 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
        }
    }
 }
 impl Display for Value {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Value::Nul => write!(f, "nul"),
            Value::Undefined => write!(f, "undefined"),
            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 {
                            functio::FunctioChainKind::Equal => '+',
                            functio::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 { "" },)?;
                    match &*value.borrow() {
                        x if std::ptr::eq(x, self) => write!(f, "<cycle>"),
                        x => write!(f, "{x}"),
                    }?;
                    write!(f, " <= {key}")?;
                }
                write!(f, "]")
            }
        }
    }
 }
 /// Runtime borrow-checked, counted reference to a [Value]
 #[derive(Debug, Clone, PartialEq, Eq)]
 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)
    }
 }
 /// AbleScript variable either holding a reference
 /// or being banned
 #[derive(Debug)]
 pub enum Variable {
    /// Reference to a value
    Ref(ValueRef),
    /// Banned variable
    Melo,
 }
 impl Variable {
    pub fn from_value(value: Value) -> Self {
        Self::Ref(ValueRef::new(value))
    }
 }
--- a/ablescript/src/value/ops.rs
+++ b/ablescript/src/value/ops.rs
@ -1,455 +0,0 @@
 use super::{
    functio::{BuiltinFunctio, FunctioChainKind},
    Abool, Functio, Value, ValueRef,
 };
 use crate::consts;
 use rand::Rng;
 use std::{
    collections::HashMap,
    ops::{Add, Div, Mul, Not, Sub},
 };
 impl Add for Value {
    type Output = Value;
    fn add(self, rhs: Self) -> Self::Output {
        match self {
            Value::Nul | Value::Undefined => match rhs {
                Value::Nul => Value::Nul,
                Value::Undefined => Value::Undefined,
                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 Sub for Value {
    type Output = Value;
    fn sub(self, rhs: Self) -> Self::Output {
        match self {
            Value::Nul | Value::Undefined => match rhs {
                Value::Nul => Value::Nul,
                Value::Undefined => Value::Undefined,
                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 Mul for Value {
    type Output = Value;
    fn mul(self, rhs: Self) -> Self::Output {
        match self {
            Value::Nul | Value::Undefined => match rhs {
                Value::Nul => Value::Nul,
                Value::Undefined => Value::Undefined,
                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 Div for Value {
    type Output = Value;
    fn div(self, rhs: Self) -> Self::Output {
        match self {
            Value::Nul | Value::Undefined => match rhs {
                Value::Nul => Value::Nul,
                Value::Undefined => Value::Undefined,
                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 = match c.len() {
                    0 => return Value::Cart(HashMap::new()),
                    l => l,
                };
                let chunk_len = match rhs.into_isize() as usize {
                    0 => rand::thread_rng().gen_range(1..=cart_len),
                    l => l,
                };
                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 Not for Value {
    type Output = Value;
    fn not(self) -> Self::Output {
        match self {
            Value::Nul => Value::Undefined,
            Value::Undefined => 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::Undefined => matches!(other, Value::Undefined),
            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),
            Value::Undefined if other == Value::Undefined => Some(Equal),
            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())),
            Value::Nul | Value::Undefined => None,
        }
    }
 }
 impl Value {
    /// Get a length of a value
    pub fn length(&self) -> isize {
        match self {
            Value::Nul => 0,
            Value::Undefined => -1,
            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 _,
        }
    }
 }
--- a/ablescript/src/variables.rs
+++ b/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),
        }
    }
 }
--- a/ablescript_cli/Cargo.toml
+++ b/ablescript_cli/Cargo.toml
@ -1,15 +1,18 @@
 [package]
 name = "ablescript_cli"
-version = "0.5.4"
+version = "0.3.0"
-authors = ["AbleScript Developers"]
+authors = ["able <abl3theabove@gmail.com>"]
 edition = "2021"
 description = "The best programming language"
 license = "MIT"
-documentation = "https://gblecorp.github.io/able-script-the-book"
+documentation = "https://ablecorp.us/able-script-the-book/"
-repository    = "https://git.ablecorp.us/AbleScript/able-script"
+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.5.3", path = "../ablescript" }
+ablescript = { version = "0.3.0", path = "../ablescript" }
-clap       = { version = "4.2", features = ["derive"] }
+
-rustyline  = "11.0"
+clap = "3.1"
 rustyline = "9.1"
--- a/ablescript_cli/src/main.rs
+++ b/ablescript_cli/src/main.rs
@ -1,31 +1,52 @@
-#![forbid(unsafe_code)]
+#![forbid(unsafe_code, clippy::unwrap_used)]
 mod repl;
-use ablescript::{interpret::ExecEnv, parser::parse};
+use ablescript::interpret::ExecEnv;
-use clap::Parser;
+use ablescript::parser::parse;
-use std::{path::PathBuf, process::exit};
+use clap::{Arg, Command};
 use std::process::exit;
 fn main() {
    // variables::test(); // NOTE(Able): Add this as a test case
-    let args = Args::parse();
+    let matches = Command::new("AbleScript")
-    match args.file {
+        .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) {
+            let source = match std::fs::read_to_string(file_path) {
                Ok(s) => s,
                Err(e) => {
-                    println!("Failed to read file \"{:?}\": {}", file_path, e);
+                    println!("Failed to read file \"{}\": {}", file_path, e);
                    exit(1)
                }
            };
            // Parse & evaluate
            if let Err(e) = parse(&source).and_then(|ast| {
-                if args.debug {
+                if ast_print {
-                    eprintln!("{:#?}", ast);
+                    println!("{:#?}", ast);
                }
-                ExecEnv::<ablescript::host_interface::Standard>::default().eval_stmts(&ast)
+                ExecEnv::new().eval_stmts(&ast)
            }) {
                println!(
                    "Error `{:?}` occurred at span: {:?} = `{:?}`",
@ -37,19 +58,7 @@ fn main() {
        }
        None => {
            println!("Hi [AbleScript {}]", env!("CARGO_PKG_VERSION"));
-            repl::repl(args.debug);
+            repl::repl(ast_print);
        }
    }
 }
 #[derive(Parser, Debug)]
 #[command(name = "AbleScript", version, about)]
 struct Args {
    /// File to execute
    #[arg(short, long)]
    file: Option<PathBuf>,
    /// Dump AST to console
    #[arg(short, long)]
    debug: bool,
 }
--- a/ablescript_cli/src/repl.rs
+++ b/ablescript_cli/src/repl.rs
@ -1,16 +1,10 @@
-use ablescript::{interpret::ExecEnv, parser::parse};
+use ablescript::interpret::ExecEnv;
-use rustyline::DefaultEditor;
+use ablescript::parser::parse;
 use rustyline::Editor;
 pub fn repl(ast_print: bool) {
-    let mut rl = match DefaultEditor::new() {
+    let mut rl = Editor::<()>::new();
-        Ok(rl) => rl,
+    let mut env = ExecEnv::new();
        Err(e) => {
            eprintln!("Failed to create editor: {e}");
            std::process::exit(-1);
        }
    };
    let mut env = ExecEnv::<ablescript::host_interface::Standard>::default();
    // If this is `Some`, the user has previously entered an
    // incomplete statement and is now completing it; otherwise, the
@ -20,7 +14,7 @@ pub fn repl(ast_print: bool) {
        match rl.readline(if partial.is_some() { ">> " } else { ":: " }) {
            Ok(readline) => {
                let readline = readline.trim_end();
-                let _ = rl.add_history_entry(readline);
+                rl.add_history_entry(readline);
                let partial_data = match partial {
                    Some(line) => line + readline,
@ -29,7 +23,7 @@ pub fn repl(ast_print: bool) {
                partial = match parse(&partial_data).and_then(|ast| {
                    if ast_print {
-                        eprintln!("{:#?}", &ast);
+                        println!("{:#?}", &ast);
                    }
                    env.eval_stmts(&ast)
                }) {
@ -37,7 +31,7 @@ pub fn repl(ast_print: bool) {
                    Err(ablescript::error::Error {
                        // Treat "Unexpected EOF" errors as "we need
                        // more data".
-                        kind: ablescript::error::ErrorKind::UnexpectedEoi,
+                        kind: ablescript::error::ErrorKind::UnexpectedEof,
                        ..
                    }) => Some(partial_data),
                    Err(e) => {
--- a/examples/by-arity-chain.able
+++ b/examples/by-arity-chain.able
@ -25,20 +25,20 @@ owo arity_1(/*foo*/);
 owo arity_2(/*foo*/, /*bar*/);
 owo arity_3(/*foo*/, /*bar*/, /*baz*/);
-i1 dim arity_0 * arity_1;
+dim i1 arity_0 * arity_1;
 i1(/*second*/);
 /*----*/ print;
-i2 dim arity_1 * arity_0;
+dim i2 arity_1 * arity_0;
 i2(/*first*/);
 /*----*/ print;
-ifancy dim arity_3 * arity_3;
+dim ifancy arity_3 * arity_3;
 ifancy(/*left1*/, /*right1*/, /*left2*/, /*right2*/, /*left3*/, /*right3*/);
 /*---*/ print;
-another dim arity_0 * arity_3;
+dim another arity_0 * arity_3;
 another(/*right1*/, /*right2*/, /*right3*/);
--- a/examples/carts.able
+++ b/examples/carts.able
@ -2,7 +2,7 @@ functio helloable() {
   /*Hello, Able!*/ print;
 }
-cart dim [/*able*/ <= 42, helloable <= /*hello*/];
+dim cart [/*able*/ <= 42, helloable <= /*hello*/];
 cart[42] print;
 cart[/*hello*/]();
--- a/examples/hello-world.able
+++ b/examples/hello-world.able
@ -1,2 +1,2 @@
-hello dim /*world*/;
+dim hello /*world*/;
 hello print;
--- a/examples/iotest.able
+++ b/examples/iotest.able
@ -1,4 +1,4 @@
-data dim;
+dim data;
 loop {
   data read;
   data print;
--- a/examples/melo-hello.able
+++ b/examples/melo-hello.able
@ -1,3 +1,3 @@
-hi dim /*wonk*/;
+dim hi /*wonk*/;
 melo hi;
 hi print; owo Should error out
--- a/examples/pass-by-reference.able
+++ b/examples/pass-by-reference.able
@ -2,13 +2,13 @@ owo Pass-by-reference test
 owo Swap two variables.
 functio swap(left, right) {
-   tmp dim left;
+   dim tmp left;
   right =: left;
   tmp =: right;
 }
-foo dim /*hello*/;
+dim foo /*hello*/;
-bar dim /*world*/;
+dim bar /*world*/;
 swap(foo, bar);
`@ -1,2 +1,2 @@`
	`hello dim /world/;`	`dim hello /world/;`
	`hello print;`	`hello print;`