jrf 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9bb2a3a16d2bbe8cfb463267ff74d7d582511d4b4891e56ad3dfa6eee75fceb
-  data.tar.gz: a13b2e9c8517c3da997452166556505b24fc4d5f898765ad33495eafd57c3081
+  metadata.gz: 7ac8b4b0fe2489c04dcba49752df7143f7e218de9f21b0496e2c3fdd2f732088
+  data.tar.gz: 2787cc4714d0e99909c4430fe23aca1fcaae1c25a079f15b2092861b53c4f5ea
 SHA512:
-  metadata.gz: 54b400cdaba584896f2511acfe9a41ef10af25033bf88cfc6e0386eaa840df9395fb0d008c320b3193d55a9c3fad444a7f54bd29f52c34f69bc9a9cf392a7809
-  data.tar.gz: 80c72675e179da483316bfeaee7114da6edb49dc66ae179aa072d48907c4c9caf74113c6681b2f4a83f4b97da6faac436f5d6af5bd31e82605b122d85892cede
+  metadata.gz: 61f498f33e794258ebed00a468aa779ece52eff4c29d0538f7bc1601391d0a6948c32ed5dfbd76439e55a283ad4c59dc8312254711341dae2b7e79bf45b8a0a0
+  data.tar.gz: 92e1c46977cf3d841c8469fcf7e757cfcb4b6c60e800b063771bed3cc88eac7622e7d9a0c4aab906cefd60d046fe77a1f4e2f932d37687c952db3a598a0f3b1c

data/exe/jrf

@@ -10,4 +10,4 @@ end
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "jrf"
 
-exit Jrf::CLI.run(ARGV)
+Jrf::CLI.run(ARGV)

data/lib/jrf/cli.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "optparse"
+
 require_relative "cli/runner"
+require_relative "version"
 
 module Jrf
   class CLI
     USAGE = "usage: jrf [options] 'STAGE >> STAGE >> ...'"
-
     HELP_TEXT = <<~'TEXT'
       usage: jrf [options] 'STAGE >> STAGE >> ...'
 
@@ -15,8 +17,10 @@ module Jrf
         -v, --verbose  print parsed stage expressions
         --lax          allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)
         -p, --pretty   pretty-print JSON output instead of compact NDJSON
+        --no-jit       do not enable YJIT, even when supported by the Ruby runtime
         --atomic-write-bytes N
                        group short outputs into atomic writes of up to N bytes
+        -V, --version  show version and exit
         -h, --help     show this help and exit
 
       Pipeline:
@@ -38,43 +42,47 @@ module Jrf
       verbose = false
       lax = false
       pretty = false
+      jit = true
       atomic_write_bytes = Runner::DEFAULT_OUTPUT_BUFFER_LIMIT
-
-      while argv.first&.start_with?("-")
-        case argv.first
-        when "-v", "--verbose"
-          verbose = true
-          argv.shift
-        when "--lax"
-          lax = true
-          argv.shift
-        when "-p", "--pretty"
-          pretty = true
-          argv.shift
-        when /\A--atomic-write-bytes=(.+)\z/
-          atomic_write_bytes = parse_atomic_write_bytes(Regexp.last_match(1), err)
-          return 1 unless atomic_write_bytes
-          argv.shift
-        when "--atomic-write-bytes"
-          argv.shift
-          atomic_write_bytes = parse_atomic_write_bytes(argv.shift, err)
-          return 1 unless atomic_write_bytes
-        when "-h", "--help"
-          out.puts HELP_TEXT
-          return 0
-        else
-          err.puts "unknown option: #{argv.first}"
-          err.puts USAGE
-          return 1
+      begin
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("-v", "--verbose", "print parsed stage expressions") { verbose = true }
+          opts.on("--lax", "allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)") { lax = true }
+          opts.on("-p", "--pretty", "pretty-print JSON output instead of compact NDJSON") { pretty = true }
+          opts.on("--no-jit", "do not enable YJIT, even when supported by the Ruby runtime") { jit = false }
+          opts.on("--atomic-write-bytes N", Integer, "group short outputs into atomic writes of up to N bytes") do |value|
+            if value.positive?
+              atomic_write_bytes = value
+            else
+              raise OptionParser::InvalidArgument, "--atomic-write-bytes requires a positive integer"
+            end
+          end
+          opts.on("-V", "--version", "show version and exit") do
+            out.puts Jrf::VERSION
+            exit
+          end
+          opts.on("-h", "--help", "show this help and exit") do
+            out.puts HELP_TEXT
+            exit
+          end
         end
+
+        parser.order!(argv)
+      rescue OptionParser::ParseError => e
+        err.puts e.message
+        err.puts USAGE
+        exit 1
       end
 
       if argv.empty?
         err.puts USAGE
-        return 1
+        exit 1
       end
 
       expression = argv.shift
+      enable_yjit if jit
+
       inputs = Enumerator.new do |y|
         if argv.empty?
           y << input
@@ -103,15 +111,12 @@ module Jrf
         pretty: pretty,
         atomic_write_bytes: atomic_write_bytes
       ).run(expression, verbose: verbose)
-      0
     end
 
-    def self.parse_atomic_write_bytes(value, err)
-      bytes = Integer(value, exception: false)
-      return bytes if bytes && bytes.positive?
+    def self.enable_yjit
+      return unless defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
 
-      err.puts "--atomic-write-bytes requires a positive integer"
-      nil
+      RubyVM::YJIT.enable
     end
   end
 end

data/lib/jrf/pipeline.rb

@@ -22,54 +22,43 @@ module Jrf
     # @yieldparam value output value
     # @return [Array, nil] output values (without block), or nil (with block)
     def call(input, &on_output)
-      if on_output
-        call_streaming(input, &on_output)
-      else
+      if on_output.nil?
         results = []
-        call_streaming(input) { |v| results << v }
-        results
+        on_output = proc { |value| results << value }
       end
-    end
-
-    private
 
-    def call_streaming(input, &on_output)
-      error = nil
       begin
         input.each { |value| process_value(value, @stages, &on_output) }
-      rescue StandardError => e
-        error = e
       ensure
         flush_reducers(@stages, &on_output)
       end
-      raise error if error
+
+      results unless results.nil?
     end
 
-    def process_value(input, stages, &on_output)
-      current_values = [input]
+    private
 
-      stages.each do |stage|
-        next_values = []
+    def process_value(value, stages, idx = 0, &on_output)
+      while idx < stages.length
+        value = stages[idx].call(value)
 
-        current_values.each do |value|
-          out = stage.call(value)
-          if out.equal?(Control::DROPPED)
-            next
-          elsif out.is_a?(Control::Flat)
-            unless out.value.is_a?(Array)
-              raise TypeError, "flat expects Array, got #{out.value.class}"
-            end
-            next_values.concat(out.value)
-          else
-            next_values << out
+        if value.equal?(Control::DROPPED)
+          return
+        elsif value.is_a?(Control::Flat)
+          value = value.value
+          unless value.is_a?(Array)
+            raise TypeError, "flat expects Array, got #{value.class}"
+          end
+          value.each do |child|
+            process_value(child, stages, idx + 1, &on_output)
           end
+          return
         end
 
-        return if next_values.empty?
-        current_values = next_values
+        idx += 1
       end
 
-      current_values.each(&on_output)
+      on_output.call(value)
     end
 
     def flush_reducers(stages, &on_output)

data/lib/jrf/row_context.rb

@@ -13,7 +13,7 @@ module Jrf
       def define_reducer(name, &definition)
         define_method(name) do |*args, **kwargs, &block|
           spec = definition.call(self, *args, **kwargs, block: block)
-          @__jrf_current_stage.allocate_reducer(
+          @__jrf_current_stage.step_reduce(
             spec.fetch(:value),
             initial: reducer_initial_value(spec.fetch(:initial)),
             finish: spec[:finish],
@@ -161,24 +161,24 @@ module Jrf
     def reduce(initial, &block)
       raise ArgumentError, "reduce requires a block" unless block
 
-      @__jrf_current_stage.allocate_reducer(current_input, initial: initial, &block)
+      @__jrf_current_stage.step_reduce(current_input, initial: initial, &block)
     end
 
     def map(&block)
       raise ArgumentError, "map requires a block" unless block
 
-      @__jrf_current_stage.allocate_map(:array, @obj, &block)
+      @__jrf_current_stage.step_map(:map, @obj, &block)
     end
 
     def map_values(&block)
       raise ArgumentError, "map_values requires a block" unless block
 
-      @__jrf_current_stage.allocate_map(:hash, @obj, &block)
+      @__jrf_current_stage.step_map(:map_values, @obj, &block)
     end
 
     def group_by(key, &block)
       block ||= proc { group }
-      @__jrf_current_stage.allocate_group_by(key, &block)
+      @__jrf_current_stage.step_group_by(key, &block)
     end
 
     private

data/lib/jrf/stage.rb

@@ -39,39 +39,52 @@ module Jrf
       @ctx.__jrf_current_stage = self
       result = @ctx.instance_eval(&@block)
 
-      if @mode.nil? && @reducers.any?
-        @mode = :reducer
-        @template = result
-      elsif @mode.nil?
-        @mode = :passthrough
+      if @mode.nil?
+        if @reducers.any?
+          @mode = :reducer
+          @template = result
+        else
+          @mode = :passthrough
+        end
       end
 
       (@mode == :reducer) ? Control::DROPPED : result
     end
 
-    def allocate_reducer(value, initial:, finish: nil, &step_fn)
+    def step_reduce(value, initial:, finish: nil, &step_fn)
       idx = @cursor
-      finish_rows = finish || ->(acc) { [acc] }
-      @reducers[idx] ||= Reducers.reduce(initial, finish: finish_rows, &step_fn)
+
+      if @reducers[idx].nil?
+        finish_rows = finish || ->(acc) { [acc] }
+        @reducers[idx] = Reducers.reduce(initial, finish: finish_rows, &step_fn)
+        result = ReducerToken.new(idx)
+      else
+        result = Control::DROPPED
+      end
+
       @reducers[idx].step(value)
-      @cursor += 1
-      ReducerToken.new(idx)
+      @cursor = idx + 1
+      result
     end
 
-    def allocate_map(type, collection, &block)
+    def step_map(builtin, collection, &block)
       idx = @cursor
       @cursor += 1
 
+      if collection.is_a?(Array)
+        raise TypeError, "map_values expects Hash, got Array" if builtin == :map_values
+      elsif !collection.is_a?(Hash)
+        raise TypeError, "#{builtin} expects #{builtin == :map_values ? "Hash" : "Array or Hash"}, got #{collection.class}"
+      end
+
       # Transformation mode (detected on first call)
       if @map_transforms[idx]
-        return transform_collection(type, collection, &block)
+        return transform_collection(builtin, collection, &block)
       end
 
-      map_reducer = (@reducers[idx] ||= MapReducer.new(type))
+      map_reducer = (@reducers[idx] ||= MapReducer.new(builtin, collection.is_a?(Array)))
 
-      case type
-      when :array
-        raise TypeError, "map expects Array, got #{collection.class}" unless collection.is_a?(Array)
+      if collection.is_a?(Array)
         collection.each_with_index do |v, i|
           slot = map_reducer.slot(i)
           with_scoped_reducers(slot.reducers) do
@@ -79,12 +92,11 @@ module Jrf
             slot.template ||= result
           end
         end
-      when :hash
-        raise TypeError, "map_values expects Hash, got #{collection.class}" unless collection.is_a?(Hash)
+      else
         collection.each do |k, v|
           slot = map_reducer.slot(k)
           with_scoped_reducers(slot.reducers) do
-            result = @ctx.send(:__jrf_with_current_input, v) { block.call(v) }
+            result = @ctx.send(:__jrf_with_current_input, v) { invoke_block(builtin, block, k, v) }
             slot.template ||= result
           end
         end
@@ -94,15 +106,15 @@ module Jrf
       if @mode.nil? && map_reducer.slots.values.all? { |s| s.reducers.empty? }
         @map_transforms[idx] = true
         @reducers[idx] = nil
-        return transformed_slots(type, map_reducer)
+        return transformed_slots(builtin, map_reducer)
       end
 
       ReducerToken.new(idx)
     end
 
-    def allocate_group_by(key, &block)
+    def step_group_by(key, &block)
       idx = @cursor
-      map_reducer = (@reducers[idx] ||= MapReducer.new(:hash))
+      map_reducer = (@reducers[idx] ||= MapReducer.new(:group_by, false))
 
       row = @ctx._
       slot = map_reducer.slot(key)
@@ -138,55 +150,82 @@ module Jrf
       @cursor = saved_cursor
     end
 
-    def transform_collection(type, collection, &block)
-      case type
-      when :array
-        raise TypeError, "map expects Array, got #{collection.class}" unless collection.is_a?(Array)
+    def invoke_block(builtin, block, key, value)
+      case builtin
+      when :map then block.call([key, value])
+      when :map_values then block.call(value)
+      else raise ArgumentError, "unexpected builtin: #{builtin}"
+      end
+    end
 
+    def transform_collection(builtin, collection, &block)
+      if collection.is_a?(Array)
         collection.each_with_object([]) do |value, result|
           mapped = @ctx.send(:__jrf_with_current_input, value) { block.call(value) }
-          append_map_result(result, mapped)
+          append_result(result, mapped, builtin)
         end
-      when :hash
-        raise TypeError, "map_values expects Hash, got #{collection.class}" unless collection.is_a?(Hash)
-
-        collection.each_with_object({}) do |(key, value), result|
-          mapped = @ctx.send(:__jrf_with_current_input, value) { block.call(value) }
-          next if mapped.equal?(Control::DROPPED)
-          raise TypeError, "flat is not supported inside map_values" if mapped.is_a?(Control::Flat)
+      else
+        case builtin
+        when :map
+          collection.each_with_object([]) do |(key, value), result|
+            mapped = @ctx.send(:__jrf_with_current_input, value) { invoke_block(builtin, block, key, value) }
+            append_result(result, mapped, builtin)
+          end
+        when :map_values
+          collection.each_with_object({}) do |(key, value), result|
+            mapped = @ctx.send(:__jrf_with_current_input, value) { invoke_block(builtin, block, key, value) }
+            next if mapped.equal?(Control::DROPPED)
+            raise TypeError, "flat is not supported inside map_values" if mapped.is_a?(Control::Flat)
 
-          result[key] = mapped
+            result[key] = mapped
+          end
+        else
+          raise ArgumentError, "unexpected builtin: #{builtin}"
         end
       end
     end
 
-    def transformed_slots(type, map_reducer)
-      case type
-      when :array
+    def transformed_slots(builtin, map_reducer)
+      if map_reducer.array_input?
         map_reducer.slots
           .sort_by { |k, _| k }
           .each_with_object([]) do |(_, slot), result|
-            append_map_result(result, slot.template)
+            append_result(result, slot.template, builtin)
+          end
+      else
+        case builtin
+        when :map
+          map_reducer.slots.each_with_object([]) do |(_key, slot), result|
+            append_result(result, slot.template, builtin)
           end
-      when :hash
-        map_reducer.slots.each_with_object({}) do |(key, slot), result|
-          next if slot.template.equal?(Control::DROPPED)
-          raise TypeError, "flat is not supported inside map_values" if slot.template.is_a?(Control::Flat)
+        when :map_values
+          map_reducer.slots.each_with_object({}) do |(key, slot), result|
+            next if slot.template.equal?(Control::DROPPED)
+            raise TypeError, "flat is not supported inside map_values" if slot.template.is_a?(Control::Flat)
 
-          result[key] = slot.template
+            result[key] = slot.template
+          end
+        else
+          raise ArgumentError, "unexpected builtin: #{builtin}"
         end
       end
     end
 
-    def append_map_result(result, mapped)
+    def append_result(result, mapped, builtin)
       return if mapped.equal?(Control::DROPPED)
 
       if mapped.is_a?(Control::Flat)
-        unless mapped.value.is_a?(Array)
-          raise TypeError, "flat expects Array, got #{mapped.value.class}"
+        case builtin
+        when :map
+          unless mapped.value.is_a?(Array)
+            raise TypeError, "flat expects Array, got #{mapped.value.class}"
+          end
+          result.concat(mapped.value)
+        when :map_values
+          raise TypeError, "flat is not supported inside map_values"
+        else
+          raise ArgumentError, "unexpected builtin: #{builtin}"
         end
-
-        result.concat(mapped.value)
       else
         result << mapped
       end
@@ -195,24 +234,35 @@ module Jrf
     class MapReducer
       attr_reader :slots
 
-      def initialize(type)
-        @type = type
+      def initialize(builtin, array_input)
+        @builtin = builtin
+        @array_input = array_input
         @slots = {}
       end
 
+      def array_input?
+        @array_input
+      end
+
       def slot(key)
         @slots[key] ||= SlotState.new
       end
 
       def finish
-        case @type
-        when :array
+        if @array_input
           keys = @slots.keys.sort
           [keys.map { |k| Stage.resolve_template(@slots[k].template, @slots[k].reducers) }]
-        when :hash
-          result = {}
-          @slots.each { |k, s| result[k] = Stage.resolve_template(s.template, s.reducers) }
-          [result]
+        else
+          case @builtin
+          when :map
+            [@slots.map { |_k, s| Stage.resolve_template(s.template, s.reducers) }]
+          when :map_values, :group_by
+            result = {}
+            @slots.each { |k, s| result[k] = Stage.resolve_template(s.template, s.reducers) }
+            [result]
+          else
+            raise ArgumentError, "unexpected builtin: #{@builtin}"
+          end
         end
       end
 

data/lib/jrf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jrf
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/test/jrf_test.rb

@@ -145,6 +145,9 @@ assert_includes(stdout, "usage: jrf [options] 'STAGE >> STAGE >> ...'")
 assert_includes(stdout, "JSON filter with the power and speed of Ruby.")
 assert_includes(stdout, "--lax")
 assert_includes(stdout, "--pretty")
+assert_includes(stdout, "--no-jit")
+assert_includes(stdout, "-V")
+assert_includes(stdout, "--version")
 assert_includes(stdout, "--atomic-write-bytes N")
 assert_includes(stdout, "Pipeline:")
 assert_includes(stdout, "Connect stages with top-level >>.")
@@ -153,6 +156,16 @@ assert_includes(stdout, "See Also:")
 assert_includes(stdout, "https://github.com/kazuho/jrf#readme")
 assert_equal([], lines(stderr), "help stderr output")
 
+stdout, stderr, status = Open3.capture3("./exe/jrf", "--version")
+assert_success(status, stderr, "version long option")
+assert_equal([Jrf::VERSION], lines(stdout), "version long option output")
+assert_equal([], lines(stderr), "version long option stderr")
+
+stdout, stderr, status = Open3.capture3("./exe/jrf", "-V")
+assert_success(status, stderr, "version short option")
+assert_equal([Jrf::VERSION], lines(stdout), "version short option output")
+assert_equal([], lines(stderr), "version short option stderr")
+
 threshold_input = StringIO.new((1..4).map { |i| "{\"foo\":\"#{'x' * 1020}\",\"i\":#{i}}\n" }.join)
 buffered_runner = RecordingRunner.new(inputs: [threshold_input], out: StringIO.new, err: StringIO.new)
 buffered_runner.run('_')
@@ -190,6 +203,18 @@ stdout, stderr, status = Open3.capture3("./exe/jrf", "--atomic-write-bytes", "0"
 assert_failure(status, "atomic write bytes rejects zero")
 assert_includes(stderr, "--atomic-write-bytes requires a positive integer")
 
+if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enabled?)
+  yjit_probe = "{\"probe\":1}\n"
+
+  stdout, stderr, status = run_jrf('RubyVM::YJIT.enabled?', yjit_probe)
+  assert_success(status, stderr, "default jit enablement")
+  assert_equal(%w[true], lines(stdout), "default jit enablement output")
+
+  stdout, stderr, status = run_jrf('RubyVM::YJIT.enabled?', yjit_probe, "--no-jit")
+  assert_success(status, stderr, "no-jit option")
+  assert_equal(%w[false], lines(stdout), "no-jit option output")
+end
+
 Dir.mktmpdir do |dir|
   gz_path = File.join(dir, "input.ndjson.gz")
   Zlib::GzipWriter.open(gz_path) do |io|
@@ -747,6 +772,26 @@ stdout, stderr, status = run_jrf('map_values { |v| reduce(0) { |acc, x| acc + x
 assert_success(status, stderr, "map_values with reduce")
 assert_equal(['{"a":6,"b":60}'], lines(stdout), "map_values with reduce output")
 
+stdout, stderr, status = run_jrf('map { |k, v| "#{k}:#{v}" }', input_map_values)
+assert_success(status, stderr, "map over hash transform")
+assert_equal(['["a:1","b:10"]', '["a:2","b:20"]', '["a:3","b:30"]'], lines(stdout), "map over hash transform output")
+
+stdout, stderr, status = run_jrf('map { |pair| pair }', input_map_values)
+assert_success(status, stderr, "map over hash single block arg")
+assert_equal(['[["a",1],["b",10]]', '[["a",2],["b",20]]', '[["a",3],["b",30]]'], lines(stdout), "map over hash single block arg output")
+
+stdout, stderr, status = run_jrf('map { |k, v| select(v >= 10 && k != "a") }', input_map_values)
+assert_success(status, stderr, "map over hash transform with select")
+assert_equal(['[10]', '[20]', '[30]'], lines(stdout), "map over hash transform with select output")
+
+stdout, stderr, status = run_jrf('map { |k, v| sum(v + k.length) }', input_map_values)
+assert_success(status, stderr, "map over hash with sum")
+assert_equal(['[9,63]'], lines(stdout), "map over hash with sum output")
+
+stdout, stderr, status = run_jrf('map { |k, v| sum(_["a"] + v + k.length) }', input_map_values)
+assert_success(status, stderr, "map over hash keeps ambient _")
+assert_equal(['[15,69]'], lines(stdout), "map over hash ambient _ output")
+
 stdout, stderr, status = run_jrf('select(false) >> map { |x| sum(x) }', input_map)
 assert_success(status, stderr, "map no matches")
 assert_equal([], lines(stdout), "map no matches output")
@@ -881,6 +926,18 @@ assert_equal([[4, 6]], j.call([[1, 2], [3, 4]]), "library map reduce")
 j = Jrf.new(proc { map_values { |v| v * 10 } })
 assert_equal([{"a" => 10, "b" => 20}], j.call([{"a" => 1, "b" => 2}]), "library map_values transform")
 
+# map hash transform
+j = Jrf.new(proc { map { |k, v| "#{k}=#{v}" } })
+assert_equal([["a=1", "b=2"]], j.call([{"a" => 1, "b" => 2}]), "library map hash transform")
+
+# map hash single block arg
+j = Jrf.new(proc { map { |pair| pair } })
+assert_equal([[["a", 1], ["b", 2]]], j.call([{"a" => 1, "b" => 2}]), "library map hash single block arg")
+
+# map hash reduce
+j = Jrf.new(proc { map { |k, v| sum(v + k.length) } })
+assert_equal([[5, 7]], j.call([{"a" => 1, "b" => 2}, {"a" => 2, "b" => 3}]), "library map hash reduce")
+
 # group_by
 j = Jrf.new(proc { group_by(_["k"]) { count() } })
 assert_equal([{"x" => 2, "y" => 1}], j.call([{"k" => "x"}, {"k" => "x"}, {"k" => "y"}]), "library group_by")
@@ -901,4 +958,13 @@ assert_equal([{"a" => 3}], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "librar
 j = Jrf.new(proc { sum(_) })
 assert_equal([], j.call([]), "library empty input")
 
+ctx = Jrf::RowContext.new
+stage = Jrf::Stage.new(ctx, proc { })
+first_token = stage.step_reduce(1, initial: 0) { |acc, v| acc + v }
+assert_equal(0, first_token.index, "step_reduce returns token while classifying reducer stage")
+stage.instance_variable_set(:@mode, :reducer)
+stage.instance_variable_set(:@cursor, 0)
+second_token = stage.step_reduce(2, initial: 0) { |acc, v| acc + v }
+raise "expected DROPPED for established reducer slot" unless second_token.equal?(Jrf::Control::DROPPED)
+
 puts "ok"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jrf
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - kazuho