kapusta 0.13.2 → 0.14.0

data/examples/pangram.kap

@@ -1,10 +1,10 @@
 (fn pangram? [s]
   (= 26
     (length (-> s
-                (: :downcase)
-                (: :gsub (ruby "/[^a-z]/") "")
-                (: :chars)
-                (: :uniq)))))
+                (. :downcase)
+                (. :gsub (ruby "/[^a-z]/") "")
+                (. :chars)
+                (. :uniq)))))
 
 (print (pangram? "The quick brown fox jumps over the lazy dog"))
 (print (pangram? "Hello, world"))

data/examples/pcall.kap

@@ -1,12 +1,12 @@
 (fn parse-int [s]
-  (: Kernel :Integer s))
+  (. Kernel :Integer s))
 
 (let [[ok value] (pcall parse-int "12")
       [bad-ok error] (pcall parse-int "oops")
-      [handled-ok handled] (xpcall parse-int (fn [e] (e.message)) "oops")]
+      [handled-ok handled] (xpcall parse-int (fn [e] (. e :message)) "oops")]
   (print ok)
   (print value)
   (print bad-ok)
-  (print (error.class))
+  (print (. error :class))
   (print handled-ok)
   (print handled))

data/examples/pipeline.kap

@@ -3,7 +3,7 @@
   ; Filter first so later stages stay focused.
   (-> words
       ; Keep the shorter words before transforming them.
-      (: :select (fn [w] (< (length w) 5)))
-      (: :map (fn [w] (w.upcase)))
-      (: :sort)
-      (: :each (fn [w] (print w)))))
+      (. :select (fn [w] (< (length w) 5)))
+      (. :map (fn [w] (. w :upcase)))
+      (. :sort)
+      (. :each (fn [w] (print w)))))

data/examples/plus-one.kap

@@ -2,11 +2,11 @@
   (var i (- (length digits) 1))
   (var carry 1)
   (while (and (>= i 0) (> carry 0))
-    (let [total (+ (. digits i) carry)]
+    (let [total (+ (: digits i) carry)]
       (tset digits i (% total 10))
-      (set carry (: (/ total 10) :floor)))
+      (set carry (. (/ total 10) :floor)))
     (set i (- i 1)))
-  (if (> carry 0) (: digits :unshift carry) digits))
+  (if (> carry 0) (. digits :unshift carry) digits))
 
 (print (plus-one [1 2 3]))
 (print (plus-one [4 3 2 1]))

data/examples/raindrops.kap

@@ -7,7 +7,7 @@
   (when (div? n 5) (add-drop "Plang"))
   (when (div? n 7) (add-drop "Plong"))
   (if (empty? drops)
-      (: n :to-s)
+      n.to-s
       (drops.join)))
 
 (print (raindrops 15))

data/examples/range-width.kap

@@ -0,0 +1,14 @@
+(fn range-width [lo hi]
+  (- hi lo))
+
+(fn min-max-range [nums]
+  (var lo 1000000)
+  (var hi -1000000)
+  (each [_ n (ipairs nums)]
+    (when (< n lo) (set lo n))
+    (when (> n hi) (set hi n)))
+  (range-width (values lo hi)))
+
+(print (min-max-range [4 2 9 1 7]))
+(print (min-max-range [10 10 10]))
+(print (min-max-range [-3 8 0 5]))

data/examples/recent-counter.kap

@@ -2,16 +2,16 @@
 (fn initialize [] (set @pings []))
 (fn ping [t]
   (let [pings @pings]
-    (pings.push t)
-    (while (< (. pings 0) (- t 3000))
-      (pings.shift))
+    (. pings :push t)
+    (while (< (: pings 0) (- t 3000))
+      (. pings :shift))
     (length pings)))
 (defn warm [history]
   (let [c (RecentCounter.new)]
-    (each [_ t (ipairs history)] (c.ping t))
+    (each [_ t (ipairs history)] (. c :ping t))
     c))
 (end)
 
 (let [c (RecentCounter.warm [100 200 300])]
-  (print (c.ping 3001))
-  (print (c.ping 3002)))
+  (print (. c :ping 3001))
+  (print (. c :ping 3002)))

data/examples/require-local-args.kap

@@ -0,0 +1,9 @@
+(module RequireLocalArgs)
+
+(defn parse [argv]
+  {:command (: argv 0) :options (. argv :drop 1)})
+
+(defn usage []
+  "usage: kapusta <command> [options]")
+
+(end)

data/examples/require-local.kap

@@ -0,0 +1,7 @@
+(require "./require-local-args")
+
+(let [parsed (RequireLocalArgs.parse ["serve" "--port" "3000"])
+      options parsed:options]
+  (print parsed:command)
+  (print (options.join " "))
+  (print (RequireLocalArgs.usage)))

data/examples/require-module-local.kap

@@ -0,0 +1,4 @@
+(local args (require :app.args))
+
+(let [parsed (args.parse ["deploy" "production"])]
+  (print (args.format-command parsed)))

data/examples/require-module.kap

@@ -0,0 +1,4 @@
+(require :app.args)
+
+(let [parsed (App.Args.parse ["deploy" "production"])]
+  (print (App.Args.format-command parsed)))

data/examples/reverse-integer.kap

@@ -4,7 +4,7 @@
     (var result 0)
     (while (> remaining 0)
       (set result (+ (* result 10) (% remaining 10)))
-      (set remaining (: (/ remaining 10) :floor)))
+      (set remaining (. (/ remaining 10) :floor)))
     (* result sign)))
 
 (print (reverse-integer 123))

data/examples/roman-to-integer.kap

@@ -1,12 +1,12 @@
 (fn roman-to-integer [s]
   (let [value-map {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000}
-        chars (s.chars)
+        chars (. s :chars)
         n (length chars)]
     (var total 0)
     (var i 0)
     (while (< i n)
-      (let [curr (. value-map (. chars i))
-            ahead (if (< (+ i 1) n) (. value-map (. 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/running-sum.kap

@@ -0,0 +1,20 @@
+(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 running-sum [nums]
+  (var total 0)
+  (icollect [_ n (ipairs nums)]
+    (do
+      (set total (+ total n))
+      total)))
+
+(print (same-list? [1 3 6 10 15 21 28 36 45 55 66 78]
+                   (running-sum [1 2 3 4 5 6 7 8 9 10 11 12])))
+
+(print (same-list? [1 2 3 4 5] (running-sum [1 1 1 1 1])))
+
+(print (same-list? [3 4 6 16 17] (running-sum [3 1 2 10 1])))

data/examples/safe-lookup.kap

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

data/examples/single-number.kap

@@ -1,6 +1,6 @@
 (fn single-number [nums]
   (accumulate [acc 0 _ n (ipairs nums)]
-    (: acc :^ n)))
+    (. acc :^ n)))
 
 (print (single-number [2 2 1]))
 (print (single-number [4 1 2 1 2]))

data/examples/stack.kap

@@ -7,32 +7,32 @@
 (fn push [x]
   (let [xs (ivar xs)
         mins (ivar mins)
-        current-min (if (mins.empty?) x (< x (. mins -1)) x (. mins -1))]
-    (xs.push x)
-    (mins.push current-min))
+        current-min (if (. mins :empty?) x (< x (: mins -1)) x (: mins -1))]
+    (. xs :push x)
+    (. mins :push current-min))
   self)
 
 (fn pop []
   (let [mins (ivar mins)]
-    (mins.pop))
+    (. mins :pop))
   (let [xs (ivar xs)]
-    (xs.pop)))
+    (. xs :pop)))
 
 (fn top []
-  (. (ivar xs) -1))
+  (: (ivar xs) -1))
 
 (fn get-min []
-  (. (ivar mins) -1))
+  (: (ivar mins) -1))
 
 (end)
 
 (let [s (MinStack.new)]
-  (s.push -2)
-  (s.push 0)
-  (s.push -3)
-  (print (s.get-min))
-  (s.pop)
-  (print (s.top))
-  (print (s.get-min)))
+  (. s :push -2)
+  (. s :push 0)
+  (. s :push -3)
+  (print (. s :get-min))
+  (. s :pop)
+  (print (. s :top))
+  (print (. s :get-min)))
 
 (print (= MinStack.superclass Object))

data/examples/subtract-product-sum.kap

@@ -6,7 +6,7 @@
     (let [d (% x 10)]
       (set product (* product d))
       (set sum (+ sum d))
-      (set x (: (/ x 10) :floor))))
+      (set x (. (/ x 10) :floor))))
   (- product sum))
 
 (print (subtract-product-sum 234))

data/examples/summary-ranges.kap

@@ -0,0 +1,45 @@
+(fn join [sep xs]
+  (var s "")
+  (each [_ x (ipairs xs)]
+    (if (= s "")
+        (set s (.. x))
+        (set s (.. s sep x))))
+  s)
+
+(fn range-boundary->string [n]
+  (.. n))
+
+(fn range-label [range-start range-end]
+  (if (= range-start range-end)
+      (range-boundary->string range-start)
+      (join "" [(range-boundary->string range-start)
+                "->"
+                (range-boundary->string range-end)])))
+
+(fn append-range [out lo hi]
+  (let [label (range-label lo hi)
+        parts [out (if (= out "") "" "|") label]]
+    (join "" parts)))
+
+(fn summary-ranges [nums]
+  (var started? false)
+  (var start 0)
+  (var prev 0)
+  (var out "")
+  (each [_ n (ipairs nums)]
+    (if started?
+        (if (= n (+ prev 1))
+            (set prev n)
+            (do
+              (set out (append-range out start prev))
+              (set start n)
+              (set prev n)))
+        (do
+          (set started? true)
+          (set start n)
+          (set prev n))))
+  (if started? (append-range out start prev) out))
+
+(print (summary-ranges [0 1 2 4 5 7]))
+(print (summary-ranges [0 2 3 4 6 8 9]))
+(print (.. "empty=" (summary-ranges [])))

data/examples/threading.kap

@@ -5,7 +5,7 @@
   (.. left value right))
 
 (fn fetch-name [user]
-  (?. user :profile :name))
+  (?: user :profile :name))
 
 (let [thread-last (->> "Ada"
                        (append " Lovelace")
@@ -20,9 +20,9 @@
                          (append "!")
                          (wrap "<" ">"))
       thread-first (-?> "kapusta"
-                        (: :upcase)
-                        (: :reverse))
+                        (. :upcase)
+                        (. :reverse))
       missing-first (-?> nil
-                         (: :upcase)
-                         (: :reverse))]
+                         (. :upcase)
+                         (. :reverse))]
   (print thread-last maybe-name missing-name thread-first missing-first))

data/examples/tset.kap

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

data/examples/two-sum-hash.kap

@@ -2,10 +2,10 @@
                      (var i 0)
                      (var answer nil)
                      (while (and (< i (length nums)) (= answer nil))
-                       (let [n (. nums i)
+                       (let [n (: nums i)
                              complement (- target n)]
-                         (if (seen.key? complement)
-                             (set answer [(. seen complement) i])
+                         (if (. seen :key? complement)
+                             (set answer [(: seen complement) i])
                              (tset seen n i)))
                        (set i (+ i 1)))
                      answer)]

data/examples/two-sum.kap

@@ -4,7 +4,7 @@
   (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]))
+      (when (= (+ (: xs i) (: xs j)) target) (set answer [i j]))
       (set j (+ j 1)))
     (set i (+ i 1)))
   answer)

data/examples/ugly-number.kap

@@ -1,5 +1,5 @@
 (macro floor-div [a b]
-  `(: (/ ,a ,b) :floor))
+  `(. (/ ,a ,b) :floor))
 
 (macro divide-out! [v d]
   `(while (= 0 (% ,v ,d))

data/examples/underground-system.kap

@@ -0,0 +1,39 @@
+(fn underground-system []
+  (let [active []
+        routes {:leyton-waterloo {:total 0 :count 0}
+                :paradise-cambridge {:total 0 :count 0}}
+        route-stat (fn [start end]
+                     (case [start end]
+                       ["Leyton" "Waterloo"] routes:leyton-waterloo
+                       ["Paradise" "Cambridge"] routes:paradise-cambridge))
+        find-trip (fn [id]
+                    (var found nil)
+                    (each [_ trip (ipairs active)]
+                      (when (= trip:id id)
+                        (set found trip)))
+                    found)
+        ops {:check-in (fn [id station time]
+                         (active.push {: id : station : time}))
+             :check-out (fn [id station time]
+                          (let [trip (find-trip id)
+                                start trip:station
+                                duration (- time trip:time)
+                                stat (route-stat start station)]
+                            (tset stat :total (+ stat:total duration))
+                            (tset stat :count (+ stat:count 1))))
+             :average-time (fn [start end]
+                             (let [stat (route-stat start end)]
+                               (/ stat:total stat:count)))}]
+    {:active active :ops ops :routes routes}))
+
+(local system (underground-system))
+
+(system:ops:check-in 45 "Leyton" 3)
+(system:ops:check-in 32 "Paradise" 8)
+(system:ops:check-in 27 "Leyton" 10)
+(system:ops:check-out 45 "Waterloo" 15)
+(system:ops:check-out 27 "Waterloo" 20)
+(system:ops:check-out 32 "Cambridge" 22)
+
+(print (system:ops:average-time "Leyton" "Waterloo"))
+(print (system:ops:average-time "Paradise" "Cambridge"))

data/examples/valid-parentheses-1.kap

@@ -7,15 +7,15 @@
 (fn valid? [s]
   (let [pairs (ivar pairs)
         stack []
-        chars (s.chars)]
+        chars (. s :chars)]
     (var i 0)
     (var ok true)
     (while (and ok (< i (length chars)))
-      (let [ch (. chars i)]
-        (if (pairs.key? ch)
-            (if (-?> (stack.pop) (= (. pairs ch))) nil (set ok false))
-            (stack.push ch)))
+      (let [ch (: chars i)]
+        (if (. pairs :key? ch)
+            (if (-?> (. stack :pop) (= (: pairs ch))) nil (set ok false))
+            (. stack :push ch)))
       (set i (+ i 1)))
-    (and ok (stack.empty?))))
+    (and ok (. stack :empty?))))
 
 (end)

data/exe/kapusta-ls

@@ -3,12 +3,59 @@
 
 require_relative '../lib/kapusta/lsp'
 
+def check_paths(args)
+  paths = args.flat_map do |arg|
+    if File.directory?(arg)
+      Dir[File.join(arg, '**', '*.kap')]
+    else
+      arg
+    end
+  end.uniq.sort
+
+  if paths.empty?
+    warn 'kapusta-ls: no .kap files found'
+    return 1
+  end
+
+  failures = []
+  paths.each do |path|
+    Kapusta.compile(File.read(path), path:)
+  rescue Kapusta::Error => e
+    failures << e.formatted
+  rescue SystemCallError => e
+    failures << "#{path}: #{e.message}"
+  end
+
+  if failures.empty?
+    puts "kapusta-ls checked #{paths.length} files"
+    0
+  else
+    warn "#{failures.length} files reported kapusta-ls diagnostics:"
+    failures.each { |failure| warn "  #{failure}" }
+    1
+  end
+end
+
 case ARGV.first
 when '--version', '-v'
   puts "kapusta-ls #{Kapusta::VERSION}"
 when '--help', '-h'
-  puts 'usage: kapusta-ls           # speak LSP over stdio'
+  puts 'usage: kapusta-ls             # speak LSP over stdio'
+  puts '       kapusta-ls FILES...    # check files or directories'
+  puts '       kapusta-ls --lint FILES...'
   puts '       kapusta-ls --version'
-else
+when '--server'
   Kapusta::LSP.start
+when '--lint'
+  exit check_paths(ARGV[1..])
+else
+  if ARGV.empty?
+    Kapusta::LSP.start
+  elsif ARGV.first.start_with?('-')
+    warn "kapusta-ls: unknown option #{ARGV.first}"
+    warn 'usage: kapusta-ls [--lint] FILES...'
+    exit 1
+  else
+    exit check_paths(ARGV)
+  end
 end

data/lib/kapusta/ast.rb

@@ -47,6 +47,14 @@ module Kapusta
     def segments
       @name.split('.')
     end
+
+    def colonized?
+      @name != ':' && !@name.start_with?(':') && @name.include?(':')
+    end
+
+    def colon_segments
+      @name.split(':')
+    end
   end
 
   class GeneratedSym < Sym