kapusta 0.2.4 → 0.3.0

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

@@ -11,174 +11,261 @@ module Kapusta
             return ['', env] if pattern.name == '_'
 
             ruby_name = define_local(env, pattern)
-            ["#{ruby_name} = #{value_code}", env]
+            return ["#{ruby_name} = #{value_code}", env]
+          end
+
+          native = try_emit_native_pattern_bind(pattern, value_code, env)
+          return native if native
+
+          emit_error!("destructure pattern this compiler cannot translate: #{pattern.inspect}")
+        end
+
+        def try_emit_native_pattern_bind(pattern, value_code, env)
+          case pattern
+          when Vec
+            try_emit_native_vec_bind(pattern, value_code, env)
+          when HashLit
+            try_emit_native_hash_bind(pattern, value_code, env)
+          end
+        rescue PatternNotTranslatable
+          nil
+        end
+
+        def try_emit_native_vec_bind(pattern, value_code, env)
+          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)
+
+              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)
+              parts << code
+              deferred << follow_up if follow_up
+              i += 1
+            end
+          end
+          if deferred.empty?
+            ["#{parts.join(', ')} = #{value_code}", current_env]
           else
-            bindings_var = temp('bindings')
-            current_env = env
-            lines = [
-              "#{bindings_var} = #{runtime_call(:destructure, emit_pattern(pattern), value_code)}"
-            ]
-            pattern_names(pattern).each do |name|
-              ruby_name = define_local(current_env, name)
-              lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+            arr_var = simple_expression?(value_code) ? value_code : temp('array')
+            lines = []
+            lines << "#{arr_var} = #{value_code}" unless arr_var == value_code
+            lines << "#{parts.join(', ')} = #{arr_var}"
+            deferred.each do |follow_up|
+              sub_code, current_env = follow_up.call(current_env)
+              lines << sub_code
             end
             [lines.join("\n"), current_env]
           end
         end
 
-        def emit_bindings_from_match(binding_names, bindings_var, env)
-          current_env = env
+        def try_emit_native_hash_bind(pattern, value_code, env)
+          pairs = pattern.pairs
+          raise PatternNotTranslatable if pairs.empty?
+
+          temp_var = simple_expression?(value_code) ? value_code : temp('hash')
           lines = []
-          binding_names.each do |name|
-            ruby_name = define_local(current_env, name)
-            lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+          lines << "#{temp_var} = #{value_code}" unless temp_var == value_code
+          current_env = env
+          pairs.each do |key, sub|
+            access = "#{temp_var}[#{key.inspect}]"
+            if sub.is_a?(Sym)
+              raise PatternNotTranslatable if sub.name == '_'
+
+              bind_name = sub.name.start_with?('?') ? sub.name.delete_prefix('?') : sub.name
+              ruby_name = define_local(current_env, bind_name)
+              lines << "#{ruby_name} = #{access}"
+            else
+              sub_code, current_env = try_emit_native_pattern_bind(sub, access, current_env) ||
+                                      raise(PatternNotTranslatable)
+              lines << sub_code
+            end
           end
           [lines.join("\n"), current_env]
         end
 
-        def pattern_match_plan(pattern, env, mode:, allow_pins:)
-          state = { bound_names: {}, binding_names: [] }
+        def native_destructure_target(pattern, env, allow_follow_up: false)
+          case pattern
+          when Sym
+            return ['_', env, nil] if pattern.name == '_'
+
+            bind_name = pattern.name.start_with?('?') ? pattern.name.delete_prefix('?') : pattern.name
+            ruby_name = define_local(env, bind_name)
+            [ruby_name, env, nil]
+          when Vec
+            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
+              else
+                code, current, follow_up = native_destructure_target(items[i], current)
+                inner << code
+                deferred << follow_up if follow_up
+                i += 1
+              end
+            end
+            raise PatternNotTranslatable unless deferred.empty?
+
+            ["(#{inner.join(', ')})", current, nil]
+          when HashLit
+            raise PatternNotTranslatable unless allow_follow_up
+
+            slot = temp('slot')
+            follow_up = lambda do |outer_env|
+              try_emit_native_hash_bind(pattern, slot, outer_env) || raise(PatternNotTranslatable)
+            end
+            [slot, env, follow_up]
+          else
+            raise PatternNotTranslatable
+          end
+        end
+
+        def native_rest_target(sym, env)
+          raise PatternNotTranslatable unless sym.is_a?(Sym)
+
+          return '*' if sym.name == '_'
+
+          bind_name = sym.name.start_with?('?') ? sym.name.delete_prefix('?') : sym.name
+          "*#{define_local(env, bind_name)}"
+        end
+
+        class PatternNotTranslatable < StandardError; end
+
+        def native_pattern_plan(pattern, env, mode:, allow_pins:)
+          state = { bound_names: {}, binding_names: [], guards: [] }
+          ruby_pattern = compile_native_pattern(pattern, env, mode:, allow_pins:, state:)
           {
-            pattern: emit_match_pattern(pattern, env, mode:, allow_pins:, state:),
+            pattern: ruby_pattern,
+            guards: state[:guards],
             bindings: state[:binding_names]
           }
+        rescue PatternNotTranslatable
+          nil
         end
 
-        def emit_match_pattern(pattern, env, mode:, allow_pins:, state:)
+        def compile_native_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 Sym then compile_native_symbol(pattern, env, mode:, state:)
+          when Vec then compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
+          when HashLit then compile_native_hash(pattern, env, mode:, allow_pins:, state:)
           when List
             if pin_pattern?(pattern)
-              emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+              compile_native_pin(pattern, env, mode:, allow_pins:)
             elsif or_pattern?(pattern)
-              emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-            elsif where_pattern?(pattern)
-              emit_error!('`where` is only valid as a case/match clause head')
+              compile_native_or(pattern, env, mode:, allow_pins:, state:)
             else
-              emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+              compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
             end
-          when nil
-            '[:lit, nil]'
-          when Symbol, String, Numeric, true, false
-            "[:lit, #{pattern.inspect}]"
-          else
-            emit_error!("bad pattern: #{pattern.inspect}")
+          when nil then 'nil'
+          when Symbol, String, Numeric, true, false then pattern.inspect
+          else raise PatternNotTranslatable
           end
         end
 
-        def emit_symbol_match_pattern(pattern, env, mode:, state:)
+        def compile_native_symbol(pattern, env, mode:, state:)
           name = pattern.name
+          return '_' if name == '_'
 
-          if name == '_'
-            '[:wild]'
-          elsif nil_allowing_pattern_name?(name)
+          if 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
+            raise PatternNotTranslatable if state[:bound_names].key?(bind_name)
 
-        def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
-          binding = prefer_pin && mode == :match ? env.lookup_if_defined(name) : nil
-          if state[:bound_names].key?(name)
-            "[:ref, #{name.inspect}]"
-          elsif binding
-            "[:pin, #{binding_value_code(binding)}]"
+            state[:bound_names][bind_name] = true
+            state[:binding_names] << bind_name
+            sanitize_local(bind_name)
           else
-            state[:bound_names][name] = true
-            state[:binding_names] << name
-            "[:bind, #{name.inspect}, #{allow_nil}]"
+            binding = mode == :match ? env.lookup_if_defined(name) : nil
+            if state[:bound_names].key?(name)
+              raise PatternNotTranslatable
+            elsif binding
+              "^(#{binding_value_code(binding)})"
+            else
+              state[:bound_names][name] = true
+              state[:binding_names] << name
+              ruby = sanitize_local(name)
+              state[:guards] << "!#{ruby}.nil?"
+              ruby
+            end
           end
         end
 
-        def emit_sequence_match_pattern(items, env, mode:, allow_pins:, state:)
+        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)
-              parts << "[:rest, #{emit_match_pattern(items[i + 1], env, mode:, allow_pins:, state:)}]"
+              has_rest = true
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              if sub.name == '_'
+                parts << '*'
+              else
+                state[:bound_names][sub.name] = true
+                state[:binding_names] << sub.name
+                parts << "*#{sanitize_local(sub.name)}"
+              end
               i += 2
             else
-              parts << emit_match_pattern(items[i], env, mode:, allow_pins:, state:)
+              parts << compile_native_pattern(items[i], env, mode:, allow_pins:, state:)
               i += 1
             end
           end
-          "[:vec, [#{parts.join(', ')}]]"
+          parts << '*' unless has_rest
+          "[#{parts.join(', ')}]"
         end
 
-        def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
-          emit_error!('pin patterns are only supported inside `case` guards') unless allow_pins && mode == :case
+        def compile_native_hash(pattern, env, mode:, allow_pins:, state:)
+          pairs = pattern.pairs.map do |key, value|
+            raise PatternNotTranslatable unless key.is_a?(Symbol)
+
+            "#{key}: #{compile_native_pattern(value, env, mode:, allow_pins:, state:)}"
+          end
+          "{#{pairs.join(', ')}}"
+        end
+
+        def compile_native_pin(pattern, env, mode:, allow_pins:)
+          raise PatternNotTranslatable unless allow_pins && mode == :case
 
           name_sym = pattern.items[1]
-          emit_error!("bad pin pattern: #{pattern.inspect}") unless name_sym.is_a?(Sym)
+          raise PatternNotTranslatable unless name_sym.is_a?(Sym)
 
           binding = env.lookup_if_defined(name_sym.name)
-          emit_error!("cannot pin undefined name: #{name_sym.name}") unless binding
+          raise PatternNotTranslatable unless binding
 
-          "[:pin, #{binding_value_code(binding)}]"
+          "^(#{binding_value_code(binding)})"
         end
 
-        def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-          initial_names = state[:binding_names].length
+        def compile_native_or(pattern, env, mode:, allow_pins:, state:)
           initial_bound = state[:bound_names].dup
-          canonical_names = nil
+          initial_names = state[:binding_names].length
+          initial_guards = state[:guards].length
           variants = pattern.items[1..].map do |subpattern|
             alt_state = {
               bound_names: initial_bound.dup,
-              binding_names: state[:binding_names].dup
+              binding_names: state[:binding_names].dup,
+              guards: state[:guards].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
-            emit_error!('all `or` patterns must bind the same names') if canonical_names.sort != alt_names.sort
+            compiled = compile_native_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
+            raise PatternNotTranslatable if alt_state[:binding_names].length > initial_names
+            raise PatternNotTranslatable if alt_state[:guards].length > initial_guards
 
             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
-            pattern.name == '_' ? '[:sym, "_"]' : "[:sym, #{pattern.name.inspect}]"
-          when Vec
-            parts = []
-            items = pattern.items
-            i = 0
-            while i < items.length
-              if items[i].is_a?(Sym) && items[i].name == '&'
-                parts << "[:rest, #{emit_pattern(items[i + 1])}]"
-                i += 2
-              else
-                parts << emit_pattern(items[i])
-                i += 1
-              end
-            end
-            "[:vec, [#{parts.join(', ')}]]"
-          when HashLit
-            pairs = pattern.pairs.map { |key, value| "[#{key.inspect}, #{emit_pattern(value)}]" }
-            "[:hash, [#{pairs.join(', ')}]]"
-          when nil
-            '[:nil]'
-          when Symbol, String, Numeric, true, false
-            "[:lit, #{pattern.inspect}]"
-          else
-            emit_error!("bad pattern: #{pattern.inspect}")
-          end
+          "(#{variants.join(' | ')})"
         end
 
         def pattern_names(pattern)

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

@@ -62,7 +62,7 @@ module Kapusta
           else
             name_sym, supers, = split_class_args(form.items[1..])
             body = emit_forms_with_headers(remaining_forms, env, :class, result: false)
-            emit_direct_class_header(name_sym, supers, body) || emit_class_wrapper(name_sym, supers, env, body)
+            emit_direct_class_header(name_sym, supers, body, env) || emit_class_wrapper(name_sym, supers, env, body)
           end
         end
 
@@ -128,7 +128,7 @@ module Kapusta
             return [emit_for_statement(form.rest, env, current_scope), env]
           when 'each'
             code = emit_each_statement(form.rest, env, current_scope)
-            return ["#{code}\nnil", env] if result_needed
+            return ["#{code}\nnil", env] if result_needed && current_scope != :toplevel
 
             return [code, env]
           end
@@ -219,19 +219,6 @@ module Kapusta
           source_name.is_a?(GeneratedSym)
         end
 
-        def runtime_helper(name)
-          helper = name.to_sym
-          @runtime_helpers << helper unless @runtime_helpers.include?(helper)
-          Runtime.helper_name(helper)
-        end
-
-        def runtime_call(name, *args)
-          rendered_args = args.map do |arg|
-            arg.is_a?(Array) ? "[#{arg.join(', ')}]" : arg || 'nil'
-          end
-          "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
-        end
-
         def method_binding?(binding)
           binding.is_a?(Env::MethodBinding)
         end

data/lib/kapusta/compiler/emitter.rb

@@ -27,14 +27,12 @@ module Kapusta
       def initialize(path:)
         @path = path
         @temp_index = 0
-        @runtime_helpers = []
       end
 
       def emit_file(forms)
         env = Env.new
         body = emit_forms_with_headers(forms, env, :toplevel)
-        helpers = Runtime.helper_source(@runtime_helpers)
-        [helpers, body].reject(&:empty?).join("\n\n") << "\n"
+        "#{body}\n"
       end
     end
   end

data/lib/kapusta/compiler/normalizer.rb

@@ -121,12 +121,12 @@ module Kapusta
       end
 
       def thread_temp
-        gensym('kap_thread')
+        gensym('thread')
       end
 
       def doto(forms)
         value = forms.first
-        temp = gensym('kap_doto')
+        temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
             List.new([form.items[0], temp, *form.items[1..]])

data/lib/kapusta/compiler.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'error'
-require_relative 'compiler/runtime'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 

data/lib/kapusta/version.rb

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

data/lib/kapusta.rb

@@ -12,10 +12,12 @@ module Kapusta
   @loaded_kapusta_features = {}
 
   def self.eval(source, path: '(eval)', **_opts)
+    install!
     Compiler.run(source, path:)
   end
 
   def self.dofile(path, **_opts)
+    install!
     source = File.read(path)
     self.eval(source, path:)
   end
@@ -25,6 +27,7 @@ module Kapusta
   end
 
   def self.require(feature, relative_to: nil)
+    install!
     feature = feature.to_s
     local_path = resolve_require_path(feature, relative_to:)
 
@@ -35,12 +38,33 @@ module Kapusta
   end
 
   def self.install!
-    @install ||= begin
-      Kernel.require 'rubygems'
-      true
+    return if @installed
+
+    @installed = true
+    Kernel.module_eval do
+      alias_method :__kapusta_original_require_relative, :require_relative
+      private :__kapusta_original_require_relative
+
+      def require_relative(path)
+        kap_path = Kapusta.send(:resolve_kap_relative, path, caller_locations(1, 1).first)
+        return Kapusta.send(:require_kapusta_file, kap_path) if kap_path
+
+        __kapusta_original_require_relative(path)
+      end
     end
   end
 
+  def self.resolve_kap_relative(path, location)
+    return unless path.is_a?(String) && location
+
+    base_file = location.absolute_path || location.path
+    return unless base_file
+
+    full = File.expand_path(path, File.dirname(File.expand_path(base_file)))
+    candidates = full.end_with?('.kap') ? [full] : ["#{full}.kap"]
+    candidates.find { |c| File.file?(c) }
+  end
+
   def self.resolve_require_path(feature, relative_to:)
     return unless local_feature?(feature)
 
@@ -88,5 +112,5 @@ module Kapusta
   end
 
   private_class_method :resolve_require_path, :local_feature?, :require_base_dir,
-                       :existing_feature_path, :require_kapusta_file
+                       :existing_feature_path, :require_kapusta_file, :resolve_kap_relative
 end

data/spec/examples_spec.rb

@@ -484,6 +484,10 @@ RSpec.describe 'examples' do
     expect(run_example('majority-element.kap')).to eq("3\n2\n1\n")
   end
 
+  it 'manhattan-distance.kap' do
+    expect(run_example('manhattan-distance.kap')).to eq("14\n")
+  end
+
   it 'plus-one.kap' do
     expect(run_example('plus-one.kap')).to eq(<<~OUT)
       [1, 2, 4]
@@ -492,4 +496,8 @@ RSpec.describe 'examples' do
       [1, 0, 0]
     OUT
   end
+
+  it 'subtract-product-sum.kap' do
+    expect(run_example('subtract-product-sum.kap')).to eq("15\n21\n0\n")
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -57,6 +57,7 @@ files:
 - examples/leap-year.kap
 - examples/length-of-last-word.kap
 - examples/majority-element.kap
+- examples/manhattan-distance.kap
 - examples/match.kap
 - examples/maximum-subarray.kap
 - examples/min-max.kap
@@ -84,6 +85,7 @@ files:
 - examples/single-number.kap
 - examples/squares.kap
 - examples/stack.kap
+- examples/subtract-product-sum.kap
 - examples/sum.kap
 - examples/threading.kap
 - examples/tic-tac-toe.kap
@@ -112,7 +114,6 @@ files:
 - lib/kapusta/compiler/emitter/patterns.rb
 - lib/kapusta/compiler/emitter/support.rb
 - lib/kapusta/compiler/normalizer.rb
-- lib/kapusta/compiler/runtime.rb
 - lib/kapusta/env.rb
 - lib/kapusta/error.rb
 - lib/kapusta/formatter.rb