kapusta 0.4.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01cc980a37ff63b56db021edb64f7ed9b4381569bb82e8e4ada099a2b17ba19e
-  data.tar.gz: 035f0f4a38d5d9fad65f4a53e8343bbcad4b681bd33dfa975f7c9c638a83ccb4
+  metadata.gz: 76f35530eebc269dfec62ee1f36f6cc11a252ee4590eeac961c9b47e4e49ca09
+  data.tar.gz: a0ee60d21fb9a6066915d916e465bef09d9208c0469712673db35bea83efd7c4
 SHA512:
-  metadata.gz: caaeb31630a5c80607fe6c2907548c2874f177add0bdbd3555e72039dd598aaf481f91778043f6b81cd511c9ac8609e48f61c474766dac9b3e8a2fa41d408970
-  data.tar.gz: 5417ad8088be602618c3662660af820be6dbf15eb27d8300b1c542e3889fbfe1813d51ca7306f988a630616d1857f333141bf20b964d0869c2caa8c3eba869e3
+  metadata.gz: 350e111e7cfe045723ea1982c18762727d64ea615219d904a79af2933874af5ce355076e242ed9c0bf5e91d135dbd4498b2b5ae107b05035f205e3ccb87bbb54
+  data.tar.gz: 7e242c3fb28fb0d5d2839f7e3d6e5dca96dda90204e1a81024111e1fc5ef4f6c7abb2a6e3628e5894eac46ce9d1c10f21db80bcae63da3ec9b4874a747b1bba1

data/README.md

@@ -14,11 +14,21 @@ For more information about Kapusta, see the official Fennel documentation and tu
 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
+## Install
 
 ```
 gem install kapusta
-kapfmt --fix examples/fizzbuzz.kap
+```
+
+It installs three executables:
+
+1. `kapusta`
+2. `kapfmt`
+3. `kapusta-ls`
+
+## Use
+
+```
 kapusta examples/fizzbuzz.kap
 ```
 
@@ -35,7 +45,7 @@ exe/kapusta --compile examples/fizzbuzz.kap > examples/fizzbuzz.rb
 ruby examples/fizzbuzz.rb
 ```
 
-## Using from Ruby
+## Use from Ruby
 
 Ruby can require a `.kap` file and use it directly.
 
@@ -100,12 +110,20 @@ Kapusta-specific additions:
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments
 - a final function literal argument is emitted as a Ruby block
 
-## Formatting
+## Format
 
 ```
-exe/kapfmt
+kapfmt --fix examples/fizzbuzz.kap
 ```
 
+## LSP
+
+Use `kapusta-ls` in the editor of your choice.
+
 ## Syntax highlight
 
-For Vim you can use https://git.sr.ht/~m15a/vim-fennel-syntax
+For Vim, you can use https://git.sr.ht/~m15a/vim-fennel-syntax
+
+## License
+
+[MIT](LICENSE)

data/bin/fennel-parity

@@ -5,15 +5,18 @@ 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
+  classify-wallet.kap
   climbing-stairs.kap
   describe.kap
   destructure.kap
+  even-squares.kap
   factorial.kap
   fib.kap
   fizzbuzz.kap
@@ -29,6 +32,7 @@ COMPATIBLE = %w[
   match.kap
   min-max.kap
   or-patterns.kap
+  power-of-three.kap
   packet-router.kap
   points.kap
   primes.kap
@@ -40,8 +44,8 @@ COMPATIBLE = %w[
   underscore-patterns.kap
 ].freeze
 
-def run(cmd, file)
-  out, err, status = Open3.capture3(cmd, file, chdir: EXAMPLES)
+def run(cmd, file, chdir: EXAMPLES)
+  out, err, status = Open3.capture3(cmd, file, chdir:)
   [out, err, status]
 rescue StandardError => e
   ['', e.message, nil]
@@ -125,6 +129,17 @@ def check(name)
   [: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 = []
@@ -142,13 +157,30 @@ COMPATIBLE.each do |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
-if failures.empty?
-  puts "All #{COMPATIBLE.size} compatible examples produce matching output."
+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 "#{failures.size} of #{COMPATIBLE.size} examples failed:\n\n"
-  failures.each do |name, reason|
+  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

data/examples/classify-wallet.kap

@@ -0,0 +1,11 @@
+(fn classify-wallet [wallet]
+  (case wallet
+    {1 a 25 b} (.. "pennies-" a "-quarters-" b)
+    {25 q} (.. "quarters-only-" q)
+    {1 p} (.. "pennies-only-" p)
+    _ "mixed"))
+
+(print (classify-wallet {1 5 25 2}))
+(print (classify-wallet {25 4}))
+(print (classify-wallet {1 10}))
+(print (classify-wallet {5 3 10 2}))

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/power-of-three.kap

@@ -0,0 +1,12 @@
+(fn power-of-three? [n]
+  (macro divisible? [v k]
+    `(= 0 (% ,v ,k)))
+  (var x n)
+  (while (and (> x 1) (divisible? x 3))
+    (set x (/ x 3)))
+  (= x 1))
+
+(print (power-of-three? 27))
+(print (power-of-three? 9))
+(print (power-of-three? 45))
+(print (power-of-three? 1))

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/exe/kapusta-ls

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/kapusta/lsp'
+
+case ARGV.first
+when '--version', '-v'
+  puts "kapusta-ls #{Kapusta::VERSION}"
+when '--help', '-h'
+  puts 'usage: kapusta-ls           # speak LSP over stdio'
+  puts '       kapusta-ls --version'
+else
+  Kapusta::LSP.start
+end

data/kapusta.gemspec

@@ -20,10 +20,10 @@ Gem::Specification.new do |spec|
   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)
+        %w[.rspec Gemfile README.md Rakefile kapfmt kapusta-ls kapusta.gemspec].include?(path)
     end
   end
   spec.bindir = 'exe'
-  spec.executables = %w[kapfmt kapusta]
+  spec.executables = %w[kapfmt kapusta kapusta-ls]
   spec.require_paths = ['lib']
 end

data/lib/kapusta/ast.rb

@@ -13,6 +13,7 @@ module Kapusta
 
   class Sym
     attr_reader :name
+    attr_accessor :line, :column
 
     def initialize(name)
       @name = name.to_s
@@ -23,7 +24,7 @@ module Kapusta
     end
 
     def inspect
-      "#<Sym #{@name}>"
+      @name.to_s
     end
 
     def ==(other)
@@ -76,7 +77,7 @@ module Kapusta
 
   class Vec
     attr_reader :items
-    attr_accessor :multiline_source
+    attr_accessor :multiline_source, :line, :column
 
     def initialize(items)
       @items = items
@@ -86,17 +87,25 @@ module Kapusta
     def to_ary
       @items
     end
+
+    def inspect
+      "[#{@items.map(&:inspect).join(' ')}]"
+    end
   end
 
   class HashLit
     attr_reader :entries
-    attr_accessor :multiline_source
+    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
       @entries.grep(Array)
     end
@@ -108,7 +117,7 @@ module Kapusta
 
   class List
     attr_reader :items
-    attr_accessor :multiline_source
+    attr_accessor :multiline_source, :line, :column
 
     def initialize(items)
       @items = items
@@ -126,6 +135,10 @@ module Kapusta
     def empty?
       @items.empty?
     end
+
+    def inspect
+      "(#{@items.map(&:inspect).join(' ')})"
+    end
   end
 
   class AutoGensym < Sym
@@ -134,27 +147,48 @@ module Kapusta
     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
@@ -26,12 +28,14 @@ module Kapusta
         end
 
         def emit_lambda(pattern, body, env, current_scope)
+          validate_fn_params!(pattern)
           return emit_simple_lambda(pattern, body, env, current_scope) if simple_parameter_pattern?(pattern)
 
           args_var = temp('args')
           body_env = env.child
           bindings_code, body_env = emit_pattern_bind(pattern, args_var, body_env)
-          body_code, = emit_sequence(body, body_env, current_scope, allow_method_definitions: false)
+          body_code, = emit_sequence(body, body_env, current_scope,
+                                     allow_method_definitions: false, result: false)
           block_locals = pattern_names(pattern).map { |name| body_env.lookup(name) }.uniq
           block_locals_clause = block_locals.empty? ? '' : "; #{block_locals.join(', ')}"
           [
@@ -54,12 +58,26 @@ module Kapusta
         def build_simple_block_parts(pattern, body, env, current_scope)
           body_env = env.child
           params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
-          body_code, = emit_sequence(body, body_env, current_scope, allow_method_definitions: false)
+          body_code, = emit_sequence(body, body_env, current_scope,
+                                     allow_method_definitions: false, result: false)
           [params, body_code]
         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 validate_fn_params!(pattern)
+          return unless pattern.is_a?(Vec)
+
+          pattern.items.each_with_index do |item, idx|
+            next unless item.is_a?(Sym) && item.name == '...'
+            next if idx == pattern.items.length - 1
+
+            emit_error!(:vararg_not_last)
+          end
         end
 
         def emit_definition_form(form, env, current_scope)
@@ -123,6 +141,7 @@ module Kapusta
         end
 
         def emit_direct_method_definition(name_sym, pattern, body, env)
+          validate_fn_params!(pattern)
           return unless simple_parameter_pattern?(pattern)
 
           ruby_name = direct_method_definition_name(name_sym)
@@ -131,7 +150,8 @@ module Kapusta
 
           body_env = env.child
           params = pattern.items.map { |sym| define_local(body_env, sym.name, shadow: true) }
-          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          body_code, = emit_sequence(body, body_env, :toplevel,
+                                     allow_method_definitions: false, result: false)
           header = params.empty? ? "def #{ruby_name}" : "def #{ruby_name}(#{params.join(', ')})"
           [
             header,
@@ -165,12 +185,14 @@ module Kapusta
         end
 
         def emit_method_body(pattern, body, env)
+          validate_fn_params!(pattern)
           return emit_simple_method_body(pattern, body, env) if simple_parameter_pattern?(pattern)
 
           args_var = temp('args')
           method_env = env.child
           bindings_code, body_env = emit_pattern_bind(pattern, args_var, method_env)
-          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+          body_code, = emit_sequence(body, body_env, :toplevel,
+                                     allow_method_definitions: false, result: false)
           block_locals = pattern_names(pattern).map { |name| body_env.lookup(name) }.uniq
           block_locals_clause = block_locals.empty? ? '' : "; #{block_locals.join(', ')}"
           ["do |*#{args_var}#{block_locals_clause}|", join_code(bindings_code, body_code)]
@@ -227,6 +249,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,8 +259,11 @@ 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)
+            walk_pattern_syms(pattern) { |sym| mark_mutability(child_env, sym, mutable: false) }
             binding_codes << bind_code
             i += 2
           end
@@ -250,11 +278,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 +294,58 @@ 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 walk_pattern_syms(pattern, &block)
+          case pattern
+          when Sym
+            yield pattern unless pattern.name == '_'
+          when Vec
+            pattern.items.each do |item|
+              next if item.is_a?(Sym) && ['&', '...'].include?(item.name)
+
+              walk_pattern_syms(item, &block)
+            end
+          when HashLit
+            pattern.pairs.each { |pair| walk_pattern_syms(pair[1], &block) }
+          end
+        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 +354,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 +398,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 +418,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