Trying to encode a RIO-like thing in Ruby's RBS

rio.rb

class RIO
  def self.succeed_now(value)
    Succeed.new(value)
  end

  def self.fail_now(error)
    Fail.new(error)
  end

  def flat_map(&blk)
    FlatMap.new(self, &blk)
  end

  def map(&blk)
    FlatMap.new(self) { |a| Succeed.new(blk.call(a)) }
  end

  def flumb(a, b)
    RIO.succeed_now([a, b])
  end

  def zip(other)
    flat_map { |a| other.map { |b| [a, b] } }
  end
end

class Fail < RIO
  def initialize(error)
    @error = error
  end

  def run
    self
  end
end

class Succeed < RIO
  def initialize(value)
    @value = value
  end

  def run
    yield @value
  end
end

class FlatMap < RIO
  def initialize(rio, &fn)
    @rio = rio
    @fn = fn
  end

  def run
    @rio.run(&@fn)
  end
end

rio.rbs

class RIO[R, E, A]
  def self.succeed_now: [R, E, A] (A) -> RIO[R, E, A]
  def self.fail_now: [R, E, A] (E) -> RIO[R, E, A]
  def map: [B] { (A) -> B } -> RIO[R, E, B]
  def flat_map: [B] { (A) -> RIO[R, E, B] } -> RIO[R, E, B]
  def run: { (A) -> void } -> void
  def zip: [B] (RIO[R, E, B]) -> RIO[R, E, [A, B]]
  def flumb: [Q, Y] (Q, Y) -> RIO[R, E, [Q, Y]]
end

class Fail[R, E, A] < RIO[R, E, A]
  @error: E

  def initialize: (E) -> void
end

class Succeed[R, E, A] < RIO[R, E, A]
  @value: A

  def initialize: (A) -> void
end

class FlatMap[R, E, A, B] < RIO[R, E, B]
  @rio: RIO[R, E, A]
  @fn: ^(A) -> RIO[R, E, B]

  def initialize: (RIO[R, E, A]) { (A) -> RIO[R, E, B] } -> void
end

$ be steep watch ./lib ./sig
👀 Watching directories, Ctrl-C to stop.
lib/rio.rb:18:6: [error] Cannot allow method body have type `::RIO[untyped, untyped, ::Array[(Q | Y)]]` because declared as type `::RIO[R, E, [Q, Y]]`
│   ::RIO[untyped, untyped, ::Array[(Q | Y)]] <: ::RIO[R, E, [Q, Y]]
│     ::Array[(Q | Y)] <: [Q, Y]
│
│ Diagnostic ID: Ruby::MethodBodyTypeMismatch
│
└   def flumb(a, b)
        ~~~~~
lib/rio.rb:22:6: [error] Cannot allow method body have type `::RIO[R, E, ::Array[(A | B)]]` because declared as type `::RIO[R, E, [A, B]]`
│   ::RIO[R, E, ::Array[(A | B)]] <: ::RIO[R, E, [A, B]]
│     ::Array[(A | B)] <: [A, B]
│
│ Diagnostic ID: Ruby::MethodBodyTypeMismatch
│
└   def zip(other)
        ~~~