kapusta 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 520158590f1244ac17f70b58ded945f66be00060f6da89cebb366fefaf27b62e
-  data.tar.gz: 6773e0faa320f23cb15106e710f380a39093c9fc6e56cead8941c28e0ccf16c5
+  metadata.gz: 326afa9f8872d9d92bf4c3ca32fa5c15f78559691aa447a23472a4042a4f3a4c
+  data.tar.gz: 625c013cad69a7e2229ea99a64796c2de90f9fd9665152c74cbd6753c67319f0
 SHA512:
-  metadata.gz: 814d37c473287d2d1e54568c7d21c22d88703cd89da761100c1f20950e47cb18eb2ac4807aa596878ded72eb7049a6083d2b9de46bc76ce2ea55787f6993f61f
-  data.tar.gz: 3a15fc05522e617cf46e8709a55dc8497252503f2b995dffaa4f8995fc34a54e9bcc2a711cd501884203bf0113c7924f159377459de8f2524e9c371c018d8238
+  metadata.gz: 2768ae288a6011b651f7e084af68717a3cf6486a45483985fe8eeb7ed9fa9ea3f2ce18c6db77b94e74b130cc10c84c486970569eee760fb82ae858070486049b
+  data.tar.gz: 04245b8c5e76773abe1f6c9efde7c64242eaec147e8f07c3d91239a893c25cf2477e4e2b7cec518aa2e82ee948238088d37f68731f41f807aebb6c911c2d03e8

data/README.md

@@ -4,7 +4,7 @@ Kapusta is a Lisp for the Ruby runtime.
 
 It is inspired by [Fennel](https://fennel-lang.org). It is not intended to be production-ready like Clojure: that would be a lot of work, and Ruby is already a rich, elegant language.
 
-Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. Where Lua is intentionally minimal, and Fennel follows that design for good reason, Kapusta exists mostly for fun. You can use it for small apps, LeetCode, DragonRuby, or maybe even Rails.
+Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. Where Fennel uses Lua's stdlib and runtime, Kapusta uses Ruby's. You can use it for small apps, LeetCode, DragonRuby, or maybe even Rails.
 
 For more information about Kapusta, see the official Fennel documentation and tutorials.
 
@@ -45,6 +45,12 @@ exe/kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
 ruby examples/fizzbuzz.rb
 ```
 
+For mruby-compatible output, such as DragonRuby, use:
+
+```
+exe/kapusta --compile --target=mruby examples/match.kap > examples/match-mruby.rb
+```
+
 ## Use from Ruby
 
 Ruby can require a `.kap` file and use it directly.
@@ -104,7 +110,9 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 Kapusta-specific additions:
 
 - `module` and `class` for Ruby host structure, including file-header forms
-- `ivar` or `@var`) / `cvar` or `@@var` / `gvar` or `$var`
+- `(end)` closes a bodyless file-header
+- `(defn name ...)` or `(fn class.name ..)`
+- `ivar` or `@var` / `cvar` or `@@var` / `gvar` or `$var`
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments

data/bin/check-all

@@ -16,4 +16,21 @@ bin/fennel-parity
 echo "== compile examples =="
 bin/compile-examples
 
+echo "== run mruby-compatible examples on mruby =="
+MRUBY_RUNTIME_EXAMPLES=()
+while IFS= read -r example || [[ -n "$example" ]]; do
+  [[ -n "$example" ]] && MRUBY_RUNTIME_EXAMPLES+=("$example")
+done < examples/mruby-runtime-examples.txt
+
+for example in "${MRUBY_RUNTIME_EXAMPLES[@]}"; do
+  ruby_file="examples-compiled/$example.rb"
+  file="examples-compiled/$example-mruby.rb"
+  if [[ ! -f "$file" ]]; then
+    file="$ruby_file"
+  fi
+
+  ruby "$ruby_file" >/dev/null
+  mruby "$file" >/dev/null
+done
+
 echo "== Success! =="

data/bin/compile-examples

@@ -4,6 +4,61 @@ set -euo pipefail
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 SOURCE_DIR="$ROOT_DIR/examples"
 TARGET_DIR="$ROOT_DIR/examples-compiled"
+tmp_files=()
+MRUBY_RUNTIME_EXAMPLES=()
+
+while IFS= read -r example || [[ -n "$example" ]]; do
+  [[ -n "$example" ]] && MRUBY_RUNTIME_EXAMPLES+=("$example")
+done < "$SOURCE_DIR/mruby-runtime-examples.txt"
+
+cleanup() {
+  rm -f "${tmp_files[@]}"
+}
+trap cleanup EXIT
+
+is_mruby_runtime_example() {
+  local name="$1"
+
+  for example in "${MRUBY_RUNTIME_EXAMPLES[@]}"; do
+    [[ "$name" == "$example" ]] && return 0
+  done
+
+  return 1
+}
+
+needs_mruby_artifact() {
+  local name="$1"
+  local ruby_file="$2"
+  local ruby_stdout
+  local ruby_stderr
+  local mruby_stdout
+  local mruby_stderr
+
+  is_mruby_runtime_example "$name" || return 1
+
+  ruby_stdout="$(mktemp)"
+  ruby_stderr="$(mktemp)"
+  mruby_stdout="$(mktemp)"
+  mruby_stderr="$(mktemp)"
+  tmp_files+=("$ruby_stdout" "$ruby_stderr" "$mruby_stdout" "$mruby_stderr")
+
+  if ! ruby "$ruby_file" > "$ruby_stdout" 2> "$ruby_stderr"; then
+    printf 'Compiled example failed under ruby: %s\n' "$ruby_file" >&2
+    cat "$ruby_stderr" >&2
+    exit 1
+  fi
+
+  if ! mruby "$ruby_file" > "$mruby_stdout" 2> "$mruby_stderr"; then
+    return 0
+  fi
+
+  ! cmp -s "$ruby_stdout" "$mruby_stdout"
+}
+
+if (($# > 0)); then
+  printf 'usage: bin/compile-examples\n' >&2
+  exit 1
+fi
 
 mkdir -p "$TARGET_DIR"
 
@@ -18,7 +73,22 @@ fi
 for kap_file in "${kap_files[@]}"; do
   name="$(basename "$kap_file" .kap)"
   ruby_file="$TARGET_DIR/$name.rb"
+  mruby_file="$TARGET_DIR/$name-mruby.rb"
 
   "$ROOT_DIR/exe/kapusta" --compile "$kap_file" > "$ruby_file"
   printf 'Compiled %s -> %s\n' "$kap_file" "$ruby_file"
+
+  if needs_mruby_artifact "$name" "$ruby_file"; then
+    tmp_mruby="$(mktemp)"
+    tmp_files+=("$tmp_mruby")
+    "$ROOT_DIR/exe/kapusta" --compile --target=mruby "$kap_file" > "$tmp_mruby"
+    if cmp -s "$ruby_file" "$tmp_mruby"; then
+      rm -f "$mruby_file"
+    else
+      mv "$tmp_mruby" "$mruby_file"
+      printf 'Compiled %s -> %s\n' "$kap_file" "$mruby_file"
+    fi
+  else
+    rm -f "$mruby_file"
+  fi
 done

data/bin/fennel-parity

@@ -9,44 +9,10 @@ EXAMPLES_ERRORS = File.join(ROOT, 'examples-errors')
 KAPUSTA = File.join(ROOT, 'exe', 'kapusta')
 KAPFMT = File.join(ROOT, 'exe', 'kapfmt')
 
-COMPATIBLE = %w[
-  ackermann.kap
-  anonymous-greeter.kap
-  classify-wallet.kap
-  climbing-stairs.kap
-  describe.kap
-  destructure.kap
-  even-squares.kap
-  factorial.kap
-  fib.kap
-  fizzbuzz.kap
-  gcd.kap
-  hashfn.kap
-  leap-year.kap
-  macros-dbg.kap
-  macros-import-helpers.kap
-  macros-import-whole.kap
-  macros-import.kap
-  macros-multi.kap
-  macros-swap.kap
-  macros-thrice-if.kap
-  macros-unless.kap
-  macros-when-let.kap
-  match.kap
-  min-max.kap
-  or-patterns.kap
-  power-of-three.kap
-  packet-router.kap
-  points.kap
-  primes.kap
-  safe-lookup.kap
-  shapes.kap
-  squares.kap
-  sum.kap
-  thread-styles.kap
-  tic-tac-toe.kap
-  underscore-patterns.kap
-].freeze
+COMPATIBLE = File.readlines(File.join(EXAMPLES, 'fennel-parity-examples.txt'), chomp: true)
+                 .reject(&:empty?)
+                 .map { |name| "#{name}.kap" }
+                 .freeze
 
 def run(cmd, file, chdir: EXAMPLES, env: {})
   out, err, status = Open3.capture3(env, cmd, file, chdir:)

data/examples/account-lockout.kap

@@ -0,0 +1,11 @@
+(local max-missed 3)
+
+(fn classify [guesses]
+  (var missed 0)
+  (each [_ g (ipairs guesses)]
+    (when (= g 1) (set missed (+ missed 1))))
+  (if (< missed max-missed) :ok :locked))
+
+(print (classify [0 1 0 1]))
+(print (classify [1 1 1]))
+(print (classify [1 1 1 0]))

data/examples/accumulator.kap

@@ -10,6 +10,8 @@
 (fn value []
   (ivar total))
 
+(end)
+
 (let [acc (Accumulator.new 10)]
   (acc.add! 5)
   (acc.add! 7)

data/examples/bank-account.kap

@@ -19,3 +19,5 @@
   (set (ivar balance)
     (- (ivar balance) amount))
   self)
+
+(end)

data/examples/bst-iterator.kap

@@ -0,0 +1,52 @@
+(class TreeNode)
+
+(fn initialize [val left right]
+  (set @val val)
+  (set @left left)
+  (set @right right))
+
+(fn val [] @val)
+(fn left [] @left)
+(fn right [] @right)
+
+(end)
+
+(class BSTIterator)
+
+(fn initialize [root]
+  (set @stack [])
+  (self.push-left root))
+
+(fn push-left [node]
+  (var n node)
+  (while n
+    (let [stack @stack]
+      (stack.push n))
+    (set n (n.left))))
+
+(fn next []
+  (let [stack @stack
+        node (stack.pop)]
+    (self.push-left (node.right))
+    (node.val)))
+
+(fn has-next? []
+  (let [stack @stack]
+    (not (stack.empty?))))
+
+(end)
+
+(let [root (TreeNode.new 7
+             (TreeNode.new 3 nil nil)
+             (TreeNode.new 15
+               (TreeNode.new 9 nil nil)
+               (TreeNode.new 20 nil nil)))
+      it (BSTIterator.new root)]
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?)))

data/examples/circle.kap

@@ -0,0 +1,18 @@
+(class Circle)
+
+(local pi 3.14159)
+
+(fn initialize [radius]
+  (set @radius radius))
+
+(fn area []
+  (* pi @radius @radius))
+
+(fn circumference []
+  (* 2 pi @radius))
+
+(end)
+
+(let [c (Circle.new 5)]
+  (print (c.area))
+  (print (c.circumference)))

data/examples/convert-temperature.kap

@@ -0,0 +1,14 @@
+(local KELVIN-OFFSET 273.15)
+(local FAHRENHEIT-SCALE 1.8)
+(local FAHRENHEIT-OFFSET 32.0)
+
+(fn convert-temperature [celsius]
+  (let [k (+ celsius KELVIN-OFFSET)
+        f (+ (* celsius FAHRENHEIT-SCALE) FAHRENHEIT-OFFSET)]
+    [k f]))
+
+(let [[k f] (convert-temperature 36.5)]
+  (print k f))
+
+(let [[k f] (convert-temperature 122.11)]
+  (print k f))

data/examples/count-effects.kap

@@ -0,0 +1,13 @@
+(fn count-by-kind [effects]
+  (var quits 0)
+  (var moves 0)
+  (each [_ effect (ipairs effects)]
+    (case (. effect :kind)
+      :quit (set quits (+ quits 1))
+      :move (set moves (+ moves 1))
+      _ nil))
+  [quits moves])
+
+(let [effects [{:kind :move} {:kind :quit} {:kind :move} {:kind :other}]
+      [q m] (count-by-kind effects)]
+  (print q m))

data/examples/counter.kap

@@ -12,6 +12,8 @@
 (fn self.zero []
   (Counter.new 0))
 
+(end)
+
 (let [c (Counter.new 10)]
   (c.tick)
   (c.tick)

data/examples/falling-drops.kap

@@ -0,0 +1,12 @@
+(fn step [drops]
+  (each [_ drop (ipairs drops)]
+    (let [falling {:kind (. drop :kind)
+                   :x (. drop :x)
+                   :y (+ (. drop :y) (. drop :speed))
+                   :w (. drop :w)
+                   :h (. drop :h)
+                   :speed (. drop :speed)}]
+      (print (. falling :kind) (. falling :x) (. falling :y)))))
+
+(step [{:kind "rain" :x 0 :y 0 :w 1 :h 1 :speed 2}
+       {:kind "snow" :x 5 :y 1 :w 1 :h 1 :speed 1}])

data/examples/fennel-parity-examples.txt

@@ -0,0 +1,40 @@
+ackermann
+anonymous-greeter
+classify-wallet
+climbing-stairs
+convert-temperature
+count-effects
+describe
+destructure
+even-squares
+factorial
+falling-drops
+fib
+fizzbuzz
+gcd
+hashfn
+leap-year
+macros-dbg
+macros-import-helpers
+macros-import-whole
+macros-import
+macros-multi
+macros-swap
+macros-thrice-if
+macros-unless
+macros-when-let
+match
+max-achievable
+min-max
+or-patterns
+power-of-three
+packet-router
+points
+primes
+safe-lookup
+shapes
+squares
+sum
+thread-styles
+tic-tac-toe
+underscore-patterns

data/examples/hit-counter.kap

@@ -9,6 +9,8 @@
   (set $last-hitter @name)
   @@total)
 
+(end)
+
 (let [a (HitCounter.new "alice")
       b (HitCounter.new "bob")]
   (print (a.hit))

data/examples/max-achievable.kap

@@ -0,0 +1,8 @@
+(local steps 2)
+
+(fn max-achievable [num t]
+  (+ num (* steps t)))
+
+(print (max-achievable 4 1))
+(print (max-achievable 3 2))
+(print (max-achievable 0 5))

data/examples/module-header.kap

@@ -1,7 +1,9 @@
 ; File header forms map directly to Ruby modules.
 (module HeaderDemo)
 
-(fn self.greet [name]
+(defn greet [name]
   (.. "Hello, " name "!"))
 
-(print (self.greet "Ada"))
+(end)
+
+(print (HeaderDemo.greet "Ada"))

data/examples/mruby-runtime-examples.txt

@@ -0,0 +1,92 @@
+account-lockout
+accumulator
+ackermann
+anagram
+anonymous-greeter
+bank-account
+baseball-game
+best-time-to-buy-sell-stock
+binary-search
+binary-to-decimal
+block-sort
+bst-iterator
+calc
+circle
+classify-wallet
+climbing-stairs
+contains-duplicate
+convert-temperature
+count-effects
+counter
+describe
+destructure
+doto-hygiene
+doto
+egg-count
+even-squares
+exceptions
+factorial
+falling-drops
+fib
+fizzbuzz
+gcd
+greet
+happy-number
+hashfn
+hit-counter
+kwargs
+leap-year
+length-of-last-word
+macros-dbg
+macros-import-helpers
+macros-import-whole
+macros-import
+macros-multi
+macros-swap
+macros-thrice-if
+macros-unless
+macros-when-let
+majority-element
+manhattan-distance
+match
+max-achievable
+maximum-subarray
+min-max
+module-header
+move-zeroes
+number-of-1-bits
+number-of-steps
+or-patterns
+packet-router
+parking-system
+pipeline
+pivot-index
+plus-one
+points
+power-of-three
+primes
+raindrops
+recent-counter
+record
+reverse-integer
+roman-to-integer
+ruby-eval
+safe-lookup
+scopes
+shapes
+signal-harvest
+single-number
+squares
+stack
+subtract-product-sum
+sum
+thread-styles
+threading
+tic-tac-toe
+tset
+two-sum-hash
+two-sum
+ugly-number
+underscore-patterns
+valid-parentheses-1
+zoo-animal-1

data/examples/number-of-1-bits.kap

@@ -0,0 +1,13 @@
+(local BIT-WIDTH 32)
+
+(fn hamming-weight [n]
+  (var x n)
+  (var count 0)
+  (for [_ 1 BIT-WIDTH]
+    (set count (+ count (% x 2)))
+    (set x (: (/ x 2) :floor)))
+  count)
+
+(print (hamming-weight 11))
+(print (hamming-weight 128))
+(print (hamming-weight 4294967293))

data/examples/number-of-steps.kap

@@ -0,0 +1,15 @@
+(local target 0)
+
+(fn steps-to-zero [n]
+  (var x n)
+  (var steps 0)
+  (while (not= x target)
+    (if (= 0 (% x 2))
+        (set x (: (/ x 2) :floor))
+        (set x (- x 1)))
+    (set steps (+ steps 1)))
+  steps)
+
+(print (steps-to-zero 14))
+(print (steps-to-zero 8))
+(print (steps-to-zero 123))

data/examples/parking-system.kap

@@ -11,6 +11,8 @@
       (and (= car-type 3) (> @small 0)) (do (set @small (- @small 1)) true)
       false))
 
+(end)
+
 (let [parking (ParkingSystem.new 1 1 0)]
   (print (parking.add-car 1))
   (print (parking.add-car 2))

data/examples/recent-counter.kap

@@ -0,0 +1,17 @@
+(class RecentCounter)
+(fn initialize [] (set @pings []))
+(fn ping [t]
+  (let [pings @pings]
+    (pings.push t)
+    (while (< (. pings 0) (- t 3000))
+      (pings.shift))
+    (length pings)))
+(defn warm [history]
+  (let [c (RecentCounter.new)]
+    (each [_ t (ipairs history)] (c.ping t))
+    c))
+(end)
+
+(let [c (RecentCounter.warm [100 200 300])]
+  (print (c.ping 3001))
+  (print (c.ping 3002)))

data/examples/scopes.kap

@@ -10,6 +10,8 @@
 (fn self.total []
   (cvar total))
 
+(end)
+
 (let [a (ScopeCounter.new)
       b (ScopeCounter.new)]
   (print (a.add! 5))

data/examples/signal-harvest.kap

@@ -0,0 +1,16 @@
+(module SignalHarvest)
+
+(local SCREEN-W 1280)
+(local TARGET-SCORE 36)
+
+(defn cell-width [columns]
+  (/ SCREEN-W columns))
+
+(defn win? [score]
+  (>= score TARGET-SCORE))
+
+(end)
+
+(print (SignalHarvest.cell-width 32))
+(print (SignalHarvest.win? 40))
+(print (SignalHarvest.win? 12))

data/examples/stack.kap

@@ -24,6 +24,8 @@
 (fn get-min []
   (. (ivar mins) -1))
 
+(end)
+
 (let [s (MinStack.new)]
   (s.push -2)
   (s.push 0)

data/examples/two-sum-hash.kap

@@ -1,17 +1,14 @@
-(let [
-  two-sum-hash
-  (fn [nums target seen]
-    (var i 0)
-    (var answer nil)
-    (while (and (< i (length nums)) (= answer nil))
-      (let [n (. nums i)
-            complement (- target n)]
-        (if (seen.key? complement)
-            (set answer [(. seen complement) i])
-            (tset seen n i)))
-      (set i (+ i 1)))
-    answer)
-]
+(let [two-sum-hash (fn [nums target seen]
+                     (var i 0)
+                     (var answer nil)
+                     (while (and (< i (length nums)) (= answer nil))
+                       (let [n (. nums i)
+                             complement (- target n)]
+                         (if (seen.key? complement)
+                             (set answer [(. seen complement) i])
+                             (tset seen n i)))
+                       (set i (+ i 1)))
+                     answer)]
   (print (two-sum-hash [2 7 11 15] 9 {}))
   (print (two-sum-hash [3 2 4] 6 {}))
   (print (two-sum-hash [1 2 3] 10 {})))

data/examples/underscore-patterns.kap

@@ -1,7 +1,7 @@
 (fn loose [v]
   (case v
     _x _x
-    _ "fallback"))
+    _ "not-reachable"))
 
 (fn strict [v]
   (case v

data/examples/valid-parentheses-1.kap

@@ -17,3 +17,5 @@
             (stack.push ch)))
       (set i (+ i 1)))
     (and ok (stack.empty?))))
+
+(end)