kapusta 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179b8b97d775c6bff99bd3d5ac3e1df1f6ab8c17637b6e16f9d688ade7f9dd06
-  data.tar.gz: 899899c13c9b1d4f85216df5d3989807d874a9ec862be94d48989f851b2d8111
+  metadata.gz: 01cc980a37ff63b56db021edb64f7ed9b4381569bb82e8e4ada099a2b17ba19e
+  data.tar.gz: 035f0f4a38d5d9fad65f4a53e8343bbcad4b681bd33dfa975f7c9c638a83ccb4
 SHA512:
-  metadata.gz: 69247136466e119860e5fee232b0bb21fa40b9d23986f09051a4acccda476a9c42b5e3e63e1382367df6c3008876af2f6a69a9b6fd2bfc0e05e1c9e69ca6a8b0
-  data.tar.gz: f65709e841e372a1dcc4c9a453d2251d58fb4fffbecd51fd1f0bcfb7c0423dc51109d6533e1b85d9b39bbc82cc994dcf64bdb5aad586c2b6476858db8e320d25
+  metadata.gz: caaeb31630a5c80607fe6c2907548c2874f177add0bdbd3555e72039dd598aaf481f91778043f6b81cd511c9ac8609e48f61c474766dac9b3e8a2fa41d408970
+  data.tar.gz: 5417ad8088be602618c3662660af820be6dbf15eb27d8300b1c542e3889fbfe1813d51ca7306f988a630616d1857f333141bf20b964d0869c2caa8c3eba869e3

data/README.md

@@ -49,7 +49,7 @@ See `examples/bank-account.kap` and `examples/use_bank_account.rb`.
 
 ## Examples
 
-See [`examples/`](https://github.com/evmorov/kapusta/tree/main/examples).
+See [`examples/`](https://github.com/evmorov/kapusta/tree/main/examples/) and [`examples-compiled/`](https://github.com/evmorov/kapusta/tree/main/examples-compiled/).
 
 ```fennel
 (fn ack [m n]
@@ -90,7 +90,6 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 | `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
 | `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
 | `with-open`, `tail!`                  | not provided                                          |
-| macros                                | not provided for now                                  |
 
 Kapusta-specific additions:
 

data/bin/check-all

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "== rspec =="
+bundle exec rspec
+
+echo "== rubocop -A =="
+bundle exec rubocop -A
+
+echo "== kapfmt =="
+for file in examples/*.kap; do ./exe/kapfmt --fix "$file"; done
+
+echo "== fennel parity =="
+bin/fennel-parity
+
+echo "== compile examples =="
+bin/compile-examples
+
+echo "== Success! =="

data/bin/fennel-parity

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'open3'
+
+ROOT = File.expand_path('..', __dir__)
+EXAMPLES = File.join(ROOT, 'examples')
+KAPUSTA = File.join(ROOT, 'exe', 'kapusta')
+KAPFMT = File.join(ROOT, 'exe', 'kapfmt')
+
+COMPATIBLE = %w[
+  ackermann.kap
+  anonymous-greeter.kap
+  climbing-stairs.kap
+  describe.kap
+  destructure.kap
+  factorial.kap
+  fib.kap
+  fizzbuzz.kap
+  gcd.kap
+  hashfn.kap
+  leap-year.kap
+  macros-dbg.kap
+  macros-multi.kap
+  macros-swap.kap
+  macros-thrice-if.kap
+  macros-unless.kap
+  macros-when-let.kap
+  match.kap
+  min-max.kap
+  or-patterns.kap
+  packet-router.kap
+  points.kap
+  primes.kap
+  safe-lookup.kap
+  shapes.kap
+  squares.kap
+  sum.kap
+  tic-tac-toe.kap
+  underscore-patterns.kap
+].freeze
+
+def run(cmd, file)
+  out, err, status = Open3.capture3(cmd, file, chdir: EXAMPLES)
+  [out, err, status]
+rescue StandardError => e
+  ['', e.message, nil]
+end
+
+def strip_outer_quotes(line)
+  if line.length >= 2 && line.start_with?('"') && line.end_with?('"')
+    line[1..-2]
+  else
+    line
+  end
+end
+
+def normalize_kapusta(out)
+  out.lines.map { |l| strip_outer_quotes(l.chomp) }
+end
+
+def normalize_fennel(out)
+  # Lua's `print` joins multiple args with TAB on one line; Ruby's `p`
+  # prints each on its own line. Split tabs so the two layouts line up.
+  out.lines.flat_map { |l| l.chomp.split("\t") }
+end
+
+def unified_diff(label_kap, kap_lines, label_fnl, fnl_lines)
+  max = [kap_lines.length, fnl_lines.length].max
+  rows = []
+  (0...max).each do |i|
+    la = kap_lines[i]
+    lb = fnl_lines[i]
+    next if la == lb
+
+    rows << format('  line %<n>3d  %<a>s: %<la>s',
+                   n: i + 1, a: label_kap, la: la.inspect)
+    rows << format('           %<b>s: %<lb>s',
+                   b: label_fnl, lb: lb.inspect)
+  end
+  rows.join("\n")
+end
+
+def check_format(path)
+  k_out, k_err, k_status = run(KAPFMT, path)
+  f_out, f_err, f_status = run('fnlfmt', path)
+
+  return "kapfmt exited #{k_status&.exitstatus}: #{k_err.strip}" if k_status.nil? || !k_status.success?
+  return "fnlfmt exited #{f_status&.exitstatus}: #{f_err.strip}" if f_status.nil? || !f_status.success?
+  return if k_out == f_out
+
+  k_lines = k_out.lines.map(&:chomp)
+  f_lines = f_out.lines.map(&:chomp)
+  "format differs:\n#{unified_diff('kapfmt', k_lines, 'fnlfmt', f_lines)}"
+end
+
+def check_run(path)
+  k_out, k_err, k_status = run(KAPUSTA, path)
+  f_out, f_err, f_status = run('fennel', path)
+
+  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?
+
+  k_lines = normalize_kapusta(k_out)
+  f_lines = normalize_fennel(f_out)
+  return if k_lines == f_lines
+
+  if k_lines.length == f_lines.length
+    "output differs:\n#{unified_diff('kapusta', k_lines, 'fennel', f_lines)}"
+  else
+    "line count differs (kapusta=#{k_lines.length}, fennel=#{f_lines.length})"
+  end
+end
+
+def check(name)
+  path = File.join(EXAMPLES, name)
+  return [:miss, "missing file: #{path}"] unless File.exist?(path)
+
+  fmt_reason = check_format(path)
+  return [:fail, fmt_reason] if fmt_reason
+
+  run_reason = check_run(path)
+  return [:fail, run_reason] if run_reason
+
+  [:ok, nil]
+end
+
+puts "Checking #{COMPATIBLE.size} compatible examples (kapfmt vs fnlfmt, kapusta vs fennel)...\n\n"
+
+failures = []
+COMPATIBLE.each do |name|
+  status, reason = check(name)
+  case status
+  when :ok
+    puts "OK    #{name}"
+  when :miss
+    failures << [name, reason]
+    puts "MISS  #{name}"
+  when :fail
+    failures << [name, reason]
+    puts "FAIL  #{name}"
+  end
+end
+
+puts
+if failures.empty?
+  puts "All #{COMPATIBLE.size} compatible examples produce matching output."
+  exit 0
+else
+  puts "#{failures.size} of #{COMPATIBLE.size} examples failed:\n\n"
+  failures.each do |name, reason|
+    puts "  * #{name}"
+    reason.each_line { |l| puts "    #{l.rstrip}" }
+    puts
+  end
+  exit 1
+end

data/examples/macros-dbg.kap

@@ -0,0 +1,9 @@
+(macro dbg [expr]
+  `(let [v# ,expr]
+     (print "dbg" v#)
+     v#))
+
+(let [result (dbg (+ 1 2 3))]
+  (print "result" result))
+
+(dbg (* 10 (+ 2 3)))

data/examples/macros-multi.kap

@@ -0,0 +1,12 @@
+(macros {:my-min (fn [x y]
+                   `(let [x# ,x
+                          y# ,y]
+                      (if (< x# y#) x# y#)))
+         :my-max (fn [x y]
+                   `(let [x# ,x
+                          y# ,y]
+                      (if (< x# y#) y# x#)))})
+
+(print (my-min 10 20))
+(print (my-max 10 20))
+(print (my-min 7 7))

data/examples/macros-swap.kap

@@ -0,0 +1,9 @@
+(macro swap! [a b]
+  `(let [tmp# ,a]
+     (set ,a ,b)
+     (set ,b tmp#)))
+
+(var x 1)
+(var y 2)
+(swap! x y)
+(print x y)

data/examples/macros-thrice-if.kap

@@ -0,0 +1,18 @@
+(macro thrice-if [condition result]
+  (fn step [i]
+    (if (< 0 i)
+        `(if ,condition
+             (do
+               ,result
+               ,(step (- i 1))))))
+
+  (step 3))
+
+(var counter 0)
+
+(fn ready? [] (< counter 5))
+
+(fn tick [] (set counter (+ counter 1)) (print "tick" counter))
+
+(thrice-if (ready?) (tick))
+(print "final" counter)

data/examples/macros-unless.kap

@@ -0,0 +1,7 @@
+(macro unless [condition & body]
+  `(if (not ,condition)
+       (do
+         ,(unpack body))))
+
+(unless false (print "shown") (print "also shown"))
+(unless true (print "hidden"))

data/examples/macros-when-let.kap

@@ -0,0 +1,7 @@
+(macro when-let [[name val] & body]
+  `(let [,name ,val]
+     (when ,name ,(unpack body))))
+
+(when-let [x (+ 1 2)] (print "got" x))
+(when-let [y nil] (print "should not print"))
+(print "done")

data/examples/packet-router.kap

@@ -1,15 +1,12 @@
 (fn inbox-line [user event]
   (match event
     [:score user points] (.. "score:" points)
-    [:profile user ?city] (if city (.. "city:" city) "city:nil")
+    [:profile user ?city] (if ?city (.. "city:" ?city) "city:nil")
     _ "other"))
 
 (fn score-delta [user event]
   (case event
-    (where (or [:bonus (= user) points] [:score (= user) points])
-      (> points 0)
-      (< points 10))
-    points
+    (where (or [:bonus (= user) p] [:score (= user) p]) (> p 0) (< p 10)) p
     _ 0))
 
 (fn packet-kind [packet]

data/examples/tic-tac-toe.kap

@@ -6,13 +6,8 @@
     [["O" _ _] ["O" _ _] ["O" _ _]] "O"
     _ "draw"))
 
-(each
-  [
-    _
-    board
-    (ipairs [
-              [["X" "X" "X"] ["O" "" ""] ["" "O" ""]]
-              [["O" "X" "X"] ["O" "" "X"] ["O" "" ""]]
-              [["X" "O" ""] ["" "X" "O"] ["" "" "X"]]
-              [["X" "O" "X"] ["O" "X" "O"] ["O" "X" "O"]]])]
+(each [_ board (ipairs [[["X" "X" "X"] ["O" "" ""] ["" "O" ""]]
+                        [["O" "X" "X"] ["O" "" "X"] ["O" "" ""]]
+                        [["X" "O" ""] ["" "X" "O"] ["" "" "X"]]
+                        [["X" "O" "X"] ["O" "X" "O"] ["O" "X" "O"]]])]
   (print (winner board)))

data/examples/ugly-number.kap

@@ -0,0 +1,22 @@
+(macro floor-div [a b]
+  `(: (/ ,a ,b) :floor))
+
+(macro divide-out! [v d]
+  `(while (= 0 (% ,v ,d))
+     (set ,v (floor-div ,v ,d))))
+
+(fn ugly? [n]
+  (var x n)
+  (if (<= n 0)
+      false
+      (do
+        (divide-out! x 2)
+        (divide-out! x 3)
+        (divide-out! x 5)
+        (= x 1))))
+
+(print (ugly? 6))
+(print (ugly? 1))
+(print (ugly? 14))
+(print (ugly? 0))
+(print (ugly? 30))

data/lib/kapusta/ast.rb

@@ -9,6 +9,8 @@ module Kapusta
     end
   end
 
+  BlankLine = Class.new
+
   class Sym
     attr_reader :name
 
@@ -74,17 +76,25 @@ module Kapusta
 
   class Vec
     attr_reader :items
+    attr_accessor :multiline_source
 
     def initialize(items)
       @items = items
+      @multiline_source = false
+    end
+
+    def to_ary
+      @items
     end
   end
 
   class HashLit
     attr_reader :entries
+    attr_accessor :multiline_source
 
     def initialize(entries)
       @entries = entries
+      @multiline_source = false
     end
 
     def pairs
@@ -98,9 +108,11 @@ module Kapusta
 
   class List
     attr_reader :items
+    attr_accessor :multiline_source
 
     def initialize(items)
       @items = items
+      @multiline_source = false
     end
 
     def head
@@ -115,4 +127,34 @@ module Kapusta
       @items.empty?
     end
   end
+
+  class AutoGensym < Sym
+    def inspect
+      "#<AutoGensym #{@name}#>"
+    end
+  end
+
+  class Quasiquote
+    attr_reader :form
+
+    def initialize(form)
+      @form = form
+    end
+  end
+
+  class Unquote
+    attr_reader :form
+
+    def initialize(form)
+      @form = form
+    end
+  end
+
+  class UnquoteSplice
+    attr_reader :form
+
+    def initialize(form)
+      @form = form
+    end
+  end
 end

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

@@ -96,11 +96,45 @@ module Kapusta
           when '/' then emit_div(args, env, current_scope)
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
           when 'print' then emit_print(args, env, current_scope)
+          when 'quasi-sym' then "Kapusta::Sym.new(#{emit_expr(args[0], env, current_scope)})"
+          when 'quasi-list' then "Kapusta::List.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-list-tail' then emit_quasi_list_tail(args, env, current_scope)
+          when 'quasi-vec' then "Kapusta::Vec.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-vec-tail' then emit_quasi_vec_tail(args, env, current_scope)
+          when 'quasi-hash' then emit_quasi_hash(args, env, current_scope)
+          when 'quasi-gensym' then emit_quasi_gensym(args[0], env, current_scope)
+          when 'macro', 'macros', 'import-macros'
+            emit_error!("#{name} must appear at the top level and is consumed by the macro expander")
           else
             emit_error!("unknown special form: #{name}")
           end
         end
 
+        def emit_quasi_list_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::List.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_vec_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::Vec.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_gensym(arg, env, current_scope)
+          "Kapusta::Compiler::MacroExpander.fresh_gensym(#{emit_expr(arg, env, current_scope)})"
+        end
+
+        def emit_quasi_hash(args, env, current_scope)
+          pairs = args.each_slice(2).map do |key, value|
+            "[#{emit_expr(key, env, current_scope)}, #{emit_expr(value, env, current_scope)}]"
+          end
+          "Kapusta::HashLit.new([#{pairs.join(', ')}])"
+        end
+
         def emit_concat(args, env, current_scope)
           return '""' if args.empty?
 

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

@@ -79,8 +79,7 @@ module Kapusta
             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)
+              ruby_name = define_local(current_env, sub.name)
               lines << "#{ruby_name} = #{access}"
             else
               sub_code, current_env = try_emit_native_pattern_bind(sub, access, current_env) ||
@@ -96,8 +95,7 @@ module Kapusta
           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 = define_local(env, pattern.name)
             [ruby_name, env, nil]
           when Vec
             inner = []
@@ -137,8 +135,7 @@ module Kapusta
 
           return '*' if sym.name == '_'
 
-          bind_name = sym.name.start_with?('?') ? sym.name.delete_prefix('?') : sym.name
-          "*#{define_local(env, bind_name)}"
+          "*#{define_local(env, sym.name)}"
         end
 
         class PatternNotTranslatable < StandardError; end
@@ -179,12 +176,11 @@ module Kapusta
           return '_' if name == '_'
 
           if nil_allowing_pattern_name?(name)
-            bind_name = name.start_with?('?') ? name.delete_prefix('?') : name
-            raise PatternNotTranslatable if state[:bound_names].key?(bind_name)
+            raise PatternNotTranslatable if state[:bound_names].key?(name)
 
-            state[:bound_names][bind_name] = true
-            state[:binding_names] << bind_name
-            sanitize_local(bind_name)
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+            sanitize_local(name)
           else
             binding = mode == :match ? env.lookup_if_defined(name) : nil
             if state[:bound_names].key?(name)

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

@@ -263,7 +263,8 @@ module Kapusta
 
         def sanitize_local(name)
           base = Kapusta.kebab_to_snake(name.respond_to?(:name) ? name.name : name)
-          base = base.gsub('?', '_q').gsub('!', '_bang')
+          base = base.sub(/\A\?/, 'q_').gsub('?', '_q')
+          base = base.sub(/\A!/, 'bang_').gsub('!', '_bang')
           base = base.gsub(/[^a-zA-Z0-9_]/, '_')
           if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)
             base = "_#{base}"