kapusta 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76f35530eebc269dfec62ee1f36f6cc11a252ee4590eeac961c9b47e4e49ca09
-  data.tar.gz: a0ee60d21fb9a6066915d916e465bef09d9208c0469712673db35bea83efd7c4
+  metadata.gz: f64991d78295bfc4a633136af86607f2d9536f3e113ae9ea819a0c5708837427
+  data.tar.gz: 0d656fcf3afefbb2c89acad7a0fa4de8a57f8a484c2ce887e5bc70e7493c71ea
 SHA512:
-  metadata.gz: 350e111e7cfe045723ea1982c18762727d64ea615219d904a79af2933874af5ce355076e242ed9c0bf5e91d135dbd4498b2b5ae107b05035f205e3ccb87bbb54
-  data.tar.gz: 7e242c3fb28fb0d5d2839f7e3d6e5dca96dda90204e1a81024111e1fc5ef4f6c7abb2a6e3628e5894eac46ce9d1c10f21db80bcae63da3ec9b4874a747b1bba1
+  metadata.gz: a27e51a26db8069c998d7e0b586beb4fda1505c2f13f572b82bbbda92bc79dbe6e3d4e308547877a0e455cd56b5c9f1c226830ca2645664dae65b47b552dc3a1
+  data.tar.gz: e6e675b9be4492d7bf75e341915bfd5e022a733240a2b7c4139c2904a99577207a7b4d182208ad1706c31bcded3ebaf3a50e03d18f27eafc68373b96141ae8b0

data/bin/fennel-parity

@@ -24,6 +24,9 @@ COMPATIBLE = %w[
   hashfn.kap
   leap-year.kap
   macros-dbg.kap
+  macros-import-helpers.kap
+  macros-import-whole.kap
+  macros-import.kap
   macros-multi.kap
   macros-swap.kap
   macros-thrice-if.kap
@@ -44,13 +47,15 @@ COMPATIBLE = %w[
   underscore-patterns.kap
 ].freeze
 
-def run(cmd, file, chdir: EXAMPLES)
-  out, err, status = Open3.capture3(cmd, file, chdir:)
+def run(cmd, file, chdir: EXAMPLES, env: {})
+  out, err, status = Open3.capture3(env, cmd, file, chdir:)
   [out, err, status]
 rescue StandardError => e
   ['', e.message, nil]
 end
 
+FENNEL_ENV = { 'FENNEL_MACRO_PATH' => './?.kapm;./?.kap' }.freeze
+
 def strip_outer_quotes(line)
   if line.length >= 2 && line.start_with?('"') && line.end_with?('"')
     line[1..-2]
@@ -100,7 +105,7 @@ end
 
 def check_run(path)
   k_out, k_err, k_status = run(KAPUSTA, path)
-  f_out, f_err, f_status = run('fennel', path)
+  f_out, f_err, f_status = run('fennel', path, env: FENNEL_ENV)
 
   return "kapusta exited #{k_status&.exitstatus}: #{k_err.strip}" if k_status.nil? || !k_status.success?
   return "fennel exited #{f_status&.exitstatus}: #{f_err.strip}" if f_status.nil? || !f_status.success?
@@ -132,7 +137,7 @@ end
 def check_error(name)
   path = File.join(EXAMPLES_ERRORS, name)
   _, _, k_status = run(KAPUSTA, path, chdir: EXAMPLES_ERRORS)
-  _, _, f_status = run('fennel', path, chdir: EXAMPLES_ERRORS)
+  _, _, f_status = run('fennel', path, chdir: EXAMPLES_ERRORS, env: FENNEL_ENV)
 
   return [:fail, 'fennel unexpectedly succeeded'] if f_status&.success?
   return [:fail, "kapusta unexpectedly succeeded (exit #{k_status&.exitstatus})"] if k_status&.success?

data/examples/import-helpers.kapm

@@ -0,0 +1,9 @@
+(local FACTOR 10)
+
+(fn double [x]
+  (* x 2))
+
+(fn scaled [x]
+  `(* ,x ,(double FACTOR)))
+
+{: scaled}

data/examples/macros-import-helpers.kap

@@ -0,0 +1,3 @@
+(import-macros {: scaled} :import-helpers)
+
+(print (scaled 3))

data/examples/macros-import-whole.kap

@@ -0,0 +1,5 @@
+(import-macros mine :shared-macros)
+
+(var n 5)
+(mine.inc-by n 2)
+(print n)

data/examples/macros-import.kap

@@ -0,0 +1,6 @@
+(import-macros {: inc-by} :shared-macros)
+
+(var counter 0)
+(inc-by counter 5)
+(inc-by counter 3)
+(print counter)

data/examples/shared-macros.kapm

@@ -0,0 +1,4 @@
+(fn inc-by [target n]
+  `(set ,target (+ ,target ,n)))
+
+{: inc-by}

data/lib/kapusta/compiler/macro_expander.rb

@@ -1,27 +1,28 @@
 # frozen_string_literal: true
 
+require_relative 'macro_gensym'
+require_relative 'macro_lowerer'
+require_relative 'macro_importer'
+
 module Kapusta
   module Compiler
     class MacroExpander
       class Error < Kapusta::Error; end
 
-      @gensym_counter = 0
-
       class << self
         def fresh_gensym(prefix)
-          @gensym_counter += 1
-          GeneratedSym.new("#{prefix}_g#{@gensym_counter}", @gensym_counter)
+          MacroGensym.fresh_gensym(prefix)
         end
 
         def fresh_local_gensym(prefix)
-          @gensym_counter += 1
-          GeneratedSym.new("#{prefix}_local_#{@gensym_counter}", @gensym_counter)
+          MacroGensym.fresh_local_gensym(prefix)
         end
       end
 
-      def initialize(path: nil)
+      def initialize(path: nil, loading: nil)
         @macros = {}
         @path = path
+        @loading = loading || []
       end
 
       def expand_all(forms)
@@ -40,7 +41,8 @@ module Kapusta
             register_macros_form(form.rest)
             return []
           when 'import-macros'
-            raise macro_error(:import_macros_unsupported, form)
+            handle_import_macros(form)
+            return []
           end
         end
         [expand(form)]
@@ -90,7 +92,8 @@ module Kapusta
             register_macros_form(list.rest)
             return List.new([Sym.new('do')])
           when 'import-macros'
-            raise macro_error(:import_macros_unsupported, list)
+            handle_import_macros(list)
+            return List.new([Sym.new('do')])
           end
 
           key = lookup_key(name)
@@ -136,152 +139,61 @@ module Kapusta
         value.is_a?(List) && value.head.is_a?(Sym) && %w[fn lambda λ].include?(value.head.name)
       end
 
-      def register(source_name, params, body)
-        proc_obj = compile_macro(source_name, params, body)
-        @macros[lookup_key(source_name)] = proc_obj
-      end
-
-      def compile_macro(name, params, body)
-        lowering = Lowering.new
-        lowered_body = body.map { |form| lowering.lower(form) }
-        gensym_locals = lowering.collected_gensyms
-
-        wrapped =
-          if gensym_locals.empty?
-            List.new([Sym.new('fn'), params, *lowered_body])
-          else
-            let_bindings = gensym_locals.flat_map do |gensym_sym, prefix|
-              [gensym_sym, List.new([Sym.new('quasi-gensym'), prefix])]
-            end
-            inner = lowered_body.length == 1 ? lowered_body.first : List.new([Sym.new('do'), *lowered_body])
-            List.new([Sym.new('fn'), params, List.new([Sym.new('let'), Vec.new(let_bindings), inner])])
-          end
-
-        macro_path = @path || "(macro #{name})"
-        ruby = Compiler.compile_forms([wrapped], path: macro_path)
-        TOPLEVEL_BINDING.eval(ruby, macro_path, 1)
-      end
-
-      def invoke_macro(key, args)
-        proc_obj = @macros[key]
-        proc_obj.call(*args)
-      end
-
-      class Lowering
-        def initialize
-          @gensyms = {}
+      def handle_import_macros(form)
+        args = form.rest
+        destructure = args[0]
+        module_arg = args[1]
+        unless destructure.is_a?(HashLit) || destructure.is_a?(Sym)
+          raise macro_error(:import_macros_destructure_invalid, form)
         end
-
-        def collected_gensyms
-          @gensyms.map { |prefix, sym| [sym, prefix] }
+        unless module_arg.is_a?(Symbol) || module_arg.is_a?(String)
+          raise macro_error(:import_macros_module_invalid, form)
         end
 
-        def lower(form)
-          case form
-          when Quasiquote then copy_position(lower_quasi(form.form), form)
-          when Unquote, UnquoteSplice
-            raise Error, Kapusta::Errors.format(:unquote_outside_quasiquote)
-          when AutoGensym
-            raise Error, Kapusta::Errors.format(:auto_gensym_outside_quasiquote, name: form.name)
-          when List then copy_position(List.new(form.items.map { |item| lower(item) }), form)
-          when Vec then copy_position(Vec.new(form.items.map { |item| lower(item) }), form)
-          when HashLit
-            copy_position(
-              HashLit.new(form.entries.map do |entry|
-                entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
-              end),
-              form
-            )
-          else
-            form
-          end
-        end
-
-        def copy_position(target, source)
-          return target unless target.respond_to?(:line=) && source.respond_to?(:line)
-
-          target.line ||= source.line
-          target.column ||= source.column
-          target
-        end
-
-        def lower_quasi(form)
-          case form
-          when AutoGensym then gensym_local_for(form.name)
-          when Sym then List.new([Sym.new('quasi-sym'), form.name])
-          when List then lower_quasi_list(form)
-          when Vec then lower_quasi_vec(form)
-          when HashLit then lower_quasi_hash(form)
-          when Unquote then lower(form.form)
-          when UnquoteSplice
-            raise Error, Kapusta::Errors.format(:unquote_splice_outside_list)
-          when Quasiquote
-            raise Error, Kapusta::Errors.format(:nested_quasiquote)
-          else
-            form
-          end
-        end
-
-        def lower_quasi_list(list)
-          items = list.items
-          return List.new([Sym.new('quasi-list')]) if items.empty?
-
-          if (tail_expr = splice_tail(items))
-            head_items = items[0...-1].map { |item| lower_quasi(item) }
-            return List.new([Sym.new('quasi-list-tail'), Vec.new(head_items), tail_expr])
-          end
-
-          lowered_items = items.map { |item| lower_quasi_item(item) }
-          List.new([Sym.new('quasi-list'), *lowered_items])
+        module_label = MacroImporter.module_label(module_arg)
+        exports = macro_importer.load(module_arg, form)
+        if destructure.is_a?(HashLit)
+          register_imported_macros(destructure, exports, module_label, form)
+        else
+          register_whole_module(destructure, exports)
         end
+      end
 
-        def lower_quasi_vec(vec)
-          items = vec.items
-          if (tail_expr = splice_tail(items))
-            head_items = items[0...-1].map { |item| lower_quasi(item) }
-            return List.new([Sym.new('quasi-vec-tail'), Vec.new(head_items), tail_expr])
-          end
-
-          lowered_items = items.map { |item| lower_quasi_item(item) }
-          List.new([Sym.new('quasi-vec'), *lowered_items])
-        end
+      def macro_importer
+        @macro_importer ||= MacroImporter.new(path: @path, loading: @loading, error_class: Error)
+      end
 
-        def lower_quasi_hash(hash)
-          parts = []
-          hash.entries.each do |entry|
-            next unless entry.is_a?(Array)
+      def register_imported_macros(destructure, exports, module_label, form)
+        destructure.pairs.each do |key, target|
+          raise macro_error(:import_macros_destructure_invalid, form) unless target.is_a?(Sym)
 
-            key, value = entry
-            parts << lower_quasi(key) << lower_quasi(value)
-          end
-          List.new([Sym.new('quasi-hash'), *parts])
+          proc_obj = exports[key] ||
+                     raise(macro_error(:import_macros_macro_not_found, form,
+                                       macro: key.to_s.tr('_', '-'), module: module_label))
+          @macros[lookup_key(target.name)] = proc_obj
         end
+      end
 
-        def lower_quasi_item(item)
-          if item.is_a?(Unquote) && unpack_call?(item.form)
-            inner = lower(item.form.items[1])
-            List.new([Sym.new('.'), inner, 0])
-          else
-            lower_quasi(item)
-          end
+      def register_whole_module(bind_sym, exports)
+        exports.each do |export_key, proc_obj|
+          macro_name = "#{bind_sym.name}.#{export_key.to_s.tr('_', '-')}"
+          @macros[lookup_key(macro_name)] = proc_obj
         end
+      end
 
-        def splice_tail(items)
-          last = items.last
-          return unless last
-          return lower(last.form) if last.is_a?(UnquoteSplice)
-          return lower(last.form.items[1]) if last.is_a?(Unquote) && unpack_call?(last.form)
-
-          nil
-        end
+      def register(source_name, params, body)
+        proc_obj = compile_macro(source_name, params, body)
+        @macros[lookup_key(source_name)] = proc_obj
+      end
 
-        def unpack_call?(form)
-          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'unpack'
-        end
+      def compile_macro(name, params, body)
+        macro_path = @path || "(macro #{name})"
+        MacroLowerer.compile(params:, body:, path: macro_path, error_class: Error)
+      end
 
-        def gensym_local_for(prefix)
-          @gensyms[prefix] ||= MacroExpander.fresh_local_gensym(prefix)
-        end
+      def invoke_macro(key, args)
+        proc_obj = @macros[key]
+        proc_obj.call(*args)
       end
     end
   end

data/lib/kapusta/compiler/macro_gensym.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module MacroGensym
+      @counter = 0
+
+      class << self
+        def fresh_gensym(prefix)
+          @counter += 1
+          GeneratedSym.new("#{prefix}_g#{@counter}", @counter)
+        end
+
+        def fresh_local_gensym(prefix)
+          @counter += 1
+          GeneratedSym.new("#{prefix}_local_#{@counter}", @counter)
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/macro_importer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'macro_lowerer'
+
+module Kapusta
+  module Compiler
+    class MacroImporter
+      EXTENSIONS = %w[kapm kap fnlm fnl].freeze
+
+      def self.module_label(module_arg)
+        module_arg.is_a?(Symbol) ? module_arg.to_s.tr('_', '-') : module_arg.to_s
+      end
+
+      def initialize(path: nil, loading: nil, error_class: Kapusta::Error)
+        @path = path
+        @loading = loading || []
+        @error_class = error_class
+      end
+
+      def load(module_arg, import_form)
+        module_label = self.class.module_label(module_arg)
+        absolute_path = resolve_macro_module(module_arg) ||
+                        raise(import_error(:import_macros_module_not_found, import_form, module: module_label))
+
+        raise import_error(:import_macros_cycle, import_form, module: module_label) if @loading.include?(absolute_path)
+
+        load_macro_module(absolute_path, module_label, import_form)
+      end
+
+      private
+
+      def resolve_macro_module(module_arg)
+        snake_stem = module_arg.to_s
+        kebab_stem = snake_stem.tr('_', '-')
+        [kebab_stem, snake_stem].uniq.each do |stem|
+          EXTENSIONS.each do |ext|
+            candidate = File.expand_path("#{stem}.#{ext}", base_dir)
+            return candidate if File.file?(candidate)
+          end
+        end
+        nil
+      end
+
+      def base_dir
+        return Dir.pwd unless @path && !@path.start_with?('(')
+
+        File.dirname(File.expand_path(@path))
+      end
+
+      def load_macro_module(absolute_path, module_label, import_form)
+        @loading.push(absolute_path)
+        begin
+          source = File.read(absolute_path)
+          forms = Reader.read_all(source)
+        rescue Kapusta::Error => e
+          raise e.with_defaults(path: absolute_path)
+        end
+        unless forms.last.is_a?(HashLit)
+          raise import_error(:import_macros_module_no_exports, import_form, module: module_label)
+        end
+
+        processed = forms.map { |form| MacroLowerer.lower_module_form(form, error_class: @error_class) }
+        wrapper = List.new([List.new([Sym.new('fn'), Vec.new([]), *processed])])
+        ruby = Compiler.compile_forms([wrapper], path: absolute_path)
+        result = TOPLEVEL_BINDING.eval(ruby, absolute_path, 1)
+
+        return result if result.is_a?(Hash)
+
+        raise import_error(:import_macros_module_no_exports, import_form, module: module_label)
+      ensure
+        @loading.pop
+      end
+
+      def import_error(code, form, **args)
+        line = form.respond_to?(:line) ? form.line : nil
+        column = form.respond_to?(:column) ? form.column : nil
+        @error_class.new(Kapusta::Errors.format(code, **args), path: @path, line:, column:)
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/macro_lowerer.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative 'macro_gensym'
+
+module Kapusta
+  module Compiler
+    class MacroLowerer
+      FN_HEADS = %w[fn lambda λ].freeze
+
+      def self.compile(params:, body:, path:, error_class:)
+        callable = new(error_class:).callable_form(params, body)
+        ruby = Compiler.compile_forms([callable], path:)
+        TOPLEVEL_BINDING.eval(ruby, path, 1)
+      end
+
+      def self.lower_module_form(form, error_class:)
+        new(error_class:).lower_module_form(form)
+      end
+
+      def initialize(error_class:)
+        @error_class = error_class
+        @gensyms = {}
+      end
+
+      def callable_form(params, body)
+        List.new([Sym.new('fn'), params, *lowered_body_with_gensyms(body)])
+      end
+
+      def lower_module_form(form)
+        return lower_fn_form(form) if fn_form?(form)
+
+        lower(form)
+      end
+
+      def lower(form)
+        case form
+        when Quasiquote then copy_position(lower_quasi(form.form), form)
+        when Unquote, UnquoteSplice
+          raise @error_class, Kapusta::Errors.format(:unquote_outside_quasiquote)
+        when AutoGensym
+          raise @error_class, Kapusta::Errors.format(:auto_gensym_outside_quasiquote, name: form.name)
+        when List then copy_position(List.new(form.items.map { |item| lower(item) }), form)
+        when Vec then copy_position(Vec.new(form.items.map { |item| lower(item) }), form)
+        when HashLit
+          copy_position(
+            HashLit.new(form.entries.map do |entry|
+              entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
+            end),
+            form
+          )
+        else
+          form
+        end
+      end
+
+      private
+
+      def lower_fn_form(form)
+        items = form.items
+        if items[1].is_a?(Sym) && items[2].is_a?(Vec)
+          name_sym = items[1]
+          params = items[2]
+          body = items[3..] || []
+        elsif items[1].is_a?(Vec)
+          name_sym = nil
+          params = items[1]
+          body = items[2..] || []
+        else
+          return form
+        end
+
+        head_items = name_sym ? [form.head, name_sym, params] : [form.head, params]
+        List.new(head_items + lowered_body_with_gensyms(body))
+      end
+
+      def lowered_body_with_gensyms(body)
+        lowered_body = body.map { |item| lower(item) }
+        wrap_gensyms(collected_gensyms, lowered_body)
+      end
+
+      def collected_gensyms
+        @gensyms.map { |prefix, sym| [sym, prefix] }
+      end
+
+      def wrap_gensyms(gensyms, body)
+        return body if gensyms.empty?
+
+        bindings = gensyms.flat_map { |sym, prefix| [sym, List.new([Sym.new('quasi-gensym'), prefix])] }
+        wrapped = body.length == 1 ? body[0] : List.new([Sym.new('do'), *body])
+        [List.new([Sym.new('let'), Vec.new(bindings), wrapped])]
+      end
+
+      def fn_form?(form)
+        form.is_a?(List) && form.head.is_a?(Sym) && FN_HEADS.include?(form.head.name)
+      end
+
+      def copy_position(target, source)
+        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
+
+        target.line ||= source.line
+        target.column ||= source.column
+        target
+      end
+
+      def lower_quasi(form)
+        case form
+        when AutoGensym then gensym_local_for(form.name)
+        when Sym then List.new([Sym.new('quasi-sym'), form.name])
+        when List then lower_quasi_list(form)
+        when Vec then lower_quasi_vec(form)
+        when HashLit then lower_quasi_hash(form)
+        when Unquote then lower(form.form)
+        when UnquoteSplice
+          raise @error_class, Kapusta::Errors.format(:unquote_splice_outside_list)
+        when Quasiquote
+          raise @error_class, Kapusta::Errors.format(:nested_quasiquote)
+        else
+          form
+        end
+      end
+
+      def lower_quasi_list(list)
+        items = list.items
+        return List.new([Sym.new('quasi-list')]) if items.empty?
+
+        if (tail_expr = splice_tail(items))
+          head_items = items[0...-1].map { |item| lower_quasi(item) }
+          return List.new([Sym.new('quasi-list-tail'), Vec.new(head_items), tail_expr])
+        end
+
+        lowered_items = items.map { |item| lower_quasi_item(item) }
+        List.new([Sym.new('quasi-list'), *lowered_items])
+      end
+
+      def lower_quasi_vec(vec)
+        items = vec.items
+        if (tail_expr = splice_tail(items))
+          head_items = items[0...-1].map { |item| lower_quasi(item) }
+          return List.new([Sym.new('quasi-vec-tail'), Vec.new(head_items), tail_expr])
+        end
+
+        lowered_items = items.map { |item| lower_quasi_item(item) }
+        List.new([Sym.new('quasi-vec'), *lowered_items])
+      end
+
+      def lower_quasi_hash(hash)
+        parts = []
+        hash.entries.each do |entry|
+          next unless entry.is_a?(Array)
+
+          key, value = entry
+          parts << lower_quasi(key) << lower_quasi(value)
+        end
+        List.new([Sym.new('quasi-hash'), *parts])
+      end
+
+      def lower_quasi_item(item)
+        if item.is_a?(Unquote) && unpack_call?(item.form)
+          inner = lower(item.form.items[1])
+          List.new([Sym.new('.'), inner, 0])
+        else
+          lower_quasi(item)
+        end
+      end
+
+      def splice_tail(items)
+        last = items.last
+        return unless last
+        return lower(last.form) if last.is_a?(UnquoteSplice)
+        return lower(last.form.items[1]) if last.is_a?(Unquote) && unpack_call?(last.form)
+
+        nil
+      end
+
+      def unpack_call?(form)
+        form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'unpack'
+      end
+
+      def gensym_local_for(prefix)
+        @gensyms[prefix] ||= MacroGensym.fresh_local_gensym(prefix)
+      end
+    end
+  end
+end

data/lib/kapusta/errors.rb

@@ -30,7 +30,12 @@ module Kapusta
       global_non_symbol_name: 'unable to bind %{type} %{value}',
       icollect_no_iterator: 'expected iterator binding table',
       if_no_body: 'expected condition and body',
-      import_macros_unsupported: 'import-macros is not yet supported',
+      import_macros_cycle: 'import-macros cycle detected for module %{module}',
+      import_macros_destructure_invalid: 'import-macros expects a hash literal as first argument',
+      import_macros_macro_not_found: 'import-macros: macro %{macro} not exported by module %{module}',
+      import_macros_module_invalid: 'import-macros expects a symbol or string module name',
+      import_macros_module_no_exports: 'import-macros: module %{module} has no export table',
+      import_macros_module_not_found: 'import-macros: module %{module} not found',
       invalid_class_name: 'invalid class name: %{name}',
       invalid_module_name: 'invalid module name: %{name}',
       let_no_body: 'expected body expression',