kapusta 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f64991d78295bfc4a633136af86607f2d9536f3e113ae9ea819a0c5708837427
-  data.tar.gz: 0d656fcf3afefbb2c89acad7a0fa4de8a57f8a484c2ce887e5bc70e7493c71ea
+  metadata.gz: 3cafef3668504ca08a40ba087c4c2b754bfda02e6f61161f19bcf8d56a254e00
+  data.tar.gz: 501b99f6ec3bfa950865b63b26ec6fd7f5b64977bb86f41d4eff51957602cc84
 SHA512:
-  metadata.gz: a27e51a26db8069c998d7e0b586beb4fda1505c2f13f572b82bbbda92bc79dbe6e3d4e308547877a0e455cd56b5c9f1c226830ca2645664dae65b47b552dc3a1
-  data.tar.gz: e6e675b9be4492d7bf75e341915bfd5e022a733240a2b7c4139c2904a99577207a7b4d182208ad1706c31bcded3ebaf3a50e03d18f27eafc68373b96141ae8b0
+  metadata.gz: b774d8f0bbd772e223743a2ec844bec4949a6f1a5a545767c3b608c8ec0c2da055fe9537c68a3cf57573ac80ed75d11d85884245b4fcbd401af16646aaab5283
+  data.tar.gz: 10b6d3f30fdfc760569c40c70e22f2b63dcf124ea3de3cffca2f061642523bc7057c878b81460181950356193c5786a35df28d4fd2b4859c1c38bc2285392f40

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,7 @@ 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` (`@var`) / `cvar` (`@@var`) / `gvar` (`$var`) escape hatches
+- `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,43 +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
-  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/circle.kap

@@ -0,0 +1,16 @@
+(class Circle)
+
+(local pi 3.14159)
+
+(fn initialize [radius]
+  (set @radius radius))
+
+(fn area []
+  (* pi @radius @radius))
+
+(fn circumference []
+  (* 2 pi @radius))
+
+(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/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

@@ -0,0 +1,17 @@
+(class HitCounter)
+
+(set @@total 0)
+
+(fn initialize [name] (set @name name))
+
+(fn hit []
+  (set @@total (+ @@total 1))
+  (set $last-hitter @name)
+  @@total)
+
+(let [a (HitCounter.new "alice")
+      b (HitCounter.new "bob")]
+  (print (a.hit))
+  (print (b.hit))
+  (print (a.hit))
+  (print $last-hitter))

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/mruby-runtime-examples.txt

@@ -0,0 +1,89 @@
+account-lockout
+accumulator
+ackermann
+anagram
+anonymous-greeter
+bank-account
+baseball-game
+best-time-to-buy-sell-stock
+binary-search
+binary-to-decimal
+block-sort
+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
+record
+reverse-integer
+roman-to-integer
+ruby-eval
+safe-lookup
+scopes
+shapes
+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

@@ -0,0 +1,18 @@
+(class ParkingSystem)
+
+(fn initialize [big medium small]
+  (set @big big)
+  (set @medium medium)
+  (set @small small))
+
+(fn add-car [car-type]
+  (if (and (= car-type 1) (> @big 0)) (do (set @big (- @big 1)) true)
+      (and (= car-type 2) (> @medium 0)) (do (set @medium (- @medium 1)) true)
+      (and (= car-type 3) (> @small 0)) (do (set @small (- @small 1)) true)
+      false))
+
+(let [parking (ParkingSystem.new 1 1 0)]
+  (print (parking.add-car 1))
+  (print (parking.add-car 2))
+  (print (parking.add-car 3))
+  (print (parking.add-car 1)))

data/examples/thread-styles.kap

@@ -0,0 +1,41 @@
+(fn positive? [n] (> n 0))
+(fn square [n] (* n n))
+(fn add [x y] (+ x y))
+(fn mul [x y] (* x y))
+(fn nonzero [n] (if (= n 0) nil n))
+(fn non-empty [s] (if (= s "") nil s))
+(fn wrap [s] (.. ">>" s "<<"))
+(fn shout [s] (.. s "!"))
+
+(fn keep [pred xs]
+  (icollect [_ x (ipairs xs)]
+    (when (pred x) x)))
+
+(fn map [f xs]
+  (icollect [_ x (ipairs xs)]
+    (f x)))
+
+(fn join [sep xs]
+  (var s "")
+  (each [_ x (ipairs xs)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(let [scores [-2 3 -1 4 0 5]
+      report (->> scores
+                  (keep positive?)
+                  (map square)
+                  (join ", "))
+      adjusted (-> 7 (add 3) (mul 2) (square))
+      ok (-?> "hello" (non-empty) (wrap) (shout))
+      bad (-?> "" (non-empty) (wrap) (shout))
+      live (-?>> 5 (nonzero) (mul 3) (add 1))
+      dead (-?>> 0 (nonzero) (mul 3) (add 1))]
+  (print report)
+  (print adjusted)
+  (print ok)
+  (print bad)
+  (print live)
+  (print dead))

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/lib/kapusta/ast.rb

@@ -117,7 +117,7 @@ module Kapusta
 
   class List
     attr_reader :items
-    attr_accessor :multiline_source, :line, :column
+    attr_accessor :multiline_source, :line, :column, :sigil
 
     def initialize(items)
       @items = items

data/lib/kapusta/cli.rb

@@ -5,7 +5,7 @@ require 'optparse'
 
 module Kapusta
   class CLI
-    Options = Struct.new(:compile, :help, :version, keyword_init: true)
+    Options = Struct.new(:compile, :target, :help, :version, keyword_init: true)
 
     def self.start(argv = ARGV)
       args = argv.dup
@@ -21,8 +21,10 @@ module Kapusta
         return
       end
 
+      raise Kapusta::Error, Kapusta::Errors.format(:target_requires_compile) if options.target && !options.compile
+
       if options.compile
-        compile_file(args)
+        compile_file(args, target: options.target)
       else
         run_file(args)
       end
@@ -32,11 +34,14 @@ module Kapusta
     end
 
     def self.parse_options(args)
-      options = Options.new(compile: false, help: false, version: false)
+      options = Options.new(compile: false, target: nil, help: false, version: false)
 
       OptionParser.new do |parser|
         parser.banner = usage
         parser.on('-c', '--compile', 'Compile .kap to Ruby') { options.compile = true }
+        parser.on('--target=TARGET', 'Compile for mruby') do |target|
+          options.target = Kapusta::Compiler.normalize_target(target)
+        end
         parser.on('-h', '--help', 'Show this help') { options.help = true }
         parser.on('-v', '--version', 'Show version') { options.version = true }
       end.order!(args)
@@ -44,12 +49,12 @@ module Kapusta
       options
     end
 
-    def self.compile_file(args)
+    def self.compile_file(args, target:)
       path = args.shift
       abort usage unless path
       abort usage unless args.empty?
 
-      $stdout.write(Kapusta.compile(File.read(path), path:))
+      $stdout.write(Kapusta.compile(File.read(path), path:, target:))
     end
 
     def self.run_file(args)
@@ -64,7 +69,7 @@ module Kapusta
     end
 
     def self.usage
-      'usage: kapusta [--compile|-c] <file.kap> | kapusta <file.kap> [args...]'
+      'usage: kapusta [--compile|-c] [--target=mruby] <file.kap> | kapusta <file.kap> [args...]'
     end
   end
 end