kapusta 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179b8b97d775c6bff99bd3d5ac3e1df1f6ab8c17637b6e16f9d688ade7f9dd06
-  data.tar.gz: 899899c13c9b1d4f85216df5d3989807d874a9ec862be94d48989f851b2d8111
+  metadata.gz: f58b2e1f81723470a819ba38e3e6e811a3aa3a97ba79443e6ad0c59457d0fa08
+  data.tar.gz: 9207c1491218f71eeeedf2495a22805b9e2d1a8336200d212437fb813005c1d8
 SHA512:
-  metadata.gz: 69247136466e119860e5fee232b0bb21fa40b9d23986f09051a4acccda476a9c42b5e3e63e1382367df6c3008876af2f6a69a9b6fd2bfc0e05e1c9e69ca6a8b0
-  data.tar.gz: f65709e841e372a1dcc4c9a453d2251d58fb4fffbecd51fd1f0bcfb7c0423dc51109d6533e1b85d9b39bbc82cc994dcf64bdb5aad586c2b6476858db8e320d25
+  metadata.gz: 9e0e2220a388a1a06ed86733e01fbc1eacf3a48536c503e7e8ccbcf85871fcda35cce16ddc9b434f3d1ac3c8dc23cb15af3d78528fc269fae62d25ef49a6fba2
+  data.tar.gz: 3a0f8628514de972b1def03cfd8f47798b630632fe728a41d46a0c9aade7587c011004695903697b929fd82c3302bf90c7efdc7d5e4edb7f0ab7bd3c9c1c7387

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,187 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'open3'
+
+ROOT = File.expand_path('..', __dir__)
+EXAMPLES = File.join(ROOT, 'examples')
+EXAMPLES_ERRORS = File.join(ROOT, 'examples-errors')
+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
+  even-squares.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, chdir: EXAMPLES)
+  out, err, status = Open3.capture3(cmd, file, chdir:)
+  [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
+
+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)
+
+  return [:fail, 'fennel unexpectedly succeeded'] if f_status&.success?
+  return [:fail, "kapusta unexpectedly succeeded (exit #{k_status&.exitstatus})"] if k_status&.success?
+
+  [: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
+
+error_files = Dir.children(EXAMPLES_ERRORS).select { |n| n.end_with?('.kap') }.sort
+puts "\nChecking #{error_files.size} error examples (both kapusta and fennel must fail)...\n\n"
+
+error_failures = []
+error_files.each do |name|
+  status, reason = check_error(name)
+  case status
+  when :ok
+    puts "OK    #{name}"
+  when :fail
+    error_failures << [name, reason]
+    puts "FAIL  #{name}"
+  end
+end
+
+puts
+total_failures = failures + error_failures
+total = COMPATIBLE.size + error_files.size
+if total_failures.empty?
+  puts "All #{total} examples (#{COMPATIBLE.size} compatible + #{error_files.size} error) match expectations."
+  exit 0
+else
+  puts "#{total_failures.size} of #{total} examples failed:\n\n"
+  total_failures.each do |name, reason|
+    puts "  * #{name}"
+    reason.each_line { |l| puts "    #{l.rstrip}" }
+    puts
+  end
+  exit 1
+end

data/examples/even-squares.kap

@@ -1,7 +1,22 @@
-(let [
-  even-squares
-  (-> [1 2 3 4 5 6]
-      (: :select (fn [n] (n.even?)))
-      (: :map (fn [n] (* n n))))
-]
-  (print (even-squares.join ", ")))
+(fn even? [n] (= 0 (% n 2)))
+
+(fn select [tbl pred]
+  (icollect [_ x (ipairs tbl)]
+    (when (pred x) x)))
+
+(fn map [tbl f]
+  (icollect [_ x (ipairs tbl)]
+    (f x)))
+
+(fn join [tbl sep]
+  (var s "")
+  (each [_ x (ipairs tbl)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(let [xs [1 2 3 4 5 6]
+      filtered (select xs even?)
+      squared (map filtered #(* $ $))]
+  (print (join squared ", ")))

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/roman-to-integer.kap

@@ -1,12 +1,12 @@
 (fn roman-to-integer [s]
-  (let [values {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000}
+  (let [value-map {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000}
         chars (s.chars)
         n (length chars)]
     (var total 0)
     (var i 0)
     (while (< i n)
-      (let [curr (. values (. chars i))
-            ahead (if (< (+ i 1) n) (. values (. chars (+ i 1))) 0)
+      (let [curr (. value-map (. chars i))
+            ahead (if (< (+ i 1) n) (. value-map (. chars (+ i 1))) 0)
             subtract? (< curr ahead)]
         (set total (+ total (if subtract? (- ahead curr) curr)))
         (set i (+ i (if subtract? 2 1)))))

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,8 +9,11 @@ module Kapusta
     end
   end
 
+  BlankLine = Class.new
+
   class Sym
     attr_reader :name
+    attr_accessor :line, :column
 
     def initialize(name)
       @name = name.to_s
@@ -21,7 +24,7 @@ module Kapusta
     end
 
     def inspect
-      "#<Sym #{@name}>"
+      @name.to_s
     end
 
     def ==(other)
@@ -74,17 +77,33 @@ module Kapusta
 
   class Vec
     attr_reader :items
+    attr_accessor :multiline_source, :line, :column
 
     def initialize(items)
       @items = items
+      @multiline_source = false
+    end
+
+    def to_ary
+      @items
+    end
+
+    def inspect
+      "[#{@items.map(&:inspect).join(' ')}]"
     end
   end
 
   class HashLit
     attr_reader :entries
+    attr_accessor :multiline_source, :line, :column
 
     def initialize(entries)
       @entries = entries
+      @multiline_source = false
+    end
+
+    def inspect
+      pairs.map { |k, v| "#{k.inspect} #{v.inspect}" }.then { |p| "{#{p.join(' ')}}" }
     end
 
     def pairs
@@ -98,9 +117,11 @@ module Kapusta
 
   class List
     attr_reader :items
+    attr_accessor :multiline_source, :line, :column
 
     def initialize(items)
       @items = items
+      @multiline_source = false
     end
 
     def head
@@ -114,5 +135,60 @@ module Kapusta
     def empty?
       @items.empty?
     end
+
+    def inspect
+      "(#{@items.map(&:inspect).join(' ')})"
+    end
+  end
+
+  class AutoGensym < Sym
+    def inspect
+      "#<AutoGensym #{@name}#>"
+    end
+  end
+
+  class MacroSym < Sym
+    def inspect
+      "#<MacroSym #{@name}>"
+    end
+  end
+
+  class Quasiquote
+    attr_reader :form
+    attr_accessor :line, :column
+
+    def initialize(form)
+      @form = form
+    end
+
+    def inspect
+      "`#{@form.inspect}"
+    end
+  end
+
+  class Unquote
+    attr_reader :form
+    attr_accessor :line, :column
+
+    def initialize(form)
+      @form = form
+    end
+
+    def inspect
+      ",#{@form.inspect}"
+    end
+  end
+
+  class UnquoteSplice
+    attr_reader :form
+    attr_accessor :line, :column
+
+    def initialize(form)
+      @form = form
+    end
+
+    def inspect
+      ",@#{@form.inspect}"
+    end
   end
 end

data/lib/kapusta/cli.rb

@@ -26,6 +26,9 @@ module Kapusta
       else
         run_file(args)
       end
+    rescue Kapusta::Error => e
+      warn e.formatted
+      exit 1
     end
 
     def self.parse_options(args)

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

@@ -13,6 +13,8 @@ module Kapusta
             name_sym = args[0]
             pattern = args[1]
             body = args[2..]
+            emit_error!(:fn_no_params) unless name_sym.is_a?(Sym) && pattern.is_a?(Vec)
+
             fn_env = env.child
             ruby_name = define_local(fn_env, name_sym.name)
             <<~RUBY.chomp
@@ -59,7 +61,9 @@ module Kapusta
         end
 
         def simple_parameter_pattern?(pattern)
-          pattern.is_a?(Vec) && pattern.items.all? { |item| item.is_a?(Sym) && !item.dotted? && item.name != '&' }
+          pattern.is_a?(Vec) && pattern.items.all? do |item|
+            item.is_a?(Sym) && (!item.dotted? || item.name == '...') && item.name != '&'
+          end
         end
 
         def emit_definition_form(form, env, current_scope)
@@ -227,6 +231,9 @@ module Kapusta
 
         def emit_let_parts(args, env, current_scope, result:)
           bindings = args[0]
+          emit_error!(:let_odd_bindings) if bindings.items.length.odd?
+          emit_error!(:let_no_body) if args.length < 2
+
           body = args[1..]
           child_env = env.child
           binding_codes = []
@@ -234,7 +241,9 @@ module Kapusta
           i = 0
           while i < items.length
             pattern = items[i]
-            value_code = emit_expr(items[i + 1], child_env, current_scope)
+            value_form = items[i + 1]
+            check_destructure_value!(pattern, value_form)
+            value_code = emit_expr(value_form, child_env, current_scope)
             bind_code, child_env = emit_pattern_bind(pattern, value_code, child_env)
             binding_codes << bind_code
             i += 2
@@ -250,11 +259,15 @@ module Kapusta
         end
 
         def emit_local_form(form, env, current_scope)
+          emit_error!(:local_arity, form: form.head.name) unless form.items.length == 3
+
           target = form.items[1]
           value_code = emit_expr(form.items[2], env, current_scope)
 
           if target.is_a?(Sym)
+            validate_binding_symbol!(target)
             ruby_name = define_local(env, target.name)
+            mark_mutability(env, target.name, mutable: form.head.name == 'var')
             ["#{ruby_name} = #{value_code}\nnil", env]
           else
             bind_code, env = emit_pattern_bind(target, value_code, env)
@@ -262,11 +275,43 @@ module Kapusta
           end
         end
 
+        def check_destructure_value!(pattern, value_form)
+          return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
+
+          case value_form
+          when String, Numeric, Symbol, true, false
+            emit_error!(:could_not_destructure_literal)
+          end
+        end
+
+        def mark_mutability(env, name, mutable:)
+          @binding_mutability ||= {}
+          ruby_name = env.lookup(name)
+          @binding_mutability[ruby_name] = mutable
+        end
+
+        def mutable_binding?(env, name)
+          ruby_name = env.lookup_if_defined(name)
+          return false unless ruby_name
+
+          (@binding_mutability ||= {}).fetch(ruby_name, true)
+        end
+
         def emit_local_expr(args, env, current_scope)
           code, = emit_local_form(List.new([Sym.new('local'), *args]), env.child, current_scope)
           "(-> do\n#{indent(code)}\nend).call"
         end
 
+        def emit_global_expr(args, _env, _current_scope)
+          emit_error!(:global_arity) unless args.length == 2
+          unless args[0].is_a?(Sym)
+            emit_error!(:global_non_symbol_name, type: args[0].class.name.downcase, value: args[0].inspect)
+          end
+
+          name = args[0].name
+          "$#{global_name(name)} = #{emit_expr(args[1], Env.new, :toplevel)}\nnil"
+        end
+
         def emit_set_form(form, env, current_scope)
           target = form.items[1]
           value_code = emit_expr(form.items[2], env, current_scope)
@@ -275,7 +320,7 @@ module Kapusta
             binding = env.lookup_if_defined(target.name)
             ruby_name =
               if binding
-                emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
+                emit_error!(:cannot_set_method_binding, name: target.name) if method_binding?(binding)
 
                 binding
               else
@@ -319,7 +364,8 @@ module Kapusta
               end
             else
               binding = env.lookup(target.name)
-              emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
+              emit_error!(:cannot_set_method_binding, name: target.name) if method_binding?(binding)
+              emit_error!(:expected_var, name: target.name) unless mutable_binding?(env, target.name)
 
               emit_assignment(binding, value_code)
             end
@@ -338,10 +384,10 @@ module Kapusta
             elsif head.is_a?(Sym) && head.name == 'gvar'
               emit_assignment("$#{global_name(target.items[1].name)}", value_code)
             else
-              emit_error!("bad set target: #{target.inspect}")
+              emit_error!(:bad_set_target, target: target.inspect)
             end
           else
-            emit_error!("bad set target: #{target.inspect}")
+            emit_error!(:bad_set_target, target: target.inspect)
           end
         end
       end