kapusta 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef91159e2623e199fc391fa483440fa9f8ca76f273fbc31caeb0b07e891ee92c
-  data.tar.gz: 5468818f0ad4b0509a31635d886f3374009e3e8499a197d82f99da22c53e3a12
+  metadata.gz: 179b8b97d775c6bff99bd3d5ac3e1df1f6ab8c17637b6e16f9d688ade7f9dd06
+  data.tar.gz: 899899c13c9b1d4f85216df5d3989807d874a9ec862be94d48989f851b2d8111
 SHA512:
-  metadata.gz: 7bcc51b164c21357c2aa2ef52e4e544cba0116ca8d8b6b1c02ecb55dc62697508a3cbb22d4c56a0a7cf0da77f53d7500827ecd2debe0760fec34ebe4d992be07
-  data.tar.gz: 40b1b709b5e083b94584424f9fb2ad7c3ec6908786ea80051173df8edaa380b9b5b76d0c485a6377f7e77bbed5799633501204d7a39acf0b919eb74197fabcf2
+  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/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/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)
@@ -108,11 +122,16 @@ module Kapusta
             when 'ipairs'
               body_env = env.child
               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'
               body_env = env.child
@@ -141,6 +160,10 @@ 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)
@@ -168,35 +191,36 @@ 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)
-          return "#{target_var} = #{body_code}" unless body_code.include?("\n")
+          return emit_assignment(target_var, body_code) unless body_code.include?("\n")
 
           ["#{target_var} = begin", indent(body_code), 'end'].join("\n")
         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)

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

@@ -17,8 +17,9 @@ module Kapusta
 
         def emit_safe_lookup(args, env, current_scope)
           object_code = emit_expr(args[0], env, current_scope)
-          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }.join(', ')
-          runtime_call(:qget_path, object_code, "[#{keys}]")
+          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
+          receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
+          keys.reduce(receiver) { |acc, key| "#{acc}&.[](#{key})" }
         end
 
         BINARY_OPERATOR_METHODS = %w[<=> ** << >> & | ^ === =~].freeze
@@ -53,35 +54,27 @@ module Kapusta
         end
 
         def emit_require(arg, env, current_scope)
-          path_code =
-            case arg
-            when Sym then arg.name.inspect
-            when Symbol then arg.to_s.inspect
-            when String then arg.inspect
-            else "(#{emit_expr(arg, env, current_scope)}).to_s"
-            end
-          if kapusta_require?(arg)
-            return [
-              'unless defined?(Kapusta)',
-              indent('require "kapusta"'),
-              'end',
-              "Kapusta.require(#{path_code}, relative_to: #{@path.inspect})"
-            ].join("\n")
+          literal = require_path_literal(arg)
+          if literal&.match?(%r{\A\.\.?/})
+            cleaned = literal.delete_suffix('.kap').sub(%r{\A\./}, '')
+            return "require_relative #{cleaned.inspect}"
           end
 
+          path_code =
+            if literal
+              literal.inspect
+            else
+              "(#{emit_expr(arg, env, current_scope)}).to_s"
+            end
           "require #{path_code}"
         end
 
-        def kapusta_require?(arg)
-          path =
-            case arg
-            when Sym then arg.name
-            when Symbol then arg.to_s
-            when String then arg
-            end
-          return false unless path
-
-          path.end_with?('.kap') || path.start_with?('./', '../') || File.absolute_path?(path)
+        def require_path_literal(arg)
+          case arg
+          when Sym then arg.name
+          when Symbol then arg.to_s
+          when String then arg
+          end
         end
 
         def emit_module_expr(args, env)
@@ -97,65 +90,65 @@ module Kapusta
         end
 
         def emit_module_wrapper(name_sym, body)
-          mod_var = temp('module')
-          [
-            '(-> do',
-            indent("#{mod_var} = #{runtime_call(:ensure_module, 'self', name_sym.name.inspect)}"),
-            indent("#{mod_var}.module_eval do"),
-            indent(body, 2),
-            indent('end'),
-            indent(mod_var),
-            'end).call'
-          ].join("\n")
+          segments = constant_segments(name_sym)
+          emit_error!("invalid module name: #{name_sym.name}") unless segments
+          inner = build_nested_module(segments, body)
+          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
 
         def emit_direct_module_header(name_sym, body)
-          const_name = simple_constant_name(name_sym)
-          return unless const_name
+          segments = constant_segments(name_sym)
+          return unless segments
 
-          [
-            "module #{const_name}",
-            indent(body),
-            'end',
-            const_name
-          ].join("\n")
+          [build_nested_module(segments, body), segments.join('::')].join("\n")
         end
 
         def emit_class_wrapper(name_sym, supers, env, body)
-          klass_var = temp('class')
-          super_code =
-            if supers.is_a?(Vec) && !supers.items.empty?
-              emit_expr(supers.items.first, env, :toplevel)
-            else
-              'Object'
-            end
-          [
-            '(-> do',
-            indent("#{klass_var} = #{runtime_call(:ensure_class, 'self', name_sym.name.inspect, super_code)}"),
-            indent("#{klass_var}.class_eval do"),
-            indent(body, 2),
-            indent('end'),
-            indent(klass_var),
-            'end).call'
-          ].join("\n")
+          segments = constant_segments(name_sym)
+          emit_error!("invalid class name: #{name_sym.name}") unless segments
+          super_code = class_super_code(supers, env)
+          inner = build_nested_class(segments, super_code, body)
+          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
 
-        def emit_direct_class_header(name_sym, supers, body)
-          const_name = simple_constant_name(name_sym)
-          return unless const_name && supers.nil?
+        def emit_direct_class_header(name_sym, supers, body, env)
+          segments = constant_segments(name_sym)
+          return unless segments
 
-          [
-            "class #{const_name}",
-            indent(body),
-            'end',
-            const_name
-          ].join("\n")
+          super_code = class_super_code(supers, env)
+          [build_nested_class(segments, super_code, body), segments.join('::')].join("\n")
         end
 
-        def simple_constant_name(name_sym)
-          return unless name_sym.is_a?(Sym) && name_sym.name.match?(/\A[A-Z]\w*\z/)
+        def constant_segments(name_sym)
+          return unless name_sym.is_a?(Sym)
 
-          name_sym.name
+          segments = name_sym.dotted? ? name_sym.segments : [name_sym.name]
+          return unless segments.all? { |s| s.match?(/\A[A-Z]\w*\z/) }
+
+          segments
+        end
+
+        def class_super_code(supers, env)
+          return unless supers.is_a?(Vec) && !supers.items.empty?
+
+          emit_expr(supers.items.first, env, :toplevel)
+        end
+
+        def build_nested_module(segments, body)
+          inner = ["module #{segments.last}", indent(body), 'end'].join("\n")
+          wrap_in_modules(segments[0...-1], inner)
+        end
+
+        def build_nested_class(segments, super_code, body)
+          header = super_code ? "class #{segments.last} < #{super_code}" : "class #{segments.last}"
+          inner = [header, indent(body), 'end'].join("\n")
+          wrap_in_modules(segments[0...-1], inner)
+        end
+
+        def wrap_in_modules(parents, inner)
+          parents.reverse.reduce(inner) do |acc, mod_name|
+            ["module #{mod_name}", indent(acc), 'end'].join("\n")
+          end
         end
 
         def emit_try(args, env, current_scope)