kapusta 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f58b2e1f81723470a819ba38e3e6e811a3aa3a97ba79443e6ad0c59457d0fa08
-  data.tar.gz: 9207c1491218f71eeeedf2495a22805b9e2d1a8336200d212437fb813005c1d8
+  metadata.gz: 76f35530eebc269dfec62ee1f36f6cc11a252ee4590eeac961c9b47e4e49ca09
+  data.tar.gz: a0ee60d21fb9a6066915d916e465bef09d9208c0469712673db35bea83efd7c4
 SHA512:
-  metadata.gz: 9e0e2220a388a1a06ed86733e01fbc1eacf3a48536c503e7e8ccbcf85871fcda35cce16ddc9b434f3d1ac3c8dc23cb15af3d78528fc269fae62d25ef49a6fba2
-  data.tar.gz: 3a0f8628514de972b1def03cfd8f47798b630632fe728a41d46a0c9aade7587c011004695903697b929fd82c3302bf90c7efdc7d5e4edb7f0ab7bd3c9c1c7387
+  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

@@ -12,6 +12,7 @@ KAPFMT = File.join(ROOT, 'exe', 'kapfmt')
 COMPATIBLE = %w[
   ackermann.kap
   anonymous-greeter.kap
+  classify-wallet.kap
   climbing-stairs.kap
   describe.kap
   destructure.kap
@@ -31,6 +32,7 @@ COMPATIBLE = %w[
   match.kap
   min-max.kap
   or-patterns.kap
+  power-of-three.kap
   packet-router.kap
   points.kap
   primes.kap

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/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/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/compiler/emitter/bindings.rb

@@ -28,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(', ')}"
           [
@@ -56,7 +58,8 @@ 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
 
@@ -66,6 +69,17 @@ module Kapusta
           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)
           return [emit_method_definition(form, env), env] unless current_scope == :toplevel
 
@@ -127,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)
@@ -135,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,
@@ -169,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)]
@@ -245,6 +263,7 @@ module Kapusta
             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
@@ -290,6 +309,21 @@ module Kapusta
           @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

data/lib/kapusta/compiler/emitter/collections.rb

@@ -4,6 +4,8 @@ module Kapusta
   module Compiler
     module EmitterModules
       module Collections
+        include LuaCompat::Emission
+
         private
 
         def emit_icollect(args, env, current_scope)
@@ -16,11 +18,44 @@ module Kapusta
 
         def emit_collect(args, env, current_scope)
           result_var = temp('result')
-          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
-            body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
-            emit_hash_collection_step(result_var, body)
+          values_form = simple_values_call(args[1]) if args.length == 2
+          emit_iteration(args[0], env, current_scope,
+                         method: 'each_with_object({})', extra_block_param: result_var) do |iter_env|
+            if values_form
+              emit_collect_values_step(result_var, values_form, iter_env, current_scope)
+            else
+              body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
+              emit_hash_collection_step(result_var, body)
+            end
+          end
+        end
+
+        def simple_values_call(form)
+          return unless form.is_a?(List) && form.items.length == 3
+
+          head = form.head
+          form if head.is_a?(Sym) && head.name == 'values'
+        end
+
+        def emit_collect_values_step(result_var, values_form, iter_env, current_scope)
+          key_form = values_form.items[1]
+          val_form = values_form.items[2]
+          key_code = emit_expr(key_form, iter_env, current_scope)
+          val_code = emit_expr(val_form, iter_env, current_scope)
+          assignment = "#{result_var}[#{key_code}] = #{val_code}"
+          guards = []
+          guards << "#{key_code}.nil?" unless definitely_non_nil?(key_form)
+          guards << "#{val_code}.nil?" unless definitely_non_nil?(val_form)
+          return assignment if guards.empty?
+
+          "#{assignment} unless #{guards.join(' || ')}"
+        end
+
+        def definitely_non_nil?(form)
+          case form
+          when Numeric, String, ::Symbol, TrueClass, FalseClass then true
+          else false
           end
-          emit_collection_result(result_var, '{}', iter_code)
         end
 
         def emit_fcollect(args, env, current_scope)
@@ -63,29 +98,8 @@ module Kapusta
         end
 
         def try_emit_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var, init_code, body_forms)
-          return unless iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
-
-          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
-          case iter_expr.head.name
-          when 'ipairs'
-            value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
-            if ignored_pattern?(binding_pats[0])
-              body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
-              return inject_block(coll_code, "#{acc_var}, #{value_var}", init_code, value_bind || '', body_code)
-            end
-            index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
-            bind_code = [index_bind, value_bind].compact.join("\n")
-            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
-            inject_block("#{coll_code}.each_with_index", "#{acc_var}, (#{value_var}, #{index_var})",
-                         init_code, bind_code, body_code)
-          when 'pairs'
-            key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
-            value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
-            bind_code = [key_bind, value_bind].compact.join("\n")
-            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
-            inject_block(coll_code, "#{acc_var}, (#{key_var}, #{value_var})",
-                         init_code, bind_code, body_code)
-          end
+          emit_lua_compat_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                 init_code, body_forms)
         end
 
         def inject_block(receiver, params, init_code, bind_code, body_code)
@@ -153,54 +167,32 @@ module Kapusta
           end
         end
 
-        def emit_iteration(bindings_vec, env, current_scope, method: 'each')
+        def emit_iteration(bindings_vec, env, current_scope, method: 'each', extra_block_param: nil, &block)
           emit_error!(:each_no_binding) unless bindings_vec.is_a?(Vec)
 
           items = bindings_vec.items
           iter_expr = items.last
           binding_pats = items[0...-1]
 
-          if iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
-            case iter_expr.head.name
-            when 'ipairs'
-              body_env = env.child
-              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
-              coll_code = emit_expr(iter_expr.items[1], env, current_scope)
-              if ignored_pattern?(binding_pats[0])
-                bind_code = value_bind || ''
-                body_code = yield(body_env)
-                return iteration_block("#{coll_code}.#{method} do |#{value_var}|", bind_code, body_code)
-              end
-              index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
-              bind_code = [index_bind, value_bind].compact.join("\n")
-              body_code = yield(body_env)
-              receiver = method == 'each' ? "#{coll_code}.each_with_index" : "#{coll_code}.each_with_index.#{method}"
-              header = "#{receiver} do |#{value_var}, #{index_var}|"
-              return iteration_block(header, bind_code, body_code)
-            when 'pairs'
-              body_env = env.child
-              key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
-              value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
-              bind_code = [key_bind, value_bind].compact.join("\n")
-              body_code = yield(body_env)
-              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}.#{method} do |#{key_var}, #{value_var}|"
-              return iteration_block(header, bind_code, body_code)
-            end
-          end
+          lua_iteration = emit_lua_compat_iteration(iter_expr, binding_pats, env, current_scope,
+                                                    method:, extra_block_param:, &block)
+          return lua_iteration if lua_iteration
 
           coll_code = emit_expr(iter_expr, env, current_scope)
           if binding_pats.length == 1
             body_env = env.child
             value_var, bind_code = bind_iteration_param(binding_pats[0], 'value', body_env)
-            body_code = yield(body_env)
-            iteration_block("#{coll_code}.#{method} do |#{value_var}|", bind_code || '', body_code)
+            body_code = block.call(body_env)
+            params = extra_block_param ? "#{value_var}, #{extra_block_param}" : value_var
+            iteration_block("#{coll_code}.#{method} do |#{params}|", bind_code || '', body_code)
           else
             parts_var = temp('parts')
             body_env = env.child
             pairs = binding_pats.each_with_index.map { |pattern, i| [pattern, "#{parts_var}[#{i}]"] }
             bind_code, body_env = emit_iteration_bindings(pairs, body_env)
-            body_code = yield(body_env)
-            iteration_block("#{coll_code}.#{method} do |*#{parts_var}|", bind_code, body_code)
+            body_code = block.call(body_env)
+            params = extra_block_param ? "#{parts_var}, #{extra_block_param}" : "*#{parts_var}"
+            iteration_block("#{coll_code}.#{method} do |#{params}|", bind_code, body_code)
           end
         end
 

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -57,21 +57,38 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          emit_error!(:case_no_subject) if args.empty?
+
           clauses = args[1..]
           emit_error!(:case_no_patterns) if clauses.empty?
           emit_error!(:case_odd_patterns) if clauses.length.odd?
 
+          value_code = emit_expr(args[0], env, current_scope)
+          if simple_case_subject?(args[0]) && simple_expression?(value_code)
+            body = try_emit_native_case(value_code, clauses, env, current_scope, mode)
+            emit_error!(:case_unsupported) unless body
+            return body
+          end
+
           value_var = temp('case_value')
           body = try_emit_native_case(value_var, clauses, env, current_scope, mode)
           emit_error!(:case_unsupported) unless body
           [
             '(-> do',
-            indent("#{value_var} = #{emit_expr(args[0], env, current_scope)}"),
+            indent("#{value_var} = #{value_code}"),
             indent(body),
             'end).call'
           ].join("\n")
         end
 
+        def simple_case_subject?(form)
+          case form
+          when Sym then !form.dotted?
+          when Numeric, String, Symbol, true, false, nil then true
+          else false
+          end
+        end
+
         def try_emit_native_case(value_var, clauses, env, current_scope, mode)
           arms = []
           i = 0
@@ -92,10 +109,15 @@ module Kapusta
             arms.concat(sub_arms)
             i += 2
           end
-          arms << ['else', indent('nil')].join("\n")
+          arms << ['else', indent('nil')].join("\n") unless wildcard_last?(clauses)
           ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
+        def wildcard_last?(clauses)
+          last_pattern = clauses[-2]
+          last_pattern.is_a?(Sym) && last_pattern.name == '_'
+        end
+
         def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
           allow_pins = !where_guards.empty? && mode == :case
           plan = native_pattern_plan(pattern, env, mode:, allow_pins:)

data/lib/kapusta/compiler/emitter/expressions.rb

@@ -111,8 +111,6 @@ module Kapusta
           when 'quasi-vec-tail' then emit_quasi_vec_tail(args, env, current_scope)
           when 'quasi-hash' then emit_quasi_hash(args, env, current_scope)
           when 'quasi-gensym' then emit_quasi_gensym(args[0], env, current_scope)
-          when 'macro', 'macros', 'import-macros'
-            emit_error!(:special_must_be_toplevel, name:)
           else
             emit_error!(:unknown_special_form, name:)
           end

data/lib/kapusta/compiler/emitter/interop.rb

@@ -427,11 +427,12 @@ module Kapusta
         def emit_sym(sym, env)
           name = sym.name
           return 'self' if name == 'self'
-          return 'Float::INFINITY' if name == 'math.huge'
 
           if (binding = env.lookup_if_defined(sym))
             return binding_value_code(binding)
           end
+
+          emit_error!(:unexpected_vararg) if name == '...'
           return emit_multisym_value(sym, env) if sym.dotted?
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)

data/lib/kapusta/compiler/emitter/patterns.rb

@@ -246,12 +246,60 @@ module Kapusta
         end
 
         def compile_native_hash(pattern, env, mode:, allow_pins:, state:)
-          pairs = pattern.pairs.map do |key, value|
-            raise PatternNotTranslatable unless key.is_a?(Symbol)
-
+          sym_pairs, other_pairs = pattern.pairs.partition { |key, _| key.is_a?(Symbol) }
+          sym_parts = sym_pairs.map do |key, value|
             "#{key}: #{compile_native_pattern(value, env, mode:, allow_pins:, state:)}"
           end
-          "{#{pairs.join(', ')}}"
+          return "{#{sym_parts.join(', ')}}" if other_pairs.empty?
+
+          capture = temp('hash')
+          sym_pattern = sym_parts.empty? ? 'Hash' : "{#{sym_parts.join(', ')}}"
+          other_pairs.each do |key, value|
+            compile_native_hash_value(value, capture, compile_native_hash_key(key), env, mode:, state:)
+          end
+          "#{sym_pattern} => #{capture}"
+        end
+
+        def compile_native_hash_key(key)
+          case key
+          when Symbol, String, Numeric, true, false then key.inspect
+          when nil then 'nil'
+          else raise PatternNotTranslatable
+          end
+        end
+
+        def compile_native_hash_value(value, capture, key_code, env, mode:, state:)
+          lookup = "#{capture}[#{key_code}]"
+          case value
+          when Sym
+            name = value.name
+            return if name == '_'
+
+            if nil_allowing_pattern_name?(name)
+              raise PatternNotTranslatable if state[:bound_names].key?(name)
+
+              state[:bound_names][name] = true
+              state[:binding_names] << name
+              state[:guards] << "(#{sanitize_local(name)} = #{lookup}; true)"
+            else
+              binding = mode == :match ? env.lookup_if_defined(name) : nil
+              if state[:bound_names].key?(name)
+                raise PatternNotTranslatable
+              elsif binding
+                state[:guards] << "#{lookup} == #{binding_value_code(binding)}"
+              else
+                state[:bound_names][name] = true
+                state[:binding_names] << name
+                state[:guards] << "!(#{sanitize_local(name)} = #{lookup}).nil?"
+              end
+            end
+          when nil
+            state[:guards] << "#{lookup}.nil?"
+          when Symbol, String, Numeric, true, false
+            state[:guards] << "#{lookup} == #{value.inspect}"
+          else
+            raise PatternNotTranslatable
+          end
         end
 
         def compile_native_pin(pattern, env, mode:, allow_pins:)

data/lib/kapusta/compiler/emitter/support.rb

@@ -128,7 +128,7 @@ module Kapusta
             code, current_env = emit_form_in_sequence(form, current_env, current_scope,
                                                       allow_method_definitions:,
                                                       result_needed: result && index == forms.length - 1)
-            codes << code
+            codes << code unless code.empty?
           end
           [codes.join("\n"), current_env]
         end

data/lib/kapusta/compiler/emitter.rb

@@ -31,7 +31,7 @@ module Kapusta
 
       def emit_file(forms)
         env = Env.new
-        body = emit_forms_with_headers(forms, env, :toplevel)
+        body = emit_forms_with_headers(forms, env, :toplevel, result: false)
         "#{body}\n"
       end
     end