kapusta 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01cc980a37ff63b56db021edb64f7ed9b4381569bb82e8e4ada099a2b17ba19e
-  data.tar.gz: 035f0f4a38d5d9fad65f4a53e8343bbcad4b681bd33dfa975f7c9c638a83ccb4
+  metadata.gz: f58b2e1f81723470a819ba38e3e6e811a3aa3a97ba79443e6ad0c59457d0fa08
+  data.tar.gz: 9207c1491218f71eeeedf2495a22805b9e2d1a8336200d212437fb813005c1d8
 SHA512:
-  metadata.gz: caaeb31630a5c80607fe6c2907548c2874f177add0bdbd3555e72039dd598aaf481f91778043f6b81cd511c9ac8609e48f61c474766dac9b3e8a2fa41d408970
-  data.tar.gz: 5417ad8088be602618c3662660af820be6dbf15eb27d8300b1c542e3889fbfe1813d51ca7306f988a630616d1857f333141bf20b964d0869c2caa8c3eba869e3
+  metadata.gz: 9e0e2220a388a1a06ed86733e01fbc1eacf3a48536c503e7e8ccbcf85871fcda35cce16ddc9b434f3d1ac3c8dc23cb15af3d78528fc269fae62d25ef49a6fba2
+  data.tar.gz: 3a0f8628514de972b1def03cfd8f47798b630632fe728a41d46a0c9aade7587c011004695903697b929fd82c3302bf90c7efdc7d5e4edb7f0ab7bd3c9c1c7387

data/bin/fennel-parity

@@ -5,6 +5,7 @@ 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')
 
@@ -14,6 +15,7 @@ COMPATIBLE = %w[
   climbing-stairs.kap
   describe.kap
   destructure.kap
+  even-squares.kap
   factorial.kap
   fib.kap
   fizzbuzz.kap
@@ -40,8 +42,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 +127,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 +155,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/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/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/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
@@ -59,7 +61,9 @@ module Kapusta
         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 emit_definition_form(form, env, current_scope)
@@ -227,6 +231,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,7 +241,9 @@ 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)
             binding_codes << bind_code
             i += 2
@@ -250,11 +259,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 +275,43 @@ 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 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 +320,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 +364,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 +384,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

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

@@ -7,12 +7,11 @@ module Kapusta
         private
 
         def emit_icollect(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_array_collection_step(result_var, body)
+          emit_error!(:icollect_no_iterator) unless args[0].is_a?(Vec) && args[0].items.length >= 2
+
+          emit_iteration(args[0], env, current_scope, method: 'filter_map') do |iter_env|
+            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
           end
-          emit_collection_result(result_var, '[]', iter_code)
         end
 
         def emit_collect(args, env, current_scope)
@@ -35,27 +34,69 @@ module Kapusta
 
         def emit_accumulate(args, env, current_scope)
           bindings = args[0].items
+          emit_error!(:accumulate_no_iterator) if bindings.length < 4
+
           acc_name = bindings[0]
-          iter_bindings = Vec.new(bindings[2..])
-          loop_env = env.child
-          acc_var = define_local(loop_env, acc_name.name)
-          iter_code = emit_iteration(iter_bindings, loop_env, current_scope) do |iter_env|
-            iter_env.define(acc_name.name, acc_var)
-            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first.then do |body|
-              emit_sequence_value_assignment(acc_var, body)
-            end
+          init_code = emit_expr(bindings[1], env, current_scope)
+          iter_items = bindings[2..]
+          iter_expr = iter_items.last
+          binding_pats = iter_items[0...-1]
+
+          body_env = env.child
+          acc_var = define_local(body_env, acc_name.name)
+
+          inject_code = try_emit_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                        init_code, args[1..])
+          return inject_code if inject_code
+
+          iter_code = emit_iteration(Vec.new(iter_items), body_env, current_scope) do |iter_env|
+            body_code, = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false)
+            emit_sequence_value_assignment(acc_var, body_code)
           end
           [
             '(-> do',
-            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent("#{acc_var} = #{init_code}"),
             indent(iter_code),
             indent(acc_var),
             'end).call'
           ].join("\n")
         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
+        end
+
+        def inject_block(receiver, params, init_code, bind_code, body_code)
+          inner = join_code(bind_code, body_code)
+          ["#{receiver}.inject(#{init_code}) do |#{params}|", indent(inner), 'end'].join("\n")
+        end
+
         def emit_faccumulate(args, env, current_scope)
           bindings = args[0].items
+          emit_error!(:accumulate_no_iterator) if bindings.length < 5
+
           acc_name = bindings[0]
           loop_name = bindings[2]
           loop_env = env.child
@@ -112,7 +153,9 @@ module Kapusta
           end
         end
 
-        def emit_iteration(bindings_vec, env, current_scope)
+        def emit_iteration(bindings_vec, env, current_scope, method: 'each')
+          emit_error!(:each_no_binding) unless bindings_vec.is_a?(Vec)
+
           items = bindings_vec.items
           iter_expr = items.last
           binding_pats = items[0...-1]
@@ -126,12 +169,13 @@ module Kapusta
               if ignored_pattern?(binding_pats[0])
                 bind_code = value_bind || ''
                 body_code = yield(body_env)
-                return iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+                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)
-              header = "#{coll_code}.each_with_index do |#{value_var}, #{index_var}|"
+              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
@@ -139,7 +183,7 @@ module Kapusta
               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)}.each do |#{key_var}, #{value_var}|"
+              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
@@ -149,14 +193,14 @@ module Kapusta
             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}.each do |#{value_var}|", bind_code || '', body_code)
+            iteration_block("#{coll_code}.#{method} do |#{value_var}|", 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}.each do |*#{parts_var}|", bind_code, body_code)
+            iteration_block("#{coll_code}.#{method} do |*#{parts_var}|", bind_code, body_code)
           end
         end
 

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

@@ -11,8 +11,7 @@ module Kapusta
         end
 
         def build_if(args, env, current_scope)
-          return 'nil' if args.empty?
-          return emit_expr(args[0], env, current_scope) if args.length == 1
+          emit_error!(:if_no_body) if args.length < 2
 
           cond = emit_expr(args[0], env, current_scope)
           truthy = emit_if_branch(args[1], env, current_scope)
@@ -58,9 +57,13 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          clauses = args[1..]
+          emit_error!(:case_no_patterns) if clauses.empty?
+          emit_error!(:case_odd_patterns) if clauses.length.odd?
+
           value_var = temp('case_value')
-          body = try_emit_native_case(value_var, args[1..], env, current_scope, mode)
-          emit_error!('case/match clauses use patterns this compiler cannot translate') unless body
+          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)}"),

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

@@ -7,17 +7,19 @@ module Kapusta
         private
 
         def emit_expr(form, env, current_scope)
-          case form
-          when Sym then emit_sym(form, env)
-          when Vec then "[#{form.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
-          when HashLit
-            "{#{form.pairs.map do |key, value|
-              "#{emit_hash_key(key, env, current_scope)} => #{emit_expr(value, env, current_scope)}"
-            end.join(', ')}}"
-          when List then emit_list(form, env, current_scope)
-          when String, Symbol, Numeric, true, false, nil then form.inspect
-          else
-            emit_error!("cannot emit form: #{form.inspect}")
+          with_current_form(form) do
+            case form
+            when Sym then emit_sym(form, env)
+            when Vec then "[#{form.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
+            when HashLit
+              "{#{form.pairs.map do |key, value|
+                "#{emit_hash_key(key, env, current_scope)} => #{emit_expr(value, env, current_scope)}"
+              end.join(', ')}}"
+            when List then emit_list(form, env, current_scope)
+            when String, Symbol, Numeric, true, false, nil then form.inspect
+            else
+              emit_error!(:cannot_emit_form, form: form.inspect)
+            end
           end
         end
 
@@ -29,7 +31,7 @@ module Kapusta
         end
 
         def emit_list(list, env, current_scope)
-          return 'nil' if list.empty?
+          emit_error!(:empty_call) if list.empty?
 
           head = list.head
           args = list.rest
@@ -43,6 +45,11 @@ module Kapusta
             return emit_self_call(head.name, args, env, current_scope)
           end
 
+          case head
+          when Numeric, String, Symbol, true, false, nil
+            emit_error!(:cannot_call_literal, value: head.inspect)
+          end
+
           emit_callable_call(emit_expr(head, env, current_scope), args, env, current_scope)
         end
 
@@ -51,6 +58,7 @@ module Kapusta
           when 'fn', 'lambda', 'λ' then emit_fn(args, env, current_scope)
           when 'let' then emit_let(args, env, current_scope)
           when 'local', 'var' then emit_local_expr(args, env, current_scope)
+          when 'global' then emit_global_expr(args, env, current_scope)
           when 'set' then emit_set_expr(args, env, current_scope)
           when 'if' then emit_if(args, env, current_scope)
           when 'case' then emit_case(args, env, current_scope, :case)
@@ -96,7 +104,7 @@ module Kapusta
           when '/' then emit_div(args, env, current_scope)
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
           when 'print' then emit_print(args, env, current_scope)
-          when 'quasi-sym' then "Kapusta::Sym.new(#{emit_expr(args[0], env, current_scope)})"
+          when 'quasi-sym' then "Kapusta::MacroSym.new(#{emit_expr(args[0], env, current_scope)})"
           when 'quasi-list' then "Kapusta::List.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
           when 'quasi-list-tail' then emit_quasi_list_tail(args, env, current_scope)
           when 'quasi-vec' then "Kapusta::Vec.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
@@ -104,9 +112,9 @@ module Kapusta
           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!("#{name} must appear at the top level and is consumed by the macro expander")
+            emit_error!(:special_must_be_toplevel, name:)
           else
-            emit_error!("unknown special form: #{name}")
+            emit_error!(:unknown_special_form, name:)
           end
         end
 
@@ -138,6 +146,9 @@ module Kapusta
         def emit_concat(args, env, current_scope)
           return '""' if args.empty?
 
+          args.each do |arg|
+            emit_error!(:vararg_with_operator) if arg.is_a?(Sym) && arg.name == '...'
+          end
           args.map { |arg| emit_string_part(arg, env, current_scope) }.join(' + ')
         end