kapusta 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76f35530eebc269dfec62ee1f36f6cc11a252ee4590eeac961c9b47e4e49ca09
-  data.tar.gz: a0ee60d21fb9a6066915d916e465bef09d9208c0469712673db35bea83efd7c4
+  metadata.gz: 520158590f1244ac17f70b58ded945f66be00060f6da89cebb366fefaf27b62e
+  data.tar.gz: 6773e0faa320f23cb15106e710f380a39093c9fc6e56cead8941c28e0ccf16c5
 SHA512:
-  metadata.gz: 350e111e7cfe045723ea1982c18762727d64ea615219d904a79af2933874af5ce355076e242ed9c0bf5e91d135dbd4498b2b5ae107b05035f205e3ccb87bbb54
-  data.tar.gz: 7e242c3fb28fb0d5d2839f7e3d6e5dca96dda90204e1a81024111e1fc5ef4f6c7abb2a6e3628e5894eac46ce9d1c10f21db80bcae63da3ec9b4874a747b1bba1
+  metadata.gz: 814d37c473287d2d1e54568c7d21c22d88703cd89da761100c1f20950e47cb18eb2ac4807aa596878ded72eb7049a6083d2b9de46bc76ce2ea55787f6993f61f
+  data.tar.gz: 3a15fc05522e617cf46e8709a55dc8497252503f2b995dffaa4f8995fc34a54e9bcc2a711cd501884203bf0113c7924f159377459de8f2524e9c371c018d8238

data/README.md

@@ -104,7 +104,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 Kapusta-specific additions:
 
 - `module` and `class` for Ruby host structure, including file-header forms
-- `ivar` (`@var`) / `cvar` (`@@var`) / `gvar` (`$var`) escape hatches
+- `ivar` or `@var`) / `cvar` or `@@var` / `gvar` or `$var`
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments

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
@@ -40,17 +43,20 @@ COMPATIBLE = %w[
   shapes.kap
   squares.kap
   sum.kap
+  thread-styles.kap
   tic-tac-toe.kap
   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 +106,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 +138,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/hit-counter.kap

@@ -0,0 +1,17 @@
+(class HitCounter)
+
+(set @@total 0)
+
+(fn initialize [name] (set @name name))
+
+(fn hit []
+  (set @@total (+ @@total 1))
+  (set $last-hitter @name)
+  @@total)
+
+(let [a (HitCounter.new "alice")
+      b (HitCounter.new "bob")]
+  (print (a.hit))
+  (print (b.hit))
+  (print (a.hit))
+  (print $last-hitter))

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/parking-system.kap

@@ -0,0 +1,18 @@
+(class ParkingSystem)
+
+(fn initialize [big medium small]
+  (set @big big)
+  (set @medium medium)
+  (set @small small))
+
+(fn add-car [car-type]
+  (if (and (= car-type 1) (> @big 0)) (do (set @big (- @big 1)) true)
+      (and (= car-type 2) (> @medium 0)) (do (set @medium (- @medium 1)) true)
+      (and (= car-type 3) (> @small 0)) (do (set @small (- @small 1)) true)
+      false))
+
+(let [parking (ParkingSystem.new 1 1 0)]
+  (print (parking.add-car 1))
+  (print (parking.add-car 2))
+  (print (parking.add-car 3))
+  (print (parking.add-car 1)))

data/examples/shared-macros.kapm

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

data/examples/thread-styles.kap

@@ -0,0 +1,41 @@
+(fn positive? [n] (> n 0))
+(fn square [n] (* n n))
+(fn add [x y] (+ x y))
+(fn mul [x y] (* x y))
+(fn nonzero [n] (if (= n 0) nil n))
+(fn non-empty [s] (if (= s "") nil s))
+(fn wrap [s] (.. ">>" s "<<"))
+(fn shout [s] (.. s "!"))
+
+(fn keep [pred xs]
+  (icollect [_ x (ipairs xs)]
+    (when (pred x) x)))
+
+(fn map [f xs]
+  (icollect [_ x (ipairs xs)]
+    (f x)))
+
+(fn join [sep xs]
+  (var s "")
+  (each [_ x (ipairs xs)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(let [scores [-2 3 -1 4 0 5]
+      report (->> scores
+                  (keep positive?)
+                  (map square)
+                  (join ", "))
+      adjusted (-> 7 (add 3) (mul 2) (square))
+      ok (-?> "hello" (non-empty) (wrap) (shout))
+      bad (-?> "" (non-empty) (wrap) (shout))
+      live (-?>> 5 (nonzero) (mul 3) (add 1))
+      dead (-?>> 0 (nonzero) (mul 3) (add 1))]
+  (print report)
+  (print adjusted)
+  (print ok)
+  (print bad)
+  (print live)
+  (print dead))

data/lib/kapusta/ast.rb

@@ -117,7 +117,7 @@ module Kapusta
 
   class List
     attr_reader :items
-    attr_accessor :multiline_source, :line, :column
+    attr_accessor :multiline_source, :line, :column, :sigil
 
     def initialize(items)
       @items = items

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