kapusta 0.5.0 → 0.8.0

data/lib/kapusta/compiler/lua_compat.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module LuaCompat
+      SPECIAL_FORMS = %w[pcall xpcall].freeze
+      ITERATOR_FORMS = %w[ipairs pairs].freeze
+
+      def self.special_form?(name)
+        SPECIAL_FORMS.include?(name)
+      end
+
+      def self.iterator_form?(name)
+        ITERATOR_FORMS.include?(name)
+      end
+
+      module Normalization
+        private
+
+        def normalize_lua_compat_form(name, items)
+          case name
+          when 'pcall' then normalize_lua_pcall(items)
+          when 'xpcall' then normalize_lua_xpcall(items)
+          end
+        end
+
+        def normalize_lua_pcall(items)
+          fn = items[1]
+          args = items[2..]
+          List.new([
+                     Sym.new('try'),
+                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
+                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
+                               List.new([Sym.new('values'), false, Sym.new('e')])])
+                   ])
+        end
+
+        def normalize_lua_xpcall(items)
+          fn = items[1]
+          handler = items[2]
+          args = items[3..]
+          List.new([
+                     Sym.new('try'),
+                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
+                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
+                               List.new([Sym.new('values'), false, List.new([handler, Sym.new('e')])])])
+                   ])
+        end
+      end
+
+      module Emission
+        private
+
+        def emit_lua_compat_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                   init_code, body_forms)
+          return unless lua_iterator_expr?(iter_expr)
+
+          case iter_expr.head.name
+          when 'ipairs'
+            emit_lua_ipairs_inject(iter_expr, binding_pats, body_env, env, current_scope,
+                                   acc_var, init_code, body_forms)
+          when 'pairs'
+            emit_lua_pairs_inject(iter_expr, binding_pats, body_env, env, current_scope,
+                                  acc_var, init_code, body_forms)
+          end
+        end
+
+        def emit_lua_compat_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                      extra_block_param: nil, &block)
+          return unless lua_iterator_expr?(iter_expr)
+
+          case iter_expr.head.name
+          when 'ipairs'
+            emit_lua_ipairs_iteration(iter_expr, binding_pats, env, current_scope,
+                                      method:, extra_block_param:, &block)
+          when 'pairs'
+            emit_lua_pairs_iteration(iter_expr, binding_pats, env, current_scope,
+                                     method:, extra_block_param:, &block)
+          end
+        end
+
+        def lua_iterator_expr?(expr)
+          expr.is_a?(List) && expr.head.is_a?(Sym) && LuaCompat.iterator_form?(expr.head.name)
+        end
+
+        def emit_lua_ipairs_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                   init_code, body_forms)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+          if ignored_pattern?(binding_pats[0])
+            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+            return inject_block(coll_code, "#{acc_var}, #{value_var}", init_code, value_bind || '', 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, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+          inject_block("#{coll_code}.each_with_index", "#{acc_var}, (#{value_var}, #{index_var})",
+                       init_code, bind_code, body_code)
+        end
+
+        def emit_lua_pairs_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                  init_code, body_forms)
+          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, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          inject_block(coll_code, "#{acc_var}, (#{key_var}, #{value_var})",
+                       init_code, bind_code, body_code)
+        end
+
+        def emit_lua_ipairs_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                      extra_block_param: nil, &block)
+          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 = block.call(body_env)
+            params = extra_block_param ? "#{value_var}, #{extra_block_param}" : value_var
+            return iteration_block("#{coll_code}.#{method} do |#{params}|", 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 = block.call(body_env)
+          receiver = method == 'each' ? "#{coll_code}.each_with_index" : "#{coll_code}.each_with_index.#{method}"
+          inner_params = "#{value_var}, #{index_var}"
+          params = extra_block_param ? "(#{inner_params}), #{extra_block_param}" : inner_params
+          iteration_block("#{receiver} do |#{params}|", bind_code, body_code)
+        end
+
+        def emit_lua_pairs_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                     extra_block_param: nil, &block)
+          body_env = env.child
+          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 = block.call(body_env)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          inner_params = "#{key_var}, #{value_var}"
+          params = extra_block_param ? "(#{inner_params}), #{extra_block_param}" : inner_params
+          iteration_block("#{coll_code}.#{method} do |#{params}|", bind_code, body_code)
+        end
+      end
+    end
+  end
+end

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)]
@@ -89,6 +91,9 @@ module Kapusta
           when 'macros'
             register_macros_form(list.rest)
             return List.new([Sym.new('do')])
+          when 'import-macros'
+            handle_import_macros(list)
+            return List.new([Sym.new('do')])
           end
 
           key = lookup_key(name)
@@ -134,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 = {}
-        end
-
-        def collected_gensyms
-          @gensyms.map { |prefix, sym| [sym, prefix] }
-        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
+      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 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
+        unless module_arg.is_a?(Symbol) || module_arg.is_a?(String)
+          raise macro_error(:import_macros_module_invalid, form)
         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