kapusta 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ba2ee0fbbd336f3604e9c51014a458c0a54eefcb30939fc6f2a72ba25941fb6
-  data.tar.gz: 687f46ff98b74d65d523404ba9350fd62921eada8e105f4fe0d9215eac036118
+  metadata.gz: d5e4a7dc8e3d044580b58064b4632706c2115964847d674c23bbe39a625e0b6e
+  data.tar.gz: b17a395b81ab568829022273e5df9ee5a186c052d6a1e4c843df631dfe1d6f76
 SHA512:
-  metadata.gz: 070c9c5f4435f2e825f0bdb70ceb25f3cc5eba62745cae80f9d348aa4fc886d74a5f8ed06a93a62d572adbfadfbce5e93b3e37993a5d637e68d615af6e1ecfa7
-  data.tar.gz: fc1697cfb31821c867c468666eee7bb3cd6af985c446cba8ea35e3c50c5928750a0989ce31c250d2c1d47f79b4f338e319a17cb00abb314c7213a1e3f2eb89e1
+  metadata.gz: d3e8ca629130a695a67a1c210ab06869518e2d232084e01a8cb6d180094e2b10b0cbc3f65c191a9a7a6b1e70727f1563f28e3637264cc7776a58c2e16e554991
+  data.tar.gz: 71695c0adf8e37705c9b9b85263e495578bcdd0d442c2d56ad09b1a6386640003164adf98d932c499472ae81d5c3d4a909898b907417e6d6463384b855b2fa33

data/README.md

@@ -103,6 +103,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
 | `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
+| `(.. "x: " nil)` errors at runtime    | `(.. "x: " nil)` produces `"x: "` (Ruby `nil.to_s`)   |
 | `with-open`, `tail!`                  | not provided                                          |
 
 Kapusta-specific additions:

data/examples/arrange-coins.kap

@@ -0,0 +1,32 @@
+(fn arrange-coins [n]
+  (let [rows (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))
+        used (faccumulate [acc {:sum 0 :rows 0} i 1 n]
+               (let [new-sum (+ (. acc :sum) i)]
+                 (if (<= new-sum n)
+                     {:sum new-sum :rows i}
+                     acc)))]
+    [(. rows :rows) (. used :sum)]))
+
+(let [[r u] (arrange-coins 0)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 1)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 5)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 8)]
+  (print r)
+  (print u))
+
+(let [[r u] (arrange-coins 10)]
+  (print r)
+  (print u))

data/examples/array-sign.kap

@@ -0,0 +1,24 @@
+(fn sign [n]
+  (if (> n 0) 1
+      (< n 0) -1
+      0))
+
+(fn array-sign [nums]
+  (accumulate [acc 1 _ n (ipairs nums)]
+    (* acc (sign n))))
+
+(fn join [tbl sep]
+  (var s "")
+  (each [_ x (ipairs tbl)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(fn debug-sign [label nums]
+  (local pretty #(.. "[" (join $ ", ") "]"))
+  (.. "case[" label "] in " (pretty nums) " out " (array-sign nums)))
+
+(print (debug-sign "mixed" [-1 -2 -3 -4 3 2 1]))
+(print (debug-sign "withzero" [1 5 0 2 -3]))
+(print (debug-sign "allneg" [-1 1 -1 1 -1]))

data/examples/case-vs-match.kap

@@ -0,0 +1,23 @@
+(fn debug-data [packet seq]
+  (local no-nil #(or $ "nil"))
+  (let [[_ packet-seq] packet]
+    (.. "packet[:ping, " (no-nil packet-seq) "] seq " (no-nil seq))))
+
+(fn show-case [packet seq]
+  (case packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(fn show-match [packet seq]
+  (match packet
+    [:ping seq] (debug-data packet seq)
+    _ "other"))
+
+(print (.. "case: " (show-case [:ping 42] 7)))
+(print (.. "case: " (show-case [:ping 42] nil)))
+(print (.. "case: " (show-case [:ping nil] nil)))
+(print (.. "case: " (show-case [:ping 42] 42)))
+(print (.. "match: " (show-match [:ping 42] 7)))
+(print (.. "match: " (show-match [:ping 42] nil)))
+(print (.. "match: " (show-match [:ping nil] nil)))
+(print (.. "match: " (show-match [:ping 42] 42)))

data/examples/divisibility-stats.kap

@@ -0,0 +1,16 @@
+(fn divisibility-stats [n]
+  (let [threes (faccumulate [acc 0 i 1 n]
+                 (let [step (if (= 0 (% i 3)) 1 0)]
+                   (+ acc step)))
+        fives (faccumulate [acc 0 i 1 n]
+                (let [step (if (= 0 (% i 5)) 1 0)]
+                  (+ acc step)))]
+    [threes fives]))
+
+(let [[t f] (divisibility-stats 30)]
+  (print t)
+  (print f))
+
+(let [[t f] (divisibility-stats 100)]
+  (print t)
+  (print f))

data/examples/equal-sums.kap

@@ -0,0 +1,7 @@
+(fn equal-sums? [a b]
+  (= (accumulate [s 0 _ x (ipairs a)] (+ s x))
+     (accumulate [s 0 _ x (ipairs b)] (+ s x))))
+
+(print (equal-sums? [1 2 3] [3 2 1]))
+(print (equal-sums? [1 2 3] [4 5 6]))
+(print (equal-sums? [0] [0]))

data/examples/fennel-parity-examples.txt

@@ -1,11 +1,16 @@
 ackermann
 anonymous-greeter
+array-sign
+arrange-coins
+case-vs-match
 classify-wallet
 climbing-stairs
 convert-temperature
 count-effects
 describe
 destructure
+divisibility-stats
+equal-sums
 even-squares
 factorial
 falling-drops
@@ -15,9 +20,9 @@ gcd
 hashfn
 leap-year
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -26,10 +31,12 @@ macros-when-let
 match
 max-achievable
 min-max
+nested-nil-pattern
+non-constant-local
 or-patterns
-power-of-three
 packet-router
 points
+power-of-three
 primes
 safe-lookup
 shapes

data/examples/mruby-runtime-examples.txt

@@ -3,6 +3,7 @@ accumulator
 ackermann
 anagram
 anonymous-greeter
+arrange-coins
 bank-account
 baseball-game
 best-time-to-buy-sell-stock
@@ -11,6 +12,7 @@ binary-to-decimal
 block-sort
 bst-iterator
 calc
+case-vs-match
 circle
 classify-wallet
 climbing-stairs
@@ -20,8 +22,9 @@ count-effects
 counter
 describe
 destructure
-doto-hygiene
+divisibility-stats
 doto
+doto-hygiene
 egg-count
 even-squares
 exceptions
@@ -38,9 +41,9 @@ kwargs
 leap-year
 length-of-last-word
 macros-dbg
+macros-import
 macros-import-helpers
 macros-import-whole
-macros-import
 macros-multi
 macros-swap
 macros-thrice-if
@@ -53,6 +56,7 @@ max-achievable
 maximum-subarray
 min-max
 module-header
+nested-nil-pattern
 move-zeroes
 number-of-1-bits
 number-of-steps
@@ -84,8 +88,8 @@ thread-styles
 threading
 tic-tac-toe
 tset
-two-sum-hash
 two-sum
+two-sum-hash
 ugly-number
 underscore-patterns
 valid-parentheses-1

data/examples/nested-nil-pattern.kap

@@ -0,0 +1,7 @@
+(fn check [packet]
+  (case packet
+    [:ping seq] (.. "got " seq)
+    _ "other"))
+
+(print (check [:ping 42]))
+(print (check [:ping nil]))

data/examples/non-constant-local.kap

@@ -0,0 +1,11 @@
+(local hash-fn #(or $ "nil"))
+(local regular-fn (fn [x] (+ x 1)))
+(local lambda-fn (λ [x] (* x 2)))
+(local vec-binding [10 20 30])
+(local hash-binding {:a 1})
+
+(print (hash-fn nil))
+(print (regular-fn 5))
+(print (lambda-fn 5))
+(print (length vec-binding))
+(print (. hash-binding :a))

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

@@ -57,7 +57,7 @@ module Kapusta
 
         def build_simple_block_parts(pattern, body, env, current_scope)
           body_env = env.child
-          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
+          params = pattern.items.map { |sym| define_local(body_env, sym, shadow: true) }
           body_code, = emit_sequence(body, body_env, current_scope,
                                      allow_method_definitions: false, result: false)
           [params, body_code]
@@ -296,7 +296,9 @@ 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))
+            if allow_constant && form.head.name == 'local' &&
+               constant_value?(form.items[2]) &&
+               (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]
@@ -316,6 +318,13 @@ module Kapusta
           candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
         end
 
+        def constant_value?(value_form)
+          case value_form
+          when Numeric, String, ::Symbol, true, false, nil then true
+          else false
+          end
+        end
+
         def check_destructure_value!(pattern, value_form)
           return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
 

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

@@ -111,30 +111,23 @@ module Kapusta
           bindings = args[0].items
           emit_error!(:accumulate_no_iterator) if bindings.length < 5
 
-          acc_name = bindings[0]
-          loop_name = bindings[2]
-          loop_env = env.child
-          acc_var = define_local(loop_env, acc_name.name)
-          loop_var = define_local(loop_env, loop_name.name)
-          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
-          accumulating_body = emit_sequence_value_assignment(acc_var, body_code)
-          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
-          )
-          [
-            '(-> do',
-            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
-            indent(loop_code),
-            indent(acc_var),
-            'end).call'
-          ].join("\n")
+          body_env = env.child
+          acc_var = define_local(body_env, bindings[0].name)
+          loop_var = define_local(body_env, bindings[2].name)
+
+          init_code = emit_expr(bindings[1], env, current_scope)
+          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) : nil
+          body_code, = emit_sequence(args[1..], body_env, current_scope, allow_method_definitions: false)
+
+          receiver =
+            if step_code
+              "#{parenthesize(start_code)}.step(#{finish_code}, #{step_code})"
+            else
+              "(#{start_code}..#{finish_code})"
+            end
+          inject_block(receiver, "#{acc_var}, #{loop_var}", init_code, '', body_code)
         end
 
         def emit_hashfn(args, env, current_scope)

data/lib/kapusta/compiler/normalizer.rb

@@ -139,6 +139,8 @@ module Kapusta
 
       def doto(forms)
         value = forms.first
+        return value if forms[1..].empty?
+
         temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
@@ -147,7 +149,8 @@ module Kapusta
             List.new([form, temp])
           end
         end
-        List.new([Sym.new('let'), Vec.new([temp, value]), *body, temp])
+        fn = List.new([Sym.new('fn'), Vec.new([temp]), *body])
+        List.new([Sym.new(':'), value, :tap, fn])
       end
 
       def gensym(prefix)

data/lib/kapusta/formatter.rb

@@ -555,30 +555,18 @@ module Kapusta
       lines = [base]
       args = list_raw_rest(list)
       semantic_length = semantic_items(args).length
+      hang_subsequent_args = hang_call_args?(list, indent)
 
       semantic_index = 0
+      hanging = nil
       args.each do |arg|
         if comment?(arg)
           lines << indent_block(render(arg, indent + INDENT), INDENT)
           next
-        end
-
-        if semantic_index.zero?
-          first = render(
-            arg,
-            indent + base.length + 1,
-            force_expand: semantic_length == 1 && fn_form?(arg)
-          )
-          first_line, *rest = first.lines(chomp: true)
-          candidate = "#{base} #{first_line}"
-
-          if lines.length == 1 && fits?(candidate, indent)
-            lines[0] = candidate
-            hanging = ' ' * (base.length + 1)
-            rest.each { |line| lines << "#{hanging}#{line}" }
-          else
-            lines << indent_block(first, INDENT)
-          end
+        elsif semantic_index.zero?
+          hanging = append_first_call_arg(lines, arg, base, indent, semantic_length)
+        elsif hanging && hang_subsequent_args
+          lines << prefix_continuation(hanging, render(arg, indent + hanging.length))
         else
           lines << indent_block(render(arg, indent + INDENT), INDENT)
         end
@@ -589,6 +577,48 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def append_first_call_arg(lines, arg, base, indent, semantic_length)
+      first = render(
+        arg,
+        indent + base.length + 1,
+        force_expand: semantic_length == 1 && fn_form?(arg)
+      )
+      first_line, *rest = first.lines(chomp: true)
+      candidate = "#{base} #{first_line}"
+
+      unless lines.length == 1 && fits?(candidate, indent)
+        lines << indent_block(first, INDENT)
+        return
+      end
+
+      hanging = ' ' * (base.length + 1)
+      lines[0] = candidate
+      rest.each { |line| lines << "#{hanging}#{line}" }
+      hanging
+    end
+
+    def hang_call_args?(list, indent)
+      return false unless operator_call?(list)
+
+      flat = flat_call_render(list)
+      flat && !fits?(flat, indent)
+    end
+
+    def operator_call?(list)
+      head = list_head(list)
+      head.is_a?(Sym) && head.name.match?(/\A[^\w.]+\z/)
+    end
+
+    def flat_call_render(list)
+      head = flat_render(list_head(list))
+      return unless head
+
+      rendered_args = semantic_items(list_raw_rest(list)).map { |arg| flat_render(arg) }
+      return if rendered_args.any?(&:nil?)
+
+      "(#{[head, *rendered_args].join(' ')})"
+    end
+
     def render_vec(vec, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(vec)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(vec, top_level:, layout:)
@@ -800,8 +830,7 @@ module Kapusta
            'fn', 'lambda', 'λ', 'macro'
         true
       else
-        flat = flat_render(form)
-        flat && flat.length > 40
+        false
       end
     end
 

data/lib/kapusta/lsp.rb

@@ -15,8 +15,38 @@ module Kapusta
     METHOD_NOT_FOUND = -32_601
     FULL_SYNC = 1
 
+    def self.debug?
+      %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+    end
+
     def self.start(input: $stdin, output: $stdout, log: $stderr)
-      new(input:, output:, log:).run
+      server = new(input:, output:, log:)
+      install_signal_handlers(log)
+      server.run
+      debug_log(log, 'run returned, calling exit!(0)')
+      exit!(0)
+    end
+
+    def self.install_signal_handlers(log)
+      %w[TERM INT HUP].each do |sig|
+        Signal.trap(sig) do
+          debug_log(log, "signal #{sig} received, exiting")
+          exit!(0)
+        rescue StandardError
+          exit!(0)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def self.debug_log(log, message)
+      return unless debug?
+
+      log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      log.flush
+    rescue StandardError
+      nil
     end
 
     def self.uri_to_path(uri)
@@ -34,7 +64,7 @@ module Kapusta
       @input = input.binmode
       @output = output.binmode
       @log = log
-      @debug = %w[1 true yes on].include?(ENV['KAPUSTA_LS_DEBUG'].to_s.downcase)
+      @debug = LSP.debug?
       @sources = {}
       @workspace_index = WorkspaceIndex.new
       @initialized = false
@@ -42,9 +72,11 @@ module Kapusta
     end
 
     def run
+      debug('run loop start')
       until (message = read_message).nil?
         handle(message)
       end
+      debug('stdin EOF, run loop exiting')
     end
 
     private
@@ -83,8 +115,14 @@ module Kapusta
 
     def write_message(payload)
       body = JSON.generate(payload)
+      tag = payload[:id] ? "response id=#{payload[:id]}" : "notify #{payload[:method]}"
+      debug("write begin (#{tag}, #{body.bytesize} bytes)")
       @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
       @output.flush
+      debug("write done (#{tag})")
+    rescue Errno::EPIPE, IOError => e
+      debug("write failed (#{e.class}: #{e.message}), exiting")
+      exit!(0)
     end
 
     def handle(message)
@@ -92,9 +130,11 @@ module Kapusta
       id = message['id']
       params = message['params'] || {}
 
+      debug("dispatch begin method=#{method.inspect} id=#{id.inspect}")
       return handle_pre_init(method, id, params) unless @initialized || method == 'initialize' || method == 'exit'
 
       dispatch(method, id, params)
+      debug("dispatch end method=#{method.inspect} id=#{id.inspect}")
     rescue StandardError => e
       log("#{e.class}: #{e.message}")
       log(e.backtrace.first(5).join("\n"))
@@ -116,8 +156,12 @@ module Kapusta
       when 'initialized' then nil
       when 'shutdown'
         @shutdown = true
+        debug('shutdown received, replying and arming watchdog')
         reply(id, nil)
-      when 'exit' then exit(@shutdown ? 0 : 1)
+        arm_shutdown_watchdog
+      when 'exit'
+        debug("exit notification received (shutdown=#{@shutdown}), calling exit!")
+        exit!(@shutdown ? 0 : 1)
       when 'textDocument/didOpen' then on_did_open(params)
       when 'textDocument/didChange' then on_did_change(params)
       when 'textDocument/didSave' then on_did_save(params)
@@ -300,14 +344,28 @@ module Kapusta
       notify('textDocument/publishDiagnostics', params)
     end
 
+    def arm_shutdown_watchdog(seconds: 2)
+      Thread.new do
+        sleep seconds
+        debug("shutdown watchdog firing after #{seconds}s, forcing exit")
+        exit!(0)
+      end
+    end
+
     def log(message)
       @log.puts "kapusta-ls: #{message}"
+      @log.flush
+    rescue StandardError
+      nil
     end
 
     def debug(message)
       return unless @debug
 
-      @log.puts "kapusta-ls[debug]: #{message}"
+      @log.write("kapusta-ls[debug pid=#{Process.pid}]: #{message}\n")
+      @log.flush
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/kapusta/version.rb

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

data/spec/examples_spec.rb

@@ -76,6 +76,29 @@ RSpec.describe 'examples' do
     expect(run_example('ackermann.kap')).to eq("9\n61\n")
   end
 
+  it 'non-constant-local.kap' do
+    expect(run_example('non-constant-local.kap')).to eq(<<~OUT)
+      "nil"
+      6
+      10
+      3
+      1
+    OUT
+  end
+
+  it 'case-vs-match.kap' do
+    expect(run_example('case-vs-match.kap')).to eq(<<~OUT)
+      "case: packet[:ping, 42] seq 42"
+      "case: packet[:ping, 42] seq 42"
+      "case: other"
+      "case: packet[:ping, 42] seq 42"
+      "match: other"
+      "match: other"
+      "match: packet[:ping, nil] seq nil"
+      "match: packet[:ping, 42] seq 42"
+    OUT
+  end
+
   it 'accumulator.kap' do
     expect(run_example('accumulator.kap')).to eq("22\n")
   end
@@ -92,6 +115,30 @@ RSpec.describe 'examples' do
     expect(run_example('circle.kap')).to eq("78.53975\n31.4159\n")
   end
 
+  it 'arrange-coins.kap' do
+    expect(run_example('arrange-coins.kap')).to eq(<<~OUT)
+      0
+      0
+      1
+      1
+      2
+      3
+      3
+      6
+      4
+      10
+    OUT
+  end
+
+  it 'divisibility-stats.kap' do
+    expect(run_example('divisibility-stats.kap')).to eq(<<~OUT)
+      10
+      6
+      33
+      20
+    OUT
+  end
+
   it 'anagram.kap' do
     expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
   end
@@ -444,15 +491,10 @@ 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: :mruby3)
-
-    expect(run_mruby_source(ruby, path:)).to eq(<<~OUT)
-      5
-      nil
-      5
-      "fallback"
+  it 'nested-nil-pattern.kap' do
+    expect(run_example('nested-nil-pattern.kap')).to eq(<<~OUT)
+      "got 42"
+      "other"
     OUT
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -31,6 +31,8 @@ files:
 - examples/ackermann.kap
 - examples/anagram.kap
 - examples/anonymous-greeter.kap
+- examples/arrange-coins.kap
+- examples/array-sign.kap
 - examples/bank-account.kap
 - examples/baseball-game.kap
 - examples/best-time-to-buy-sell-stock.kap
@@ -40,6 +42,7 @@ files:
 - examples/blocks-and-kwargs.kap
 - examples/bst-iterator.kap
 - examples/calc.kap
+- examples/case-vs-match.kap
 - examples/circle.kap
 - examples/classify-wallet.kap
 - examples/climbing-stairs.kap
@@ -49,9 +52,11 @@ files:
 - examples/counter.kap
 - examples/describe.kap
 - examples/destructure.kap
+- examples/divisibility-stats.kap
 - examples/doto-hygiene.kap
 - examples/doto.kap
 - examples/egg-count.kap
+- examples/equal-sums.kap
 - examples/even-squares.kap
 - examples/exceptions.kap
 - examples/factorial.kap
@@ -87,6 +92,8 @@ files:
 - examples/module-header.kap
 - examples/move-zeroes.kap
 - examples/mruby-runtime-examples.txt
+- examples/nested-nil-pattern.kap
+- examples/non-constant-local.kap
 - examples/number-of-1-bits.kap
 - examples/number-of-steps.kap
 - examples/or-patterns.kap