ex_aequo_streams 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0fb93ecf83932800fa74ebfda93021116c2ed3eaa75e52ab1ba24570d4b5d52
-  data.tar.gz: 78ae3b27a6adc254cd0b7065358c72474533a9d4a7845a34ad925db41286a90e
+  metadata.gz: ae3e6d30027b024529d7e8ca5046e188e81fd8c9803869c08324974a8303ecfe
+  data.tar.gz: 4ba3a1aecd827bd6bc1cd5b06b7bb50e1292041d87a0e906b9f4ca8a8a69239f
 SHA512:
-  metadata.gz: df1e6ea0cea3264a5e15141a63fa2d85fcb73395633072ac4cf0d2b379f4df3fa50bde6031503ae8bcfa1d546d062f3b2f8b428568617539abc9618eed70de04
-  data.tar.gz: 42cdce54adfcc06a648f35a5d05fc5c677ad72fbb9dd140f92e2567c6e0c2edfb1520b93fa2a71a03a60547281844a7fbb658a8ec323787317da4d7deab81405
+  metadata.gz: a03fba937252d9fd90d637b6aa58622fbb75640029fa9c1cbfd7c8d538aeaa09e4c3ee06551aaea500ad153760efe2142e965df00d888f4b35a4faf0e6322829
+  data.tar.gz: 6c88b678b4b5e9b62ec05f92a3ee4aca8c85030b53a8cda1553197ac882f53f9265071ef888839ed1a252567417ba672dbca68e009e31e5d7eeba40d3a35cd7d

data/lib/ex_aequo/streams/stream/class_methods.rb

@@ -31,23 +31,23 @@ module ExAequo
 
         def interleave(*streams)
           case streams
-          in []
-            empty
           in [hs, *tsts]
             return interleave(*tsts) if hs.empty?
             cons_stream(hs.head) { interleave(*[*tsts, hs.tail]) }
+          else
+            empty
           end
         end
 
         def interleave_n(*streams)
           case streams
-          in []
-            empty
           in [[s, c], *r]
             return interleave_n(*r) if s.empty?
 
             s.take_and_drop(c) => sh, sr
             prefixed(*sh) { interleave_n(*[*r, [sr, c]]) }
+          else
+            empty
           end
         end
 
@@ -62,10 +62,10 @@ module ExAequo
 
         def prefixed(value, *values, &blk)
           case values 
-          in []
-            new(value, &blk)
           in [next_head, *next_tails]
             new(value) { prefixed(next_head, *next_tails, &blk) }
+          else
+            new(value, &blk)
           end
         end
 
@@ -85,10 +85,6 @@ module ExAequo
           fh.close rescue nil
           empty
         end
-
-        def get_heads(streams)
-          heads = streams.map(&:head)
-        end
       end
     end
   end

data/lib/ex_aequo/streams/stream/empty.rb

@@ -7,14 +7,25 @@ module ExAequo
       class Empty < ExAequo::Streams::Stream
          include Singleton 
 
-         def empty? = true
+         def advance(_) = self
+         def drop_until(*) = self
+         def drop_while(*) = self
          def empty = self
+         def empty? = true
          def force = []
+         def func_drop_until(*) = self
+         def func_drop_while(*) = self
          def func_flat_map(_) = self
+         def func_take_stream(_) = self
          def head = raise StopIteration, "must not access head of the empty stream"
          def head_stream(_) = self
          def head_tail = raise StopIteration, "must not access head of the empty stream"
          def tail = self
+         def take_stream(_) = self
+         def take_until(*) = []
+         def take_until_stream(*) = self
+         def take_while(*) = []
+         def take_while_stream(*) = self
 
          private
          def initialize = nil

data/lib/ex_aequo/streams/stream/func_methods.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ExAequo
+  module Streams
+    class Stream
+      module FuncMethods
+        def func_drop_until(f, advance: 0)
+          current = self
+          loop do
+            return empty if current.empty?
+            return current.drop(advance) if f.(current.head)
+            current = current.tail
+          end 
+        end
+
+        def func_drop_while(f, advance: 0)
+          if f.(head)
+            return empty if tail.empty?
+            self.class.new(tail.head) { tail.tail }
+              .func_drop_while(f, advance:)
+          else
+            drop(advance)
+          end
+        end
+
+        def func_flat_map(f)
+          expanded = f.(head)
+          # TODO: allow expanded to ab any enumarable by defining a general tail function
+          raise ArgumentError, "not a stream #{expanded.inspect}" unless self.class === expanded
+
+          # p(expanded: expanded.force.inspect)
+          return tail.func_flat_map(f) if expanded.empty?
+          self.class.new(expanded.head) {
+            self.class.interleave(tail.func_flat_map(f), expanded.tail)
+          }
+        end
+
+        def func_map(f)
+          return self.class.empty if empty?
+          self.class.new(f.(head)) {
+            tail.func_map(f)
+          }
+        end
+
+        def func_take_stream(more)
+          return empty if more.zero?
+          cons_stream(head) { tail.func_take_stream(more.pred) }
+        end
+
+        def func_take_until(f, more: 0)
+          result = []
+          current = self
+          loop do
+            return result if current.empty?
+            return result + current.take(more) if f.(current.head)
+            result << current.head
+            current = current.tail
+          end
+        end
+
+        def func_take_until_stream(f, more: 0)
+          if f.(head)
+            func_take_stream(more)
+          else
+            cons_stream(head) {
+              tail.func_take_until_stream(f, more:)
+            }
+          end
+        end
+
+        def func_take_while_stream(f, more: 0)
+          if f.(head)
+            cons_stream(head) {
+              tail.func_take_while_stream(f, more:)
+            }
+          else
+            func_take_stream(more)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/streams/stream/stream_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ExAequo
+  module Streams
+    class Stream
+      module StreamMethods
+
+        def append(*streams)
+          case streams
+          in [sfirst, *srest]
+            return sfirst.append(*srest) if empty?
+            self.class.new(head) { tail.append(*streams) }
+          else
+            self
+          end
+        end
+
+        def drop(n)
+          n.times.inject(self) { |s,| s.tail }
+        end
+
+        def drop_until(fn_desc=nil, advance: 0, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_drop_until(f, advance:)
+        end
+
+        def drop_while(fn_desc=nil, advance: 0, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_drop_while(f, advance:)
+        end
+
+        def head_stream(n)
+          return empty if n < 1
+          self.class.new(head) { tail.head_stream(n.pred) }
+        end
+
+        def flat_map(fn_desc=nil, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_flat_map(f)
+        end
+
+        def map(fn_desc=nil, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_map(f)
+        end
+
+        def take_until_stream(fn_desc=nil, more: 0, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_take_until_stream(f, more:)
+        end
+
+        def take_while_stream(fn_desc=nil, more: 0, &blk)
+          f = Fn.mk_fun_or(fn_desc, &blk)
+          func_take_while_stream(f, more:)
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/streams/stream.rb

@@ -9,69 +9,23 @@ module ExAequo
     class Stream
 
       extend ClassMethods
+      include FuncMethods
+      include StreamMethods
 
       attr_reader :head
 
-      def append(*streams)
-        case streams
-        in []
-          self
-        in [sfirst, *srest]
-          return sfirst.append(*srest) if empty?
-          self.class.new(head) { tail.append(*streams) }
-        end
-      end
-
-      def drop(n)
-        n.times.inject(self) { |s,| s.tail }
-      end
-
       def empty? = false
 
       def empty = self.class.empty
 
       def force = take_while { true }
 
-      def head_stream(n)
-        return empty if n < 1
-        self.class.new(head) { tail.head_stream(n.pred) }
-      end
-
       def head_tail = [head, tail]
 
-      def flat_map(fn_desc=nil, &blk)
-        f = Fn.mk_fun_or(fn_desc, &blk)
-        func_flat_map(f)
-      end
-
-      def func_flat_map(f)
-        expanded = f.(head)
-        # TODO: allow expanded to ab any enumarable by defining a general tail function
-        raise ArgumentError, "not a stream #{expaneded.inspect}" unless self.class === expanded
-
-        # p(expanded: expanded.force.inspect)
-        return tail.func_flat_map(f) if expanded.empty?
-        self.class.new(expanded.head) {
-          self.class.interleave(tail.func_flat_map(f), expanded.tail)
-        }
-      end
-
-      def map(fn_desc=nil, &blk)
-        f = Fn.mk_fun_or(fn_desc, &blk)
-        mapf(f)
-      end
-
       def nth(n)
         n.times.reduce(self) {|s,| s.tail}.head
       end
 
-      def mapf(f)
-        return self.class.empty if empty?
-        self.class.new(f.(head)) {
-          tail.mapf(f)
-        }
-      end
-
       def split_at(n)
         [head_stream(n), drop(n)]
       end
@@ -94,6 +48,11 @@ module ExAequo
         [take(n), drop(n)]
       end
 
+      def take_until(fn_desc=nil, more: 0, &blk)
+        f = Fn.mk_fun_or(fn_desc, &blk)
+        func_take_until(f, more:)
+      end
+
       def take_while(&blk)
         current = self
         result = []

data/lib/ex_aequo/streams/version.rb

@@ -2,7 +2,7 @@
 
 module ExAequo
   module Streams
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ex_aequo_streams
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Dober
@@ -52,6 +52,8 @@ files:
 - lib/ex_aequo/streams/stream.rb
 - lib/ex_aequo/streams/stream/class_methods.rb
 - lib/ex_aequo/streams/stream/empty.rb
+- lib/ex_aequo/streams/stream/func_methods.rb
+- lib/ex_aequo/streams/stream/stream_methods.rb
 - lib/ex_aequo/streams/version.rb
 homepage: https://codeberg.org/lab419/rb_ex_aequo_streams
 licenses: