kapusta 0.2.4 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef91159e2623e199fc391fa483440fa9f8ca76f273fbc31caeb0b07e891ee92c
-  data.tar.gz: 5468818f0ad4b0509a31635d886f3374009e3e8499a197d82f99da22c53e3a12
+  metadata.gz: 01cc980a37ff63b56db021edb64f7ed9b4381569bb82e8e4ada099a2b17ba19e
+  data.tar.gz: 035f0f4a38d5d9fad65f4a53e8343bbcad4b681bd33dfa975f7c9c638a83ccb4
 SHA512:
-  metadata.gz: 7bcc51b164c21357c2aa2ef52e4e544cba0116ca8d8b6b1c02ecb55dc62697508a3cbb22d4c56a0a7cf0da77f53d7500827ecd2debe0760fec34ebe4d992be07
-  data.tar.gz: 40b1b709b5e083b94584424f9fb2ad7c3ec6908786ea80051173df8edaa380b9b5b76d0c485a6377f7e77bbed5799633501204d7a39acf0b919eb74197fabcf2
+  metadata.gz: caaeb31630a5c80607fe6c2907548c2874f177add0bdbd3555e72039dd598aaf481f91778043f6b81cd511c9ac8609e48f61c474766dac9b3e8a2fa41d408970
+  data.tar.gz: 5417ad8088be602618c3662660af820be6dbf15eb27d8300b1c542e3889fbfe1813d51ca7306f988a630616d1857f333141bf20b964d0869c2caa8c3eba869e3

data/README.md

@@ -8,6 +8,12 @@ Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. W
 
 For more information about Kapusta, see the official Fennel documentation and tutorials.
 
+## Features
+
+1. Compiles to readable Ruby.
+2. Compiled `.rb` files don't depend on Kapusta. Run with plain `ruby`, or load `.kap` files at runtime via `require 'kapusta'`.
+3. Two-way Ruby interop.
+
 ## Usage
 
 ```
@@ -43,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]
@@ -84,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/manhattan-distance.kap

@@ -0,0 +1,9 @@
+(fn manhattan [edge]
+  (let [{:from [x1 y1] :to [x2 y2]} edge]
+    (+ (: (- x1 x2) :abs) (: (- y1 y2) :abs))))
+
+(fn total-distance [edges]
+  (accumulate [total 0 _ edge (ipairs edges)]
+    (+ total (manhattan edge))))
+
+(print (total-distance [{:from [0 0] :to [3 4]} {:from [1 1] :to [4 5]}]))

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/subtract-product-sum.kap

@@ -0,0 +1,14 @@
+(fn subtract-product-sum [n]
+  (var x n)
+  (var product 1)
+  (var sum 0)
+  (while (> x 0)
+    (let [d (% x 10)]
+      (set product (* product d))
+      (set sum (+ sum d))
+      (set x (: (/ x 10) :floor))))
+  (- product sum))
+
+(print (subtract-product-sum 234))
+(print (subtract-product-sum 4421))
+(print (subtract-product-sum 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,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/bindings.rb

@@ -281,12 +281,23 @@ module Kapusta
               else
                 define_local(env, target.name)
               end
-            ["#{ruby_name} = #{value_code}", env]
+            [emit_assignment(ruby_name, value_code), env]
           else
             [emit_set_target(target, value_code, env, current_scope), env]
           end
         end
 
+        def emit_assignment(lhs, value_code)
+          prefix = "#{lhs} "
+          if value_code.start_with?(prefix) &&
+             (m = value_code[prefix.length..].match(/\A(\S+) (.*)\z/m)) &&
+             !m[1].include?('=')
+            "#{lhs} #{m[1]}= #{m[2]}"
+          else
+            "#{lhs} = #{value_code}"
+          end
+        end
+
         def emit_set_expr(args, env, current_scope)
           target = args[0]
           value_code = emit_expr(args[1], env, current_scope)
@@ -302,7 +313,7 @@ module Kapusta
               last = segments.last
               snake = Kapusta.kebab_to_snake(last)
               if direct_method_name?(last)
-                "#{receiver}.#{snake} = #{value_code}"
+                emit_assignment("#{receiver}.#{snake}", value_code)
               else
                 "#{receiver}.public_send(:\"#{snake}=\", #{value_code})"
               end
@@ -310,7 +321,7 @@ module Kapusta
               binding = env.lookup(target.name)
               emit_error!("cannot set method binding: #{target.name}") if method_binding?(binding)
 
-              "#{binding} = #{value_code}"
+              emit_assignment(binding, value_code)
             end
           when List
             head = target.head
@@ -319,13 +330,13 @@ module Kapusta
               keys = target.items[2..].map { |item| emit_expr(item, env, current_scope) }
               receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
               prefix = keys[0...-1].map { |k| "[#{k}]" }.join
-              "#{receiver}#{prefix}[#{keys.last}] = #{value_code}"
+              emit_assignment("#{receiver}#{prefix}[#{keys.last}]", value_code)
             elsif head.is_a?(Sym) && head.name == 'ivar'
-              "@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
+              emit_assignment("@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
             elsif head.is_a?(Sym) && head.name == 'cvar'
-              "@@#{Kapusta.kebab_to_snake(target.items[1].name)} = #{value_code}"
+              emit_assignment("@@#{Kapusta.kebab_to_snake(target.items[1].name)}", value_code)
             elsif head.is_a?(Sym) && head.name == 'gvar'
-              "$#{global_name(target.items[1].name)} = #{value_code}"
+              emit_assignment("$#{global_name(target.items[1].name)}", value_code)
             else
               emit_error!("bad set target: #{target.inspect}")
             end