ThoughtWorksInc/Binding.scala/com.thoughtworks.binding/PatchStreamT

PatchStreamT

object PatchStreamT extends LowPriority0
class Object
trait Matchable
class Any

Type members

Classlikes

object Patch
Companion:
class
sealed trait Patch[+A]
Companion:
object

Types

opaque type Snapshot[+A]

A scalaz.FingerTree representing the snapshot of the sequence at a certain time.

A scalaz.FingerTree representing the snapshot of the sequence at a certain time.

Note:

The measurement of this scalaz.FingerTree is the size.

Value members

Concrete methods

def apply[M[_], A]: CovariantStreamT[M, Patch[A]] =:= PatchStreamT[M, A]
def fromCovariantStreamT[M[_], A](stream: CovariantStreamT[M, A])(using Functor[M]): PatchStreamT[M, A]
def fromIterable[M[_], A](iterable: Iterable[A])(using Applicative[M]): PatchStreamT[M, A]

Givens

Givens

given given_OneStep_From_PatchStreamT[M[_], From, A](using M: Applicative[M], asIterable: From => Iterable[A]): OneStep[From, PatchStreamT[M, A]]
given given_OneStep_From_PatchStreamT[M[_], From, A](using M: Nondeterminism[M], asIterable: From => Iterable[CovariantStreamT[M, A]]): OneStep[From, PatchStreamT[M, A]]

Inherited givens

given given_OneStep_From_PatchStreamT[M[_], A, From](using toStream: From <:< CovariantStreamT[M, A], M: Functor[M]): OneStep[From, PatchStreamT[M, A]]
Inherited from:
LowPriority0

Extensions

Extensions

extension [M[_], A](upstream: => PatchStreamT[M, A])
def flatMap[B](f: A => PatchStreamT[M, B])(using M: Nondeterminism[M]): PatchStreamT[M, B]

Returns a new data-binding sequence by applying a function to all elements of this sequence and using the elements of the resulting collections.

Returns a new data-binding sequence by applying a function to all elements of this sequence and using the elements of the resulting collections.

Whenever upstream or one of the subsequence changes, the result sequence changes accordingly. The time complexity to update the result sequence, when upstream changes, is O(log(n) + c), where n is the size of upstream, and c is number of elements in upstream, mapped to mutable subsequences by f, of which the indices in upstream are changing. For example, if the size of upstream is 10 and 4 elements of them mapped to mutable subsequences, when an element is prepended to upstream, c is 4. However when an element is appended to upstream, c is zero, because no element's index in `upstream is changed.

The time complexity to update the result sequence, when one of the subsequence changes, is O(log(n)), where n is the size of upstream.

Example:

Given a source PatchStreamT from an iterable,

 import scala.concurrent.Future
 import scalaz.std.scalaFuture.given
 val bindingSeq = PatchStreamT.fromIterable[Future, String](Seq("foo", "bar"))

when flat-mapping it to more PatchStreamT,

 val flatten = bindingSeq.flatMap { s =>
   PatchStreamT.fromIterable(s)
 }

then it should returns a StreamT including each intermediate states during flat-mapping

 import com.thoughtworks.dsl.keywords.Await
 import com.thoughtworks.dsl.macros.Reset.Default.*
 `*`[Future] {
   val snapshotLazyList = !Await(flatten.snapshots.toLazyList)
   snapshotLazyList.map(_.toList.mkString) should be(
     LazyList(
       "",
       "foo",
       "foobar",
     )
   )
 }
def memoize(using Functor[M]): PatchStreamT[M, A]
def mergeMap[B](mapper: A => CovariantStreamT[M, B])(using M: Nondeterminism[M]): CovariantStreamT[M, B]
def mergeWith(eventLoop: => CovariantStreamT[M, Nothing])(using Nondeterminism[M]): PatchStreamT[M, A]
def noSkip(using Monad[M]): PatchStreamT[M, A]
def snapshots(using Applicative[M]): CovariantStreamT[M, FingerTree[Int, A]]

Return a CovariantStreamT, whose each element is a scalaz.FingerTree representing the snapshot of the sequence at that time.

Return a CovariantStreamT, whose each element is a scalaz.FingerTree representing the snapshot of the sequence at that time.

Note:

The measurement of the scalaz.FingerTree is the size.

Example:

Given a PatchStreamT created from an iterable,

 import scala.concurrent.Future
 import scalaz.std.scalaFuture.given
 val bindingSeq = PatchStreamT.fromIterable[Future, String](Seq("foo", "bar", "baz"))

when taking snapshots,

 val snapshots = bindingSeq.snapshots

then it should contains an empty value and an initial value

 import com.thoughtworks.dsl.keywords.Await
 import com.thoughtworks.dsl.macros.Reset.Default.*
 `*`[Future] {
   val snapshotLazyList = !Await(snapshots.toLazyList)
   inside(snapshotLazyList) {
     case LazyList(empty, initial) =>
       empty.toList should be(Nil)
       initial.toList should be(List("foo", "bar", "baz"))
   }
 }