kapusta 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 520158590f1244ac17f70b58ded945f66be00060f6da89cebb366fefaf27b62e
-  data.tar.gz: 6773e0faa320f23cb15106e710f380a39093c9fc6e56cead8941c28e0ccf16c5
+  metadata.gz: 3cafef3668504ca08a40ba087c4c2b754bfda02e6f61161f19bcf8d56a254e00
+  data.tar.gz: 501b99f6ec3bfa950865b63b26ec6fd7f5b64977bb86f41d4eff51957602cc84
 SHA512:
-  metadata.gz: 814d37c473287d2d1e54568c7d21c22d88703cd89da761100c1f20950e47cb18eb2ac4807aa596878ded72eb7049a6083d2b9de46bc76ce2ea55787f6993f61f
-  data.tar.gz: 3a15fc05522e617cf46e8709a55dc8497252503f2b995dffaa4f8995fc34a54e9bcc2a711cd501884203bf0113c7924f159377459de8f2524e9c371c018d8238
+  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` or `@var`) / `cvar` or `@@var` / `gvar` or `$var`
+- `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/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/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/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/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

data/lib/kapusta/compiler/emitter/bindings.rb

@@ -181,6 +181,14 @@ module Kapusta
 
         def emit_toplevel_method_bridge(ruby_name)
           method_name = ruby_name.to_sym.inspect
+          if mruby_target?
+            return [
+              "define_singleton_method(#{method_name}) do |*args|",
+              indent("Object.instance_method(#{method_name}).bind(self).call(*args)"),
+              'end'
+            ].join("\n")
+          end
+
           "define_singleton_method(#{method_name}, Object.instance_method(#{method_name}).bind(self))"
         end
 
@@ -229,8 +237,14 @@ module Kapusta
 
           binding = env.lookup_if_defined(name)
           return false if binding.nil?
+          return false if method_binding?(binding)
+          return false if constant_binding?(binding)
+
+          true
+        end
 
-          !method_binding?(binding)
+        def constant_binding?(binding)
+          binding.is_a?(String) && binding.match?(/\A[A-Z][A-Z0-9_]*\z/)
         end
 
         def emit_let(args, env, current_scope)
@@ -277,7 +291,7 @@ module Kapusta
           chunks.reject(&:empty?).join("\n")
         end
 
-        def emit_local_form(form, env, current_scope)
+        def emit_local_form(form, env, current_scope, allow_constant: false)
           emit_error!(:local_arity, form: form.head.name) unless form.items.length == 3
 
           target = form.items[1]
@@ -285,6 +299,12 @@ module Kapusta
 
           if target.is_a?(Sym)
             validate_binding_symbol!(target)
+            if allow_constant && form.head.name == 'local' && (constant_name = constant_name_for(target.name))
+              env.define(target.name, constant_name)
+              mark_mutability(env, target.name, mutable: false)
+              return ["#{constant_name} = #{value_code}\nnil", env]
+            end
+
             ruby_name = define_local(env, target.name)
             mark_mutability(env, target.name, mutable: form.head.name == 'var')
             ["#{ruby_name} = #{value_code}\nnil", env]
@@ -294,6 +314,11 @@ module Kapusta
           end
         end
 
+        def constant_name_for(source_name)
+          candidate = source_name.tr('-', '_').upcase
+          candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
+        end
+
         def check_destructure_value!(pattern, value_form)
           return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
 

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -57,6 +57,25 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          value_code, value_var, body = build_case_parts(args, env, current_scope, mode)
+          return body unless value_var
+
+          [
+            '(-> do',
+            indent("#{value_var} = #{value_code}"),
+            indent(body),
+            'end).call'
+          ].join("\n")
+        end
+
+        def emit_case_statement(args, env, current_scope, mode)
+          value_code, value_var, body = build_case_parts(args, env, current_scope, mode)
+          return body unless value_var
+
+          "#{value_var} = #{value_code}\n#{body}"
+        end
+
+        def build_case_parts(args, env, current_scope, mode)
           emit_error!(:case_no_subject) if args.empty?
 
           clauses = args[1..]
@@ -65,20 +84,22 @@ module Kapusta
 
           value_code = emit_expr(args[0], env, current_scope)
           if simple_case_subject?(args[0]) && simple_expression?(value_code)
-            body = try_emit_native_case(value_code, clauses, env, current_scope, mode)
+            body = emit_case_body(value_code, clauses, env, current_scope, mode)
             emit_error!(:case_unsupported) unless body
-            return body
+            return [value_code, nil, body]
           end
 
           value_var = temp('case_value')
-          body = try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          body = emit_case_body(value_var, clauses, env, current_scope, mode)
           emit_error!(:case_unsupported) unless body
-          [
-            '(-> do',
-            indent("#{value_var} = #{value_code}"),
-            indent(body),
-            'end).call'
-          ].join("\n")
+          [value_code, value_var, body]
+        end
+
+        def emit_case_body(value_var, clauses, env, current_scope, mode)
+          return try_emit_compat_case(value_var, clauses, env, current_scope, mode) if mruby_target?
+
+          try_emit_native_case(value_var, clauses, env, current_scope, mode) ||
+            try_emit_compat_case(value_var, clauses, env, current_scope, mode)
         end
 
         def simple_case_subject?(form)
@@ -113,11 +134,6 @@ module Kapusta
           ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
-        def wildcard_last?(clauses)
-          last_pattern = clauses[-2]
-          last_pattern.is_a?(Sym) && last_pattern.name == '_'
-        end
-
         def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
           allow_pins = !where_guards.empty? && mode == :case
           plan = native_pattern_plan(pattern, env, mode:, allow_pins:)
@@ -132,6 +148,73 @@ module Kapusta
           ["in #{plan[:pattern]}#{guard_clause}", indent(body_code)].join("\n")
         end
 
+        def try_emit_compat_case(value_var, clauses, env, current_scope, mode)
+          arms = []
+          i = 0
+          while i < clauses.length
+            pattern = clauses[i]
+            body = clauses[i + 1]
+            inner, where_guards = if where_pattern?(pattern)
+                                    [pattern.items[1], pattern.items[2..]]
+                                  else
+                                    [pattern, []]
+                                  end
+            sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
+            sub_arms = sub_patterns.map do |sub|
+              try_compat_arm(sub, body, where_guards, value_var, env, current_scope, mode)
+            end
+            return if sub_arms.any?(&:nil?)
+
+            arms.concat(sub_arms)
+            i += 2
+          end
+          emit_compat_case_lines(arms)
+        end
+
+        def wildcard_last?(clauses)
+          last_pattern = clauses[-2]
+          last_pattern.is_a?(Sym) && last_pattern.name == '_'
+        end
+
+        def try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
+          allow_pins = !where_guards.empty? && mode == :case
+          arm_env = env.child
+          plan = compat_pattern_plan(pattern, value_var, env, arm_env, mode:, allow_pins:)
+          return unless plan
+
+          where_guard_codes = where_guards.map { |g| emit_expr(g, arm_env, current_scope) }
+          if where_guard_codes.empty?
+            guard_codes = plan[:conditions]
+            prelude     = plan[:prelude]
+          else
+            prelude_guards = plan[:prelude].map { |line| "begin #{line}; true end" }
+            guard_codes = plan[:conditions] + prelude_guards + where_guard_codes
+            prelude     = []
+          end
+          body_code = emit_expr(body, arm_env, current_scope)
+          [guard_codes, prelude, body_code]
+        end
+
+        def emit_compat_case_lines(arms)
+          last_idx = arms.length - 1
+          has_unconditional = arms.any? { |conditions, _prelude, _body_code| conditions.empty? }
+          lines = ['case']
+          arms.each_with_index do |(conditions, prelude, body_code), idx|
+            lines << if conditions.empty?
+                       idx == last_idx ? 'else' : 'when true'
+                     else
+                       "when #{conditions.join(' && ')}"
+                     end
+            lines << indent([*prelude, body_code].join("\n"))
+          end
+          unless has_unconditional
+            lines << 'else'
+            lines << indent('nil')
+          end
+          lines << 'end'
+          lines.join("\n")
+        end
+
         def emit_while(args, env, current_scope)
           <<~RUBY.chomp
             (-> do

data/lib/kapusta/compiler/emitter/interop.rb

@@ -300,6 +300,8 @@ module Kapusta
         def emit_bound_call(binding, args, env, current_scope)
           return emit_self_method_binding_call(binding, args, env, current_scope) if method_binding?(binding)
 
+          emit_error!(:cannot_call_constant, name: binding) if constant_binding?(binding)
+
           emit_callable_call(binding, args, env, current_scope)
         end
 

data/lib/kapusta/compiler/emitter/patterns.rb

@@ -161,6 +161,131 @@ module Kapusta
 
         class PatternNotTranslatable < StandardError; end
 
+        def compat_pattern_plan(pattern, value_code, env, arm_env, mode:, allow_pins:)
+          state = { bound_names: {}, conditions: [], prelude: [] }
+          compile_compat_pattern(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          { conditions: state[:conditions], prelude: state[:prelude] }
+        rescue PatternNotTranslatable
+          nil
+        end
+
+        def compile_compat_pattern(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          case pattern
+          when Sym
+            compile_compat_symbol(pattern, value_code, env, arm_env, mode:, state:)
+          when Vec
+            compile_compat_sequence(pattern.items, value_code, env, arm_env, mode:, allow_pins:, state:)
+          when HashLit
+            compile_compat_hash(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          when List
+            if pin_pattern?(pattern)
+              compile_compat_pin(pattern, value_code, env, mode:, allow_pins:, state:)
+            elsif or_pattern?(pattern)
+              raise PatternNotTranslatable
+            else
+              compile_compat_sequence(pattern.items, value_code, env, arm_env, mode:, allow_pins:, state:)
+            end
+          when nil
+            state[:conditions] << "#{value_code}.nil?"
+          when Symbol, String, Numeric, true, false
+            state[:conditions] << "#{value_code} == #{pattern.inspect}"
+          else
+            raise PatternNotTranslatable
+          end
+        end
+
+        def compile_compat_symbol(pattern, value_code, env, arm_env, mode:, state:)
+          name = pattern.name
+          return if name == '_'
+
+          if nil_allowing_pattern_name?(name)
+            raise PatternNotTranslatable if state[:bound_names].key?(name)
+
+            ruby = define_local(arm_env, name)
+            state[:bound_names][name] = true
+            state[:prelude] << "#{ruby} = #{value_code}"
+            return
+          end
+
+          binding = mode == :match ? env.lookup_if_defined(name) : nil
+          if state[:bound_names].key?(name)
+            raise PatternNotTranslatable
+          elsif binding
+            state[:conditions] << "#{value_code} == #{binding_value_code(binding)}"
+          else
+            ruby = define_local(arm_env, name)
+            state[:bound_names][name] = true
+            state[:conditions] << "(#{ruby} = #{value_code}) != nil"
+          end
+        end
+
+        def compile_compat_sequence(items, value_code, env, arm_env, mode:, allow_pins:, state:)
+          min_length = compat_sequence_min_length(items)
+          state[:conditions] << "#{value_code}.is_a?(Array)"
+          state[:conditions] << "#{value_code}.length >= #{min_length}"
+
+          index = 0
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              unless sub.name == '_'
+                ruby = define_local(arm_env, sub.name)
+                state[:prelude] << "#{ruby} = #{value_code}[#{index}..]"
+              end
+              i += 2
+            else
+              compile_compat_pattern(items[i], "#{value_code}[#{index}]", env, arm_env,
+                                     mode:, allow_pins:, state:)
+              index += 1
+              i += 1
+            end
+          end
+        end
+
+        def compat_sequence_min_length(items)
+          count = 0
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              i += 2
+            else
+              count += 1
+              i += 1
+            end
+          end
+          count
+        end
+
+        def compile_compat_hash(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          state[:conditions] << "#{value_code}.is_a?(Hash)"
+          pattern.pairs.each do |key, value|
+            lookup = "#{value_code}[#{compile_compat_hash_key(key)}]"
+            compile_compat_pattern(value, lookup, env, arm_env, mode:, allow_pins:, state:)
+          end
+        end
+
+        def compile_compat_hash_key(key)
+          case key
+          when Symbol, String, Numeric, true, false, nil then key.inspect
+          else raise PatternNotTranslatable
+          end
+        end
+
+        def compile_compat_pin(pattern, value_code, env, mode:, allow_pins:, state:)
+          raise PatternNotTranslatable unless allow_pins && mode == :case
+
+          name_sym = pattern.items[1]
+          raise PatternNotTranslatable unless name_sym.is_a?(Sym)
+
+          binding = env.lookup_if_defined(name_sym.name)
+          raise PatternNotTranslatable unless binding
+
+          state[:conditions] << "#{value_code} == #{binding_value_code(binding)}"
+        end
+
         def native_pattern_plan(pattern, env, mode:, allow_pins:)
           state = { bound_names: {}, binding_names: [], guards: [] }
           ruby_pattern = compile_native_pattern(pattern, env, mode:, allow_pins:, state:)

data/lib/kapusta/compiler/emitter/support.rb

@@ -25,6 +25,10 @@ module Kapusta
           (@form_stack ||= []).last
         end
 
+        def mruby_target?
+          @target == :mruby
+        end
+
         def positionable?(form)
           form.respond_to?(:line) && form.respond_to?(:column)
         end
@@ -97,7 +101,8 @@ module Kapusta
             if named_function_form?(form)
               emit_named_fn_assignment(form, env, current_scope)
             elsif local_form?(form)
-              code, env = emit_local_form(form, env, current_scope)
+              code, env = emit_local_form(form, env, current_scope,
+                                          allow_constant: allow_method_definitions)
               code = code.delete_suffix("\nnil") unless result_needed
               [code, env]
             elsif do_form?(form)
@@ -136,7 +141,7 @@ module Kapusta
         def sequence_statement_form?(form)
           return false unless form.is_a?(List) && form.head.is_a?(Sym)
 
-          %w[let while for each].include?(form.head.name)
+          %w[let while for each case match].include?(form.head.name)
         end
 
         def emit_sequence_statement_form(form, env, current_scope, result_needed:)
@@ -152,6 +157,8 @@ module Kapusta
             return ["#{code}\nnil", env] if result_needed && current_scope != :toplevel
 
             return [code, env]
+          when 'case', 'match'
+            return [emit_case_statement(form.rest, env, current_scope, form.head.name.to_sym), env] unless result_needed
           end
 
           [emit_expr(form, env, current_scope), env]

data/lib/kapusta/compiler/emitter.rb

@@ -24,8 +24,9 @@ module Kapusta
       include EmitterModules::Interop
       include EmitterModules::Patterns
 
-      def initialize(path:)
+      def initialize(path:, target: nil)
         @path = path
+        @target = target
         @temp_index = 0
       end
 

data/lib/kapusta/compiler.rb

@@ -34,17 +34,17 @@ module Kapusta
     ].freeze
     SPECIAL_FORMS = (CORE_SPECIAL_FORMS + LuaCompat::SPECIAL_FORMS).freeze
 
-    def self.compile(source, path: '(kapusta)')
+    def self.compile(source, path: '(kapusta)', target: nil)
       forms = Reader.read_all(source)
       expanded = MacroExpander.new(path:).expand_all(forms)
-      compile_forms(expanded, path:)
+      compile_forms(expanded, path:, target:)
     rescue Kapusta::Error => e
       raise e.with_defaults(path:)
     end
 
-    def self.compile_forms(forms, path: '(kapusta)')
+    def self.compile_forms(forms, path: '(kapusta)', target: nil)
       normalized = Normalizer.new.normalize_all(forms)
-      Emitter.new(path:).emit_file(normalized)
+      Emitter.new(path:, target: normalize_target(target)).emit_file(normalized)
     rescue Kapusta::Error => e
       raise e.with_defaults(path:)
     end
@@ -57,5 +57,14 @@ module Kapusta
     def self.run_file(path)
       run(File.read(path), path:)
     end
+
+    def self.normalize_target(target)
+      case target
+      when nil then nil
+      when :mruby, 'mruby' then :mruby
+      else
+        raise Error, Kapusta::Errors.format(:unknown_target, target: target.inspect)
+      end
+    end
   end
 end

data/lib/kapusta/errors.rb

@@ -10,6 +10,7 @@ module Kapusta
       bad_set_target: 'bad set target: %{target}',
       bad_shorthand: 'bad shorthand',
       bind_table_dots: 'unable to bind table ...',
+      cannot_call_constant: 'cannot call constant %{name}; reference it without parentheses',
       cannot_call_literal: 'cannot call literal value %{value}',
       cannot_emit_form: 'cannot emit form: %{form}',
       cannot_set_method_binding: 'cannot set method binding: %{name}',
@@ -51,6 +52,7 @@ module Kapusta
       odd_forms_in_hash: 'odd number of forms in hash',
       rest_not_last: 'expected rest argument before last parameter',
       shadowed_special: 'local %{name} was overshadowed by a special form or macro',
+      target_requires_compile: '--target requires --compile',
       tset_no_value: 'tset: expected table, key, and value arguments',
       unclosed_delimiter: "unclosed opening delimiter '%{char}'",
       undefined_symbol: 'undefined symbol: %{name}',
@@ -58,6 +60,7 @@ module Kapusta
       unexpected_eof: 'unexpected eof',
       unexpected_vararg: 'unexpected vararg',
       unknown_special_form: 'unknown special form: %{name}',
+      unknown_target: 'unknown target %{target}; only mruby is supported',
       unquote_outside_quasiquote: 'unquote outside quasiquote',
       unquote_splice_outside_list: 'unquote-splice must appear inside a quoted list/vec',
       unterminated_string: 'unterminated string',

data/lib/kapusta/formatter.rb

@@ -657,7 +657,6 @@ module Kapusta
 
     def render_let_bindings(bindings, indent)
       return render(bindings, indent + '(let '.length, force_expand: true) if contains_comments?(bindings.items)
-      return render(bindings, indent + '(let '.length, layout: :pairwise) if bindings.items.length <= 2
 
       hanging = render_hanging_pairwise_vec(bindings)
       hanging || render(bindings, indent + '(let '.length, layout: :pairwise)

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

data/lib/kapusta.rb

@@ -23,8 +23,8 @@ module Kapusta
     self.eval(source, path:)
   end
 
-  def self.compile(source, path: '(eval)', **_opts)
-    Compiler.compile(source, path:)
+  def self.compile(source, path: '(eval)', target: nil, **_opts)
+    Compiler.compile(source, path:, target:)
   end
 
   def self.require(feature, relative_to: nil)

data/spec/cli_spec.rb

@@ -66,6 +66,19 @@ RSpec.describe Kapusta::CLI do
     end
   end
 
+  it 'compiles case and match forms for mruby with --target=mruby' do
+    path = File.expand_path('../examples/match.kap', __dir__)
+
+    ruby = capture_stdout do
+      described_class.start(['--compile', '--target=mruby', path])
+    end
+
+    expect(ruby).not_to match(/^\s*in\b/)
+    expect(ruby).not_to include('^(')
+    expect(ruby).to include("case\n")
+    expect(ruby).to include('when ')
+  end
+
   it 'rejects extra positional arguments in compile mode' do
     path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
 
@@ -77,6 +90,28 @@ RSpec.describe Kapusta::CLI do
     expect(error_output).to include('usage: kapusta')
   end
 
+  it 'rejects unsupported targets' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    error_output = capture_stderr do
+      expect { described_class.start(['--compile', '--target=mri', path]) }
+        .to raise_error(SystemExit)
+    end
+
+    expect(error_output).to include('unknown target "mri"; only mruby is supported')
+  end
+
+  it 'rejects target without compile mode' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    error_output = capture_stderr do
+      expect { described_class.start(['--target=mruby', path]) }
+        .to raise_error(SystemExit)
+    end
+
+    expect(error_output).to include('--target requires --compile')
+  end
+
   it 'passes remaining arguments through to the Kapusta program' do
     path = File.expand_path('../examples/greet.kap', __dir__)
 

data/spec/examples_spec.rb

@@ -2,10 +2,21 @@
 
 require 'spec_helper'
 require 'fileutils'
+require 'open3'
 require 'stringio'
+require 'tempfile'
 
 EXAMPLES_DIR = File.expand_path('../examples', __dir__)
 
+def example_list(name)
+  File.readlines(File.join(EXAMPLES_DIR, name), chomp: true)
+      .reject(&:empty?)
+      .map { |example| "#{example}.kap" }
+      .freeze
+end
+
+MRUBY_RUNTIME_EXAMPLES = example_list('mruby-runtime-examples.txt')
+
 def run_example(name, argv: [])
   previous_argv = ARGV.dup
   previous_stdout = $stdout
@@ -27,6 +38,39 @@ ensure
   $stdout = previous_stdout
 end
 
+def compile_example(name, target: nil)
+  path = File.join(EXAMPLES_DIR, name)
+  Kapusta.compile(File.read(path), path:, target:)
+end
+
+def run_compiled_source(source, path:)
+  previous_argv = ARGV.dup
+  previous_stdout = $stdout
+  ARGV.replace([])
+  $stdout = StringIO.new
+  TOPLEVEL_BINDING.eval(source, path, 1)
+  $stdout.string
+ensure
+  $stdout = previous_stdout
+  ARGV.replace(previous_argv)
+end
+
+def run_mruby_source(source, path:)
+  stdout, stderr, status = capture_mruby_source(source, path:)
+
+  raise "mruby failed for #{path}:\n#{stderr}" unless status.success?
+
+  stdout
+end
+
+def capture_mruby_source(source, path:)
+  Tempfile.create([File.basename(path, '.kap'), '.rb']) do |file|
+    file.write(source)
+    file.close
+    Open3.capture3('mruby', file.path)
+  end
+end
+
 RSpec.describe 'examples' do
   it 'ackermann.kap' do
     expect(run_example('ackermann.kap')).to eq("9\n61\n")
@@ -36,6 +80,18 @@ RSpec.describe 'examples' do
     expect(run_example('accumulator.kap')).to eq("22\n")
   end
 
+  it 'account-lockout.kap' do
+    expect(run_example('account-lockout.kap')).to eq(<<~OUT)
+      :ok
+      :locked
+      :locked
+    OUT
+  end
+
+  it 'circle.kap' do
+    expect(run_example('circle.kap')).to eq("78.53975\n31.4159\n")
+  end
+
   it 'anagram.kap' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
@@ -107,6 +163,26 @@ RSpec.describe 'examples' do
     expect(run_example('happy-number.kap')).to eq("true\nfalse\ntrue\n")
   end
 
+  it 'number-of-1-bits.kap' do
+    expect(run_example('number-of-1-bits.kap')).to eq("3\n1\n31\n")
+  end
+
+  it 'number-of-steps.kap' do
+    expect(run_example('number-of-steps.kap')).to eq("6\n4\n12\n")
+  end
+
+  it 'convert-temperature.kap' do
+    expect(run_example('convert-temperature.kap')).to eq("309.65\n97.7\n395.26\n251.798\n")
+  end
+
+  it 'count-effects.kap' do
+    expect(run_example('count-effects.kap')).to eq("1\n2\n")
+  end
+
+  it 'max-achievable.kap' do
+    expect(run_example('max-achievable.kap')).to eq("6\n7\n10\n")
+  end
+
   it 'move-zeroes.kap' do
     expect(run_example('move-zeroes.kap')).to eq(<<~OUT)
       [1, 3, 12, 0, 0]
@@ -368,6 +444,18 @@ RSpec.describe 'examples' do
     OUT
   end
 
+  it 'underscore-patterns.kap on mruby keeps loose nil and strict fallback separate' do
+    path = File.join(EXAMPLES_DIR, 'underscore-patterns.kap')
+    ruby = compile_example('underscore-patterns.kap', target: :mruby)
+
+    expect(run_mruby_source(ruby, path:)).to eq(<<~OUT)
+      5
+      nil
+      5
+      "fallback"
+    OUT
+  end
+
   it 'scopes.kap' do
     expect(run_example('scopes.kap')).to eq("5\n9\n9\n9\n")
   end
@@ -577,3 +665,30 @@ RSpec.describe 'examples' do
     OUT
   end
 end
+
+RSpec.describe 'mruby runtime examples' do
+  MRUBY_RUNTIME_EXAMPLES.each do |name|
+    it name do
+      path = File.join(EXAMPLES_DIR, name)
+      ruby = compile_example(name)
+      expected = run_example(name)
+      expect(run_compiled_source(ruby, path:)).to eq(expected)
+      mruby_stdout, _mruby_stderr, mruby_status = capture_mruby_source(ruby, path:)
+
+      if mruby_status.success? && mruby_stdout == expected
+        expect(run_mruby_source(ruby, path:)).to eq(expected)
+      else
+        mruby_ruby = compile_example(name, target: :mruby)
+
+        if mruby_ruby == ruby
+          expect(mruby_status).to be_success
+        else
+          expect(mruby_ruby).not_to match(/^\s*in\b/)
+          expect(mruby_ruby).not_to include('^(')
+          expect(run_compiled_source(mruby_ruby, path:)).to eq(expected)
+          run_mruby_source(mruby_ruby, path:)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,15 @@
 require 'bundler/setup'
 require 'kapusta'
 
+module SilenceConstantRedefinitionWarnings
+  def warn(message, category: nil)
+    return if /already initialized constant|previous definition of/.match?(message)
+
+    super
+  end
+end
+Warning.singleton_class.prepend(SilenceConstantRedefinitionWarnings)
+
 RSpec.configure do |config|
   config.disable_monkey_patching!
   config.example_status_persistence_file_path = '.rspec_status'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -26,6 +26,7 @@ files:
 - bin/console
 - bin/fennel-parity
 - bin/setup
+- examples/account-lockout.kap
 - examples/accumulator.kap
 - examples/ackermann.kap
 - examples/anagram.kap
@@ -38,9 +39,12 @@ files:
 - examples/block-sort.kap
 - examples/blocks-and-kwargs.kap
 - examples/calc.kap
+- examples/circle.kap
 - examples/classify-wallet.kap
 - examples/climbing-stairs.kap
 - examples/contains-duplicate.kap
+- examples/convert-temperature.kap
+- examples/count-effects.kap
 - examples/counter.kap
 - examples/describe.kap
 - examples/destructure.kap
@@ -50,6 +54,8 @@ files:
 - examples/even-squares.kap
 - examples/exceptions.kap
 - examples/factorial.kap
+- examples/falling-drops.kap
+- examples/fennel-parity-examples.txt
 - examples/fib.kap
 - examples/files.kap
 - examples/fizzbuzz.kap
@@ -74,10 +80,14 @@ files:
 - examples/majority-element.kap
 - examples/manhattan-distance.kap
 - examples/match.kap
+- examples/max-achievable.kap
 - examples/maximum-subarray.kap
 - examples/min-max.kap
 - examples/module-header.kap
 - examples/move-zeroes.kap
+- examples/mruby-runtime-examples.txt
+- examples/number-of-1-bits.kap
+- examples/number-of-steps.kap
 - examples/or-patterns.kap
 - examples/packet-router.kap
 - examples/palindrome.kap