kapusta 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e247dd5e305dcac681bcdb9decbf30d8e0628232626f751c2f39fe8d79796e02
-  data.tar.gz: 6d1e24c986c1301045e469b03a76295e03276cee031939ac87dea34187931251
+  metadata.gz: 81b3b1124689c8b7a89734ab0b8a5b584ba8ef6edcffab89fefcd4e86e6a6e2a
+  data.tar.gz: f3e83405f8de3298e0bfde66dcc8afd67f38e2fa2733b34085ef00579635c247
 SHA512:
-  metadata.gz: 919382905342cffcbf1b6986a232f9050dcacfeb196fab8131d9d72a462d8c741e560fe1b72922998bb980a8fb3eeecbda9c348acd694b3299d890b44022132c
-  data.tar.gz: 50e77ee9da2df8b1a2f6e694b205dde09e2631d6b49cbc9ddd9cc022e2f86122055abd721d5a82f76af1a2004e78e0f14f2a1b4d02c16cbfb8ee09fb1397a900
+  metadata.gz: f2c058a5c9f86be04f3d29ade387ede8ebe818365078a2a31f161a4044eb6b6a0dfd1e65453e681e79898e57dfd2e830281572ef33cc9ca57668ae088e901eb2
+  data.tar.gz: fc20f32661cf1979ae93aba6adf7be488e96007d151f8997704f37e6d000fa9affeca6383b8fc749471fa823eb24c4fb2dcd3e6c39fa475cfdf25a7fafa4207d

data/README.md

@@ -128,8 +128,8 @@ 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.
+1. Use `module Name <<` + `fn` for stateless functions ([`examples/app/args.kap`](https://github.com/evmorov/kapusta/tree/main/examples/app/args.kap)).
+2. Use `class` + `fn` for state or dependencies ([`examples/use_bank_account.rb`](https://github.com/evmorov/kapusta/tree/main/examples/use_bank_account.rb)).
 3. Avoid returning hashes of functions as the main app structure.
 
 ## Comparison with Fennel

data/examples/app/args.kap

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

data/examples/digit-tools.kap

@@ -0,0 +1,24 @@
+(module Digits <<
+  (fn sum [n]
+    (var total 0)
+    (var x n)
+    (while (> x 0)
+      (set total (+ total (% x 10)))
+      (set x (/ x 10)))
+    total)
+
+  (fn reverse [n]
+    (var result 0)
+    (var x n)
+    (while (> x 0)
+      (set result (+ (* result 10) (% x 10)))
+      (set x (/ x 10)))
+    result)
+
+  (fn palindrome? [n]
+    (= n (Digits.reverse n))))
+
+(print (Digits.sum 12345))
+(print (Digits.reverse 1230))
+(print (Digits.palindrome? 121))
+(print (Digits.palindrome? 123))

data/examples/excel-column.kap

@@ -0,0 +1,26 @@
+(module Excel <<)
+
+(fn to-number [title]
+  (var result 0)
+  (each [ch title.chars]
+    (set result (+ (* result 26) (- ch.ord 64))))
+  result)
+
+(fn to-title [number]
+  (var n number)
+  (var chars [])
+  (while (> n 0)
+    (set n (- n 1))
+    (let [code (+ 65 (% n 26))]
+      (chars.unshift code.chr))
+    (set n (/ n 26)))
+  (chars.join ""))
+
+(end)
+
+(print (Excel.to-number "A"))
+(print (Excel.to-number "AB"))
+(print (Excel.to-number "ZY"))
+(print (Excel.to-title 1))
+(print (Excel.to-title 28))
+(print (Excel.to-title 701))

data/examples/logger-rate-limiter.kap

@@ -0,0 +1,26 @@
+(require "singleton")
+
+(class RateLimiter)
+(include Singleton)
+
+(fn initialize []
+  (set (ivar last) {}))
+
+(fn should-print? [timestamp message]
+  (let [last (ivar last)]
+    (if (or (not (last.key? message)) (>= timestamp (: last message)))
+        (do
+          (tset last message (+ timestamp 10))
+          true)
+        false)))
+
+(end)
+
+(let [logger (RateLimiter.instance)]
+  (print (logger.should-print? 1 "foo"))
+  (print (logger.should-print? 2 "bar"))
+  (print (logger.should-print? 3 "foo"))
+  (print (logger.should-print? 8 "bar"))
+  (print (logger.should-print? 10 "foo"))
+  (print (logger.should-print? 11 "foo"))
+  (print (= logger (RateLimiter.instance))))

data/examples/mruby-runtime-examples.txt

@@ -22,11 +22,13 @@ count-effects
 count-items-matching-rule
 counter
 destructure
+digit-tools
 divisibility-stats
 doto
 doto-hygiene
 egg-count
 even-squares
+excel-column
 exceptions
 factorial
 falling-drops

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

@@ -163,6 +163,7 @@ module Kapusta
           body = with_class_body do
             emit_sequence(parsed.body, env.child, :module, allow_method_definitions: true, result: false).first
           end
+          body = wrap_singleton(body) if parsed.singleton
           emit_module_wrapper(parsed.name, body)
         end
 
@@ -432,6 +433,9 @@ module Kapusta
         def emit_self_call(name, args, env, current_scope)
           positional, kwargs, block_form = split_call_args(args, env, current_scope)
           snake = Kapusta.kebab_to_snake(name)
+          if Language.class_body_declaration?(snake) && kwargs.nil? && block_form.nil?
+            return positional.empty? ? snake : "#{snake} #{positional.join(', ')}"
+          end
           if direct_method_name?(snake)
             return emit_direct_self_call(snake, positional, kwargs, block_form, env, current_scope)
           end

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

@@ -95,6 +95,7 @@ module Kapusta
               body, next_i = with_class_body do
                 emit_form_run(forms, body_start, env.child, :module, header_form: form)
               end
+              body = wrap_singleton(body) if parsed.singleton
               [emit_direct_module_header(parsed.name, body) || emit_module_wrapper(parsed.name, body), next_i]
             end
           else
@@ -157,6 +158,7 @@ module Kapusta
 
           name = form.head.name
           return if special_form?(name)
+          return if Language.class_body_declaration?(Kapusta.kebab_to_snake(name))
           return if form.head.dotted?
           return if env.lookup_if_defined(name)
 
@@ -175,6 +177,7 @@ module Kapusta
               emit_sequence(parsed.body, env.child, :module, allow_method_definitions: true,
                                                              result: false).first
             end
+            body = wrap_singleton(body) if parsed.singleton
             emit_direct_module_header(parsed.name, body) || emit_module_wrapper(parsed.name, body)
           else
             parsed = Language.parse_class_args(args)
@@ -315,6 +318,10 @@ module Kapusta
           text.lines.map { |line| line.strip.empty? ? line : "#{prefix}#{line}" }.join
         end
 
+        def wrap_singleton(body)
+          ['class << self', indent(body), 'end'].join("\n")
+        end
+
         def temp(prefix)
           @temp_index += 1
           "kap_#{prefix}_#{@temp_index}"

data/lib/kapusta/compiler/language.rb

@@ -8,7 +8,7 @@ module Kapusta
 
         def anonymous? = name.nil?
       end
-      ModuleForm = Struct.new(:name, :body, :prefix_length, keyword_init: true)
+      ModuleForm = Struct.new(:name, :body, :singleton, :prefix_length, keyword_init: true)
       ClassForm = Struct.new(:name, :supers, :body, :prefix_length, keyword_init: true)
       TryForm = Struct.new(:body, :clauses, keyword_init: true)
       CatchClause = Struct.new(:klass, :bind_sym, :body, keyword_init: true)
@@ -165,6 +165,12 @@ module Kapusta
         quasi-sym quasi-list quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym
       ].freeze
       SPECIAL_FORMS = (CORE_SPECIAL_FORMS + LuaCompat::SPECIAL_FORMS).freeze
+      CLASS_BODY_DECLARATIONS = %w[
+        include extend prepend
+        private public protected
+        module_function
+        attr_accessor attr_reader attr_writer
+      ].freeze
 
       module_function
 
@@ -207,6 +213,8 @@ module Kapusta
 
       def special_form?(name) = SPECIAL_FORMS.include?(name)
 
+      def class_body_declaration?(name) = CLASS_BODY_DECLARATIONS.include?(name)
+
       def function_head?(name) = FUNCTION_HEADS.include?(name)
 
       def function_definition_head?(name) = FUNCTION_DEFINITION_HEADS.include?(name)
@@ -282,7 +290,10 @@ module Kapusta
       end
 
       def parse_module_args(args)
-        ModuleForm.new(name: args[0], body: args[1..] || [], prefix_length: 1)
+        rest = args[1..] || []
+        singleton = rest[0].is_a?(Sym) && rest[0].name == '<<'
+        rest = rest.drop(1) if singleton
+        ModuleForm.new(name: args[0], body: rest, singleton:, prefix_length: singleton ? 2 : 1)
       end
 
       def parse_class_args(args)

data/lib/kapusta/formatter.rb

@@ -13,7 +13,7 @@ module Kapusta
     STDIN_PATH = '-'
     BODY_ONLY_HEADS = %w[do finally].freeze
     SINGLE_PREFIX_BODY_HEADS = %w[
-      while when unless for each icollect collect fcollect accumulate faccumulate module
+      while when unless for each icollect collect fcollect accumulate faccumulate
     ].freeze
     CASE_HEADS = %w[case match].freeze
     private_constant :BODY_ONLY_HEADS, :SINGLE_PREFIX_BODY_HEADS, :CASE_HEADS
@@ -188,6 +188,7 @@ module Kapusta
       when 'try' then render_try(list, indent)
       when *SINGLE_PREFIX_BODY_HEADS then render_single_prefix_body_form(name, raw_args, indent)
       when 'class' then render_class(list, indent)
+      when 'module' then render_module(list, indent)
       when 'catch' then render_catch(list, indent)
       when 'if' then render_if(list, indent)
       when *CASE_HEADS then render_case_or_match(name, list, raw_args, indent)
@@ -234,6 +235,14 @@ module Kapusta
       render_prefix_body_form('class', raw_prefix, raw_body, indent)
     end
 
+    def render_module(list, indent)
+      args = list_rest(list)
+      raw_args = list_raw_rest(list)
+      prefix_length = Compiler::Language.parse_module_args(args).prefix_length
+      raw_prefix, raw_body = split_raw_items(raw_args, prefix_length)
+      render_prefix_body_form('module', raw_prefix, raw_body, indent)
+    end
+
     def render_try(list, indent)
       args = list_rest(list)
       return render_sequential_head_form('try', list_raw_rest(list), indent) if contains_comments?(list_raw_rest(list))

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

data/spec/examples_spec.rb

@@ -779,6 +779,38 @@ RSpec.describe 'examples' do
       "alice"
     OUT
   end
+
+  it 'excel-column.kap' do
+    expect(run_example('excel-column.kap')).to eq(<<~OUT)
+      1
+      28
+      701
+      "A"
+      "AB"
+      "ZY"
+    OUT
+  end
+
+  it 'logger-rate-limiter.kap' do
+    expect(run_example('logger-rate-limiter.kap')).to eq(<<~OUT)
+      true
+      true
+      false
+      false
+      false
+      true
+      true
+    OUT
+  end
+
+  it 'digit-tools.kap' do
+    expect(run_example('digit-tools.kap')).to eq(<<~OUT)
+      15
+      321
+      true
+      false
+    OUT
+  end
 end
 
 RSpec.describe 'mruby runtime examples' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -53,12 +53,14 @@ files:
 - examples/count-items-matching-rule.kap
 - examples/counter.kap
 - examples/destructure.kap
+- examples/digit-tools.kap
 - examples/divisibility-stats.kap
 - examples/doto-hygiene.kap
 - examples/doto.kap
 - examples/egg-count.kap
 - examples/equal-sums.kap
 - examples/even-squares.kap
+- examples/excel-column.kap
 - examples/exceptions.kap
 - examples/factorial.kap
 - examples/falling-drops.kap
@@ -77,6 +79,7 @@ files:
 - examples/leap-year.kap
 - examples/left-right-difference.kap
 - examples/length-of-last-word.kap
+- examples/logger-rate-limiter.kap
 - examples/macros-dbg.kap
 - examples/macros-import-helpers.kap
 - examples/macros-import-whole.kap