kapusta 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f08d47c985c44cde4016b3f4188f1a59a4a4b72ae752d3876af8ab7c66c12069
+  data.tar.gz: d9b96c75f4a99de5bbdb9e7bdbdf258bfda5bf7791d13ffe2d115a655627f8b0
+SHA512:
+  metadata.gz: f936f5546667301b2bf9a96f0a16f8b61f6ea0b6fefc6c10a87c8a794b60b376274d2672b24e2a23b269adc3d932d418442dfdbce6d8957569a6ae426d0a3a4f
+  data.tar.gz: fb523b8572d114ee9e5b87c4a993607b9ab610a82f3aa0886a1465064877d956768fde168f7e58e2cfe2f31cddc8efddf82473d6addeab97f7c112d8d1fadcbb

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-I lib

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', require: false
+end

data/README.md

@@ -0,0 +1,58 @@
+# Kapusta
+
+Kapusta is a Lisp for the Ruby runtime.
+
+It is inspired by Fennel. It is not intended to be production-ready like Clojure: that would be a lot of work, and Ruby is already a rich, elegant language.
+
+Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. Where Lua is intentionally minimal, and Fennel follows that design for good reason, Kapusta exists mostly for fun. You can use it for small apps, LeetCode, DragonRuby, or maybe even Rails.
+
+For more information about Kapusta, see the official Fennel documentation and tutorials.
+
+## Usage
+
+```
+exe/kapusta examples/fizzbuzz.kap
+```
+
+or
+
+```
+exe/kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
+ruby examples/fizzbuzz.rb
+```
+
+## Comparison with Fennel
+
+Kapusta keeps most core Fennel forms. The main differences come from Ruby's runtime and object model.
+
+| Fennel                                | Kapusta                                               |
+|---------------------------------------|-------------------------------------------------------|
+| Lua stdlib                            | Ruby stdlib                                           |
+| `:foo` is a Lua string                | `:foo` is a Ruby symbol                               |
+| `(. xs 1)` is the first element       | `(. xs 0)` is the first element                       |
+| `string.format`, `table.insert`, etc. | use Ruby methods and stdlib instead                   |
+| `values` uses Lua multiple returns    | `values` lowers to a Ruby array, usually destructured |
+| `with-open`, `tail!`                  | not provided                                          |
+
+Kapusta-specific additions:
+
+- `module` and `class` for Ruby host structure, including file-header forms
+- `ivar` / `cvar` / `gvar` escape hatches
+- `try` / `catch` / `finally` plus `raise` for exceptions
+- `(ruby "...")` raw host escape hatch
+- a trailing symbol-keyed hash is emitted as Ruby keyword arguments
+- a final function literal argument is emitted as a Ruby block
+
+## Examples
+
+See `examples/`.
+
+## Formatting
+
+```
+exe/kapfmt
+```
+
+## Syntax highlight
+
+For Vim you can use https://git.sr.ht/~m15a/vim-fennel-syntax

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
+
+RuboCop::RakeTask.new(:rubocop)
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'kapusta'
+require 'irb'
+
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bundle install

data/examples/accumulator.kap

@@ -0,0 +1,16 @@
+(class Accumulator)
+
+(fn initialize [start]
+  (set (ivar total) start))
+
+(fn add! [n]
+  (set (ivar total) (+ (ivar total) n))
+  self)
+
+(fn value []
+  (ivar total))
+
+(let [acc (Accumulator.new 10)]
+  (acc.add! 5)
+  (acc.add! 7)
+  (puts (acc.value)))

data/examples/ackermann.kap

@@ -0,0 +1,7 @@
+(fn ack [m n]
+  (if (= m 0) (+ n 1)
+      (= n 0) (ack (- m 1) 1)
+      (ack (- m 1) (ack m (- n 1)))))
+
+(print (ack 2 3))
+(print (ack 3 3))

data/examples/anagram.kap

@@ -0,0 +1,13 @@
+(fn normalize-word [word]
+  (let [lower (word.downcase)
+        chars (lower.chars)
+        sorted (chars.sort)]
+    (sorted.join)))
+
+(fn anagram? [a b]
+  (= (normalize-word a)
+    (normalize-word b)))
+
+(puts (anagram? "listen" "silent"))
+(puts (anagram? "apple" "papel"))
+(puts (anagram? "hello" "world"))

data/examples/binary-search.kap

@@ -0,0 +1,16 @@
+(fn binary-search [xs target]
+  (var lo 0)
+  (var hi (- (length xs) 1))
+  (var answer nil)
+  (while (and (<= lo hi) (= answer nil))
+    (let [mid (: (/ (+ lo hi) 2) :floor)
+          guess (. xs mid)]
+      (if (= guess target) (set answer mid)
+          (< guess target) (set lo (+ mid 1))
+          (set hi (- mid 1)))))
+  answer)
+
+(let [found (binary-search [1 3 5 7 9 11] 7)
+      missing (binary-search [1 3 5 7 9 11] 2)]
+  (puts found)
+  (puts (missing.inspect)))

data/examples/block-sort.kap

@@ -0,0 +1,3 @@
+(let [xs [3 1 2]
+      sorted (xs.sort (fn [a b] (b.<=> a)))]
+  (puts (sorted.join ", ")))

data/examples/calc.kap

@@ -0,0 +1,10 @@
+(fn eval-expr [expr]
+  (case expr
+    [:num n] n
+    [:add a b] (+ (eval-expr a) (eval-expr b))
+    [:sub a b] (- (eval-expr a) (eval-expr b))
+    [:mul a b] (* (eval-expr a) (eval-expr b))
+    [:div a b] (/ (eval-expr a) (eval-expr b))
+    _ (raise (ArgumentError.new (.. "unknown op: " (expr.inspect))))))
+
+(puts (eval-expr [:add [:num 2] [:mul [:num 3] [:num 4]]]))

data/examples/counter.kap

@@ -0,0 +1,19 @@
+(class Counter)
+
+(fn initialize [start]
+  (set (ivar n) start))
+
+(fn tick []
+  (set (ivar n) (+ (ivar n) 1))
+  (ivar n))
+
+(fn value []
+  (ivar n))
+
+(fn self.zero []
+  (Counter.new 0))
+
+(let [c (Counter.new 10)]
+  (c.tick)
+  (c.tick)
+  (puts (c.value)))

data/examples/describe.kap

@@ -0,0 +1,9 @@
+(fn describe [x]
+  (case x
+    0 "zero"
+    1 "one"
+    (where n (< n 0)) "negative"
+    _ "many"))
+
+(each [_ n (ipairs [-3 0 1 2 99])]
+  (print n (describe n)))

data/examples/destructure.kap

@@ -0,0 +1,4 @@
+(let [[a b c] [1 2 3]
+      {: name : age} {:name "Ada" :age 36}]
+  (print (+ a b c))
+  (print name age))

data/examples/doto.kap

@@ -0,0 +1,2 @@
+(let [xs (doto [] (: :push 1) (: :push 2) (: :push 3))]
+  (puts (xs.join ", ")))

data/examples/egg-count.kap

@@ -0,0 +1,10 @@
+(fn egg-count [number]
+  (local odd? #(> (% $ 2) 0))
+  (var n number)
+  (var eggs 0)
+  (while (> n 0)
+    (when (odd? n) (set eggs (+ eggs 1)))
+    (set n (: (/ n 2) :floor)))
+  eggs)
+
+(print (egg-count 30))

data/examples/even-squares.kap

@@ -0,0 +1,7 @@
+(let [
+  even-squares
+  (-> [1 2 3 4 5 6]
+      (: :select (fn [n] (n.even?)))
+      (: :map (fn [n] (* n n))))
+]
+  (puts (even-squares.join ", ")))

data/examples/exceptions.kap

@@ -0,0 +1,14 @@
+(fn require-score [s]
+  (if (= s "oops")
+      (raise (ArgumentError.new "not a number"))
+      (Integer s)))
+
+(fn parse-score [s]
+  (try (require-score s)
+    (catch ArgumentError e
+      (.. "bad: " s))
+    (finally
+      (puts (.. "seen: " s)))))
+
+(each [_ s (ipairs ["12" "oops"])]
+  (puts (parse-score s)))

data/examples/factorial.kap

@@ -0,0 +1,8 @@
+(fn factorial [n]
+  (case n
+    0 1
+    1 1
+    _ (* n (factorial (- n 1)))))
+
+(each [_ n (ipairs [0 1 5 6 10])]
+  (print n (factorial n)))

data/examples/fib.kap

@@ -0,0 +1,4 @@
+(fn fib [n]
+  (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
+
+(print (fib 10))

data/examples/fizzbuzz.kap

@@ -0,0 +1,7 @@
+(for [n 1 20]
+  (let [d3? (= 0 (% n 3))
+        d5? (= 0 (% n 5))]
+    (if (and d3? d5?) (print "FizzBuzz")
+        d3? (print "Fizz")
+        d5? (print "Buzz")
+        (print n))))

data/examples/gcd.kap

@@ -0,0 +1,5 @@
+(fn gcd [a b]
+  (if (= b 0) a (gcd b (% a b))))
+
+(print (gcd 48 36))
+(print (gcd 270 192))

data/examples/greet.kap

@@ -0,0 +1,2 @@
+(let [name (or (. ARGV 0) "world")]
+  (puts (.. "Hello, " name "!")))

data/examples/hashfn.kap

@@ -0,0 +1,4 @@
+(let [add #(+ $1 $2)
+      triple #(* 3 $)]
+  (print (add 2 3))
+  (print (triple 7)))

data/examples/kwargs.kap

@@ -0,0 +1 @@
+(puts (format "%<name>s has %<count>d tasks" {:name "Ada" :count 3}))

data/examples/leap-year.kap

@@ -0,0 +1,5 @@
+(fn leap-year? [y]
+  (let [div? #(= 0 (% $1 $2))]
+    (and (div? y 4) (or (not (div? y 100)) (div? y 400)))))
+
+(print (leap-year? 2000))

data/examples/match.kap

@@ -0,0 +1,9 @@
+(fn describe-user [user]
+  (match user
+    {: name :stats {: score}} (.. name ": " score)
+    {: name} (.. name ": no score")
+    _ "unknown"))
+
+(puts (describe-user {:name "Ada" :stats {:score 9}}))
+(puts (describe-user {:name "Lin"}))
+(puts (describe-user {}))

data/examples/min-max.kap

@@ -0,0 +1,11 @@
+(fn min-max [xs]
+  (let [[first & rest] xs]
+    (var lo first)
+    (var hi first)
+    (each [_ x (ipairs rest)]
+      (when (< x lo) (set lo x))
+      (when (> x hi) (set hi x)))
+    [lo hi]))
+
+(let [[lo hi] (min-max [3 1 4 1 5 9 2 6])]
+  (print lo hi))

data/examples/module-header.kap

@@ -0,0 +1,6 @@
+(module HeaderDemo)
+
+(fn self.greet [name]
+  (.. "Hello, " name "!"))
+
+(puts (self.greet "Ada"))

data/examples/palindrome.kap

@@ -0,0 +1,8 @@
+(fn palindrome? [s]
+  (let [lower (s.downcase)
+        normalized (lower.gsub (ruby "/[^a-z]/") "")]
+    (= normalized (normalized.reverse))))
+
+(puts (palindrome? "racecar"))
+(puts (palindrome? "A man, a plan, a canal: Panama"))
+(puts (palindrome? "kapusta"))

data/examples/pangram.kap

@@ -0,0 +1,9 @@
+(fn pangram? [s]
+  (let [lower (s.downcase)
+        letters (lower.gsub (ruby "/[^a-z]/") "")
+        chars (letters.chars)
+        uniq (chars.uniq)]
+    (= (uniq.length) 26)))
+
+(puts (pangram? "The quick brown fox jumps over the lazy dog"))
+(puts (pangram? "Hello, world"))

data/examples/pcall.kap

@@ -0,0 +1,9 @@
+(let [[ok value] (pcall Integer "12")
+      [bad-ok error] (pcall Integer "oops")
+      [handled-ok handled] (xpcall Integer (fn [e] (e.message)) "oops")]
+  (puts ok)
+  (puts value)
+  (puts bad-ok)
+  (puts (error.class))
+  (puts handled-ok)
+  (puts handled))

data/examples/pipeline.kap

@@ -0,0 +1,6 @@
+(let [words ["red" "green" "blue" "black" "olive"]]
+  (-> words
+      (: :select (fn [w] (< (length w) 5)))
+      (: :map (fn [w] (w.upcase)))
+      (: :sort)
+      (: :each (fn [w] (puts w)))))

data/examples/points.kap

@@ -0,0 +1,9 @@
+(fn point-kind [point]
+  (case point
+    [0 0] "origin"
+    [0 _] "y-axis"
+    [_ 0] "x-axis"
+    [_ _] "point"))
+
+(each [_ point (ipairs [[0 0] [0 2] [3 0] [3 4]])]
+  (puts (point-kind point)))

data/examples/primes.kap

@@ -0,0 +1,8 @@
+(fn prime? [n]
+  (var ok true)
+  (for [d 2 (- n 1) &until (not ok)]
+    (when (= 0 (% n d)) (set ok false)))
+  (and (> n 1) ok))
+
+(let [ps (fcollect [n 2 30] (when (prime? n) n))]
+  (each [_ p (ipairs ps)] (print p)))

data/examples/raindrops.kap

@@ -0,0 +1,13 @@
+(fn raindrops [n]
+  (local div? #(= 0 (% $1 $2)))
+  (local empty? #(= 0 (length $1)))
+  (local drops [])
+  (local add-drop #(drops.push $1))
+  (when (div? n 3) (add-drop "Pling"))
+  (when (div? n 5) (add-drop "Plang"))
+  (when (div? n 7) (add-drop "Plong"))
+  (if (empty? drops)
+      (tostring n)
+      (drops.join)))
+
+(print (raindrops 15))

data/examples/record.kap

@@ -0,0 +1,6 @@
+(fn format-record [record]
+  (let [{: name : role : tags} record]
+    (.. name " / " role " / " (tags.join ", "))))
+
+(let [record {:name "Ada" :role "engineer" :tags ["ruby" "lisp"]}]
+  (puts (format-record record)))

data/examples/regex.kap

@@ -0,0 +1,9 @@
+(fn parse-date [s]
+  (let [re (ruby "/\\A(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})\\z/")]
+    (case (re.match s)
+      nil nil
+      m (m.named-captures))))
+
+(each [_ s (ipairs ["2026-04-23" "hello" "1999-12-31"])]
+  (let [parsed (parse-date s)]
+    (puts (.. s " -> " (parsed.inspect)))))

data/examples/ruby-eval.kap

@@ -0,0 +1 @@
+(puts (ruby "[1, 2, 3].map { _1 * 10 }.join('-')"))

data/examples/safe-lookup.kap

@@ -0,0 +1,6 @@
+(let [user {:profile {:name "Ada"}}
+      missing {}
+      name (?. user :profile :name)
+      missing-name (?. missing :profile :name)]
+  (puts name)
+  (puts (missing-name.inspect)))

data/examples/scopes.kap

@@ -0,0 +1,18 @@
+(class ScopeCounter)
+
+(set (cvar total) 0)
+
+(fn add! [n]
+  (set (cvar total) (+ (cvar total) n))
+  (set (gvar last-total) (cvar total))
+  (cvar total))
+
+(fn self.total []
+  (cvar total))
+
+(let [a (ScopeCounter.new)
+      b (ScopeCounter.new)]
+  (puts (a.add! 5))
+  (puts (b.add! 4))
+  (puts (ScopeCounter.total))
+  (puts (gvar last-total)))

data/examples/shapes.kap

@@ -0,0 +1,9 @@
+(fn area [shape]
+  (case shape
+    [:circle r] (* 3.14 r r)
+    [:square s] (* s s)
+    [:rect w h] (* w h)
+    _ 0))
+
+(each [_ s (ipairs [[:circle 5] [:square 3] [:rect 2 4] [:dot]])]
+  (print (area s)))

data/examples/squares.kap

@@ -0,0 +1,3 @@
+(let [xs [1 2 3 4 5]
+      ys (icollect [_ x (ipairs xs)] (* x x))]
+  (each [_ y (ipairs ys)] (print y)))

data/examples/stack.kap

@@ -0,0 +1,19 @@
+(class Stack)
+
+(fn initialize []
+  (set (ivar xs) []))
+
+(fn push! [x]
+  (let [xs (ivar xs)]
+    (xs.push x))
+  self)
+
+(fn pop! []
+  (let [xs (ivar xs)]
+    (xs.pop)))
+
+(fn empty? []
+  (= 0 (length (ivar xs))))
+
+(fn size []
+  (length (ivar xs)))

data/examples/sum.kap

@@ -0,0 +1,3 @@
+(let [xs [10 20 30 40]
+      total (accumulate [s 0 _ x (ipairs xs)] (+ s x))]
+  (print total))

data/examples/tset.kap

@@ -0,0 +1,4 @@
+(let [person {:name "Ada"}]
+  (tset person :city "Amsterdam")
+  (puts (person.inspect))
+  (puts (. person :city)))

data/examples/two-sum.kap

@@ -0,0 +1,17 @@
+(fn two-sum [xs target]
+  (var i 0)
+  (var answer nil)
+  (while (and (< i (length xs)) (= answer nil))
+    (var j (+ i 1))
+    (while (and (< j (length xs)) (= answer nil))
+      (when (= (+ (. xs i) (. xs j)) target) (set answer [i j]))
+      (set j (+ j 1)))
+    (set i (+ i 1)))
+  answer)
+
+(let [first-pair (two-sum [2 7 11 15] 9)
+      second-pair (two-sum [3 2 4] 6)
+      missing-pair (two-sum [1 2 3] 10)]
+  (puts (first-pair.inspect))
+  (puts (second-pair.inspect))
+  (puts (missing-pair.inspect)))

data/exe/kapfmt

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/kapusta/formatter'
+
+exit Kapusta::Formatter.new(ARGV).run

data/exe/kapusta

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/kapusta/cli'
+
+Kapusta::CLI.start

data/kapfmt

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+load File.expand_path('exe/kapfmt', __dir__)

data/kapusta.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lib/kapusta/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'kapusta'
+  spec.version = Kapusta::VERSION
+  spec.authors = ['Evgenii Morozov']
+
+  spec.summary = 'A Lisp for the Ruby runtime'
+  spec.description = 'Kapusta is a Lisp for the Ruby runtime.'
+  spec.required_ruby_version = '>= 3.1'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").select do |path|
+      path.start_with?('bin/', 'docs/', 'examples/', 'exe/', 'lib/', 'spec/') ||
+        %w[.rspec Gemfile README.md Rakefile kapfmt kapusta.gemspec].include?(path)
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = %w[kapfmt kapusta]
+  spec.require_paths = ['lib']
+end

data/lib/kapusta/ast.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Sym
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def to_s
+      @name
+    end
+
+    def inspect
+      "#<Sym #{@name}>"
+    end
+
+    def ==(other)
+      other.is_a?(Sym) && other.name == @name
+    end
+    alias eql? ==
+
+    def hash
+      @name.hash
+    end
+
+    def dotted?
+      @name != '.' && @name.include?('.')
+    end
+
+    def segments
+      @name.split('.')
+    end
+  end
+
+  class Vec
+    attr_reader :items
+
+    def initialize(items)
+      @items = items
+    end
+  end
+
+  class HashLit
+    attr_reader :pairs
+
+    def initialize(pairs)
+      @pairs = pairs
+    end
+
+    def all_sym_keys?
+      @pairs.all? { |key, _| key.is_a?(Symbol) }
+    end
+  end
+
+  class List
+    attr_reader :items
+
+    def initialize(items)
+      @items = items
+    end
+
+    def head
+      @items.first
+    end
+
+    def rest
+      @items[1..] || []
+    end
+
+    def empty?
+      @items.empty?
+    end
+  end
+end