kapusta 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62ac0b0f6d3ce6116b82110191b5c36783ed1689e2567076dbe68fc66e6ab3f7
-  data.tar.gz: 6b705edf9d441c4f753e8420b0e8bc6a2327d91f6ab9041a603c3afe6546487b
+  metadata.gz: 2398c1c908306ac808914717a67e74f8085ee6048deb9c9dd665f4dd8c39cc2f
+  data.tar.gz: 1022c2df415418d26f1b84b1b16830cc525829182a82e93c1a450d0dd4b5bdd2
 SHA512:
-  metadata.gz: 243b1e47fd6a5684f7b4d2a9bf46e27d6b96883fb3cf71bf4f90edb4d48f0e5afa006c2da0191f5fc3cb116e37b506243b0f7030b90a6c6096629173e98074de
-  data.tar.gz: 825b21b71cb0eacb24623beff28dc2fcb1b542cf50268d78ebcfba2b156bf634992975fb1f1a3a0e27f407c51e54c8eb96683d544f861de5f5cc51731fc819c3
+  metadata.gz: 6a31f0bab47d9c5c0d40720c52422717e0d04a9c03bb03a115ac62c7f541226dc3d9b7e9aa052bf55d574e1193ecab82e97b0610d43bbe1702038024486a1953
+  data.tar.gz: f20bf20a890d1b23f3ec7d2d113a3340c6255132a367a655cddab52ded9e2276bd236439d242ca0ea46f857096a5f5885620dd9a104f8b0f337c9aba75e50366

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

@@ -270,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)
@@ -290,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)
@@ -307,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

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.2'
+  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.2
+  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__)