xenum 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6702efc29813e62dabd6f74d9c7bc8067b191a79f3b416f6a1336ba20e6497d4
-  data.tar.gz: 94676ca2107d67c7680d2e6b963e67c5e19f7ab8386c9808e96c751dcafe34ee
+  metadata.gz: b26e4083a610a02bfcaf4fcd7b74902c65d1468950ad62e09e0f69be08fa33e2
+  data.tar.gz: 3fafdc0f08284afe73ecd91701e48840ea103fa68e3694c682d3633d03fc7176
 SHA512:
-  metadata.gz: f82eac1237b52b16d7950bcaee008811a71ad905e966141893a13a51d04aa8ea9590d47590099f2eb204ec5d2df1a3b75a26db1e3ad5d0a6c159c56bf84776f2
-  data.tar.gz: 71df4dec9373651f55a6b5f9abbd4b74f0778b6be2726de4a69735886c0b5528c4e47a46f9d65fb7119b4c3ffa0ee655ce26b092273dfd1ec4b9eedb2bd23b81
+  metadata.gz: b1731083f8b65c5e86be5713e65476a2aa8aec75b42321f9041ee80c02e94d2b5b72e536094be03ca24a526ea1023093a08e13108f73de4439ab12fc4e9947f4
+  data.tar.gz: 925ffb7471110f7743abd3ffed92010c3fad9db65ea2952a283c590c9cf37db28fb19c583646f8cf268990398839c68df3fc75c3c6e02ff96f543ad88d7921d5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    xenum (0.1.3)
+    xenum (0.1.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -42,6 +42,10 @@ works like `Array#insert`, but not limited to `Array`
 # [0, 1, 2, 3, 4, 5, 6, 7, "a", "b", 8, 9]
 ```
 
+### lazy_unshift
+
+just like `lazy_insert(0, ...)`
+
 ### lazy_product
 
 works like `Array#product`, but not limited to `Array`
@@ -56,7 +60,7 @@ works like `Array#product`, but not limited to `Array`
 
 ### merge_sort
 
-lazily merge sort two sorted `Enumerable`
+lazily merge sort `Enumerable`
 
 ```ruby
 e = (6..8).merge_sort([3,4,5]).merge_sort(3.times)

data/lib/xenum/merge_sort.rb

@@ -0,0 +1,121 @@
+module Xenum
+  module MergeSort
+    NULL = Object.new
+
+    class << self
+      def recur(*enums)
+        case enums.size
+        when 0
+          [].to_enum
+        when 1
+          enums[0]
+        else
+          enums2 = recur(*enums.pop(enums.size / 2))
+          enums1 = recur(*enums)
+          _recur(enums1, enums2)
+        end
+      end
+
+      def iter(*enums)
+        Enumerator.new do |yielder|
+          enums = enums.each_with_object([]) do |e, arr|
+            c = Candidate.new(e)
+            arr << c if c.value != NULL
+          end
+          enums.sort!{ |a, b| b <=> a }
+
+          resort = -> do
+            i = -1
+            x = enums[i]
+            loop do
+              e = enums[i-1]
+              break unless e
+              break if (e <=> x) >= 0
+              enums[i] = e
+              i -= 1
+            end
+            enums[i] = x
+          end
+
+          loop do
+            break if enums.empty?
+            resort.call
+            least = enums[-1]
+            yielder << least.value
+            least.fetch
+            next enums.pop if least.value == NULL
+          end
+        end
+      end
+
+      private
+
+      def _recur(this, that)
+        this = this.to_enum unless Enumerator === this
+        that = that.to_enum unless Enumerator === that
+
+        Enumerator.new do |e|
+          a = NULL
+          b = NULL
+          remain = nil
+
+          loop do
+            if a == NULL
+              a = begin
+                    this.next
+                  rescue StopIteration
+                    remain = that
+                    break
+                  end
+            end
+
+            if b == NULL
+              b = begin
+                    that.next
+                  rescue StopIteration
+                    remain = this
+                    break
+                  end
+            end
+
+            if (a <=> b) <= 0
+              e.yield(a)
+              a = NULL
+            else
+              e.yield(b)
+              b = NULL
+            end
+          end
+
+          e.yield(a) if a != NULL
+          e.yield(b) if b != NULL
+
+          loop do
+            e.yield(remain.next)
+          rescue StopIteration
+            break
+          end
+        end
+      end
+    end
+
+    class Candidate
+      attr_accessor :value
+
+      def initialize(enum)
+        @enum = Enumerator === enum ? enum : enum.to_enum
+        fetch
+      end
+
+      def <=>(another)
+        value <=> another.value
+      end
+
+      def fetch
+        @value = @enum.next
+      rescue StopIteration
+        @value = NULL
+      end
+    end
+  end
+end

data/lib/xenum/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Xenum
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/xenum.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "xenum/version"
+require_relative "xenum/merge_sort"
 
 module Xenum
-  NULL = Object.new
 end
 
 module Enumerable
@@ -36,6 +36,10 @@ module Enumerable
     end
   end
 
+  def lazy_unshift(*objs)
+    lazy_insert(0, *objs)
+  end
+
   def lazy_product(*enums)
     if enums.empty?
       return Enumerator.new do |yielder|
@@ -56,69 +60,12 @@ module Enumerable
   end
 
   def merge_sort(*enums)
-    case enums.size
-    when 0
-      self
-    when 1
-      _merge_sort(enums[0])
-    else
-      enums2 = enums.pop((enums.size / 2) - 1)
-      enum2 = enums.pop
-      e2 = enum2.merge_sort(*enums2)
-      e1 = merge_sort(*enums)
-      e1.merge_sort(e2)
-    end
+    enums << self
+    Xenum::MergeSort.iter(*enums)
   end
 
   private
 
-  def _merge_sort(that)
-    this = Enumerator === self ? self : self.to_enum
-    that = Enumerator === that ? that : that.to_enum
-
-    Enumerator.new do |e|
-      a = Xenum::NULL
-      b = Xenum::NULL
-      remain = nil
-
-      loop do
-        if a == Xenum::NULL
-          a = begin
-                this.next
-              rescue StopIteration
-                remain = that
-                break
-              end
-        end
-
-        if b == Xenum::NULL
-          b = begin
-                that.next
-              rescue StopIteration
-                remain = this
-                break
-              end
-        end
-
-        if (a <=> b) <= 0
-          e.yield(a)
-          a = Xenum::NULL
-        else
-          e.yield(b)
-          b = Xenum::NULL
-        end
-      end
-
-      e.yield(a) if a != Xenum::NULL
-      e.yield(b) if b != Xenum::NULL
-
-      loop do
-        e.yield(remain.next)
-      rescue StopIteration
-        break
-      end
-    end
-  end
 
   def lazy_insert_neg(index, objs)
     these = Enumerator === self ? self : self.to_enum

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xenum
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - ken
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-19 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -24,6 +24,7 @@ files:
 - README.md
 - Rakefile
 - lib/xenum.rb
+- lib/xenum/merge_sort.rb
 - lib/xenum/version.rb
 - sig/xenum.rbs
 homepage: https://github.com/turnon/xenum