kapusta 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25c55d7f1c7a4b1dcd3cca0e7a513a74591905e9dfc97e96f015b695d75905a2
-  data.tar.gz: '0940fc49053103149667dd8bf515e159d87a10182bb3fbd5eb152ba63f487e06'
+  metadata.gz: 2398c1c908306ac808914717a67e74f8085ee6048deb9c9dd665f4dd8c39cc2f
+  data.tar.gz: 1022c2df415418d26f1b84b1b16830cc525829182a82e93c1a450d0dd4b5bdd2
 SHA512:
-  metadata.gz: a3a8cb442fcb6d5157dcf3885e9d6a7323735418e488715e35baea0006b098e8822b8252013eea2636f96a35665db8173556507af293188f632108827f8119d5
-  data.tar.gz: d0f19cbc23c569524cb64c0b70b14d4ea5ed149291acad18528611a7b12c2ff1b4d9c27ce1a239ec07e9c19bb36c5907f294fbca4b0b783bfc2991c880b93fc7
+  metadata.gz: 6a31f0bab47d9c5c0d40720c52422717e0d04a9c03bb03a115ac62c7f541226dc3d9b7e9aa052bf55d574e1193ecab82e97b0610d43bbe1702038024486a1953
+  data.tar.gz: f20bf20a890d1b23f3ec7d2d113a3340c6255132a367a655cddab52ded9e2276bd236439d242ca0ea46f857096a5f5885620dd9a104f8b0f337c9aba75e50366

data/README.md

@@ -10,6 +10,14 @@ For more information about Kapusta, see the official Fennel documentation and tu
 
 ## Usage
 
+```
+gem install kapusta
+kapfmt --fix examples/fizzbuzz.kap
+kapusta examples/fizzbuzz.kap
+```
+
+or
+
 ```
 exe/kapusta examples/fizzbuzz.kap
 ```
@@ -37,7 +45,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` / `cvar` / `gvar` escape hatches
+- `ivar` (`@var`) / `cvar` (`@@var`) / `gvar` (`$var`) escape hatches
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments

data/examples/anonymous-greeter.kap

@@ -0,0 +1,4 @@
+(let [name nil
+      greet (fn [value] (if value (.. "Hello, " value "!") "Hello, anonymous!"))]
+  (print (greet name))
+  (print (greet "Ada")))

data/examples/binary-to-decimal.kap

@@ -0,0 +1,7 @@
+(fn binary-to-decimal [bits]
+  (faccumulate [value 0 i 0 (- (length bits) 1)]
+    (+ (* value 2) (if (= (. bits i) "1") 1 0))))
+
+(print (binary-to-decimal "1011"))
+(print (binary-to-decimal "0"))
+(print (binary-to-decimal "101010"))

data/examples/or-patterns.kap

@@ -0,0 +1,8 @@
+(fn swap-kind [v]
+  (case v
+    (where (or [:pair x y] [:flipped y x])) (.. x ":" y)
+    _ "other"))
+
+(print (swap-kind [:pair 1 2]))
+(print (swap-kind [:flipped 1 2]))
+(print (swap-kind [:nope 1 2]))

data/examples/packet-router.kap

@@ -0,0 +1,26 @@
+(fn inbox-line [user event]
+  (match event
+    [:score user points] (.. "score:" points)
+    [:profile user ?city] (if city (.. "city:" city) "city:nil")
+    _ "other"))
+
+(fn score-delta [user event]
+  (case event
+    (where (or [:bonus (= user) points] [:score (= user) points])
+      (> points 0)
+      (< points 10))
+    points
+    _ 0))
+
+(fn packet-kind [packet]
+  (case packet
+    [:ping seq] (.. "ping:" seq)
+    [:pong seq] (.. "pong:" seq)
+    _ "other"))
+
+(print (inbox-line "Ada" [:score "Ada" 9]))
+(print (inbox-line "Ada" [:score "Lin" 7]))
+(print (inbox-line "Ada" [:profile "Ada" nil]))
+(print (score-delta "Ada" [:bonus "Ada" 5]))
+(print (score-delta "Ada" [:score "Lin" 5]))
+(print (packet-kind [:ping 7 :fast]))

data/examples/tic-tac-toe.kap

@@ -0,0 +1,18 @@
+(fn winner [board]
+  (case board
+    [["X" "X" "X"] _ _] "X"
+    [_ ["O" "O" "O"] _] "O"
+    [["X" _ _] [_ "X" _] [_ _ "X"]] "X"
+    [["O" _ _] ["O" _ _] ["O" _ _]] "O"
+    _ "draw"))
+
+(each
+  [
+    _
+    board
+    (ipairs [
+              [["X" "X" "X"] ["O" "" ""] ["" "O" ""]]
+              [["O" "X" "X"] ["O" "" "X"] ["O" "" ""]]
+              [["X" "O" ""] ["" "X" "O"] ["" "" "X"]]
+              [["X" "O" "X"] ["O" "X" "O"] ["O" "X" "O"]]])]
+  (print (winner board)))

data/examples/underscore-patterns.kap

@@ -0,0 +1,14 @@
+(fn loose [v]
+  (case v
+    _x _x
+    _ "fallback"))
+
+(fn strict [v]
+  (case v
+    x x
+    _ "fallback"))
+
+(print (loose 5))
+(print (loose nil))
+(print (strict 5))
+(print (strict nil))

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

@@ -50,44 +50,19 @@ module Kapusta
 
         def emit_fcollect(args, env, current_scope)
           result_var = temp('result')
-          bindings = args[0].items
-          ruby_name = temp(sanitize_local(bindings[0].name))
-          loop_env = env.child
-          loop_env.define(bindings[0].name, ruby_name)
-          start_code = emit_expr(bindings[1], env, current_scope)
-          finish_code = emit_expr(bindings[2], env, current_scope)
-          step_code = '1'
-          until_form = nil
-          i = 3
-          while i < bindings.length
-            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
-              until_form = bindings[i + 1]
-              i += 2
-            else
-              step_code = emit_expr(bindings[i], env, current_scope)
-              i += 1
+          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
+          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope, allow_method_definitions: false)
+          collecting_body = <<~RUBY.chomp
+            __kap_value = begin
+            #{indent(body_code)}
             end
-          end
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
-          finish_var = temp('finish')
-          step_var = temp('step')
-          cmp_var = temp('cmp')
+            #{result_var} << __kap_value unless __kap_value.nil?
+          RUBY
+          loop_code = emit_counted_loop(**parsed, current_scope:, body_code: collecting_body)
           <<~RUBY.chomp
             (-> do
               #{result_var} = []
-              #{ruby_name} = #{start_code}
-              #{finish_var} = #{finish_code}
-              #{step_var} = #{step_code}
-              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
-              while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
-                #{until_code}
-                __kap_value = begin
-                #{indent(body_code)}
-                end
-                #{result_var} << __kap_value unless __kap_value.nil?
-                #{ruby_name} += #{step_var}
-              end
+              #{indent(loop_code)}
               #{result_var}
             end).call
           RUBY
@@ -124,26 +99,22 @@ module Kapusta
           loop_env = env.child
           loop_env.define(acc_name.name, acc_var)
           loop_env.define(loop_name.name, loop_var)
-          start_code = emit_expr(bindings[3], env, current_scope)
-          finish_code = emit_expr(bindings[4], env, current_scope)
-          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1'
           body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          finish_var = temp('finish')
-          step_var = temp('step')
-          cmp_var = temp('cmp')
+          accumulating_body = "#{acc_var} = begin\n#{indent(body_code)}\nend"
+          loop_code = emit_counted_loop(
+            ruby_name: loop_var,
+            start_code: emit_expr(bindings[3], env, current_scope),
+            finish_code: emit_expr(bindings[4], env, current_scope),
+            step_code: bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1',
+            until_form: nil,
+            loop_env:,
+            current_scope:,
+            body_code: accumulating_body
+          )
           <<~RUBY.chomp
             (-> do
               #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{loop_var} = #{start_code}
-              #{finish_var} = #{finish_code}
-              #{step_var} = #{step_code}
-              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
-              while #{loop_var}.public_send(#{cmp_var}, #{finish_var})
-                #{acc_var} = begin
-                #{indent(body_code)}
-                end
-                #{loop_var} += #{step_var}
-              end
+              #{indent(loop_code)}
               #{acc_var}
             end).call
           RUBY

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

@@ -26,9 +26,9 @@ module Kapusta
           RUBY
         end
 
-        def emit_case(args, env, current_scope)
+        def emit_case(args, env, current_scope, mode)
           value_var = temp('case_value')
-          body = build_case_clauses(value_var, args[1..], env, current_scope)
+          body = build_case_clauses(value_var, args[1..], env, current_scope, mode)
           <<~RUBY.chomp
             (-> do
               #{value_var} = #{emit_expr(args[0], env, current_scope)}
@@ -37,31 +37,32 @@ module Kapusta
           RUBY
         end
 
-        def build_case_clauses(value_var, clauses, env, current_scope)
+        def build_case_clauses(value_var, clauses, env, current_scope, mode)
           return 'nil' if clauses.empty?
 
           pattern = clauses[0]
           body = clauses[1]
-          else_code = build_case_clauses(value_var, clauses[2..], env, current_scope)
-          emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          else_code = build_case_clauses(value_var, clauses[2..], env, current_scope, mode)
+          emit_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
         end
 
-        def emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        def emit_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           if where_pattern?(pattern)
-            emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope)
+            emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           else
-            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope)
+            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           end
         end
 
-        def emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        def emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           match_var = temp('match')
           bindings_var = temp('bindings')
+          plan = pattern_match_plan(pattern, env, mode:, allow_pins: false)
           arm_env = env.child
-          assign_code, arm_env = emit_bindings_from_match(pattern, bindings_var, arm_env)
+          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
           body_code = emit_expr(body, arm_env, current_scope)
           <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, emit_pattern(pattern), value_var)}
+            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
               #{bindings_var} = #{match_var}[1]
               #{assign_code}
@@ -72,17 +73,18 @@ module Kapusta
           RUBY
         end
 
-        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           inner = pattern.items[1]
-          guard = pattern.items[2]
+          guards = pattern.items[2..]
           match_var = temp('match')
           bindings_var = temp('bindings')
+          plan = pattern_match_plan(inner, env, mode:, allow_pins: mode == :case)
           arm_env = env.child
-          assign_code, arm_env = emit_bindings_from_match(inner, bindings_var, arm_env)
-          guard_code = emit_expr(guard, arm_env, current_scope)
+          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
+          guard_code = emit_case_guards(guards, arm_env, current_scope)
           body_code = emit_expr(body, arm_env, current_scope)
           <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, emit_pattern(inner), value_var)}
+            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
               #{bindings_var} = #{match_var}[1]
               #{assign_code}
@@ -97,6 +99,12 @@ module Kapusta
           RUBY
         end
 
+        def emit_case_guards(guards, env, current_scope)
+          return 'true' if guards.empty?
+
+          guards.map { |guard| parenthesize(emit_expr(guard, env, current_scope)) }.join(' && ')
+        end
+
         def emit_while(args, env, current_scope)
           body_code, = emit_sequence(args[1..], env, current_scope, allow_method_definitions: false)
           <<~RUBY.chomp
@@ -110,42 +118,12 @@ module Kapusta
         end
 
         def emit_for(args, env, current_scope)
-          bindings = args[0].items
-          name = bindings[0]
-          start_code = emit_expr(bindings[1], env, current_scope)
-          finish_code = emit_expr(bindings[2], env, current_scope)
-          step_code = '1'
-          until_form = nil
-          i = 3
-          while i < bindings.length
-            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
-              until_form = bindings[i + 1]
-              i += 2
-            else
-              step_code = emit_expr(bindings[i], env, current_scope)
-              i += 1
-            end
-          end
-
-          loop_env = env.child
-          ruby_name = temp(sanitize_local(name.name))
-          loop_env.define(name.name, ruby_name)
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
-          cmp_var = temp('cmp')
-          step_var = temp('step')
-          finish_var = temp('finish')
+          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
+          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope, allow_method_definitions: false)
+          loop_code = emit_counted_loop(**parsed, current_scope:, body_code:)
           <<~RUBY.chomp
             (-> do
-              #{ruby_name} = #{start_code}
-              #{finish_var} = #{finish_code}
-              #{step_var} = #{step_code}
-              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
-              while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
-                #{until_code}
-                #{indent(body_code)}
-                #{ruby_name} += #{step_var}
-              end
+              #{indent(loop_code)}
               nil
             end).call
           RUBY

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

@@ -51,7 +51,8 @@ module Kapusta
           when 'local', 'var' then emit_local_expr(args, env, current_scope)
           when 'set' then emit_set_expr(args, env, current_scope)
           when 'if' then emit_if(args, env, current_scope)
-          when 'case', 'match' then emit_case(args, env, current_scope)
+          when 'case' then emit_case(args, env, current_scope, :case)
+          when 'match' then emit_case(args, env, current_scope, :match)
           when 'while' then emit_while(args, env, current_scope)
           when 'for' then emit_for(args, env, current_scope)
           when 'each' then emit_each(args, env, current_scope)

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

@@ -28,10 +28,10 @@ module Kapusta
           end
         end
 
-        def emit_bindings_from_match(pattern, bindings_var, env)
+        def emit_bindings_from_match(binding_names, bindings_var, env)
           current_env = env
           lines = []
-          pattern_names(pattern).each do |name|
+          binding_names.each do |name|
             ruby_name = temp(sanitize_local(name))
             current_env.define(name, ruby_name)
             lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
@@ -39,6 +39,118 @@ module Kapusta
           [lines.join("\n"), current_env]
         end
 
+        def pattern_match_plan(pattern, env, mode:, allow_pins:)
+          state = { bound_names: {}, binding_names: [] }
+          {
+            pattern: emit_match_pattern(pattern, env, mode:, allow_pins:, state:),
+            bindings: state[:binding_names]
+          }
+        end
+
+        def emit_match_pattern(pattern, env, mode:, allow_pins:, state:)
+          case pattern
+          when Sym
+            emit_symbol_match_pattern(pattern, env, mode:, state:)
+          when Vec
+            emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+          when HashLit
+            pairs = pattern.pairs.map do |key, value|
+              "[#{key.inspect}, #{emit_match_pattern(value, env, mode:, allow_pins:, state:)}]"
+            end
+            "[:hash, [#{pairs.join(', ')}]]"
+          when List
+            if pin_pattern?(pattern)
+              emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+            elsif or_pattern?(pattern)
+              emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
+            elsif where_pattern?(pattern)
+              raise Error, '`where` is only valid as a case/match clause head'
+            else
+              emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+            end
+          when nil
+            '[:lit, nil]'
+          when Symbol, String, Numeric, true, false
+            "[:lit, #{pattern.inspect}]"
+          else
+            raise Error, "bad pattern: #{pattern.inspect}"
+          end
+        end
+
+        def emit_symbol_match_pattern(pattern, env, mode:, state:)
+          name = pattern.name
+
+          if name == '_'
+            '[:wild]'
+          elsif nil_allowing_pattern_name?(name)
+            bind_name = name.start_with?('?') ? name.delete_prefix('?') : name
+            emit_named_match_pattern(bind_name, env, mode:, state:, allow_nil: true, prefer_pin: false)
+          else
+            emit_named_match_pattern(name, env, mode:, state:, allow_nil: false, prefer_pin: true)
+          end
+        end
+
+        def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
+          if state[:bound_names].key?(name)
+            "[:ref, #{name.inspect}]"
+          elsif prefer_pin && mode == :match && env.defined?(name)
+            "[:pin, #{env.lookup(name)}]"
+          else
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+            "[:bind, #{name.inspect}, #{allow_nil}]"
+          end
+        end
+
+        def emit_sequence_match_pattern(items, env, mode:, allow_pins:, state:)
+          parts = []
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              parts << "[:rest, #{emit_match_pattern(items[i + 1], env, mode:, allow_pins:, state:)}]"
+              i += 2
+            else
+              parts << emit_match_pattern(items[i], env, mode:, allow_pins:, state:)
+              i += 1
+            end
+          end
+          "[:vec, [#{parts.join(', ')}]]"
+        end
+
+        def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+          raise Error, 'pin patterns are only supported inside `case` guards' unless allow_pins && mode == :case
+
+          name_sym = pattern.items[1]
+          raise Error, "bad pin pattern: #{pattern.inspect}" unless name_sym.is_a?(Sym)
+          raise Error, "cannot pin undefined name: #{name_sym.name}" unless env.defined?(name_sym.name)
+
+          "[:pin, #{env.lookup(name_sym.name)}]"
+        end
+
+        def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
+          initial_names = state[:binding_names].length
+          initial_bound = state[:bound_names].dup
+          canonical_names = nil
+          variants = pattern.items[1..].map do |subpattern|
+            alt_state = {
+              bound_names: initial_bound.dup,
+              binding_names: state[:binding_names].dup
+            }
+            compiled = emit_match_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
+            alt_names = alt_state[:binding_names][initial_names..]
+            canonical_names ||= alt_names
+            raise Error, 'all `or` patterns must bind the same names' if canonical_names.sort != alt_names.sort
+
+            compiled
+          end
+
+          canonical_names.each do |name|
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+          end
+          "[:or, [#{variants.join(', ')}]]"
+        end
+
         def emit_pattern(pattern)
           case pattern
           when Sym
@@ -99,6 +211,25 @@ module Kapusta
         def where_pattern?(pattern)
           pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'where'
         end
+
+        def pin_pattern?(pattern)
+          pattern.is_a?(List) &&
+            pattern.items.length == 2 &&
+            pattern.head.is_a?(Sym) &&
+            pattern.head.name == '='
+        end
+
+        def or_pattern?(pattern)
+          pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'or'
+        end
+
+        def nil_allowing_pattern_name?(name)
+          name.length > 1 && (name.start_with?('?') || name.start_with?('_'))
+        end
+
+        def rest_pattern_marker?(items, index)
+          items[index].is_a?(Sym) && items[index].name == '&'
+        end
       end
     end
   end

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

@@ -156,6 +156,47 @@ module Kapusta
           "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
         end
 
+        def parse_counted_for_bindings(bindings, env, current_scope)
+          name_sym = bindings[0]
+          ruby_name = temp(sanitize_local(name_sym.name))
+          loop_env = env.child
+          loop_env.define(name_sym.name, ruby_name)
+          start_code = emit_expr(bindings[1], env, current_scope)
+          finish_code = emit_expr(bindings[2], env, current_scope)
+          step_code = '1'
+          until_form = nil
+          i = 3
+          while i < bindings.length
+            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
+              until_form = bindings[i + 1]
+              i += 2
+            else
+              step_code = emit_expr(bindings[i], env, current_scope)
+              i += 1
+            end
+          end
+          { ruby_name:, loop_env:, start_code:, finish_code:, step_code:, until_form: }
+        end
+
+        def emit_counted_loop(ruby_name:, start_code:, finish_code:, step_code:,
+                              until_form:, loop_env:, current_scope:, body_code:)
+          finish_var = temp('finish')
+          step_var = temp('step')
+          cmp_var = temp('cmp')
+          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
+          <<~RUBY.chomp
+            #{ruby_name} = #{start_code}
+            #{finish_var} = #{finish_code}
+            #{step_var} = #{step_code}
+            #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
+            while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
+              #{until_code}
+              #{indent(body_code)}
+              #{ruby_name} += #{step_var}
+            end
+          RUBY
+        end
+
         def sanitize_local(name)
           base = Kapusta.kebab_to_snake(name)
           base = base.gsub('?', '_q').gsub('!', '_bang')

data/lib/kapusta/compiler/runtime.rb

@@ -63,12 +63,29 @@ module Kapusta
             end
           end
         RUBY
-        stringify: <<~RUBY.chomp,
+        stringify: <<~'RUBY'.chomp,
           def __kap_stringify(value)
+            render = nil
+            render = lambda do |item|
+              case item
+              when nil then 'nil'
+              when true then 'true'
+              when false then 'false'
+              when String, Symbol then item.inspect
+              when Array
+                "[#{item.map { |child| render.call(child) }.join(', ')}]"
+              when Hash
+                "{#{item.map { |key, child| "#{render.call(key)}=>#{render.call(child)}" }.join(', ')}}"
+              else
+                item.inspect
+              end
+            end
+
             case value
             when nil then 'nil'
             when true then 'true'
             when false then 'false'
+            when Array, Hash then render.call(value)
             else value.to_s
             end
           end
@@ -253,9 +270,16 @@ module Kapusta
         match_pattern_into: <<~'RUBY'.chomp
           def __kap_match_pattern_into(pattern, value, bindings)
             case pattern[0]
-            when :sym
+            when :bind
               name = pattern[1]
-              bindings[name] = value unless name == '_'
+              allow_nil = pattern[2]
+              return false if value.nil? && !allow_nil
+
+              bindings[name] = value
+              true
+            when :ref
+              bindings.key?(pattern[1]) && bindings[pattern[1]] == value
+            when :wild
               true
             when :vec
               return false unless value.is_a?(Array) || value.respond_to?(:to_ary)
@@ -273,7 +297,7 @@ module Kapusta
                 end
                 __kap_match_pattern_into(rest_pattern, array[rest_idx..], bindings)
               else
-                return false unless array.length == items.length
+                return false unless array.length >= items.length
 
                 items.each_with_index do |item, i|
                   return false unless __kap_match_pattern_into(item, array[i], bindings)
@@ -290,8 +314,16 @@ module Kapusta
               true
             when :lit
               value == pattern[1]
-            when :nil
-              value.nil?
+            when :pin
+              value == pattern[1]
+            when :or
+              pattern[1].any? do |option|
+                option_bindings = bindings.dup
+                next false unless __kap_match_pattern_into(option, value, option_bindings)
+
+                bindings.replace(option_bindings)
+                true
+              end
             else
               raise "bad pattern: #{pattern.inspect}"
             end
@@ -327,257 +359,19 @@ module Kapusta
         seen[name] = true
       end
 
-      def call(callee, positional, kwargs = nil, block = nil)
-        raise "not callable: #{callee.inspect}" unless callee.respond_to?(:call)
-
-        if block
-          kwargs ? callee.call(*positional, **kwargs, &block) : callee.call(*positional, &block)
-        else
-          kwargs ? callee.call(*positional, **kwargs) : callee.call(*positional)
-        end
-      end
-
-      def send_call(receiver, method_name, positional, kwargs = nil, block = nil)
-        if block
-          if kwargs
-            receiver.public_send(method_name, *positional, **kwargs,
-                                 &block)
-          else
-            receiver.public_send(method_name, *positional, &block)
-          end
-        elsif kwargs
-          receiver.public_send(method_name, *positional,
-                               **kwargs)
-        else
-          receiver.public_send(method_name, *positional)
-        end
-      end
-
-      def invoke_self(receiver, method_name, positional, kwargs = nil, block = nil)
-        if block
-          if kwargs
-            receiver.send(method_name, *positional, **kwargs,
-                          &block)
-          else
-            receiver.send(method_name, *positional, &block)
-          end
-        else
-          kwargs ? receiver.send(method_name, *positional, **kwargs) : receiver.send(method_name, *positional)
-        end
-      end
-
-      def stringify(value)
-        case value
-        when nil then 'nil'
-        when true then 'true'
-        when false then 'false'
-        else value.to_s
-        end
-      end
-
-      def print_values(*values)
-        $stdout.puts(values.map { |value| stringify(value) }.join("\t"))
-        nil
-      end
-
-      def concat(values)
-        values.map { |value| stringify(value) }.join
-      end
-
-      def get_path(obj, keys)
-        keys.reduce(obj) { |acc, key| acc[key] }
-      end
-
-      def qget_path(obj, keys)
-        keys.each do |key|
-          return nil if obj.nil?
-
-          obj = obj[key]
-        end
-        obj
-      end
-
-      def set_path(obj, keys, value)
-        target = obj
-        keys[0...-1].each { |key| target = target[key] }
-        target[keys.last] = value
-      end
-
-      def method_path_value(base, segments)
-        segments.reduce(base) { |obj, segment| obj.public_send(Kapusta.kebab_to_snake(segment).to_sym) }
-      end
-
-      def set_method_path(base, segments, value)
-        target = base
-        segments[0...-1].each do |segment|
-          target = target.public_send(Kapusta.kebab_to_snake(segment).to_sym)
-        end
-        setter = "#{Kapusta.kebab_to_snake(segments.last)}="
-        target.public_send(setter.to_sym, value)
-      end
-
-      def current_class_scope(receiver)
-        receiver.is_a?(Module) ? receiver : receiver.class
-      end
-
-      def get_ivar(receiver, name)
-        receiver.instance_variable_get("@#{Kapusta.kebab_to_snake(name)}")
-      end
-
-      def set_ivar(receiver, name, value)
-        receiver.instance_variable_set("@#{Kapusta.kebab_to_snake(name)}", value)
-      end
-
-      def get_cvar(receiver, name)
-        current_class_scope(receiver).class_variable_get("@@#{Kapusta.kebab_to_snake(name)}")
-      end
-
-      def set_cvar(receiver, name, value)
-        current_class_scope(receiver).class_variable_set("@@#{Kapusta.kebab_to_snake(name)}", value)
+      HELPER_SOURCES.each_value do |source|
+        module_eval(source, __FILE__, __LINE__)
       end
 
-      def get_gvar(name)
-        Kernel.eval("$#{Kapusta.kebab_to_snake(name)}", binding, __FILE__, __LINE__) # $stderr
-      end
+      helper_methods = []
 
-      def set_gvar(name, value)
-        Kernel.eval("$#{Kapusta.kebab_to_snake(name)} = value", binding, __FILE__, __LINE__) # $stderr = value
+      HELPER_SOURCES.each_key do |name|
+        helper_method = :"__kap_#{name}"
+        define_singleton_method(name, instance_method(helper_method))
+        helper_methods << helper_method
       end
 
-      def ensure_module(holder, path)
-        segments = path.split('.')
-        last = segments.pop
-        scope = holder.is_a?(Module) ? holder : Object
-        segments.each do |segment|
-          scope =
-            if scope.const_defined?(segment, false)
-              scope.const_get(segment, false)
-            else
-              mod = Module.new
-              scope.const_set(segment, mod)
-              mod
-            end
-        end
-        if scope.const_defined?(last, false)
-          scope.const_get(last, false)
-        else
-          mod = Module.new
-          scope.const_set(last, mod)
-          mod
-        end
-      end
-
-      def ensure_class(holder, path, super_class)
-        segments = path.split('.')
-        last = segments.pop
-        scope = holder.is_a?(Module) ? holder : Object
-        segments.each do |segment|
-          scope =
-            if scope.const_defined?(segment, false)
-              scope.const_get(segment, false)
-            else
-              mod = Module.new
-              scope.const_set(segment, mod)
-              mod
-            end
-        end
-        if scope.const_defined?(last, false)
-          scope.const_get(last, false)
-        else
-          klass = Class.new(super_class)
-          scope.const_set(last, klass)
-          klass
-        end
-      end
-
-      def destructure(pattern, value)
-        bindings = {}
-        destructure_into(pattern, value, bindings)
-        bindings
-      end
-
-      def destructure_into(pattern, value, bindings)
-        case pattern[0]
-        when :sym
-          name = pattern[1]
-          bindings[name] = value unless name == '_'
-        when :vec
-          items = pattern[1]
-          rest_idx = items.index { |item| item.is_a?(Array) && item[0] == :rest }
-          if rest_idx
-            before = items[0...rest_idx]
-            rest_pattern = items[rest_idx][1]
-            before.each_with_index do |item, i|
-              destructure_into(item, value ? value[i] : nil, bindings)
-            end
-            rest_value = value ? (value[rest_idx..] || []) : []
-            destructure_into(rest_pattern, rest_value, bindings)
-          else
-            items.each_with_index do |item, i|
-              destructure_into(item, value ? value[i] : nil, bindings)
-            end
-          end
-        when :hash
-          pattern[1].each do |key, subpattern|
-            destructure_into(subpattern, value ? value[key] : nil, bindings)
-          end
-        when :ignore
-          nil
-        else
-          raise "unknown destructure pattern: #{pattern.inspect}"
-        end
-      end
-
-      def match_pattern(pattern, value)
-        bindings = {}
-        [match_pattern_into(pattern, value, bindings), bindings]
-      end
-
-      def match_pattern_into(pattern, value, bindings)
-        case pattern[0]
-        when :sym
-          name = pattern[1]
-          bindings[name] = value unless name == '_'
-          true
-        when :vec
-          return false unless value.is_a?(Array) || value.respond_to?(:to_ary)
-
-          array = value.is_a?(Array) ? value : value.to_ary
-          items = pattern[1]
-          rest_idx = items.index { |item| item.is_a?(Array) && item[0] == :rest }
-          if rest_idx
-            before = items[0...rest_idx]
-            rest_pattern = items[rest_idx][1]
-            return false if array.length < before.length
-
-            before.each_with_index do |item, i|
-              return false unless match_pattern_into(item, array[i], bindings)
-            end
-            match_pattern_into(rest_pattern, array[rest_idx..], bindings)
-          else
-            return false unless array.length == items.length
-
-            items.each_with_index do |item, i|
-              return false unless match_pattern_into(item, array[i], bindings)
-            end
-            true
-          end
-        when :hash
-          return false unless value.is_a?(Hash)
-
-          pattern[1].each do |key, subpattern|
-            return false unless value.key?(key)
-            return false unless match_pattern_into(subpattern, value[key], bindings)
-          end
-          true
-        when :lit
-          value == pattern[1]
-        when :nil
-          value.nil?
-        else
-          raise "bad pattern: #{pattern.inspect}"
-        end
-      end
+      send(:private, *helper_methods)
     end
   end
 end

data/lib/kapusta/formatter.rb

@@ -519,11 +519,12 @@ module Kapusta
     def render_pairwise_vec(vec, indent)
       lines = ['[']
 
-      vec.items.each_slice(2) do |left, right|
-        if right
-          pair = render_pair(left, right, indent + INDENT)
-          if pair
-            lines << indent_block(pair, INDENT)
+      vec.items.each_slice(2) do |pair|
+        left, right = pair
+        if pair.length == 2
+          rendered_pair = render_pair(left, right, indent + INDENT)
+          if rendered_pair
+            lines << indent_block(rendered_pair, INDENT)
           else
             lines << indent_block(render(left, indent + INDENT), INDENT)
             lines << indent_block(render(right, indent + INDENT), INDENT)
@@ -547,8 +548,9 @@ module Kapusta
 
     def render_hanging_pairwise_vec(vec)
       pairs = vec.items.each_slice(2).to_a
-      rendered_pairs = pairs.map do |left, right|
-        return nil unless right
+      rendered_pairs = pairs.map do |pair|
+        left, right = pair
+        return nil unless pair.length == 2
 
         render_binding_pair(left, right)
       end

data/lib/kapusta/version.rb

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

data/spec/examples_spec.rb

@@ -31,6 +31,10 @@ RSpec.describe 'examples' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
 
+  it 'anonymous-greeter.kap' do
+    expect(run_example('anonymous-greeter.kap')).to eq("Hello, anonymous!\nHello, Ada!\n")
+  end
+
   it 'calc.kap' do
     expect(run_example('calc.kap')).to eq("14\n")
   end
@@ -39,6 +43,10 @@ RSpec.describe 'examples' do
     expect(run_example('binary-search.kap')).to eq("3\nnil\n")
   end
 
+  it 'binary-to-decimal.kap' do
+    expect(run_example('binary-to-decimal.kap')).to eq("11\n0\n42\n")
+  end
+
   it 'blocks-and-kwargs.kap' do
     path = File.expand_path('../tmp/blocks-and-kwargs.txt', EXAMPLES_DIR)
     FileUtils.rm_f(path)
@@ -169,6 +177,18 @@ RSpec.describe 'examples' do
     expect(run_example('match.kap')).to eq("Ada: 9\nLin: no score\nunknown\n")
   end
 
+  it 'packet-router.kap' do
+    expect(run_example('packet-router.kap')).to eq("score:9\nother\ncity:nil\n5\n0\nping:7\n")
+  end
+
+  it 'or-patterns.kap' do
+    expect(run_example('or-patterns.kap')).to eq("1:2\n2:1\nother\n")
+  end
+
+  it 'underscore-patterns.kap' do
+    expect(run_example('underscore-patterns.kap')).to eq("5\nnil\n5\nfallback\n")
+  end
+
   it 'scopes.kap' do
     expect(run_example('scopes.kap')).to eq("5\n9\n9\n9\n")
   end
@@ -224,6 +244,10 @@ RSpec.describe 'examples' do
   it 'threading.kap' do
     expect(run_example('threading.kap')).to eq("[Ada Lovelace]!\t<Ada!>\tnil\tATSUPAK\tnil\n")
   end
+
+  it 'tic-tac-toe.kap' do
+    expect(run_example('tic-tac-toe.kap')).to eq("X\nO\nX\ndraw\n")
+  end
 end
 
 RSpec.describe Kapusta do

data/spec/formatter_spec.rb

@@ -272,6 +272,26 @@ RSpec.describe Kapusta::Formatter do
     end
   end
 
+  it 'preserves nil-valued let bindings before function bindings' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'sample.kap')
+      File.write(path, <<~KAP)
+        (let [name nil get-input (fn [] "Dave")]
+          (print (get-input)))
+      KAP
+
+      output = capture_stdout do
+        expect(described_class.new([path]).run).to eq(0)
+      end
+
+      expect(output).to eq(<<~KAP)
+        (let [name nil
+              get-input (fn [] "Dave")]
+          (print (get-input)))
+      KAP
+    end
+  end
+
   example_idempotence_paths.each do |relative_path|
     it "keeps #{relative_path} unchanged" do
       path = File.expand_path("../#{relative_path}", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Evgenii Morozov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies: []
 description: Kapusta is a Lisp for the Ruby runtime.
 email:
@@ -27,7 +27,9 @@ files:
 - examples/accumulator.kap
 - examples/ackermann.kap
 - examples/anagram.kap
+- examples/anonymous-greeter.kap
 - examples/binary-search.kap
+- examples/binary-to-decimal.kap
 - examples/block-sort.kap
 - examples/blocks-and-kwargs.kap
 - examples/calc.kap
@@ -51,6 +53,8 @@ files:
 - examples/match.kap
 - examples/min-max.kap
 - examples/module-header.kap
+- examples/or-patterns.kap
+- examples/packet-router.kap
 - examples/palindrome.kap
 - examples/pangram.kap
 - examples/pcall.kap
@@ -68,11 +72,12 @@ files:
 - examples/stack.kap
 - examples/sum.kap
 - examples/threading.kap
+- examples/tic-tac-toe.kap
 - examples/tset.kap
 - examples/two-sum.kap
+- examples/underscore-patterns.kap
 - exe/kapfmt
 - exe/kapusta
-- kapfmt
 - kapusta.gemspec
 - lib/kapusta.rb
 - lib/kapusta/ast.rb

data/kapfmt

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-load File.expand_path('exe/kapfmt', __dir__)