spitewaste 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cd3201a4c8647de4fb29c8529c45fb379c2633cd660a4155e28720931202f94
-  data.tar.gz: 3ba703110341a406d476aa8afa8d89c8a57b9d6e136f319956f28f7d311b16e7
+  metadata.gz: dd82c27931f053688f5ce4b0406bfb1a87448dd14be21deaaf75d6faf4c7353d
+  data.tar.gz: f08502018fb3474f708d2adbeac4df57db03a7a38d86d00c1a0ecd17182c8336
 SHA512:
-  metadata.gz: d103c80be7025cca6d784127444702460394e4d0f137f124581212b6d92523b80c7e95e15642f9c0036b26545e821dcee206686818d0728dbe57c7b57a388ef0
-  data.tar.gz: 39f473d86a4df1a125a6edae3ff1e29c5a069da2aa72862834097b7151bd11c4fdfe93f8119b60c7009468e4f5c2a05ef60a92d99a9b9198485f79c42411f33d
+  metadata.gz: 3cee6b9e82a342c672f5c4ecc8c3ca3820c160ddb286f22fd59ab35c5b74c961b856077798a7238ff2966c0477d31f54e48797fcff480b8fe7a3e081a37e91d0
+  data.tar.gz: 2b7c2e45a492defe0236641d26fe830e40a88983387caeda1490dd561ee73465d0ad915b57450aa00a776f5b2e1675aa698fb5a4a838c9d91a0afb44a905bc6b

data/Rakefile

@@ -15,9 +15,8 @@ task :docs do |t|
 
   Dir.chdir('lib/spitewaste/libspw') do |d|
     Dir['*.spw'].sort.each do |path|
-      next if path['random']
-      lib = File.basename path, '.spw'
-      docs[lib] = extract_docs path
+      mod = File.basename path, '.spw'
+      docs[mod] = extract_docs path
     end
 
     File.open('docs.json', ?w) { |f|

data/bin/spw

@@ -7,5 +7,6 @@ require 'spitewaste/cli/exec'
 require 'spitewaste/cli/compile'
 require 'spitewaste/cli/convert'
 require 'spitewaste/cli/image'
+require 'spitewaste/cli/version'
 
 SpitewasteCLI.start ARGV

data/lib/spitewaste.rb

@@ -21,6 +21,10 @@ module Spitewaste
     return :whitespace if white > black
     program[/import|[^-\w\s]/] ? :spitewaste : :assembly
   end
+
+  def strpack s
+    s.bytes.zip(0..).sum { |b, e| b * 128 ** e }
+  end
 end
 
 require 'spitewaste/assembler'

data/lib/spitewaste/assembler.rb

@@ -85,7 +85,7 @@ module Spitewaste
       @ip = 0
       while @instructions[@ip]
         next @ip -= 1 if optimize_constant_pow
-        next if optimize_constant_strpack
+        # next if optimize_constant_strpack
         @ip += 1
       end
     end

data/lib/spitewaste/cli/version.rb

@@ -0,0 +1,9 @@
+require 'spitewaste/version'
+
+class SpitewasteCLI
+  desc 'version', 'Display the current version of Spitewaste and exit.'
+
+  def version
+    puts "spw version #{Spitewaste::VERSION}"
+  end
+end

data/lib/spitewaste/emitters/image.rb

@@ -4,7 +4,8 @@ require 'yaml'
 
 module Spitewaste
   class ImageEmitter < Emitter
-    SCHEMES  = YAML.load_file(File.join __dir__, 'schemes.yaml')['schemes']
+    schemes  = File.read File.join __dir__, 'schemes.yaml'
+    SCHEMES  = YAML.safe_load(schemes, aliases: true)['schemes']
     LINEFEED = ChunkyPNG::Image.from_file File.join __dir__, 'linefeed.png'
     DEFAULTS =  {
       colors: 'gruvbox_dark',
@@ -112,7 +113,7 @@ module Spitewaste
       flow:  %i[jump jz jn ret exit],
       math:  %i[add sub mul div mod],
       heap:  %i[store load],
-      io:    %i[ichr inum ochr onum],
+      io:    %i[ichr inum ochr onum shell],
       calls: %i[call label]
     }.flat_map { |type, insns| insns.map { |i| [i, type] } }.to_h
 

data/lib/spitewaste/emitters/schemes.yaml

@@ -599,6 +599,52 @@ schemes:
       cyan:    '0x99faf2'
       white:   '0xffffff'
 
+  konsole_linux: &konsole_linux
+    primary:
+      foreground: '0xe3e3e3'
+      bright_foreground: '0xffffff'
+      dim_foreground:    '0xe3e3e3'
+      background: '0x1f1f1f'
+      bright_background: '0x686868' # not sure
+      dim_background:    '0x1f1f1f' # not sure
+    cursor:
+      text: '0x191622'
+      cursor: '0xf8f8f2'
+    search:
+      matches:
+        foreground: '0xb2b2b2'
+        background: '0xb26818'
+      focused_match:
+        foreground: CellBackground
+        background: CellForeground
+    normal:
+      black:   '0x000000'
+      red:     '0xb21818'
+      green:   '0x18b218'
+      yellow:  '0xb26818'
+      blue:    '0x1818b2'
+      magenta: '0xb218b2'
+      cyan:    '0x18b2b2'
+      white:   '0xb2b2b2'
+    bright:
+      black:   '0x686868'
+      red:     '0xff5454'
+      green:   '0x54ff54'
+      yellow:  '0xffff54'
+      blue:    '0x5454ff'
+      magenta: '0xff54ff'
+      cyan:    '0x54ffff'
+      white:   '0xffffff'
+    dim:
+      black:   '0x000000'
+      red:     '0xb21818'
+      green:   '0x18b218'
+      yellow:  '0xb26818'
+      blue:    '0x1818b2'
+      magenta: '0xb218b2'
+      cyan:    '0x18b2b2'
+      white:   '0xb2b2b2'
+
   low_contrast: &low_contrast
     primary:
       background: '0x333333'
@@ -717,6 +763,41 @@ schemes:
       cyan:    '0x5fb3b3'
       white:   '0xadb5c0'
 
+  omni: &omni
+    primary:
+      background: '0x191622'
+      foreground: '0xe1e1e6'
+    cursor:
+      text: '0x191622'
+      cursor: '0xf8f8f2'
+    normal:
+      black: '0x000000'
+      red: '0xff5555'
+      green: '0x50fa7b'
+      yellow: '0xeffa78'
+      blue: '0xbd93f9'
+      magenta: '0xff79c6'
+      cyan: '0x8d79ba'
+      white: '0xbfbfbf'
+    bright:
+      black: '0x4d4d4d'
+      red: '0xff6e67'
+      green: '0x5af78e'
+      yellow: '0xeaf08d'
+      blue: '0xcaa9fa'
+      magenta: '0xff92d0'
+      cyan: '0xaa91e3'
+      white: '0xe6e6e6'
+    dim:
+      black: '0x000000'
+      red: '0xa90000'
+      green: '0x049f2b'
+      yellow: '0xa3b106'
+      blue: '0x530aba'
+      magenta: '0xbb006b'
+      cyan: '0x433364'
+      white: '0x5f5f5f'
+
   one_dark: &one_dark
     primary:
       background: '0x1e2127'
@@ -740,6 +821,29 @@ schemes:
       cyan:    '0x56b6c2'
       white:   '0xffffff'
 
+  palenight: &palenight
+    primary:
+      background: '0x292d3e'
+      foreground: '0xd0d0d0'
+    normal:
+      black:   '0x292d3e'
+      red:     '0xf07178'
+      green:   '0xc3e88d'
+      yellow:  '0xffcb6b'
+      blue:    '0x82aaff'
+      magenta: '0xc792ea'
+      cyan:    '0x89ddff'
+      white:   '0xd0d0d0'
+    bright:
+      black:   '0x434758'
+      red:     '0xff8b92'
+      green:   '0xddffa7'
+      yellow:  '0xffe585'
+      blue:    '0x9cc4ff'
+      magenta: '0xe1acff'
+      cyan:    '0xa3f7ff'
+      white:   '0xffffff'
+
   papercolor_light: &papercolor_light
     primary:
       background: '0xeeeeee'
@@ -812,6 +916,29 @@ schemes:
       cyan:    '0x4fb8cc'
       white:   '0xf1f1f1'
 
+  remedy_dark: &remedy_dark
+    primary:
+      background: '0x2c2b2a'
+      foreground: '0xf9e7c4'
+    normal:
+      black:   '0x282a2e'
+      blue:    '0x5f819d'
+      cyan:    '0x5e8d87'
+      green:   '0x8c9440'
+      magenta: '0x85678f'
+      red:     '0xa54242'
+      white:   '0x707880'
+      yellow:  '0xde935f'
+    bright:
+      black:   '0x373b41'
+      blue:    '0x81a2be'
+      cyan:    '0x8abeb7'
+      green:   '0xb5bd68'
+      magenta: '0xb294bb'
+      red:     '0xcc6666'
+      white:   '0xc5c8c6'
+      yellow:  '0xf0c674'
+
   snazzy: &snazzy
     primary:
       background: '0x282a36'

data/lib/spitewaste/libspw/array.spw

@@ -10,6 +10,12 @@ import util  ; dec, die!, eq
 
 $amax = 1000
 
+; prints the array A to stdout in the form [e1,e2,...]
+; [A] => []
+aryprint:
+  map (:to_s) push ',' :strjoinc
+  push '[' ochr :print push ']' ochr ret
+
 ; places an array of N elements E at the top of the stack
 ; [N E] => [A]
 ;
@@ -36,7 +42,23 @@ arysum: reduce (add) ret
 ; [7 50 10 2] => [7 50 10 2 50 10 2]
 arydup:
   dup $++ push -2 copy 1 store
-  times (push -2 load $-- :ncopy) ret
+  times (@-2 $-- :ncopy) ret
+
+; returns 1 if the arrays A1 and A2 have the same length and
+; contain the same elements in the same order, 0 otherwise
+; [A1 A2] => [0 | 1]
+;
+; [1 2 3 3 1 2 3 3] => [1]
+; [1 2 3 3 3 2 1 3] => [0]
+; [1 2 2 1 2 3 3] => [0]
+; [1 2 3 3 1 2 2] => [0]
+; [7 10 2 7 10 2] => [1]
+; [6 1 9 1] => [0]
+aryeq: dup $++ :roll copy 1 copy 1 :eq jz _aryeq_difflen ; length mismatch
+  ^-1 times (@-1 :ncopy :eq jz _aryeq_no)
+  push 1 @-1 :nslide ret
+_aryeq_no: push 0 @-1 @-5 sub $-- :nslide ret ; ! -5 is magic from times()
+_aryeq_difflen: add push 0 swap :nslide ret
 
 ; places the element E at the end of the array A, increasing its length by 1
 ; [A E] => [A']
@@ -99,15 +121,15 @@ arycat: dup $++ :roll add ret
 ;;;
 
 arypack:
-  :arydup reduce (:max) $++ push -1 swap store
-  $-- times (push -1 load mul add)
-  push $amax mul push -1 load add
-  push $amax mul push -10 load add ret
+  :arydup reduce (:max) $++ ^-1
+  $-- times (@-1 mul add)
+  push $amax mul @-1 add
+  push $amax mul @-10 add ret
 
 aryunpack:
-  push $amax :divmod push -2 swap store
-  push $amax :divmod push -1 swap store
-  push -2 load times (push -1 load :divmod swap)
+  push $amax :divmod ^-2
+  push $amax :divmod ^-1
+  @-2 times (@-1 :divmod swap)
   push 2 sub load ret
 
 arylen: push $amax mod ret
@@ -161,8 +183,8 @@ _aryswap_noop: pop pop ret
 ; [6 8 -3 4 0 5] => [-3 8]
 ; [7 1] => [7 7]
 minmax:
-  :arydup reduce (:max) push -1 swap store
-  reduce (:min) push -1 load ret
+  :arydup reduce (:max) ^-1
+  reduce (:min) @-1 ret
 
 ;;; TODO: make sort not atrociously inefficient
 
@@ -170,22 +192,37 @@ sort: push -3 copy 1 store ; preserve length
 _sort_loop:
   :arydup reduce (:min)
   push -1 copy 1 store copy 1 $++ :bury ; stash minimum element
-  :arydup push -1 load :aryindex
+  :arydup @-1 :aryindex
   copy 1 swap sub :dig $-- ; remove minimum element from array
   push 0 copy 1 sub jn _sort_loop
   push 3 sub load ret
 
+; returns 0 if any of the elements in array A is
+; strictly less than the one before it, 1 otherwise
+; [A] => [0 | 1]
+;
+; [1 2 3 3] => [1]
+; [3 2 1 3] => [0]
+; [1 1 2 2 4] => [1]
+; [1 2 3 4 3 5] => [0]
+sorted?: $--
+_sorted_loop:
+  copy 1 copy 3 sub jn _sorted_no
+  $-- dup jz _sorted_yes
+  slide 1 jump _sorted_loop
+_sorted_no: $++ push 0 swap :nslide ret
+_sorted_yes: push 1 slide 3 ret
+
 ; reverses the array A
 ; [A] => [A']
 ;
 ; [1 2 3 3] => [3 2 1 3]
 ; [7 1] => [7 1]
 ; [5 4 3 2 1 5] => [1 2 3 4 5 5]
-aryrev: push -3 copy 1 store
-_aryrev_loop:
-  swap copy 1 :bury $--
-  push 0 copy 1 sub jn _aryrev_loop
-  push 3 sub load ret
+aryrev:
+  push -10 :aryheap push -10
+  @-9 times (dup load swap $--)
+  pop @-9 ret
 
 ; returns the array A replicated N times
 ; ! N must be greater than 1
@@ -196,4 +233,4 @@ aryrep: push -1 swap push -3 copy 1 store store
 _aryrep_loop:
   push -1 dup :dec load jz _aryrep_done
   :arydup jump _aryrep_loop
-_aryrep_done: push -3 load $-- times (:arycat) ret
+_aryrep_done: @-3 $-- times (:arycat) ret

data/lib/spitewaste/libspw/bits.spw

@@ -12,8 +12,8 @@ $bitfun(op, bit, done) {
 push -2,1,-1,0 store store
 _`op`_loop: push -1
   copy 2 push 2 mod copy 2 push 2 mod `bit`
-  push -1 load swap push -2 load dup push 2 mul
-  push -2 swap store mul add store
+  @-1 swap @-2 dup push 2 mul
+  ^-2 mul add store
   push 2 div swap push 2 div
   dup copy 2 mul jz _`op`_done swap jump _`op`_loop
 _`op`_done: `done` ret
@@ -35,7 +35,7 @@ band: $bitfun(band, mul, mul $-- load)
 ; [61 77] => [125]   [93 65] => [93]
 ; [14 87] => [95]    [71 37] => [103]
 ; [7 19]  => [23]    [38 92] => [126]
-bor: $bitfun(bor, add $++ push 2 div, add push -2 load mul push -1 load add)
+bor: $bitfun(bor, add $++ push 2 div, add @-2 mul @-1 add)
 
 ; returns the bitwise XOR of A and B
 ; [A B] => [A ^ B]
@@ -44,7 +44,7 @@ bor: $bitfun(bor, add $++ push 2 div, add push -2 load mul push -1 load add)
 ; [51 5]  => [54]    [97 77] => [44]
 ; [39 65] => [102]   [12 26] => [22]
 ; [44 36] => [8]     [6 21]  => [19]
-bxor: $bitfun(bxor, :neq, add push -2 load mul push -1 load add)
+bxor: $bitfun(bxor, :neq, add @-2 mul @-1 add)
 
 ; returns the infinite-precision bitwise NOT of N by inverting all of its bits
 ; [N] => [~N]

data/lib/spitewaste/libspw/docs.json

@@ -135,6 +135,95 @@
         ]
       ]
     },
+    "aryeq": {
+      "full": "returns 1 if the arrays A1 and A2 have the same length and\ncontain the same elements in the same order, 0 otherwise\n[A1 A2] => [0 | 1]\n\n[1 2 3 3 1 2 3 3] => [1]\n[1 2 3 3 3 2 1 3] => [0]\n[1 2 2 1 2 3 3] => [0]\n[1 2 3 3 1 2 2] => [0]\n[7 10 2 7 10 2] => [1]\n[6 1 9 1] => [0]\n",
+      "desc": "returns 1 if the arrays A1 and A2 have the same length and\ncontain the same elements in the same order, 0 otherwise",
+      "effect": "[A1 A2] => [0 | 1]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            2,
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            1,
+            2,
+            2
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            7,
+            10,
+            2,
+            7,
+            10,
+            2
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            6,
+            1,
+            9,
+            1
+          ],
+          [
+            0
+          ]
+        ]
+      ]
+    },
     "aryfill": {
       "full": "places an array of N elements E at the top of the stack\n[N E] => [A]\n\n[3 0] => [0 0 0 3]\n[5 1] => [1 1 1 1 1 5]\n[4 -2] => [-2 -2 -2 -2 4]\n",
       "desc": "places an array of N elements E at the top of the stack",
@@ -338,6 +427,14 @@
         ]
       ]
     },
+    "aryprint": {
+      "full": "prints the array A to stdout in the form [e1,e2,...]\n[A] => []\n",
+      "desc": "prints the array A to stdout in the form [e1,e2,...]",
+      "effect": "[A] => []",
+      "cases": [
+
+      ]
+    },
     "arypush": {
       "full": "places the element E at the end of the array A, increasing its length by 1\n[A E] => [A']\n\n[3 2 1 3 7] => [3 2 1 7 4]\n[4 2 2 0] => [4 2 0 3]\n[6 1 9] => [6 9 2]\n[7 5 8 2 4] => [7 5 8 4 3]\n",
       "desc": "places the element E at the end of the array A, increasing its length by 1",
@@ -794,6 +891,60 @@
           ]
         ]
       ]
+    },
+    "sorted?": {
+      "full": "returns 0 if any of the elements in array A is\nstrictly less than the one before it, 1 otherwise\n[A] => [0 | 1]\n\n[1 2 3 3] => [1]\n[3 2 1 3] => [0]\n[1 1 2 2 4] => [1]\n[1 2 3 4 3 5] => [0]\n",
+      "desc": "returns 0 if any of the elements in array A is\nstrictly less than the one before it, 1 otherwise",
+      "effect": "[A] => [0 | 1]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1,
+            1,
+            2,
+            2,
+            4
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            1,
+            2,
+            3,
+            4,
+            3,
+            5
+          ],
+          [
+            0
+          ]
+        ]
+      ]
     }
   },
   "bits": {
@@ -1304,6 +1455,53 @@
     }
   },
   "fun": {
+    "ROT13": {
+      "full": "applies the ROT13 \"cipher\" to the string S\n[S] => [S']\n\n[\"gnat\"] => [\"tang\"]\n[\"purely\"] => [\"cheryl\"]\n[\"cat.PNG\"] => [\"png.CAT\"]\n[\"Hello, world.\"] => [\"Uryyb, jbeyq.\"]\n[\"a123z\"] => [\"n123m\"]\n",
+      "desc": "applies the ROT13 \"cipher\" to the string S",
+      "effect": "[S] => [S']",
+      "cases": [
+        [
+          [
+            244873063
+          ],
+          [
+            217821428
+          ]
+        ],
+        [
+          [
+            4186733066992
+          ],
+          [
+            3743573177443
+          ]
+        ],
+        [
+          [
+            314962935099619
+          ],
+          [
+            371687373272944
+          ]
+        ],
+        [
+          [
+            905009539406525881141375688
+          ],
+          [
+            906989270706565425435408725
+          ]
+        ],
+        [
+          [
+            32856905953
+          ],
+          [
+            29367245038
+          ]
+        ]
+      ]
+    },
     "anagrams?": {
       "full": "returns whether the strings S and T are composed of the same characters\n[S T] => [0 | 1]\n\n[\"allergy\" \"gallery\"] => [1]\n[\"largely\" \"regally\"] => [1]\n[\"foo\" \"bar\"] => [0]\n",
       "desc": "returns whether the strings S and T are composed of the same characters",
@@ -1405,6 +1603,45 @@
         ]
       ]
     },
+    "collatz_len": {
+      "full": "returns the length L of the Collatz sequence for integer N\n[N] => [L]\n\n[1] => [1]\n[4] => [3]\n[7] => [17]\n[189] => [107]\n",
+      "desc": "returns the length L of the Collatz sequence for integer N",
+      "effect": "[N] => [L]",
+      "cases": [
+        [
+          [
+            1
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            4
+          ],
+          [
+            3
+          ]
+        ],
+        [
+          [
+            7
+          ],
+          [
+            17
+          ]
+        ],
+        [
+          [
+            189
+          ],
+          [
+            107
+          ]
+        ]
+      ]
+    },
     "isop": {
       "full": "returns the sum of the alphabetical characters in string S where A=1, B=2...\n[S] => [sum]\n\n[\"Math\"] => [42]\n[\"wizards\"] => [100]\n[\"AbCd\"] => [10]\n",
       "desc": "returns the sum of the alphabetical characters in string S where A=1, B=2...",
@@ -1509,33 +1746,49 @@
   },
   "io": {
     "getline": {
-      "full": "reads a line of input onto the top of the stack as a packed string\n",
-      "desc": "",
-      "effect": "reads a line of input onto the top of the stack as a packed string",
+      "full": "reads a line of input onto the top of the stack as a packed string\n[] => [L]\n",
+      "desc": "reads a line of input onto the top of the stack as a packed string",
+      "effect": "[] => [L]",
       "cases": [
 
       ]
     },
     "print": {
-      "full": "prints the character at the top of the stack until terminating zero\n",
-      "desc": "",
-      "effect": "prints the character at the top of the stack until terminating zero",
+      "full": "prints the character at the top of the stack until terminating zero\n[0 ... C] => []\n",
+      "desc": "prints the character at the top of the stack until terminating zero",
+      "effect": "[0 ... C] => []",
       "cases": [
 
       ]
     },
     "println": {
-      "full": "print with newline\n",
-      "desc": "",
-      "effect": "print with newline",
+      "full": "print with newline\n[0 ... C] => []\n",
+      "desc": "print with newline",
+      "effect": "[0 ... C] => []",
+      "cases": [
+
+      ]
+    },
+    "prompt": {
+      "full": "displays the string S then reads a line of input\n[S] => [L]\n",
+      "desc": "displays the string S then reads a line of input",
+      "effect": "[S] => [L]",
       "cases": [
 
       ]
     },
     "readall": {
-      "full": "consume stdin until EOF\n",
-      "desc": "",
-      "effect": "consume stdin until EOF",
+      "full": "consume stdin until EOF into the string S\n[] => [S]\n",
+      "desc": "consume stdin until EOF into the string S",
+      "effect": "[] => [S]",
+      "cases": [
+
+      ]
+    },
+    "readfile": {
+      "full": "returns the contents C of the file at path P (a string)\nNON-STANDARD! This function makes use of the `shell` instruction, which is\nonly(?) available in the Spiceweight Whitespace interpreter.\n[P] => [C]\n",
+      "desc": "returns the contents C of the file at path P (a string)\nNON-STANDARD! This function makes use of the `shell` instruction, which is\nonly(?) available in the Spiceweight Whitespace interpreter.",
+      "effect": "[P] => [C]",
       "cases": [
 
       ]
@@ -2373,6 +2626,64 @@
       ]
     }
   },
+  "random": {
+    "bogosort": {
+      "full": "sorts the array A if you're lucky\n[A] => [A']\n",
+      "desc": "sorts the array A if you're lucky",
+      "effect": "[A] => [A']",
+      "cases": [
+
+      ]
+    },
+    "dice": {
+      "full": "returns an array A of N random integers between 1 and D (inclusive)\n[N D] => [A]\n",
+      "desc": "returns an array A of N random integers between 1 and D (inclusive)",
+      "effect": "[N D] => [A]",
+      "cases": [
+
+      ]
+    },
+    "rand": {
+      "full": "returns the next number N in the linear congruential generator (better MINSTD)\n[] => [N]\n",
+      "desc": "returns the next number N in the linear congruential generator (better MINSTD)",
+      "effect": "[] => [N]",
+      "cases": [
+
+      ]
+    },
+    "rand_range": {
+      "full": "returns a random integer I between A and B (inclusive)\n[A B] => [I]\n",
+      "desc": "returns a random integer I between A and B (inclusive)",
+      "effect": "[A B] => [I]",
+      "cases": [
+
+      ]
+    },
+    "shuffle": {
+      "full": "shuffles the array A in-place using the modern Fisher-Yates algorithm\n[A] => [A']\n",
+      "desc": "shuffles the array A in-place using the modern Fisher-Yates algorithm",
+      "effect": "[A] => [A']",
+      "cases": [
+
+      ]
+    },
+    "srand": {
+      "full": "seeds the random number generator with integer S\n[S] => []\n",
+      "desc": "seeds the random number generator with integer S",
+      "effect": "[S] => []",
+      "cases": [
+
+      ]
+    },
+    "strfry": {
+      "full": "shuffles the characters of the string S, producing a random anagram\n[S] => [S']\n",
+      "desc": "shuffles the characters of the string S, producing a random anagram",
+      "effect": "[S] => [S']",
+      "cases": [
+
+      ]
+    }
+  },
   "rational": {
     "from_r": {
       "full": "decomposes the rational number R into its numerator N and denominator D\n[R] => [N D]\n\n[R(22,7)] => [22 7]\n[R(-3,4)] => [-3 4]\n[R(3,-4)] => [-3 4]\n[R(4,8)]  => [4 8]  ; no implicit simplification\n",
@@ -3428,6 +3739,93 @@
         ]
       ]
     },
+    "swapary": {
+      "full": "swaps the two arrays at the top of the stack\n[A B] => [B A]\n\n[1 2 3 3 3 2 1 3] => [3 2 1 3 1 2 3 3]\n[5 6 2 9 7 5 3 1 5] => [9 7 5 3 1 5 5 6 2]\n[0 0 2 4 2 0 3] => [4 2 0 3 0 0 2]\n[1 1 2 1] => [2 1 1 1]\n",
+      "desc": "swaps the two arrays at the top of the stack",
+      "effect": "[A B] => [B A]",
+      "cases": [
+        [
+          [
+            1,
+            2,
+            3,
+            3,
+            3,
+            2,
+            1,
+            3
+          ],
+          [
+            3,
+            2,
+            1,
+            3,
+            1,
+            2,
+            3,
+            3
+          ]
+        ],
+        [
+          [
+            5,
+            6,
+            2,
+            9,
+            7,
+            5,
+            3,
+            1,
+            5
+          ],
+          [
+            9,
+            7,
+            5,
+            3,
+            1,
+            5,
+            5,
+            6,
+            2
+          ]
+        ],
+        [
+          [
+            0,
+            0,
+            2,
+            4,
+            2,
+            0,
+            3
+          ],
+          [
+            4,
+            2,
+            0,
+            3,
+            0,
+            0,
+            2
+          ]
+        ],
+        [
+          [
+            1,
+            1,
+            2,
+            1
+          ],
+          [
+            2,
+            1,
+            1,
+            1
+          ]
+        ]
+      ]
+    },
     "to_a": {
       "full": "pops elements off the stack until it hits the specified sentinel value S,\npushing them to the resulting pseudo-array. It's often more convenient to\nbuild up a collection in reverse order, and we often don't know in advance\nhow many elements we'll meet, but we do know to stop at the sentinel.\n[S En ... E1 S] => [E1 ... En n]\n\n[-1 9 8 7 -1] => [7 8 9 3]\n[0 'c' 'b' 'a' 0] => ['a' 'b' 'c' 3]\n",
       "desc": "pops elements off the stack until it hits the specified sentinel value S,\npushing them to the resulting pseudo-array. It's often more convenient to\nbuild up a collection in reverse order, and we often don't know in advance\nhow many elements we'll meet, but we do know to stop at the sentinel.",
@@ -3863,6 +4261,49 @@
         ]
       ]
     },
+    "strbegins?": {
+      "full": "returns 1 if the string S begins with substring T, 0 otherwise\n[S T] => [0 | 1]\n\n[\"foobar\" \"foo\"] => [1]\n[\"foobar\" \"boo\"] => [0]\n[\"abc123\" \"123\"] => [0]\n[\" foo\" \" \"] = [1]\n",
+      "desc": "returns 1 if the string S begins with substring T, 0 otherwise",
+      "effect": "[S T] => [0 | 1]",
+      "cases": [
+        [
+          [
+            3943255767014,
+            1832934
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3943255767014,
+            1832930
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1765872824673,
+            842033
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            234615584,
+            32
+          ],
+          [
+            1
+          ]
+        ]
+      ]
+    },
     "strcat": {
       "full": "takes two packed strings and returns their concatenation (as a packed string)\n[S T] => [S+T]\n\n[\"foo\" \"\"] => [\"foo\"]\n[\"\" \"foo\"] => [\"foo\"]\n[\"foo\" \"bar\"] => [\"foobar\"]\n",
       "desc": "takes two packed strings and returns their concatenation (as a packed string)",
@@ -4074,6 +4515,49 @@
         ]
       ]
     },
+    "strends?": {
+      "full": "returns 1 if the string S ends with substring T, 0 otherwise\n[S T] => [0 | 1]\n\n[\"foobar\" \"bar\"] => [1]\n[\"foobar\" \"foo\"] => [0]\n[\"abc123\" \"abc\"] => [0]\n[\"foo \" \" \"] = [1]\n",
+      "desc": "returns 1 if the string S ends with substring T, 0 otherwise",
+      "effect": "[S T] => [0 | 1]",
+      "cases": [
+        [
+          [
+            3943255767014,
+            1880290
+          ],
+          [
+            1
+          ]
+        ],
+        [
+          [
+            3943255767014,
+            1832934
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            1765872824673,
+            1634657
+          ],
+          [
+            0
+          ]
+        ],
+        [
+          [
+            68941798,
+            32
+          ],
+          [
+            1
+          ]
+        ]
+      ]
+    },
     "strexpand": {
       "full": "expands the length-2 string S to contain the intervening ASCII characters\n[S] => [S']\n\n[\"CJ\"] => [\"CDEFGHIJ\"]\n[\"DA\"] => [\"DCBA\"]\n[\"af\"] => [\"abcdef\"]\n[\"09\"] => [\"0123456789\"]\n[\"90\"] => [\"9876543210\"]\n[\"(1\"] => [\"()*+,-./01\"]\n",
       "desc": "expands the length-2 string S to contain the intervening ASCII characters",
@@ -4686,6 +5170,25 @@
         ]
       ]
     },
+    "strtoa": {
+      "full": "gets the characters of the string S onto the stack as a pseudo-array, but\nwith a leading 0 on the assumption that it'll eventually be repacked\n\n[\"abc\"] => [0 99 98 97 3]\n",
+      "desc": "gets the characters of the string S onto the stack as a pseudo-array, but",
+      "effect": "with a leading 0 on the assumption that it'll eventually be repacked",
+      "cases": [
+        [
+          [
+            1634657
+          ],
+          [
+            0,
+            99,
+            98,
+            97,
+            3
+          ]
+        ]
+      ]
+    },
     "strtrans": {
       "full": "translates all characters in A to the corresponding characters in B\nin string S, ; similar to the `tr` utility in Unix. A and B must be\nof the same length. TODO: make this smarter (ranges, length mismatch)\n[S A B] => [S']\n\n[\"abcd\" \"abc\" \"xyz\"] => [\"xyzd\"]\n[\"foobar\" \"oba\" \"ele\"] => [\"feeler\"]\n[\"abcdcba\" \"abcd\" \"xyz|\"] => [\"xyz|zyx\"]\n",
       "desc": "translates all characters in A to the corresponding characters in B\nin string S, ; similar to the `tr` utility in Unix. A and B must be\nof the same length. TODO: make this smarter (ranges, length mismatch)",
@@ -4776,6 +5279,14 @@
 
       ]
     },
+    "aryheap": {
+      "full": "stashes the array A in negative heap space starting at index I\n[A I] => []\n",
+      "desc": "stashes the array A in negative heap space starting at index I",
+      "effect": "[A I] => []",
+      "cases": [
+
+      ]
+    },
     "between?": {
       "full": "returns 1 if the number N is between A and B (inclusive), 0 otherwise\n[N A B]\n\n[5 0 10] => [1]\n[11 0 10] => [0]\n[4 0 4] => [1]\n[-1 0 4] => [0]\n[-5 -10 0] => [1]\n[3 4 2] => [0]\n",
       "desc": "returns 1 if the number N is between A and B (inclusive), 0 otherwise",
@@ -4852,9 +5363,9 @@
       ]
     },
     "die!": {
-      "full": "prints the string at the top of the stack and halts execution\n",
-      "desc": "",
-      "effect": "prints the string at the top of the stack and halts execution",
+      "full": "prints the string at the top of the stack and halts execution after pushing\nsomething onto the stack to signal abnormal termination/unclean exit\n[...] => [... 1]\n",
+      "desc": "prints the string at the top of the stack and halts execution after pushing\nsomething onto the stack to signal abnormal termination/unclean exit",
+      "effect": "[...] => [... 1]",
       "cases": [
 
       ]
@@ -5056,7 +5567,7 @@
         ]
       ]
     },
-    "heap_seeking_missile": {
+    "heap-seeking_missile": {
       "full": "Though extremely rare, it's possible that we know a particular value is\nstored in the heap at some key, just not which one. This subroutine takes\na value V to search for and a starting index I, and either returns the first\nkey associated with that value or loops forever. Probably don't touch.\n[V I]\n",
       "desc": "Though extremely rare, it's possible that we know a particular value is\nstored in the heap at some key, just not which one. This subroutine takes\na value V to search for and a starting index I, and either returns the first\nkey associated with that value or loops forever. Probably don't touch.",
       "effect": "[V I]",
@@ -5064,6 +5575,22 @@
 
       ]
     },
+    "heapary": {
+      "full": "restores the heaped array starting at index I\n[I] => [A]\n",
+      "desc": "restores the heaped array starting at index I",
+      "effect": "[I] => [A]",
+      "cases": [
+
+      ]
+    },
+    "heapswap": {
+      "full": "swaps the elements in the heap at indices I and J\n[I J] => []\n",
+      "desc": "swaps the elements in the heap at indices I and J",
+      "effect": "[I J] => []",
+      "cases": [
+
+      ]
+    },
     "hex2rgb": {
       "full": "converts the #RRGGBB (leading '#' optional) color string S to\nits individual RGB components as integers in the range 0-255\n[S] => [R G B]\n\n[\"#000000\"] => [0 0 0]\n[\"ffffff\"]  => [255 255 255]\n[\"#102030\"] => [16 32 48]\n[\"c0ffee\"] => [192 255 238]\n",
       "desc": "converts the #RRGGBB (leading '#' optional) color string S to\nits individual RGB components as integers in the range 0-255",
@@ -5739,6 +6266,14 @@
           ]
         ]
       ]
+    },
+    "time": {
+      "full": "returns the number of nanoseconds N since the Unix epoch\n[] => [N]\n",
+      "desc": "returns the number of nanoseconds N since the Unix epoch",
+      "effect": "[] => [N]",
+      "cases": [
+
+      ]
     }
   }
 }