kapusta 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a5fcd922c54b5fa491785e6087c4fc2f8e6de1a8d94deab10fca3f775518b9b
-  data.tar.gz: d95f4bce9e6673104c44fc0ff281a705e796797490285cc50ef509b6b9fe5e97
+  metadata.gz: 179b8b97d775c6bff99bd3d5ac3e1df1f6ab8c17637b6e16f9d688ade7f9dd06
+  data.tar.gz: 899899c13c9b1d4f85216df5d3989807d874a9ec862be94d48989f851b2d8111
 SHA512:
-  metadata.gz: cb5ba4420166be83a152c22bf56a12563efdb8cc64e54f230f6d299051761c5abc2329ae42dfc5e6127a721f66250b9804d6ec86a9b053dc36282599b2f8c986
-  data.tar.gz: 334d34e9e47bdecf6a4aa35cc6e905770efb6913fa6c2e9f90b0f3b1a95915b9044c8e3f36c81778a865f91a6d43f675318bf1ae892e19292cb4a2d2de179685
+  metadata.gz: 69247136466e119860e5fee232b0bb21fa40b9d23986f09051a4acccda476a9c42b5e3e63e1382367df6c3008876af2f6a69a9b6fd2bfc0e05e1c9e69ca6a8b0
+  data.tar.gz: f65709e841e372a1dcc4c9a453d2251d58fb4fffbecd51fd1f0bcfb7c0423dc51109d6533e1b85d9b39bbc82cc994dcf64bdb5aad586c2b6476858db8e320d25

data/README.md

@@ -8,6 +8,12 @@ Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. W
 
 For more information about Kapusta, see the official Fennel documentation and tutorials.
 
+## Features
+
+1. Compiles to readable Ruby.
+2. Compiled `.rb` files don't depend on Kapusta. Run with plain `ruby`, or load `.kap` files at runtime via `require 'kapusta'`.
+3. Two-way Ruby interop.
+
 ## Usage
 
 ```

data/examples/counter.kap

@@ -4,8 +4,7 @@
   (set (ivar n) start))
 
 (fn tick []
-  (set (ivar n) (+ (ivar n) 1))
-  (ivar n))
+  (set (ivar n) (+ (ivar n) 1)))
 
 (fn value []
   (ivar n))

data/examples/length-of-last-word.kap

@@ -1,6 +1,9 @@
 (fn length-of-last-word [s]
-  (let [words (s.strip.split)]
-    (: (. words -1) :length)))
+  (-> s
+      (: :strip)
+      (: :split)
+      (. -1)
+      (: :length)))
 
 (print (length-of-last-word "Hello World"))
 (print (length-of-last-word "   fly me   to   the moon  "))

data/examples/manhattan-distance.kap

@@ -0,0 +1,9 @@
+(fn manhattan [edge]
+  (let [{:from [x1 y1] :to [x2 y2]} edge]
+    (+ (: (- x1 x2) :abs) (: (- y1 y2) :abs))))
+
+(fn total-distance [edges]
+  (accumulate [total 0 _ edge (ipairs edges)]
+    (+ total (manhattan edge))))
+
+(print (total-distance [{:from [0 0] :to [3 4]} {:from [1 1] :to [4 5]}]))

data/examples/palindrome.kap

@@ -1,7 +1,6 @@
 (fn palindrome? [s]
-  (let [lower (s.downcase)
-        normalized (lower.gsub (ruby "/[^a-z]/") "")]
-    (= normalized (normalized.reverse))))
+  (let [normalized (-> s (: :downcase) (: :gsub (ruby "/[^a-z]/") ""))]
+    (= normalized (: normalized :reverse))))
 
 (print (palindrome? "racecar"))
 (print (palindrome? "A man, a plan, a canal: Panama"))

data/examples/pangram.kap

@@ -1,9 +1,10 @@
 (fn pangram? [s]
-  (let [lower (s.downcase)
-        letters (lower.gsub (ruby "/[^a-z]/") "")
-        chars (letters.chars)
-        uniq (chars.uniq)]
-    (= (uniq.length) 26)))
+  (= 26
+    (length (-> s
+                (: :downcase)
+                (: :gsub (ruby "/[^a-z]/") "")
+                (: :chars)
+                (: :uniq)))))
 
 (print (pangram? "The quick brown fox jumps over the lazy dog"))
 (print (pangram? "Hello, world"))

data/examples/pivot-index.kap

@@ -0,0 +1,13 @@
+(fn pivot-index [nums]
+  (var total 0)
+  (each [n nums] (set total (+ total n)))
+  (var left 0)
+  (var found -1)
+  (each [i n (ipairs nums)]
+    (when (and (= found -1) (= left (- total left n))) (set found i))
+    (set left (+ left n)))
+  found)
+
+(print (pivot-index [1 7 3 6 5 6]))
+(print (pivot-index [1 2 3]))
+(print (pivot-index [2 1 -1]))

data/examples/subtract-product-sum.kap

@@ -0,0 +1,14 @@
+(fn subtract-product-sum [n]
+  (var x n)
+  (var product 1)
+  (var sum 0)
+  (while (> x 0)
+    (let [d (% x 10)]
+      (set product (* product d))
+      (set sum (+ sum d))
+      (set x (: (/ x 10) :floor))))
+  (- product sum))
+
+(print (subtract-product-sum 234))
+(print (subtract-product-sum 4421))
+(print (subtract-product-sum 1))

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

@@ -281,12 +281,23 @@ module Kapusta
               else
                 define_local(env, target.name)
               end
-            ["#{ruby_name} = #{value_code}", env]
+            [emit_assignment(ruby_name, value_code), env]
           else
             [emit_set_target(target, value_code, env, current_scope), env]
           end
         end
 
+        def emit_assignment(lhs, value_code)
+          prefix = "#{lhs} "
+          if value_code.start_with?(prefix) &&
+             (m = value_code[prefix.length..].match(/\A(\S+) (.*)\z/m)) &&
+             !m[1].include?('=')
+            "#{lhs} #{m[1]}= #{m[2]}"
+          else
+            "#{lhs} = #{value_code}"
+          end
+        end
+
         def emit_set_expr(args, env, current_scope)
           target = args[0]
           value_code = emit_expr(args[1], env, current_scope)
@@ -302,7 +313,7 @@ module Kapusta
               last = segments.last
               snake = Kapusta.kebab_to_snake(last)
               if direct_method_name?(last)
-                "#{receiver}.#{snake} = #{value_code}"
+                emit_assignment("#{receiver}.#{snake}", value_code)
               else
                 "#{receiver}.public_send(:\"#{snake}=\", #{value_code})"
               end
@@ -310,7 +321,7 @@ module Kapusta
               binding = env.lookup(target.name)
               emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
 
-              "#{binding} = #{value_code}"
+              emit_assignment(binding, value_code)
             end
           when List
             head = target.head
@@ -319,13 +330,13 @@ module Kapusta
               keys = target.items[2..].map { |item| emit_expr(item, env, current_scope) }
               receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
               prefix = keys[0...-1].map { |k| "[#{k}]" }.join
-              "#{receiver}#{prefix}[#{keys.last}] = #{value_code}"
+              emit_assignment("#{receiver}#{prefix}[#{keys.last}]", value_code)
             elsif head.is_a?(Sym) && head.name == 'ivar'
-              "@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
+              emit_assignment("@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
             elsif head.is_a?(Sym) && head.name == 'cvar'
-              "@@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
+              emit_assignment("@@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
             elsif head.is_a?(Sym) && head.name == 'gvar'
-              "$#{global_name(target.items[1].name)} = #{value_code}"
+              emit_assignment("$#{global_name(target.items[1].name)}", value_code)
             else
               emit_error!("bad set target: #{target.inspect}")
             end

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

@@ -45,13 +45,13 @@ module Kapusta
               emit_sequence_value_assignment(acc_var, body)
             end
           end
-          <<~RUBY.chomp
-            (-> do
-              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{iter_code}
-              #{acc_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent(iter_code),
+            indent(acc_var),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_faccumulate(args, env, current_scope)
@@ -73,29 +73,43 @@ module Kapusta
             current_scope:,
             body_code: accumulating_body
           )
-          <<~RUBY.chomp
-            (-> do
-              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{indent(loop_code)}
-              #{acc_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent(loop_code),
+            indent(acc_var),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_hashfn(args, env, current_scope)
-          args_var = temp('args')
-          hash_env = env.child
-          hash_env.define('$', "#{args_var}[0]")
-          (1..9).each do |index|
-            hash_env.define("$#{index}", "#{args_var}[#{index - 1}]")
+          if needs_explicit_args?(args[0])
+            args_var = temp('args')
+            hash_env = env.child
+            hash_env.define('$', "#{args_var}[0]")
+            (1..9).each { |i| hash_env.define("$#{i}", "#{args_var}[#{i - 1}]") }
+            hash_env.define('$...', args_var)
+            body_code = emit_expr(args[0], hash_env, current_scope)
+            ["->(*#{args_var}) do", indent(body_code), 'end'].join("\n")
+          else
+            hash_env = env.child
+            hash_env.define('$', '_1')
+            (1..9).each { |i| hash_env.define("$#{i}", "_#{i}") }
+            body_code = emit_expr(args[0], hash_env, current_scope)
+            ['proc do', indent(body_code), 'end'].join("\n")
           end
-          hash_env.define('$...', args_var)
-          body_code = emit_expr(args[0], hash_env, current_scope)
-          <<~RUBY.chomp
-            ->(*#{args_var}) do
-              #{body_code}
+        end
+
+        def needs_explicit_args?(form)
+          case form
+          when Sym then form.name == '$...'
+          when List, Vec then form.items.any? { |item| needs_explicit_args?(item) }
+          when HashLit
+            form.entries.any? do |entry|
+              entry.is_a?(Array) ? entry.any? { |item| needs_explicit_args?(item) } : needs_explicit_args?(entry)
             end
-          RUBY
+          else false
+          end
         end
 
         def emit_iteration(bindings_vec, env, current_scope)
@@ -106,22 +120,24 @@ module Kapusta
           if iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
             case iter_expr.head.name
             when 'ipairs'
-              value_var = temp('value')
-              index_var = temp('index')
               body_env = env.child
-              bind_code, body_env = emit_iteration_bindings(
-                [[binding_pats[0], index_var], [binding_pats[1], value_var]], body_env
-              )
+              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+              coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+              if ignored_pattern?(binding_pats[0])
+                bind_code = value_bind || ''
+                body_code = yield(body_env)
+                return iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+              end
+              index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
+              bind_code = [index_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
-              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}" \
-                       ".each_with_index do |#{value_var}, #{index_var}|"
+              header = "#{coll_code}.each_with_index do |#{value_var}, #{index_var}|"
               return iteration_block(header, bind_code, body_code)
             when 'pairs'
-              key_var = temp('key')
-              value_var = temp('value')
               body_env = env.child
-              bind_code, body_env = emit_iteration_bindings([[binding_pats[0], key_var], [binding_pats[1], value_var]],
-                                                            body_env)
+              key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
+              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+              bind_code = [key_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
               header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|"
               return iteration_block(header, bind_code, body_code)
@@ -130,11 +146,10 @@ module Kapusta
 
           coll_code = emit_expr(iter_expr, env, current_scope)
           if binding_pats.length == 1
-            value_var = temp('value')
             body_env = env.child
-            bind_code, body_env = emit_iteration_bindings([[binding_pats[0], value_var]], body_env)
+            value_var, bind_code = bind_iteration_param(binding_pats[0], 'value', body_env)
             body_code = yield(body_env)
-            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+            iteration_block("#{coll_code}.each do |#{value_var}|", bind_code || '', body_code)
           else
             parts_var = temp('parts')
             body_env = env.child
@@ -145,6 +160,21 @@ module Kapusta
           end
         end
 
+        def ignored_pattern?(pattern)
+          pattern.is_a?(Sym) && !pattern.dotted? && pattern.name == '_'
+        end
+
+        def bind_iteration_param(pattern, fallback_name, env)
+          if pattern.is_a?(Sym) && !pattern.dotted?
+            ruby_name = pattern.name == '_' ? '_' : define_local(env, pattern.name)
+            [ruby_name, nil]
+          else
+            tmp = temp(fallback_name)
+            bind_code, _new_env = emit_iteration_bindings([[pattern, tmp]], env)
+            [tmp, bind_code.empty? ? nil : bind_code]
+          end
+        end
+
         def iteration_block(header, bind_code, body_code)
           [header, indent(join_code(bind_code, body_code)), 'end'].join("\n")
         end
@@ -161,39 +191,38 @@ module Kapusta
         end
 
         def emit_collection_result(result_var, initial_code, iter_code)
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = #{initial_code}
-              #{indent(iter_code)}
-              #{result_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{result_var} = #{initial_code}"),
+            indent(iter_code),
+            indent(result_var),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_array_collection_step(result_var, body_code)
           value_var = temp('value')
-          <<~RUBY.chomp
-            #{emit_sequence_value_assignment(value_var, body_code)}
-            #{result_var} << #{value_var} unless #{value_var}.nil?
-          RUBY
+          [
+            emit_sequence_value_assignment(value_var, body_code),
+            "#{result_var} << #{value_var} unless #{value_var}.nil?"
+          ].join("\n")
         end
 
         def emit_hash_collection_step(result_var, body_code)
           pair_var = temp('pair')
-          <<~RUBY.chomp
-            #{emit_sequence_value_assignment(pair_var, body_code)}
-            if #{pair_var}.is_a?(Array) && #{pair_var}.length == 2 && !#{pair_var}[0].nil? && !#{pair_var}[1].nil?
-              #{result_var}[#{pair_var}[0]] = #{pair_var}[1]
-            end
-          RUBY
+          [
+            emit_sequence_value_assignment(pair_var, body_code),
+            "if #{pair_var}.is_a?(Array) && #{pair_var}.length == 2 && " \
+            "!#{pair_var}[0].nil? && !#{pair_var}[1].nil?",
+            indent("#{result_var}[#{pair_var}[0]] = #{pair_var}[1]"),
+            'end'
+          ].join("\n")
         end
 
         def emit_sequence_value_assignment(target_var, body_code)
-          <<~RUBY.chomp
-            #{target_var} = begin
-            #{indent(body_code)}
-            end
-          RUBY
+          return emit_assignment(target_var, body_code) unless body_code.include?("\n")
+
+          ["#{target_var} = begin", indent(body_code), 'end'].join("\n")
         end
       end
     end

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

@@ -16,6 +16,8 @@ module Kapusta
 
           cond = emit_expr(args[0], env, current_scope)
           truthy = emit_if_branch(args[1], env, current_scope)
+          return "#{truthy} if #{cond}" if args.length == 2 && !truthy.include?("\n") && !cond.include?("\n")
+
           lines = ["if #{cond}", indent(truthy)]
           append_else_lines(lines, args[2..], env, current_scope)
           lines << 'end'
@@ -57,81 +59,52 @@ module Kapusta
 
         def emit_case(args, env, current_scope, mode)
           value_var = temp('case_value')
-          body = build_case_clauses(value_var, args[1..], env, current_scope, mode)
-          <<~RUBY.chomp
-            (-> do
-              #{value_var} = #{emit_expr(args[0], env, current_scope)}
-              #{body}
-            end).call
-          RUBY
+          body = try_emit_native_case(value_var, args[1..], env, current_scope, mode)
+          emit_error!('case/match clauses use patterns this compiler cannot translate') unless body
+          [
+            '(-> do',
+            indent("#{value_var} = #{emit_expr(args[0], env, current_scope)}"),
+            indent(body),
+            'end).call'
+          ].join("\n")
         end
 
-        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, mode)
-          emit_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-        end
+        def try_emit_native_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_native_arm(sub, body, where_guards, env, current_scope, mode)
+            end
+            return if sub_arms.any?(&:nil?)
 
-        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, mode)
-          else
-            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
+            arms.concat(sub_arms)
+            i += 2
           end
+          arms << ['else', indent('nil')].join("\n")
+          ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
-        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(plan[:bindings], bindings_var, arm_env)
-          body_code = emit_expr(body, arm_env, current_scope)
-          arm_body = [assign_code, body_code].reject(&:empty?).join("\n")
-          <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
-            if #{match_var}[0]
-              #{bindings_var} = #{match_var}[1]
-              #{arm_body}
-            else
-              #{indent(else_code)}
-            end
-          RUBY
-        end
+        def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
+          allow_pins = !where_guards.empty? && mode == :case
+          plan = native_pattern_plan(pattern, env, mode:, allow_pins:)
+          return unless plan
 
-        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-          inner = pattern.items[1]
-          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(plan[:bindings], bindings_var, arm_env)
-          guard_code = emit_case_guards(guards, arm_env, current_scope)
+          plan[:bindings].each { |name| arm_env.define(name, sanitize_local(name)) }
+          guard_codes = plan[:guards] +
+                        where_guards.map { |g| emit_expr(g, arm_env, current_scope) }
+          guard_clause = guard_codes.empty? ? '' : " if #{guard_codes.join(' && ')}"
           body_code = emit_expr(body, arm_env, current_scope)
-          bindings_line = assign_code.empty? ? '' : "\n  #{assign_code}"
-          <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
-            if #{match_var}[0]
-              #{bindings_var} = #{match_var}[1]#{bindings_line}
-              if #{guard_code}
-                #{body_code}
-              else
-                #{indent(else_code, 2)}
-              end
-            else
-              #{indent(else_code)}
-            end
-          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(' && ')
+          ["in #{plan[:pattern]}#{guard_clause}", indent(body_code)].join("\n")
         end
 
         def emit_while(args, env, current_scope)