enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-enum-ext/test/enum.rb

@@ -0,0 +1,223 @@
+##
+# Enumerable(Ext) Test
+
+assert("Enumerable#drop") do
+  a = [1, 2, 3, 4, 5, 0]
+
+  assert_equal [4, 5, 0], a.drop(3)
+  assert_equal [], a.drop(6)
+end
+
+assert("Enumerable#drop_while") do
+  a = [1, 2, 3, 4, 5, 0]
+  assert_equal [3, 4, 5, 0], a.drop_while {|i| i < 3 }
+end
+
+assert("Enumerable#take") do
+  a = [1, 2, 3, 4, 5, 0]
+  assert_equal [1, 2, 3], a.take(3)
+end
+
+assert("Enumerable#take_while") do
+  a = [1, 2, 3, 4, 5, 0]
+  assert_equal [1, 2], a.take_while {|i| i < 3}
+end
+
+assert("Enumerable#each_cons") do
+  a = []
+  b = (1..5).each_cons(3){|e| a << e}
+  assert_equal [[1, 2, 3], [2, 3, 4], [3, 4, 5]], a
+  assert_equal nil, b
+end
+
+assert("Enumerable#each_slice") do
+  a = []
+  b = (1..10).each_slice(3){|e| a << e}
+  assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]], a
+  assert_equal nil, b
+end
+
+assert("Enumerable#group_by") do
+  r = (1..6).group_by {|i| i % 3 }
+  assert_equal [3, 6], r[0]
+  assert_equal [1, 4], r[1]
+  assert_equal [2, 5], r[2]
+end
+
+assert("Enumerable#sort_by") do
+  assert_equal ["car", "train", "bicycle"], %w{car bicycle train}.sort_by {|e| e.length}
+end
+
+assert("Enumerable#first") do
+  a = Object.new
+  a.extend Enumerable
+  def a.each
+    yield 1
+    yield 2
+    yield 3
+  end
+  assert_equal 1, a.first
+  assert_equal [1, 2], a.first(2)
+  assert_equal [1, 2, 3], a.first(10)
+  a = Object.new
+  a.extend Enumerable
+  def a.each
+  end
+  assert_nil a.first
+end
+
+assert("Enumerable#count") do
+  a = [1, 2, 4, 2]
+  assert_equal 4, a.count
+  assert_equal 2, a.count(2)
+  assert_equal 3, a.count{|x| x % 2 == 0}
+end
+
+assert("Enumerable#flat_map") do
+  assert_equal [1, 2, 3, 4], [1, 2, 3, 4].flat_map { |e| e }
+  assert_equal [1, -1, 2, -2, 3, -3, 4, -4], [1, 2, 3, 4].flat_map { |e| [e, -e] }
+  assert_equal [1, 2, 100, 3, 4, 100], [[1, 2], [3, 4]].flat_map { |e| e + [100] }
+end
+
+assert("Enumerable#max_by") do
+  assert_equal "albatross", %w[albatross dog horse].max_by { |x| x.length }
+end
+
+assert("Enumerable#min_by") do
+  assert_equal "dog", %w[albatross dog horse].min_by { |x| x.length }
+end
+
+assert("Enumerable#minmax") do
+  a = %w(albatross dog horse)
+  assert_equal ["albatross", "horse"], a.minmax
+  assert_equal ["dog", "albatross"], a.minmax { |a, b| a.length <=> b.length }
+end
+
+assert("Enumerable#minmax_by") do
+  assert_equal ["dog", "albatross"], %w(albatross dog horse).minmax_by { |x| x.length }
+end
+
+assert("Enumerable#none?") do
+  assert_true %w(ant bear cat).none? { |word| word.length == 5 }
+  assert_false %w(ant bear cat).none? { |word| word.length >= 4 }
+  assert_true [].none?
+  assert_true [nil, false].none?
+  assert_false [nil, true].none?
+end
+
+assert("Enumerable#one?") do
+  assert_true %w(ant bear cat).one? { |word| word.length == 4 }
+  assert_false %w(ant bear cat).one? { |word| word.length > 4 }
+  assert_false %w(ant bear cat).one? { |word| word.length < 4 }
+  assert_false [nil, true, 99].one?
+  assert_true [nil, true, false].one?
+  assert_true [ nil, true, 99 ].one?(Integer)
+  assert_false [].one?
+  assert_true [nil, true, false].one?(NilClass)
+end
+
+assert("Enumerable#all? (enhancement)") do
+  assert_false [1, 2, nil].all?(Integer)
+  assert_true [1, 2, 3].all?(Numeric)
+end
+
+assert("Enumerable#any? (enhancement)") do
+  assert_true [nil, true, 99].any?(Integer)
+  assert_false [1, 2, 3].any?(Array)
+end
+
+assert("Enumerable#each_with_object") do
+  assert_equal [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], (1..10).each_with_object([]) { |i, a| a << i*2 }
+  assert_raise(ArgumentError) { (1..10).each_with_object() { |i, a| a << i*2 } }
+end
+
+assert("Enumerable#reverse_each") do
+  r = (1..3)
+  a = []
+  assert_same r, r.reverse_each { |v| a << v }
+  assert_equal [3, 2, 1], a
+end
+
+assert("Enumerable#cycle") do
+  a = []
+  ["a", "b", "c"].cycle(2) { |v| a << v }
+  assert_equal ["a", "b", "c", "a", "b", "c"], a
+  assert_raise(TypeError) { ["a", "b", "c"].cycle("a") { |v| a << v } }
+
+  empty = Class.new do
+    include Enumerable
+    def each
+    end
+  end
+  assert_nil empty.new.cycle { break :nope }
+end
+
+assert("Enumerable#find_index") do
+  assert_nil (1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 }
+  assert_equal 34, (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 }
+  assert_equal 49 ,(1..100).find_index(50)
+end
+
+assert("Enumerable#zip") do
+  a = [ 4, 5, 6 ]
+  b = [ 7, 8, 9 ]
+  assert_equal [[4, 7], [5, 8], [6, 9]], a.zip(b)
+  assert_equal [[1, 4, 7], [2, 5, 8], [3, 6, 9]], [1, 2, 3].zip(a, b)
+  assert_equal [[1, 4, 7], [2, 5, 8]], [1, 2].zip(a, b)
+  assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], a.zip([1, 2], [8])
+
+  ret = []
+  assert_equal nil, a.zip([1, 2], [8]) { |i| ret << i }
+  assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], ret
+
+  assert_raise(TypeError) { [1].zip(1) }
+end
+
+assert("Enumerable#to_h") do
+  c = Class.new {
+    include Enumerable
+    def each
+      yield [1,2]
+      yield [3,4]
+    end
+  }
+  h0 = {1=>2, 3=>4}
+  h = c.new.to_h
+  assert_equal Hash, h.class
+  assert_equal h0, h
+  assert_equal({1=>4,3=>8}, c.new.to_h{|k,v|[k,v*2]})
+end
+
+assert("Enumerable#filter_map") do
+  assert_equal [4, 8, 12, 16, 20], (1..10).filter_map{|i| i * 2 if i%2==0}
+end
+
+assert("Enumerable#tally") do
+  assert_equal({"a"=>1, "b"=>2, "c"=>1}, ["a", "b", "c", "b"].tally)
+end
+
+assert("Enumerable#grep_v") do
+  a = [1, 2, 3, 4, 5, 0]
+  assert_equal [1, 5, 0], a.grep_v(2..4)
+  assert_equal [1, 2, 3, 4, 5, 0], a.grep_v(6..8)
+  assert_equal [2, 4, 6, 8, 10], a.grep_v(0) {|v| v * 2}
+end
+
+assert("Enumerable#each_entry") do
+  each_entry_test = Class.new {
+    include Enumerable
+    def each
+      yield 1
+      yield 1, 2
+      yield
+    end
+  }
+  e = each_entry_test.new
+  a = []
+  e.each_entry {|v|
+    a.push(v)
+  }
+  assert_equal 1, a[0]
+  assert_equal [1,2], a[1]
+  assert_equal nil, a[2]
+end

data/ext/enclave/mruby/mrbgems/mruby-enum-lazy/README.md

@@ -0,0 +1,91 @@
+# mruby-enum-lazy
+
+## Overview
+
+This mrbgem provides lazy evaluation for Enumerable objects in mruby. It introduces the `Enumerable#lazy` method, which returns an instance of `Enumerator::Lazy`. This allows for more efficient processing of collections, especially large or potentially infinite sequences, by evaluating elements only when they are needed.
+
+## Functionality
+
+When you call `.lazy` on an Enumerable object (like an Array or Range), you get back an `Enumerator::Lazy` object. This object behaves much like a regular Enumerator, but with a key difference: methods that transform the collection are deferred until the results are actually required.
+
+The following methods are implemented to act lazily:
+
+- `map` / `collect`
+- `select` / `find_all`
+- `reject`
+- `grep`
+- `grep_v`
+- `drop`
+- `drop_while`
+- `take`
+- `take_while`
+- `flat_map` / `collect_concat`
+- `zip`
+- `uniq`
+
+To trigger the evaluation of the lazy operations and retrieve all results (if finite), you can use methods like `force` or `to_a`.
+
+### How it works
+
+Operations on an `Enumerator::Lazy` object are chained together. The actual computation of each element is postponed until it's requested (e.g., by `force`, `to_a`, or iterating with `each`). This can lead to significant performance improvements by avoiding unnecessary computations and memory allocations, particularly when dealing with large data sets or when only a subset of results is needed.
+
+## Usage Example
+
+Here's a simple example demonstrating lazy evaluation:
+
+```ruby
+# Without lazy evaluation
+# This would attempt to create an infinite array, which is not feasible.
+# (1..Float::INFINITY).map { |x| x * x }.select { |x| x % 2 == 0 }.take(5).to_a
+
+# With lazy evaluation
+p (1..Float::INFINITY).lazy.map { |x| x * x }.select { |x| x % 2 == 0 }.take(5).force
+# Output: [4, 16, 36, 64, 100]
+
+# Another example:
+a = [1, 2, 3, 4, 5]
+lazy_sequence = a.lazy.map do |x|
+  puts "mapping #{x}"
+  x * 10
+end.select do |x|
+  puts "selecting #{x}"
+  x > 20
+end
+
+puts "Applying force..."
+result = lazy_sequence.force
+# Output:
+# mapping 1
+# selecting 10
+# mapping 2
+# selecting 20
+# mapping 3
+# selecting 30
+# mapping 4
+# selecting 40
+# mapping 5
+# selecting 50
+# Applying force...
+p result # Output: [30, 40, 50]
+```
+
+## Dependencies
+
+This gem depends on the following mruby core gems:
+
+- `mruby-enumerator`
+- `mruby-enum-ext`
+
+## License
+
+MIT License
+
+## Author
+
+mruby developers
+
+## Acknowledgements
+
+Based on <https://github.com/yhara/enumerable-lazy>
+Inspired by <https://github.com/antimon2/enumerable_lz>
+Reference: <http://jp.rubyist.net/magazine/?0034-Enumerable_lz> (ja)

data/ext/enclave/mruby/mrbgems/mruby-enum-lazy/mrbgem.rake

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-enum-lazy') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Enumerator::Lazy class'
+  spec.add_dependency('mruby-enumerator', :core => 'mruby-enumerator')
+  spec.add_dependency('mruby-enum-ext', :core => 'mruby-enum-ext')
+end

data/ext/enclave/mruby/mrbgems/mruby-enum-lazy/mrblib/lazy.rb

@@ -0,0 +1,363 @@
+module Enumerable
+
+  #
+  # call-seq:
+  #   enum.lazy -> lazy_enumerator
+  #
+  # Returns an Enumerator::Lazy, which redefines most Enumerable
+  # methods to postpone enumeration and enumerate values only on an
+  # as-needed basis.
+  #
+  # === Example
+  #
+  # The following program finds pythagorean triples:
+  #
+  #   def pythagorean_triples
+  #     (1..Float::INFINITY).lazy.flat_map {|z|
+  #       (1..z).flat_map {|x|
+  #         (x..z).select {|y|
+  #           x*x + y*y == z*z
+  #         }.map {|y|
+  #           [x, y, z]
+  #         }
+  #       }
+  #     }
+  #   end
+  #   # show first ten pythagorean triples
+  #   p pythagorean_triples.take(10).force # take is lazy, so force is needed
+  #   p pythagorean_triples.first(10)      # first is eager
+  #   # show pythagorean triples less than 100
+  #   p pythagorean_triples.take_while { |*, z| z < 100 }.force
+  #
+  def lazy
+    Enumerator::Lazy.new(self)
+  end
+end
+
+class Enumerator
+  # == Acknowledgements
+  #
+  #   Based on https://github.com/yhara/enumerable-lazy
+  #   Inspired by https://github.com/antimon2/enumerable_lz
+  #   http://jp.rubyist.net/magazine/?0034-Enumerable_lz (ja)
+  class Lazy < Enumerator
+    #
+    # call-seq:
+    #   Lazy.new(obj, &block)
+    #
+    # Creates a new Lazy enumerator. When the enumerator is actually enumerated
+    # (e.g. by calling #force), obj will be enumerated and each value passed
+    # to the given block. The block can yield values back by calling yielder.yield.
+    # For example, to create a method that acts like Array#select:
+    #
+    #   def select
+    #     Lazy.new(self) do |yielder, value|
+    #       yielder.yield(value) if yield(value)
+    #     end
+    #   end
+    #
+    def initialize(obj, &block)
+      super(){|yielder|
+        begin
+          obj.each {|x|
+            if block
+              block.call(yielder, x)
+            else
+              yielder << x
+            end
+          }
+        rescue StopIteration
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.to_enum(method = :each, *args)                 -> lazy_enum
+    #   lazy.to_enum(method = :each, *args) {|*args| ... }  -> lazy_enum
+    #   lazy.enum_for(method = :each, *args)                -> lazy_enum
+    #   lazy.enum_for(method = :each, *args) {|*args| ... } -> lazy_enum
+    #
+    # Similar to Object#to_enum, except it returns a lazy enumerator.
+    # This makes it easy to define Enumerable methods that will
+    # naturally remain lazy if called on a lazy enumerator.
+    #
+    #   For example:
+    #
+    #   module Enumerable
+    #     def filter_map(&block)
+    #       map(&block).compact
+    #     end
+    #   end
+    #
+    def to_enum(meth=:each, *args, &block)
+      unless self.respond_to?(meth)
+        raise ArgumentError, "undefined method #{meth}"
+      end
+      lz = Lazy.new(self, &block)
+      obj = self
+      lz.instance_eval {
+        @obj = obj
+        @meth = meth
+        @args = args
+      }
+      lz
+    end
+    alias enum_for to_enum
+
+    #
+    # call-seq:
+    #   lazy.map {|obj| block } -> lazy_enumerator
+    #   lazy.collect {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#map, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.map {|i| i**2 }
+    #   #=> #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:map>
+    #   (1..Float::INFINITY).lazy.map {|i| i**2 }.first(3)
+    #   #=> [1, 4, 9]
+    #
+    def map(&block)
+      Lazy.new(self){|yielder, val|
+        yielder << block.call(val)
+      }
+    end
+    alias collect map
+
+    #
+    # call-seq:
+    #   lazy.select {|obj| block } -> lazy_enumerator
+    #   lazy.find_all {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#select, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.select {|i| i.even? }.first(3)
+    #   #=> [2, 4, 6]
+    #
+    def select(&block)
+      Lazy.new(self){|yielder, val|
+        if block.call(val)
+          yielder << val
+        end
+      }
+    end
+    alias find_all select
+
+    #
+    # call-seq:
+    #   lazy.reject {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#reject, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.reject {|i| i.even? }.first(3)
+    #   #=> [1, 3, 5]
+    #
+    def reject(&block)
+      Lazy.new(self){|yielder, val|
+        unless block.call(val)
+          yielder << val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.grep(pattern) -> lazy_enumerator
+    #
+    # Like Enumerable#grep, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.grep(1..10).force
+    #   #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    #
+    def grep(pattern)
+      Lazy.new(self){|yielder, val|
+        if pattern === val
+          yielder << val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.grep_v(pattern) -> lazy_enumerator
+    #
+    # Like Enumerable#grep_v, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.grep_v(2..4).first(3)
+    #   #=> [1, 5, 6]
+    #
+    def grep_v(pattern)
+      Lazy.new(self){|yielder, val|
+        unless pattern === val
+          yielder << val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.drop(n) -> lazy_enumerator
+    #
+    # Like Enumerable#drop, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.drop(3).first(3)
+    #   #=> [4, 5, 6]
+    #
+    def drop(n)
+      dropped = 0
+      Lazy.new(self){|yielder, val|
+        if dropped < n
+          dropped += 1
+        else
+          yielder << val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.drop_while {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#drop_while, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.drop_while {|i| i < 4 }.first(3)
+    #   #=> [4, 5, 6]
+    #
+    def drop_while(&block)
+      dropping = true
+      Lazy.new(self){|yielder, val|
+        if dropping
+          if not block.call(val)
+            yielder << val
+            dropping = false
+          end
+        else
+          yielder << val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.take(n) -> lazy_enumerator
+    #
+    # Like Enumerable#take, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.take(3).force
+    #   #=> [1, 2, 3]
+    #
+    def take(n)
+      if n == 0
+        return Lazy.new(self){raise StopIteration}
+      end
+      taken = 0
+      Lazy.new(self){|yielder, val|
+        yielder << val
+        taken += 1
+        if taken >= n
+          raise StopIteration
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.take_while {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#take_while, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.take_while {|i| i < 4 }.force
+    #   #=> [1, 2, 3]
+    #
+    def take_while(&block)
+      Lazy.new(self){|yielder, val|
+        if block.call(val)
+          yielder << val
+        else
+          raise StopIteration
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.flat_map {|obj| block } -> lazy_enumerator
+    #   lazy.collect_concat {|obj| block } -> lazy_enumerator
+    #
+    # Like Enumerable#flat_map, but chains operation to be lazy-evaluated.
+    #
+    #   ["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
+    #   #=> ["f", "o", "o", "b", "a", "r"]
+    #
+    def flat_map(&block)
+      Lazy.new(self){|yielder, val|
+        ary = block.call(val)
+        # TODO: check ary is an Array
+        ary.each {|x|
+          yielder << x
+        }
+      }
+    end
+    alias collect_concat flat_map
+
+    #
+    # call-seq:
+    #   lazy.zip(arg, ...) -> lazy_enumerator
+    #   lazy.zip(arg, ...) {|arr| block } -> lazy_enumerator
+    #
+    # Like Enumerable#zip, but chains operation to be lazy-evaluated.
+    # However, if a block is given to zip, values are enumerated immediately.
+    #
+    #   (1..Float::INFINITY).lazy.zip(('a'..'z').cycle).first(3)
+    #   #=> [[1, "a"], [2, "b"], [3, "c"]]
+    #
+    def zip(*args, &block)
+      enums = [self] + args
+      Lazy.new(self){|yielder, val|
+        ary = enums.map {|e| e.next}
+        if block
+          yielder << block.call(ary)
+        else
+          yielder << ary
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.uniq -> lazy_enumerator
+    #   lazy.uniq {|item| block } -> lazy_enumerator
+    #
+    # Like Enumerable#uniq, but chains operation to be lazy-evaluated.
+    #
+    #   (1..Float::INFINITY).lazy.map {|i| i % 3}.uniq.first(3)
+    #   #=> [1, 2, 0]
+    #
+    def uniq(&block)
+      hash = {}
+      Lazy.new(self){|yielder, val|
+        if block
+          v = block.call(val)
+        else
+          v = val
+        end
+        unless hash.include?(v)
+          yielder << val
+          hash[v] = val
+        end
+      }
+    end
+
+    #
+    # call-seq:
+    #   lazy.force -> array
+    #
+    # Forces lazy evaluation and returns an array containing the values
+    # enumerated by the lazy enumerator. This is an alias for to_a.
+    #
+    #   (1..Float::INFINITY).lazy.take(3).force
+    #   #=> [1, 2, 3]
+    #
+    alias force to_a
+  end
+end