fiber_stream 0.2.0 → 0.4.0

data/lib/fiber_stream/ractor_producer.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module FiberStream
+  # Producer-side context for `Source.ractor_producer`.
+  #
+  # Producer blocks call `emit`, `complete`, or `fail` to send one protocol
+  # message after receiving one downstream acknowledgment. A `false` return
+  # means cooperative cancellation was observed before the requested message
+  # could be sent.
+  class RactorProducer
+    def initialize(data_port, ack_port, transfer)
+      @data_port = data_port
+      @ack_port = ack_port
+      @transfer = transfer
+      @terminal = false
+      @cancelled = false
+      @send_failed = false
+    end
+
+    def emit(value, transfer: nil)
+      return false if terminal? || cancelled?
+
+      message_transfer = validate_transfer_override!(transfer)
+      return false unless wait_for_ack
+
+      send_emitted_message(RactorPort::Element.new(value), message_transfer)
+    end
+
+    def complete
+      return false if terminal? || cancelled?
+      return false unless wait_for_ack
+
+      send_terminal_message(RactorPort::Complete.new)
+    end
+
+    def fail(error = nil, cause_class_name: nil, cause_message: nil)
+      return false if terminal? || cancelled?
+
+      failure = failure_message(error, cause_class_name, cause_message)
+      return false unless wait_for_ack
+
+      send_terminal_message(failure)
+    end
+
+    def cancelled?
+      @cancelled
+    end
+
+    def terminal? # :nodoc:
+      @terminal
+    end
+
+    def send_failed? # :nodoc:
+      @send_failed
+    end
+
+    private
+
+    def send_emitted_message(message, transfer)
+      send_data_message(message, transfer)
+      true
+    rescue Exception => error # rubocop:disable Lint/RescueException
+      report_same_ack_failure(error)
+      false
+    end
+
+    def send_terminal_message(message)
+      send_data_message(message, @transfer)
+      @terminal = true
+      true
+    rescue Exception => send_error # rubocop:disable Lint/RescueException
+      report_same_ack_failure(send_error)
+      false
+    end
+
+    def validate_transfer_override!(transfer)
+      return @transfer if transfer.nil?
+      return transfer if [:copy, :move].include?(transfer)
+
+      raise ArgumentError, "transfer must be :copy or :move"
+    end
+
+    def wait_for_ack
+      case @ack_port.receive
+      in RactorPort::Ack
+        true
+      in RactorPort::Cancel
+        @cancelled = true
+        false
+      else
+        raise TypeError, "invalid ractor producer control message"
+      end
+    end
+
+    def send_data_message(message, transfer)
+      if transfer == :move
+        @data_port.send(message, move: true)
+      else
+        @data_port.send(message)
+      end
+    end
+
+    def failure_message(error, cause_class_name, cause_message)
+      if error
+        return RactorPort::Failure.new(safe_class_name(error), safe_message(error))
+      end
+
+      unless cause_class_name.is_a?(String) && cause_message.is_a?(String)
+        raise ArgumentError, "fail requires an error or String failure metadata"
+      end
+
+      RactorPort::Failure.new(cause_class_name, cause_message)
+    end
+
+    def safe_class_name(error)
+      name = error.class.name
+      name.is_a?(String) && !name.empty? ? name : "Exception"
+    rescue Exception # rubocop:disable Lint/RescueException
+      "Exception"
+    end
+
+    def safe_message(error)
+      message = error.message
+      message.is_a?(String) ? message : ""
+    rescue Exception # rubocop:disable Lint/RescueException
+      ""
+    end
+
+    def report_same_ack_failure(error)
+      send_data_message(RactorPort::Failure.new(safe_class_name(error), safe_message(error)), :copy)
+      @terminal = true
+    rescue Exception # rubocop:disable Lint/RescueException
+      @terminal = true
+      @send_failed = true
+    end
+  end
+
+  # Builder passed to `Source.ractor_merge_producers`.
+  #
+  # Each `producer` call records one lazily started owned producer definition.
+  # Registration validates producer block isolation and transfer policy but
+  # does not create Ractor ports or start producer code.
+  class RactorProducerGroup
+    Definition = Data.define(:args, :transfer, :block)
+    private_constant :Definition
+
+    def initialize(default_transfer)
+      @default_transfer = default_transfer
+      @definitions = []
+    end
+
+    def producer(*args, transfer: nil, &block)
+      raise ArgumentError, "missing block" unless block
+      unless transfer.nil? || [:copy, :move].include?(transfer)
+        raise ArgumentError, "transfer must be :copy or :move"
+      end
+      raise TypeError, "block must be shareable" unless Ractor.shareable?(block)
+
+      @definitions << Definition.new(args:, transfer: transfer || @default_transfer, block:)
+      self
+    end
+
+    def definitions
+      @definitions.dup.freeze
+    end
+  end
+end

data/lib/fiber_stream/running_pipeline.rb

@@ -2,6 +2,15 @@
 
 module FiberStream
   class RunningPipeline
+    ValueMessage = Data.define(:value)
+    ErrorMessage = Data.define(:error)
+    CancelledMessage = Data.define(:error)
+    private_constant :ValueMessage, :ErrorMessage, :CancelledMessage
+
+    def self.start(scheduler, &run) # :nodoc:
+      new(scheduler, &run)
+    end
+
     def initialize(scheduler, &run)
       @scheduler = scheduler
       @completion = nil
@@ -82,16 +91,19 @@ module FiberStream
     private
 
     def run_background(run)
-      complete([:value, run.call])
+      complete(ValueMessage.new(value: run.call))
+    rescue SystemExit, SignalException => error
+      complete(ErrorMessage.new(error:))
+      raise
     rescue Exception => error # rubocop:disable Lint/RescueException
       complete(classify_error(error))
     end
 
     def classify_error(error)
       if cancellation_error?(error)
-        [:cancelled, error]
+        CancelledMessage.new(error:)
       else
-        [:error, error]
+        ErrorMessage.new(error:)
       end
     end
 
@@ -114,11 +126,13 @@ module FiberStream
     end
 
     def deliver(message)
-      case message.fetch(0)
-      when :value
-        message.fetch(1)
-      when :error, :cancelled
-        raise message.fetch(1)
+      case message
+      in ValueMessage[value:]
+        value
+      in ErrorMessage[error:]
+        raise error
+      in CancelledMessage[error:]
+        raise error
       end
     end
 

data/lib/fiber_stream/sink.rb

@@ -10,10 +10,7 @@ module FiberStream
       new do |stream|
         values = []
 
-        loop do
-          value = stream.next
-          break if Pull.done?(value)
-
+        Pull.each_value(stream) do |value|
           values << value
         end
 
@@ -45,10 +42,7 @@ module FiberStream
       new do |stream|
         accumulator = initial
 
-        loop do
-          value = stream.next
-          break if Pull.done?(value)
-
+        Pull.each_value(stream) do |value|
           accumulator = block.call(accumulator, value)
         end
 
@@ -68,10 +62,7 @@ module FiberStream
       new do |stream|
         count = 0
 
-        loop do
-          value = stream.next
-          break if Pull.done?(value)
-
+        Pull.each_value(stream) do |value|
           block.call(value)
           count += 1
         end
@@ -99,15 +90,17 @@ module FiberStream
       end
     end
 
+    def self.build(&run) # :nodoc:
+      new(&run)
+    end
+
     def initialize(&run)
       @run = run
     end
 
     private_class_method :new
 
-    private
-
-    def run(stream)
+    def run_stream(stream) # :nodoc:
       @run.call(stream)
     end
 
@@ -121,10 +114,7 @@ module FiberStream
       end
 
       def run(stream)
-        loop do
-          value = stream.next
-          break if Pull.done?(value)
-
+        Pull.each_value(stream) do |value|
           write(value)
         end
 

data/lib/fiber_stream/source.rb

@@ -2,6 +2,9 @@
 
 module FiberStream
   class Source
+    RactorMergePortPair = Data.define(:port, :ack_port)
+    private_constant :RactorMergePortPair
+
     # Creates a source definition from an Enumerable.
     #
     # The enumerable is not consumed until values are pulled by `run_with`. Each
@@ -17,7 +20,9 @@ module FiberStream
     # The IO object is not read until values are pulled by `run_with`. Each
     # materialization reads from the same IO object's current position; this
     # source does not snapshot, reopen, or guarantee replayability. The IO is
-    # closed only when `close: true` is passed.
+    # closed only when `close: true` is passed. `chunk_size` is the maximum byte
+    # count passed to `readpartial` for one downstream pull; very large values
+    # may cause the IO implementation to attempt large allocations.
     def self.io(io, chunk_size: 16 * 1024, close: false)
       raise TypeError, "io must respond to readpartial" unless io.respond_to?(:readpartial)
       raise TypeError, "chunk_size must be an Integer" unless chunk_size.is_a?(Integer)
@@ -34,19 +39,82 @@ module FiberStream
     # producer-owned port that receives `RactorPort::Ack` and
     # `RactorPort::Cancel` control messages. The producer must wait for an ack
     # before sending each `RactorPort::Element`, `RactorPort::Complete`, or
-    # `RactorPort::Failure` message.
+    # `RactorPort::Failure` message. Failure metadata is producer-provided and
+    # should be sanitized before crossing trust boundaries.
     def self.ractor_port(port, ack_port:, ack_transfer: :copy, cancel: true)
       raise TypeError, "port must respond to receive" unless port.respond_to?(:receive)
       unless ack_port.respond_to?(:send) && ack_port.method(:send).owner != Kernel
         raise TypeError, "ack_port must provide Ractor-style send"
       end
 
-      Flow.__send__(:validate_ractor_transfer_policy!, :ack_transfer, ack_transfer)
+      Internal::RactorTransferPolicy.validate!(:ack_transfer, ack_transfer)
       raise TypeError, "cancel must be true or false" unless [true, false].include?(cancel)
 
       new(-> { Pull.ractor_port(port, ack_port, ack_transfer, cancel) })
     end
 
+    # Creates a backpressure-aware source definition from multiple Ractor port
+    # pairs.
+    #
+    # Each pair must be a Hash with `:port` and `:ack_port`. The source sends
+    # at most one outstanding `RactorPort::Ack` to each active producer and
+    # emits producer values in coordinator-observed ready order. Producer work
+    # is isolated in Ractors, so demanding this source does not require a
+    # `Fiber.scheduler`. Failure metadata is producer-provided and should be
+    # sanitized before crossing trust boundaries.
+    def self.ractor_merge_ports(ports, ack_transfer: :copy, cancel: true)
+      pairs = normalize_ractor_merge_port_pairs(ports)
+
+      Internal::RactorTransferPolicy.validate!(:ack_transfer, ack_transfer)
+      raise TypeError, "cancel must be true or false" unless [true, false].include?(cancel)
+
+      new(-> { Pull.ractor_merge_ports(pairs, ack_transfer, cancel) })
+    end
+
+    # Creates a source backed by one FiberStream-owned producer ractor.
+    #
+    # The producer ractor is started lazily on first downstream demand. The
+    # shareable block receives a `RactorProducer` context and the provided
+    # arguments. Calls to the context preserve one-outstanding-ack
+    # backpressure, and cleanup always requests cooperative cancellation.
+    def self.ractor_producer(*args, transfer: :copy, ack_transfer: :copy, &block)
+      raise ArgumentError, "missing block" unless block
+
+      Internal::RactorTransferPolicy.validate!(:transfer, transfer)
+      Internal::RactorTransferPolicy.validate!(:ack_transfer, ack_transfer)
+      raise TypeError, "block must be shareable" unless Ractor.shareable?(block)
+
+      group = RactorProducerGroup.new(transfer)
+      group.producer(*args, &block)
+      definitions = group.definitions
+
+      new(-> { Pull.ractor_producer(definitions, ack_transfer) })
+    end
+
+    # Creates a source backed by multiple FiberStream-owned producer ractors.
+    #
+    # The registration block runs at construction to collect producer
+    # definitions, but producer ractors and ports are started lazily on first
+    # downstream demand. Outputs are merged with the same ready-order semantics
+    # as `Source.ractor_merge_ports`.
+    def self.ractor_merge_producers(transfer: :copy, ack_transfer: :copy, &block)
+      raise ArgumentError, "missing block" unless block
+
+      Internal::RactorTransferPolicy.validate!(:transfer, transfer)
+      Internal::RactorTransferPolicy.validate!(:ack_transfer, ack_transfer)
+
+      group = RactorProducerGroup.new(transfer)
+      block.call(group)
+      definitions = group.definitions
+      raise ArgumentError, "ractor_merge_producers requires at least two producers" if definitions.size < 2
+
+      new(-> { Pull.ractor_merge_producers(definitions, ack_transfer) })
+    end
+
+    def self.build(source_factory, flows = []) # :nodoc:
+      new(source_factory, flows)
+    end
+
     def initialize(source_factory, flows = [])
       @source_factory = source_factory
       @flows = flows
@@ -59,7 +127,7 @@ module FiberStream
     def via(flow)
       raise TypeError, "expected FiberStream::Flow" unless flow.is_a?(Flow)
 
-      self.class.__send__(:new, @source_factory, @flows + [flow])
+      self.class.build(@source_factory, @flows + [flow])
     end
 
     # Returns a new source definition that emits this source, then `source`.
@@ -71,10 +139,7 @@ module FiberStream
     def concat(source)
       raise TypeError, "expected FiberStream::Source" unless source.is_a?(Source)
 
-      self.class.__send__(
-        :new,
-        -> { Pull.concat(materializer, source.__send__(:materializer)) }
-      )
+      self.class.build(-> { Pull.concat(to_pull_materializer, source.to_pull_materializer) })
     end
 
     # Returns a new source definition that emits pairs from this source and
@@ -87,10 +152,21 @@ module FiberStream
     def zip(source)
       raise TypeError, "expected FiberStream::Source" unless source.is_a?(Source)
 
-      self.class.__send__(
-        :new,
-        -> { Pull.zip(materializer, source.__send__(:materializer)) }
-      )
+      self.class.build(-> { Pull.zip(to_pull_materializer, source.to_pull_materializer) })
+    end
+
+    # Returns a new source definition that emits values from this source and
+    # `source` in scheduler-observed ready order.
+    #
+    # Construction is lazy. The merged source starts one scheduled producer
+    # fiber per input source only when downstream demand reaches the merge. Each
+    # input's own element order is preserved, but cross-input ordering is not
+    # deterministic and requires an installed `Fiber.scheduler` from a
+    # non-blocking fiber when demanded.
+    def merge(source)
+      raise TypeError, "expected FiberStream::Source" unless source.is_a?(Source)
+
+      self.class.build(-> { Pull.merge(to_pull_materializer, source.to_pull_materializer) })
     end
 
     # Returns a new source definition that maps each element with `block`.
@@ -112,6 +188,18 @@ module FiberStream
       via(Flow.parallel_map(concurrency: concurrency, &block))
     end
 
+    # Returns a new source definition that maps elements concurrently and emits
+    # mapped values in completion order.
+    #
+    # This is a convenience wrapper around
+    # `via(FiberStream::Flow.parallel_unordered_map(concurrency:) { ... })`.
+    # The operation preserves the same scheduler requirement, validation,
+    # bounded upstream run-ahead, and cancellation behavior while making no
+    # input-order guarantee.
+    def parallel_unordered_map(concurrency:, &block)
+      via(Flow.parallel_unordered_map(concurrency: concurrency, &block))
+    end
+
     # Returns a new source definition that maps elements in Ractor workers.
     #
     # This is a convenience wrapper around
@@ -154,6 +242,24 @@ module FiberStream
       via(Flow.drop(count))
     end
 
+    # Returns a new source definition that groups adjacent elements into arrays.
+    #
+    # This is a convenience wrapper around
+    # `via(FiberStream::Flow.grouped(count))` and preserves the same validation,
+    # ordering, final partial group, and pull-driven backpressure behavior.
+    def grouped(count)
+      via(Flow.grouped(count))
+    end
+
+    # Returns a new source definition that emits running accumulators.
+    #
+    # This is a convenience wrapper around
+    # `via(FiberStream::Flow.scan(initial) { ... })` and preserves the same
+    # reducer order, lazy construction, and pull-driven backpressure behavior.
+    def scan(initial, &block)
+      via(Flow.scan(initial, &block))
+    end
+
     # Returns a new source definition that emits leading elements while `block`
     # is truthy.
     #
@@ -194,11 +300,25 @@ module FiberStream
     # Returns a new source definition that splits String chunks into lines.
     #
     # This is a convenience wrapper around
-    # `via(FiberStream::Flow.lines(chomp:, max_length:))`.
+    # `via(FiberStream::Flow.lines(chomp:, max_length:))`. With
+    # `max_length: nil`, one unterminated line can buffer without bound. Set a
+    # positive `max_length` for untrusted, network-facing, or otherwise
+    # unbounded streams.
     def lines(chomp: true, max_length: nil)
       via(Flow.lines(chomp: chomp, max_length: max_length))
     end
 
+    # Returns a new source definition that splits String chunks into frames.
+    #
+    # This is a convenience wrapper around
+    # `via(FiberStream::Flow.split(separator, keep_separator:, max_length:))`.
+    # With `max_length: nil`, one unterminated frame can buffer without bound.
+    # Set a positive `max_length` for untrusted, network-facing, or otherwise
+    # unbounded streams.
+    def split(separator, keep_separator: false, max_length: nil)
+      via(Flow.split(separator, keep_separator: keep_separator, max_length: max_length))
+    end
+
     # Returns a runnable pipeline from this source to `sink`.
     #
     # Construction is lazy. The source and sink are not materialized until
@@ -206,7 +326,7 @@ module FiberStream
     def to(sink)
       raise TypeError, "expected FiberStream::Sink" unless sink.is_a?(Sink)
 
-      Pipeline.__send__(:new, self, sink)
+      Pipeline.build(self, sink)
     end
 
     # Materializes and runs this source with `sink`.
@@ -222,7 +342,7 @@ module FiberStream
       begin
         stream = materialize
 
-        sink.__send__(:run, stream)
+        sink.run_stream(stream)
       rescue StandardError => error
         primary_error = error
         raise
@@ -237,19 +357,57 @@ module FiberStream
 
     private_class_method :new
 
-    private
+    def to_pull_materializer # :nodoc:
+      method(:materialize)
+    end
+
+    def self.normalize_ractor_merge_port_pairs(ports)
+      raise TypeError, "ports must respond to each" unless ports.respond_to?(:each)
+
+      data_port_ids = {}
+      ack_port_ids = {}
+      pairs =
+        ports.each.map do |pair|
+          normalize_ractor_merge_port_pair(pair, data_port_ids, ack_port_ids)
+        end
 
-    def materializer
-      -> { materialize }
+      raise ArgumentError, "ractor_merge_ports requires at least two port pairs" if pairs.size < 2
+
+      pairs.freeze
     end
 
+    def self.normalize_ractor_merge_port_pair(pair, data_port_ids, ack_port_ids)
+      raise TypeError, "port pair must be a Hash" unless pair.is_a?(Hash)
+      raise TypeError, "port pair must include :port and :ack_port" unless pair.key?(:port) && pair.key?(:ack_port)
+
+      port = pair.fetch(:port)
+      ack_port = pair.fetch(:ack_port)
+      raise TypeError, "port must respond to receive" unless port.respond_to?(:receive)
+      unless ack_port.respond_to?(:send) && ack_port.method(:send).owner != Kernel
+        raise TypeError, "ack_port must provide Ractor-style send"
+      end
+
+      port_id = port.object_id
+      ack_port_id = ack_port.object_id
+      raise ArgumentError, "data ports must be distinct" if data_port_ids.key?(port_id)
+      raise ArgumentError, "ack ports must be distinct" if ack_port_ids.key?(ack_port_id)
+
+      data_port_ids[port_id] = true
+      ack_port_ids[ack_port_id] = true
+      RactorMergePortPair.new(port:, ack_port:)
+    end
+
+    private_class_method :normalize_ractor_merge_port_pairs, :normalize_ractor_merge_port_pair
+
+    private
+
     def materialize
       stream = nil
 
       begin
         stream = @source_factory.call
         @flows.each do |flow|
-          stream = flow.__send__(:attach, stream)
+          stream = flow.attach_to(stream)
         end
         stream
       rescue StandardError

data/lib/fiber_stream/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FiberStream
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/fiber_stream.rb

@@ -3,7 +3,9 @@
 require_relative "fiber_stream/pull"
 require_relative "fiber_stream/version"
 require_relative "fiber_stream/errors"
+require_relative "fiber_stream/internal/ractor_transfer_policy"
 require_relative "fiber_stream/ractor_port"
+require_relative "fiber_stream/ractor_producer"
 require_relative "fiber_stream/flow"
 require_relative "fiber_stream/sink"
 require_relative "fiber_stream/running_pipeline"

data/sig/fiber_stream.rbs

@@ -1,7 +1,8 @@
 module FiberStream
   type ractor_transfer_policy = :copy | :move
+  type ractor_port_pair = { port: untyped, ack_port: untyped }
   type ractor_map_error_kind = :input_transfer | :output_transfer | :worker | :worker_termination | :isolation
-  type ractor_port_source_error_kind = :invalid_message | :producer_failure | :receive | :ack_transfer | :cancel_transfer
+  type ractor_port_source_error_kind = :invalid_message | :producer_failure | :receive | :ack_transfer | :cancel_transfer | :producer_setup
   type ractor_port_cancel_reason = :closed
 
   class SchedulerRequiredError < RuntimeError
@@ -47,24 +48,43 @@ module FiberStream
     end
   end
 
+  class RactorProducer
+    def emit: [Elem] (Elem value, ?transfer: ractor_transfer_policy?) -> bool
+    def complete: () -> bool
+    def fail: (?untyped error, ?cause_class_name: String?, ?cause_message: String?) -> bool
+    def cancelled?: () -> bool
+  end
+
+  class RactorProducerGroup
+    def producer: (*untyped args, ?transfer: ractor_transfer_policy?) { (RactorProducer producer, *untyped args) -> void } -> self
+  end
+
   class Source[Elem]
     def self.each: [Elem] (Enumerable[Elem] enumerable) -> Source[Elem]
     def self.io: (untyped io, ?chunk_size: Integer, ?close: bool) -> Source[String]
     def self.ractor_port: [Elem] (untyped port, ack_port: untyped, ?ack_transfer: ractor_transfer_policy, ?cancel: bool) -> Source[Elem]
+    def self.ractor_merge_ports: [Elem] (Enumerable[ractor_port_pair] ports, ?ack_transfer: ractor_transfer_policy, ?cancel: bool) -> Source[Elem]
+    def self.ractor_producer: [Elem] (*untyped args, ?transfer: ractor_transfer_policy, ?ack_transfer: ractor_transfer_policy) { (RactorProducer producer, *untyped args) -> void } -> Source[Elem]
+    def self.ractor_merge_producers: [Elem] (?transfer: ractor_transfer_policy, ?ack_transfer: ractor_transfer_policy) { (RactorProducerGroup group) -> void } -> Source[Elem]
     def via: [Out] (Flow[Elem, Out] flow) -> Source[Out]
     def concat: [Other] (Source[Other] source) -> Source[Elem | Other]
     def zip: [Other] (Source[Other] source) -> Source[[Elem, Other]]
+    def merge: [Other] (Source[Other] source) -> Source[Elem | Other]
     def map: [Out] () { (Elem) -> Out } -> Source[Out]
     def parallel_map: [Out] (concurrency: Integer) { (Elem) -> Out } -> Source[Out]
+    def parallel_unordered_map: [Out] (concurrency: Integer) { (Elem) -> Out } -> Source[Out]
     def ractor_map: [Out] (workers: Integer, ?input_transfer: ractor_transfer_policy, ?output_transfer: ractor_transfer_policy) { (Elem) -> Out } -> Source[Out]
     def select: () { (Elem) -> boolish } -> Source[Elem]
     def take: (Integer count) -> Source[Elem]
     def drop: (Integer count) -> Source[Elem]
+    def grouped: (Integer count) -> Source[Array[Elem]]
+    def scan: [Acc] (Acc initial) { (Acc, Elem) -> Acc } -> Source[Acc]
     def take_while: () { (Elem) -> boolish } -> Source[Elem]
     def drop_while: () { (Elem) -> boolish } -> Source[Elem]
     def async: () -> Source[Elem]
     def buffer: (Integer count) -> Source[Elem]
     def lines: (?chomp: bool, ?max_length: Integer?) -> Source[String]
+    def split: (String separator, ?keep_separator: bool, ?max_length: Integer?) -> Source[String]
     def to: [Mat] (Sink[Elem, Mat] sink) -> Pipeline[Mat]
     def run_with: [Mat] (Sink[Elem, Mat] sink) -> Mat
   end
@@ -72,15 +92,19 @@ module FiberStream
   class Flow[In, Out]
     def self.map: [In, Out] () { (In) -> Out } -> Flow[In, Out]
     def self.parallel_map: [In, Out] (concurrency: Integer) { (In) -> Out } -> Flow[In, Out]
+    def self.parallel_unordered_map: [In, Out] (concurrency: Integer) { (In) -> Out } -> Flow[In, Out]
     def self.ractor_map: [In, Out] (workers: Integer, ?input_transfer: ractor_transfer_policy, ?output_transfer: ractor_transfer_policy) { (In) -> Out } -> Flow[In, Out]
     def self.select: [Elem] () { (Elem) -> boolish } -> Flow[Elem, Elem]
     def self.take: [Elem] (Integer count) -> Flow[Elem, Elem]
     def self.drop: [Elem] (Integer count) -> Flow[Elem, Elem]
+    def self.grouped: [Elem] (Integer count) -> Flow[Elem, Array[Elem]]
+    def self.scan: [Elem, Acc] (Acc initial) { (Acc, Elem) -> Acc } -> Flow[Elem, Acc]
     def self.take_while: [Elem] () { (Elem) -> boolish } -> Flow[Elem, Elem]
     def self.drop_while: [Elem] () { (Elem) -> boolish } -> Flow[Elem, Elem]
     def self.async: [Elem] () -> Flow[Elem, Elem]
     def self.buffer: [Elem] (Integer count) -> Flow[Elem, Elem]
     def self.lines: (?chomp: bool, ?max_length: Integer?) -> Flow[String, String]
+    def self.split: (String separator, ?keep_separator: bool, ?max_length: Integer?) -> Flow[String, String]
     def via: [Next] (Flow[Out, Next] flow) -> Flow[In, Next]
     def to: [Mat] (Sink[Out, Mat] sink) -> Sink[In, Mat]
   end