kapusta 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cafef3668504ca08a40ba087c4c2b754bfda02e6f61161f19bcf8d56a254e00
-  data.tar.gz: 501b99f6ec3bfa950865b63b26ec6fd7f5b64977bb86f41d4eff51957602cc84
+  metadata.gz: 85bcd0988a353fb851e5ff955c2b5196f39193e1c3c8fb6ca4a111d6260e774d
+  data.tar.gz: 80efbc138038947b866eaac96ef21d5cdccd04a461a25f2e17cbd7ce925ceaec
 SHA512:
-  metadata.gz: b774d8f0bbd772e223743a2ec844bec4949a6f1a5a545767c3b608c8ec0c2da055fe9537c68a3cf57573ac80ed75d11d85884245b4fcbd401af16646aaab5283
-  data.tar.gz: 10b6d3f30fdfc760569c40c70e22f2b63dcf124ea3de3cffca2f061642523bc7057c878b81460181950356193c5786a35df28d4fd2b4859c1c38bc2285392f40
+  metadata.gz: 16d02e652b9221990ac027423e677a8f27c285d582c6bfb368f585140305e1c48dff5add4a8491a7996b5be99e34efd761e7fb280d8932fc6548622939b166b4
+  data.tar.gz: 8ab10f9991b7029d9366e47d434a9e9166568b870369f1fe585007fbe2cf9b750c84e8eb3b8fb015db255977eef80fd3255750fa99006d577a9564b640d84319

data/README.md

@@ -110,6 +110,8 @@ 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
+- `(end)` closes a bodyless file-header
+- `(defn name ...)` or `(fn class.name ..)`
 - `ivar` or `@var` / `cvar` or `@@var` / `gvar` or `$var`
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch

data/examples/accumulator.kap

@@ -10,6 +10,8 @@
 (fn value []
   (ivar total))
 
+(end)
+
 (let [acc (Accumulator.new 10)]
   (acc.add! 5)
   (acc.add! 7)

data/examples/bank-account.kap

@@ -19,3 +19,5 @@
   (set (ivar balance)
     (- (ivar balance) amount))
   self)
+
+(end)

data/examples/bst-iterator.kap

@@ -0,0 +1,52 @@
+(class TreeNode)
+
+(fn initialize [val left right]
+  (set @val val)
+  (set @left left)
+  (set @right right))
+
+(fn val [] @val)
+(fn left [] @left)
+(fn right [] @right)
+
+(end)
+
+(class BSTIterator)
+
+(fn initialize [root]
+  (set @stack [])
+  (self.push-left root))
+
+(fn push-left [node]
+  (var n node)
+  (while n
+    (let [stack @stack]
+      (stack.push n))
+    (set n (n.left))))
+
+(fn next []
+  (let [stack @stack
+        node (stack.pop)]
+    (self.push-left (node.right))
+    (node.val)))
+
+(fn has-next? []
+  (let [stack @stack]
+    (not (stack.empty?))))
+
+(end)
+
+(let [root (TreeNode.new 7
+             (TreeNode.new 3 nil nil)
+             (TreeNode.new 15
+               (TreeNode.new 9 nil nil)
+               (TreeNode.new 20 nil nil)))
+      it (BSTIterator.new root)]
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.has-next?))
+  (print (it.next))
+  (print (it.next))
+  (print (it.has-next?)))

data/examples/circle.kap

@@ -11,6 +11,8 @@
 (fn circumference []
   (* 2 pi @radius))
 
+(end)
+
 (let [c (Circle.new 5)]
   (print (c.area))
   (print (c.circumference)))

data/examples/counter.kap

@@ -12,6 +12,8 @@
 (fn self.zero []
   (Counter.new 0))
 
+(end)
+
 (let [c (Counter.new 10)]
   (c.tick)
   (c.tick)

data/examples/hit-counter.kap

@@ -9,6 +9,8 @@
   (set $last-hitter @name)
   @@total)
 
+(end)
+
 (let [a (HitCounter.new "alice")
       b (HitCounter.new "bob")]
   (print (a.hit))

data/examples/module-header.kap

@@ -1,7 +1,9 @@
 ; File header forms map directly to Ruby modules.
 (module HeaderDemo)
 
-(fn self.greet [name]
+(defn greet [name]
   (.. "Hello, " name "!"))
 
-(print (self.greet "Ada"))
+(end)
+
+(print (HeaderDemo.greet "Ada"))

data/examples/mruby-runtime-examples.txt

@@ -9,6 +9,7 @@ best-time-to-buy-sell-stock
 binary-search
 binary-to-decimal
 block-sort
+bst-iterator
 calc
 circle
 classify-wallet
@@ -65,6 +66,7 @@ points
 power-of-three
 primes
 raindrops
+recent-counter
 record
 reverse-integer
 roman-to-integer
@@ -72,6 +74,7 @@ ruby-eval
 safe-lookup
 scopes
 shapes
+signal-harvest
 single-number
 squares
 stack

data/examples/parking-system.kap

@@ -11,6 +11,8 @@
       (and (= car-type 3) (> @small 0)) (do (set @small (- @small 1)) true)
       false))
 
+(end)
+
 (let [parking (ParkingSystem.new 1 1 0)]
   (print (parking.add-car 1))
   (print (parking.add-car 2))

data/examples/recent-counter.kap

@@ -0,0 +1,17 @@
+(class RecentCounter)
+(fn initialize [] (set @pings []))
+(fn ping [t]
+  (let [pings @pings]
+    (pings.push t)
+    (while (< (. pings 0) (- t 3000))
+      (pings.shift))
+    (length pings)))
+(defn warm [history]
+  (let [c (RecentCounter.new)]
+    (each [_ t (ipairs history)] (c.ping t))
+    c))
+(end)
+
+(let [c (RecentCounter.warm [100 200 300])]
+  (print (c.ping 3001))
+  (print (c.ping 3002)))

data/examples/scopes.kap

@@ -10,6 +10,8 @@
 (fn self.total []
   (cvar total))
 
+(end)
+
 (let [a (ScopeCounter.new)
       b (ScopeCounter.new)]
   (print (a.add! 5))

data/examples/signal-harvest.kap

@@ -0,0 +1,16 @@
+(module SignalHarvest)
+
+(local SCREEN-W 1280)
+(local TARGET-SCORE 36)
+
+(defn cell-width [columns]
+  (/ SCREEN-W columns))
+
+(defn win? [score]
+  (>= score TARGET-SCORE))
+
+(end)
+
+(print (SignalHarvest.cell-width 32))
+(print (SignalHarvest.win? 40))
+(print (SignalHarvest.win? 12))

data/examples/stack.kap

@@ -24,6 +24,8 @@
 (fn get-min []
   (. (ivar mins) -1))
 
+(end)
+
 (let [s (MinStack.new)]
   (s.push -2)
   (s.push 0)

data/examples/valid-parentheses-1.kap

@@ -17,3 +17,5 @@
             (stack.push ch)))
       (set i (+ i 1)))
     (and ok (stack.empty?))))
+
+(end)

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

@@ -148,10 +148,7 @@ module Kapusta
           return unless ruby_name
           return if captures_outer_binding?(body, env, pattern_names(pattern))
 
-          body_env = env.child
-          params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
-          body_code, = emit_sequence(body, body_env, :toplevel,
-                                     allow_method_definitions: false, result: false)
+          params, body_code = build_simple_block_parts(pattern, body, env, :toplevel)
           header = params.empty? ? "def #{ruby_name}" : "def #{ruby_name}(#{params.join(', ')})"
           [
             header,

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

@@ -111,27 +111,30 @@ module Kapusta
         end
 
         def try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+            try_native_arm(pattern, body, where_guards, env, current_scope, mode)
+          end
+          return unless arms
+
+          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
+          ["case #{value_var}", *arms, 'end'].join("\n")
+        end
+
+        def collect_case_arms(clauses)
           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
+            inner, where_guards = extract_pattern_and_guards(pattern)
             sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
-            sub_arms = sub_patterns.map do |sub|
-              try_native_arm(sub, body, where_guards, env, current_scope, mode)
-            end
+            sub_arms = sub_patterns.map { |sub| yield sub, body, where_guards }
             return if sub_arms.any?(&:nil?)
 
             arms.concat(sub_arms)
             i += 2
           end
-          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
-          ["case #{value_var}", *arms, 'end'].join("\n")
+          arms
         end
 
         def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
@@ -149,25 +152,11 @@ module Kapusta
         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
+          arms = collect_case_arms(clauses) do |pattern, body, where_guards|
+            try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
           end
+          return unless arms
+
           emit_compat_case_lines(arms)
         end
 
@@ -176,6 +165,12 @@ module Kapusta
           last_pattern.is_a?(Sym) && last_pattern.name == '_'
         end
 
+        def extract_pattern_and_guards(pattern)
+          return [pattern, []] unless where_pattern?(pattern)
+
+          [pattern.items[1], pattern.items[2..]]
+        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
@@ -185,11 +180,11 @@ module Kapusta
           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]
+            prelude = plan[:prelude]
           else
             prelude_guards = plan[:prelude].map { |line| "begin #{line}; true end" }
             guard_codes = plan[:conditions] + prelude_guards + where_guard_codes
-            prelude     = []
+            prelude = []
           end
           body_code = emit_expr(body, arm_env, current_scope)
           [guard_codes, prelude, body_code]

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

@@ -83,6 +83,8 @@ module Kapusta
           when 'require' then emit_require(args[0], env, current_scope)
           when 'module' then emit_module_expr(args, env)
           when 'class' then emit_class_expr(args, env)
+          when 'end' then emit_error!(:end_outside_header)
+          when 'defn' then emit_error!(:defn_outside_header)
           when 'try' then emit_try(args, env, current_scope)
           when 'raise' then emit_raise(args, env, current_scope)
           when 'ivar' then "@#{Kapusta.kebab_to_snake(args[0].name)}"

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

@@ -102,7 +102,7 @@ module Kapusta
           segments = constant_segments(name_sym)
           return unless segments
 
-          [build_nested_module(segments, body), segments.join('::')].join("\n")
+          build_nested_module(segments, body)
         end
 
         def emit_class_wrapper(name_sym, supers, env, body)
@@ -118,7 +118,7 @@ module Kapusta
           return unless segments
 
           super_code = class_super_code(supers, env)
-          [build_nested_class(segments, super_code, body), segments.join('::')].join("\n")
+          build_nested_class(segments, super_code, body)
         end
 
         def constant_segments(name_sym)
@@ -483,20 +483,28 @@ module Kapusta
           Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
         end
 
+        SIMPLE_EXPRESSION_PATTERNS = [
+          /\A[a-z_]\w*\z/, # local
+          /\A@@?[a-z_]\w*\z/, # @ivar / @@cvar
+          /\A\$[a-zA-Z_]\w*\z/, # $gvar
+          /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/, # Constant / A::B::C
+          /\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/, # bare call foo(...)
+          /\A-?\d+(?:\.\d+)?\z/, # number
+          /\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # local + .m/[k] chain
+          /\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # const + chain
+          /\A:[a-zA-Z_]\w*[!?=]?\z/, # :symbol
+          /\A"(?:[^"\\]|\\.)*"\z/, # "string"
+          /\A'(?:[^'\\]|\\.)*'\z/, # 'string'
+          /\A\[[^\[\]\n]*\]\z/ # [flat, array]
+        ].freeze
+        private_constant :SIMPLE_EXPRESSION_PATTERNS
+
+        SIMPLE_EXPRESSION_KEYWORDS = %w[nil true false self].freeze
+        private_constant :SIMPLE_EXPRESSION_KEYWORDS
+
         def simple_expression?(code)
-          code.match?(/\A[a-z_]\w*\z/) ||
-            code.match?(/\A@@?[a-z_]\w*\z/) ||
-            code.match?(/\A\$[a-zA-Z_]\w*\z/) ||
-            code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/) ||
-            code.match?(/\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/) ||
-            code.match?(/\A-?\d+(?:\.\d+)?\z/) ||
-            code.match?(/\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
-            code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
-            code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||
-            code.match?(/\A"(?:[^"\\]|\\.)*"\z/) ||
-            code.match?(/\A'(?:[^'\\]|\\.)*'\z/) ||
-            code.match?(/\A\[[^\[\]\n]*\]\z/) ||
-            %w[nil true false self].include?(code) ||
+          SIMPLE_EXPRESSION_PATTERNS.any? { |re| code.match?(re) } ||
+            SIMPLE_EXPRESSION_KEYWORDS.include?(code) ||
             negation_simple?(code)
         end
 

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

@@ -56,20 +56,13 @@ module Kapusta
           parts = []
           deferred = []
           current_env = env
-          items = pattern.items
-          i = 0
-          while i < items.length
-            if items[i].is_a?(Sym) && items[i].name == '&'
-              sub = items[i + 1]
-              raise PatternNotTranslatable unless sub.is_a?(Sym)
-
+          each_pattern_item(pattern.items) do |kind, sub|
+            if kind == :rest
               parts << native_rest_target(sub, current_env)
-              i += 2
             else
-              code, current_env, follow_up = native_destructure_target(items[i], current_env, allow_follow_up: true)
+              code, current_env, follow_up = native_destructure_target(sub, current_env, allow_follow_up: true)
               parts << code
               deferred << follow_up if follow_up
-              i += 1
             end
           end
           if deferred.empty?
@@ -122,17 +115,13 @@ module Kapusta
             inner = []
             current = env
             deferred = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                inner << native_rest_target(items[i + 1], current)
-                i += 2
+            each_pattern_item(pattern.items) do |kind, sub|
+              if kind == :rest
+                inner << native_rest_target(sub, current)
               else
-                code, current, follow_up = native_destructure_target(items[i], current)
+                code, current, follow_up = native_destructure_target(sub, current)
                 inner << code
                 deferred << follow_up if follow_up
-                i += 1
               end
             end
             raise PatternNotTranslatable unless deferred.empty?
@@ -225,36 +214,26 @@ module Kapusta
           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]
+          each_pattern_item(items) do |kind, sub|
+            if kind == :rest
               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,
+              compile_compat_pattern(sub, "#{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
+          each_pattern_item(items) do |kind, _sub|
+            count += 1 if kind == :item
           end
           count
         end
@@ -346,11 +325,9 @@ module Kapusta
         def compile_native_sequence(items, env, mode:, allow_pins:, state:)
           parts = []
           has_rest = false
-          i = 0
-          while i < items.length
-            if rest_pattern_marker?(items, i)
+          each_pattern_item(items) do |kind, sub|
+            if kind == :rest
               has_rest = true
-              sub = items[i + 1]
               raise PatternNotTranslatable unless sub.is_a?(Sym)
 
               if sub.name == '_'
@@ -360,10 +337,8 @@ module Kapusta
                 state[:binding_names] << sub.name
                 parts << "*#{sanitize_local(sub.name)}"
               end
-              i += 2
             else
-              parts << compile_native_pattern(items[i], env, mode:, allow_pins:, state:)
-              i += 1
+              parts << compile_native_pattern(sub, env, mode:, allow_pins:, state:)
             end
           end
           parts << '*' unless has_rest
@@ -464,16 +439,8 @@ module Kapusta
             pattern.name == '_' ? [] : [pattern.name]
           when Vec
             names = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                names.concat(pattern_names(items[i + 1]))
-                i += 2
-              else
-                names.concat(pattern_names(items[i]))
-                i += 1
-              end
+            each_pattern_item(pattern.items) do |_kind, sub|
+              names.concat(pattern_names(sub))
             end
             names
           when HashLit
@@ -504,8 +471,18 @@ module Kapusta
           name.length > 1 && (name.start_with?('?') || name.start_with?('_'))
         end
 
-        def rest_pattern_marker?(items, index)
-          items[index].is_a?(Sym) && items[index].name == '&'
+        def each_pattern_item(items)
+          i = 0
+          while i < items.length
+            item = items[i]
+            if item.is_a?(Sym) && item.name == '&'
+              yield :rest, items[i + 1]
+              i += 2
+            else
+              yield :item, item
+              i += 1
+            end
+          end
         end
       end
     end