kapusta 0.13.2 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa363e8e708ddf94ca3406bda52d7603663e9de82a79eec94328082f5310b638
-  data.tar.gz: cf1a0911c16fa481bc1680380eb2677329276289c513e8d66d9f4450cad9d762
+  metadata.gz: e247dd5e305dcac681bcdb9decbf30d8e0628232626f751c2f39fe8d79796e02
+  data.tar.gz: 6d1e24c986c1301045e469b03a76295e03276cee031939ac87dea34187931251
 SHA512:
-  metadata.gz: d2e4405abbab87cc70e8b00ab05840f50b6050c965d63351e6db3a2e5ab2f97219bb517d837ef8f8166df27ae4d53d0bd9a595de6bbed3d5e0319de0c13b2a88
-  data.tar.gz: 8e88867b98adba5e17d0eaf6a506518bdb0a7f7b2628d5ce3937fad5f29e73766dba4767340716f06ec7ff3e9b68df6924b7cadf936a71cb18bf47e88a26ca4b
+  metadata.gz: 919382905342cffcbf1b6986a232f9050dcacfeb196fab8131d9d72a462d8c741e560fe1b72922998bb980a8fb3eeecbda9c348acd694b3299d890b44022132c
+  data.tar.gz: 50e77ee9da2df8b1a2f6e694b205dde09e2631d6b49cbc9ddd9cc022e2f86122055abd721d5a82f76af1a2004e78e0f14f2a1b4d02c16cbfb8ee09fb1397a900

data/README.md

@@ -92,20 +92,59 @@ p ack(2, 3)
 p ack(3, 3)
 ```
 
+## Calls and lookup
+
+Hash lookup uses `:`.
+
+```fennel
+user:name
+(: user :name)
+(?: user :profile :name) ; safe lookup
+```
+
+Method calls use `.`.
+
+```fennel
+user.name
+(. user :name)
+```
+
+Kapusta source always uses `require`.
+
+```fennel
+(require :app.args)
+(local messages (require :app.messages))
+(require "./config")
+```
+
+Compiled Ruby uses the Ruby form that fits:
+
+```ruby
+require "app/args"
+require "app/messages"
+messages = App::Messages
+require_relative "config"
+```
+
+For larger programs, organize code with Kapusta's Ruby host forms:
+
+1. Use `module` + `defn` for stateless functions.
+2. Use `class` + `fn` for state or dependencies.
+3. Avoid returning hashes of functions as the main app structure.
+
 ## 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 |
-| `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)             |
-| `(.. "x: " nil)` errors at runtime    | `(.. "x: " nil)` produces `"x: "` (Ruby `nil.to_s`)   |
-| `with-open`, `tail!`                  | not provided                                          |
+| 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                 |
+| `(print x)` is Lua's `print` (bare)   | `(print x)` is Ruby's `p` (inspect-style)           |
+| `(.. "x: " nil)` errors at runtime    | `(.. "x: " nil)` produces `"x: "` (Ruby `nil.to_s`) |
+| `with-open`, `tail!`                  | not provided                                        |
 
 Kapusta-specific additions:
 
@@ -116,7 +155,7 @@ Kapusta-specific additions:
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - pass Ruby keyword arguments by ending a call with a symbol-keyed hash: `(File.open path "r" {:encoding "UTF-8"})`
-- pass a Ruby block by ending a call with a `(fn ...)` or `#(...)` literal: `(File.open path "r" (fn [io] (: io :read)))`
+- pass a Ruby block by ending a call with a `(fn ...)` or `#(...)` literal: `(File.open path "r" (fn [io] io.read))`
 
 ## Format
 

data/bin/check-all

@@ -8,7 +8,12 @@ echo "== rubocop -A =="
 bundle exec rubocop -A
 
 echo "== kapfmt =="
-for file in examples/*.kap; do ./exe/kapfmt --fix "$file"; done
+while IFS= read -r file; do
+  ./exe/kapfmt --fix "$file"
+done < <(find examples -type f -name '*.kap' | sort)
+
+echo "== kapusta-ls =="
+./exe/kapusta-ls --lint examples
 
 echo "== fennel parity =="
 bin/fennel-parity

data/bin/compile-examples

@@ -63,7 +63,10 @@ fi
 mkdir -p "$TARGET_DIR"
 
 shopt -s nullglob
-kap_files=("$SOURCE_DIR"/*.kap)
+kap_files=()
+while IFS= read -r kap_file; do
+  kap_files+=("$kap_file")
+done < <(find "$SOURCE_DIR" -type f -name '*.kap' | sort)
 
 if ((${#kap_files[@]} == 0)); then
   printf 'No .kap files found in %s\n' "$SOURCE_DIR" >&2
@@ -71,9 +74,11 @@ if ((${#kap_files[@]} == 0)); then
 fi
 
 for kap_file in "${kap_files[@]}"; do
-  name="$(basename "$kap_file" .kap)"
+  relative_name="${kap_file#"$SOURCE_DIR"/}"
+  name="${relative_name%.kap}"
   ruby_file="$TARGET_DIR/$name.rb"
   mruby_file="$TARGET_DIR/$name-mruby.rb"
+  mkdir -p "$(dirname "$ruby_file")"
 
   "$ROOT_DIR/exe/kapusta" --compile "$kap_file" > "$ruby_file"
   printf 'Compiled %s -> %s\n' "$kap_file" "$ruby_file"

data/examples/anagram.kap

@@ -1,8 +1,8 @@
 (fn normalize-word [word]
   (-> word
-      (: :downcase)
-      (: :chars)
-      (: :sort)))
+      (. :downcase)
+      (. :chars)
+      (. :sort)))
 
 (fn anagram? [a b]
   (= (normalize-word a)

data/examples/app/args.kap

@@ -0,0 +1,9 @@
+(module App.Args)
+
+(defn parse [argv]
+  {:command (: argv 0) :target (: argv 1)})
+
+(defn format-command [parsed]
+  (.. (: parsed :command) " -> " (: parsed :target)))
+
+(end)

data/examples/arrange-coins.kap

@@ -1,15 +1,15 @@
 (fn arrange-coins [n]
   (let [rows (faccumulate [acc {:sum 0 :rows 0} i 1 n]
-               (let [new-sum (+ (. acc :sum) i)]
+               (let [new-sum (+ acc:sum i)]
                  (if (<= new-sum n)
                      {:sum new-sum :rows i}
                      acc)))
         used (faccumulate [acc {:sum 0 :rows 0} i 1 n]
-               (let [new-sum (+ (. acc :sum) i)]
+               (let [new-sum (+ acc:sum i)]
                  (if (<= new-sum n)
                      {:sum new-sum :rows i}
                      acc)))]
-    [(. rows :rows) (. used :sum)]))
+    [rows:rows used:sum]))
 
 (let [[r u] (arrange-coins 0)]
   (print r)

data/examples/baseball-game.kap

@@ -1,11 +1,11 @@
 (fn cal-points [ops]
   (let [scores []]
     (each [op ops]
-      (if (= op "C") (do (-?> (scores.pop) (: :abs)) nil)
-          (= op "D") (scores.push (* 2 (. scores -1)))
-          (= op "+") (scores.push (+ (. scores -1) (. scores -2)))
-          (scores.push (: op :to-i))))
-    scores.sum))
+      (if (= op "C") (do (. (. scores :pop) :abs) nil)
+          (= op "D") (. scores :push (* 2 (: scores -1)))
+          (= op "+") (. scores :push (+ (: scores -1) (: scores -2)))
+          (. scores :push (. op :to-i))))
+    (. scores :sum)))
 
 (print (cal-points ["5" "2" "C" "D" "+"]))
 (print (cal-points ["5" "-2" "4" "C" "D" "9" "+" "+"]))

data/examples/best-time-to-buy-sell-stock.kap

@@ -1,8 +1,8 @@
 (fn max-profit [prices]
-  (var min-price (. prices 0))
+  (var min-price (: prices 0))
   (var best 0)
   (for [i 1 (- (length prices) 1)]
-    (let [p (. prices i)]
+    (let [p (: prices i)]
       (when (< p min-price) (set min-price p))
       (when (> (- p min-price) best) (set best (- p min-price)))))
   best)

data/examples/binary-search.kap

@@ -3,8 +3,8 @@
   (var hi (- (length xs) 1))
   (var answer nil)
   (while (and (<= lo hi) (= answer nil))
-    (let [mid (: (/ (+ lo hi) 2) :floor)
-          guess (. xs mid)]
+    (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)))))

data/examples/binary-to-decimal.kap

@@ -1,6 +1,6 @@
 (fn binary-to-decimal [bits]
   (faccumulate [value 0 i 0 (- (length bits) 1)]
-    (+ (* value 2) (if (= (. bits i) "1") 1 0))))
+    (+ (* value 2) (if (= (: bits i) "1") 1 0))))
 
 (print (binary-to-decimal "1011"))
 (print (binary-to-decimal "0"))

data/examples/blocks-and-kwargs.kap

@@ -8,12 +8,12 @@
       (File.open path
         "w"
         {:encoding "UTF-8"}
-        (fn [io] (: io :write "Ada\nLin\n")))
+        (fn [io] (io.write "Ada\nLin\n")))
       (File.open path
         "r"
         {:encoding "UTF-8"}
         (fn [io]
-          (let [content (: io :read)]
+          (let [content (io.read)]
             (print (content.strip))
             (print (length (content.lines)))))))
     (finally

data/examples/count-effects.kap

@@ -2,7 +2,7 @@
   (var quits 0)
   (var moves 0)
   (each [_ effect (ipairs effects)]
-    (case (. effect :kind)
+    (case effect:kind
       :quit (set quits (+ quits 1))
       :move (set moves (+ moves 1))
       _ nil))

data/examples/count-items-matching-rule.kap

@@ -0,0 +1,18 @@
+(local rule-keys {"type" :type
+                  "color" :color
+                  "name" :name
+                  "rating" :rating
+                  "category" :category
+                  "owner" :owner})
+
+(fn count-matches [items rule-key rule-value]
+  (let [key (: rule-keys rule-key)]
+    (accumulate [count 0 _ item (ipairs items)]
+      (if (= (: item key) rule-value) (+ count 1) count))))
+
+(let [items [{:type "phone" :color "blue" :name "pixel"}
+             {:type "computer" :color "silver" :name "lenovo"}
+             {:type "phone" :color "gold" :name "iphone"}]]
+  (print (count-matches items "type" "phone"))
+  (print (count-matches items "color" "silver"))
+  (print (count-matches items "name" "pixel")))

data/examples/doto-hygiene.kap

@@ -1,5 +1,5 @@
 (let [__doto__ 99
       xs []]
   (doto xs
-        (: :push __doto__))
-  (print (xs.inspect)))
+        (. :push __doto__))
+  (print (. xs :inspect)))

data/examples/doto.kap

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

data/examples/egg-count.kap

@@ -4,7 +4,7 @@
   (var eggs 0)
   (while (> n 0)
     (when (odd? n) (set eggs (+ eggs 1)))
-    (set n (: (/ n 2) :floor)))
+    (set n (. (/ n 2) :floor)))
   eggs)
 
 (print (egg-count 30))

data/examples/exceptions.kap

@@ -1,7 +1,7 @@
 (fn require-score [s]
   (if (= s "oops")
       (raise (ArgumentError.new "not a number"))
-      (: s :to-i)))
+      s.to-i))
 
 (fn parse-score [s]
   (try (require-score s)

data/examples/falling-drops.kap

@@ -1,12 +1,12 @@
 (fn step [drops]
   (each [_ drop (ipairs drops)]
-    (let [falling {:kind (. drop :kind)
-                   :x (. drop :x)
-                   :y (+ (. drop :y) (. drop :speed))
-                   :w (. drop :w)
-                   :h (. drop :h)
-                   :speed (. drop :speed)}]
-      (print (. falling :kind) (. falling :x) (. falling :y)))))
+    (let [falling {:kind drop:kind
+                   :x drop:x
+                   :y (+ drop:y drop:speed)
+                   :w drop:w
+                   :h drop:h
+                   :speed drop:speed}]
+      (print falling:kind falling:x falling:y))))
 
 (step [{:kind "rain" :x 0 :y 0 :w 1 :h 1 :speed 2}
        {:kind "snow" :x 5 :y 1 :w 1 :h 1 :speed 1}])

data/examples/fennel-parity-examples.txt

@@ -1,19 +1,15 @@
 ackermann
 anonymous-greeter
 array-sign
-arrange-coins
 case-vs-match
 classify-wallet
 climbing-stairs
 convert-temperature
-count-effects
-describe
 destructure
 divisibility-stats
 equal-sums
 even-squares
 factorial
-falling-drops
 fib
 fizzbuzz
 gcd
@@ -30,18 +26,19 @@ macros-unless
 macros-when-let
 match
 max-achievable
+maximum-subarray
 min-max
 nested-nil-pattern
-non-constant-local
 or-patterns
 packet-router
 points
 power-of-three
 primes
-safe-lookup
+range-width
 shapes
 squares
 sum
+summary-ranges
 thread-styles
 tic-tac-toe
 underscore-patterns

data/examples/good-pairs.kap

@@ -0,0 +1,18 @@
+(fn add-good-pairs [pairs counts n]
+  (let [prev (or (: counts n) 0)
+        next-pairs (+ pairs prev)]
+    (tset counts n (+ prev 1))
+    (values next-pairs counts)))
+
+(fn num-identical-pairs [nums]
+  (var pairs 0)
+  (var counts {})
+  (each [_ n (ipairs nums)]
+    (let [(next-pairs next-counts) (add-good-pairs pairs counts n)]
+      (set pairs next-pairs)
+      (set counts next-counts)))
+  pairs)
+
+(print (num-identical-pairs [1 2 3 1 1 3]))
+(print (num-identical-pairs [1 1 1 1]))
+(print (num-identical-pairs [1 2 3]))

data/examples/greet.kap

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

data/examples/happy-number.kap

@@ -4,13 +4,13 @@
   (while (> x 0)
     (let [d (% x 10)]
       (set total (+ total (* d d)))
-      (set x (: (/ x 10) :floor))))
+      (set x (. (/ x 10) :floor))))
   total)
 
 (fn happy? [n]
   (let [seen {}]
     (var x n)
-    (while (and (not= x 1) (not (seen.key? x)))
+    (while (and (not= x 1) (not (. seen :key? x)))
       (tset seen x true)
       (set x (sum-of-squares x)))
     (= x 1)))

data/examples/left-right-difference.kap

@@ -0,0 +1,60 @@
+(fn same-list? [a b]
+  (var ok (= (length a) (length b)))
+  (each [i value (ipairs a)]
+    (when (not (= value (: b i)))
+      (set ok false)))
+  ok)
+
+(fn abs [n]
+  (if (< n 0) (- n) n))
+
+(fn left-right-difference [nums]
+  (let [total (accumulate [sum 0 _ n (ipairs nums)] (+ sum n))]
+    (var left 0)
+    (icollect [_ n (ipairs nums)]
+      (do
+        (let [right (- total left n)
+              diff (abs (- left right))]
+          (set left (+ left n))
+          diff)))))
+
+(print (same-list? [209
+                    206
+                    201
+                    194
+                    185
+                    174
+                    161
+                    146
+                    129
+                    110
+                    89
+                    66
+                    41
+                    14
+                    15
+                    46
+                    79
+                    114
+                    151
+                    190]
+                   (left-right-difference [1
+                                           2
+                                           3
+                                           4
+                                           5
+                                           6
+                                           7
+                                           8
+                                           9
+                                           10
+                                           11
+                                           12
+                                           13
+                                           14
+                                           15
+                                           16
+                                           17
+                                           18
+                                           19
+                                           20])))

data/examples/length-of-last-word.kap

@@ -1,9 +1,9 @@
 (fn length-of-last-word [s]
   (-> s
-      (: :strip)
-      (: :split)
-      (. -1)
-      (: :length)))
+      (. :strip)
+      (. :split)
+      (: -1)
+      (. :length)))
 
 (print (length-of-last-word "Hello World"))
 (print (length-of-last-word "   fly me   to   the moon  "))

data/examples/manhattan-distance.kap

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

data/examples/maximum-subarray.kap

@@ -1,11 +1,27 @@
+(fn max-subarray-step [current best n]
+  (let [extended (+ current n)
+        next-current (if (> extended n) extended n)
+        next-best (if (> next-current best) next-current best)]
+    (values next-current next-best)))
+
+(fn max-subarray-state [nums]
+  (var current 0)
+  (var best 0)
+  (var initialized? false)
+  (each [_ n (ipairs nums)]
+    (if initialized?
+        (let [(next-current next-best) (max-subarray-step current best n)]
+          (set current next-current)
+          (set best next-best))
+        (do
+          (set current n)
+          (set best n)
+          (set initialized? true))))
+  (values current best))
+
 (fn max-subarray [nums]
-  (var best (. nums 0))
-  (var curr (. nums 0))
-  (for [i 1 (- (length nums) 1)]
-    (let [n (. nums i)]
-      (set curr (if (> (+ curr n) n) (+ curr n) n))
-      (when (> curr best) (set best curr))))
-  best)
+  (let [(_current best) (max-subarray-state nums)]
+    best))
 
 (print (max-subarray [-2 1 -3 4 -1 2 1 -5 4]))
 (print (max-subarray [1]))

data/examples/minimum-start-value.kap

@@ -0,0 +1,19 @@
+(fn minimum-start-value [nums]
+  (var prefix 0)
+  (var lowest 0)
+  (each [_ n (ipairs nums)]
+    (set prefix (+ prefix n))
+    (when (< prefix lowest) (set lowest prefix)))
+  (values (+ 1 (- lowest)) prefix))
+
+(let [[start total] (minimum-start-value [-3 2 -3 4 2])]
+  (print start)
+  (print total))
+
+(let [[start total] (minimum-start-value [1 2])]
+  (print start)
+  (print total))
+
+(let [[start total] (minimum-start-value [1 -2 -3])]
+  (print start)
+  (print total))

data/examples/move-zeroes.kap

@@ -1,8 +1,8 @@
 (fn move-zeroes [nums]
   (var write 0)
   (for [read 0 (- (length nums) 1)]
-    (when (not= (. nums read) 0)
-      (tset nums write (. nums read))
+    (when (not= (: nums read) 0)
+      (tset nums write (: nums read))
       (set write (+ write 1))))
   (for [i write (- (length nums) 1)]
     (tset nums i 0))

data/examples/mruby-runtime-examples.txt

@@ -19,8 +19,8 @@ climbing-stairs
 contains-duplicate
 convert-temperature
 count-effects
+count-items-matching-rule
 counter
-describe
 destructure
 divisibility-stats
 doto
@@ -33,12 +33,14 @@ falling-drops
 fib
 fizzbuzz
 gcd
+good-pairs
 greet
 happy-number
 hashfn
 hit-counter
 kwargs
 leap-year
+left-right-difference
 length-of-last-word
 macros-dbg
 macros-import
@@ -55,9 +57,10 @@ match
 max-achievable
 maximum-subarray
 min-max
+minimum-start-value
 module-header
-nested-nil-pattern
 move-zeroes
+nested-nil-pattern
 number-of-1-bits
 number-of-steps
 or-patterns
@@ -70,11 +73,13 @@ points
 power-of-three
 primes
 raindrops
+range-width
 recent-counter
 record
 reverse-integer
 roman-to-integer
 ruby-eval
+running-sum
 safe-lookup
 scopes
 shapes
@@ -84,6 +89,7 @@ squares
 stack
 subtract-product-sum
 sum
+summary-ranges
 thread-styles
 threading
 tic-tac-toe

data/examples/non-constant-local.kap

@@ -8,4 +8,4 @@
 (print (regular-fn 5))
 (print (lambda-fn 5))
 (print (length vec-binding))
-(print (. hash-binding :a))
+(print hash-binding:a)

data/examples/number-of-1-bits.kap

@@ -5,7 +5,7 @@
   (var count 0)
   (for [_ 1 BIT-WIDTH]
     (set count (+ count (% x 2)))
-    (set x (: (/ x 2) :floor)))
+    (set x (. (/ x 2) :floor)))
   count)
 
 (print (hamming-weight 11))

data/examples/number-of-steps.kap

@@ -5,7 +5,7 @@
   (var steps 0)
   (while (not= x target)
     (if (= 0 (% x 2))
-        (set x (: (/ x 2) :floor))
+        (set x (. (/ x 2) :floor))
         (set x (- x 1)))
     (set steps (+ steps 1)))
   steps)

data/examples/palindrome.kap

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