t
scalqa

Stream._extend._map

trait _map[A] extends Stream.Flow._extend._map[A]

Stream Conversion Interface

Self Type
Stream[A]
Ordering
  1. Alphabetic
Inherited
  1. Stream._extend._map
  2. Stream.Flow._extend._map
  3. Stream.Flow._extend.Z.Shared
  4. scala.AnyRef
  5. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Method

  1. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  2. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  3. def collect[B](f: PartialFunction[A, B])(implicit arg0: Tag[B]): Stream[B]

    Filter and converter

    Filter and converter

    Only lets elements for which given PartialFinction is defined

    The elements are converted to returned type

    def all = ~~[Any] + "ABC" + 1 + 22.0 + "DE" + 333F + "F"

all.lp                                     // Prints ~(ABC, 1, 22.0, DE, 333.0, F)

all.collect{
    case s: String if (s.length > 1) => s
}.lp                                       // Prints ~(ABC, DE)

    Note. collect always requires double evaluation for each element, so letMap is preferred in many cases

    Definition Classes
    _map → Shared
  4. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  5. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  7. def flatMap[B](f: Mapping[A, ~[B]])(implicit i: Tag[B]): Stream[B]

    Map multiplier

    Map multiplier

    For every existing element, a mapped stream of elements is inserted into the pipeline

    Note. The mapping can return an empty stream, in which case total number of elements might even be reduced

    ~~(1, 2, 3).flatMap(i => Seq(i * 10, i * 100, i * 1000)).lp

// Output
~(10, 100, 1000, 20, 200, 2000, 30, 300, 3000)
    f

    function to provide a stream of elements for each existing element

    Definition Classes
    _map → _map
  8. def flatten[B](implicit f: Mapping[A, ~[B]], i: Tag[B]): Stream[B]

    Converts a stream of streams into a flat stream

    Converts a stream of streams into a flat stream

    val stream: ~[~[Char]] = ~~(
  'a' to 'd',
  List('x', 'y', 'z'),
  Vector('v', 'e', 'c', 't', 'o', 'r'))

stream.flatten.lp // Prints: ~(a, b, c, d, x, y, z, v, e, c, t, o, r)
    Definition Classes
    _map
  9. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  10. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  11. def letMap[B](f: Mapping[A, Opt[B]])(implicit i: Tag[B]): Stream[B]

    Filter and converter

    Filter and converter

    Only lets elements for which given function returns non empty Opt

    The elements are converted to the new type

    def all = "ABC" ~+ "1" + "22" + "D" + "333" + "E"

all.letMap(v => if (v.length < 2) \/ else v).lp // Prints: ~(ABC, 22, 333)

all.letMap({
  case s if (s.length >= 2) => s
  case _                    => \/
}).lp                                           // Prints: ~(ABC, 22, 333)

    Note: letMap is often a faster alternative to collect with PartialFunction, because it is evaluated just once for each element

    Definition Classes
    _map → Shared
  12. def letType[B](implicit t: ClassTag[B]): Stream[B]

    Filter and type converter

    Filter and type converter

    Only lets elements, which are instances of the given type

    Note, the result is mapped to the specified type

    def all = ~~[Any] + "1" + 2 + 3.0 + 4l + "5"

all.lp                  // Prints ~(1, 2, 3.0, 4, 5)

all.letType[String].lp  // Prints ~(1, 5)
    Definition Classes
    _map → Shared
  13. def map[B](f: Mapping[A, B])(implicit i: Tag[B]): Stream[B]

    Element conversion

    Element conversion

    Converts every element in the pipeline with given function

    (1 to 5).all.map( _ / 2.0).lp  // Prints ~(0.5, 1.0, 1.5, 2.0, 2.5)
    Definition Classes
    _map → _map
  14. def mapCast[B]: Stream[B]

    Element cast

    Element cast

    Casts the pipeline elements into the type specified

    def all: ~[Any] = ~~[Any] + 1 + 2 + 3

all.mapCast[Int].lp   // Prints: ~(1, 2, 3)

    Note. The cast will not fail immediately, and if there is a problem, it will come up later during pumping action

    Definition Classes
    _map → _map
  15. def mapIdx[B](f: Mapping.Idx[A, B], start: Int = 0)(implicit arg0: Tag[B]): ~[B]

    Indexed element conversion

    Indexed element conversion

    Converts every element in the pipeline with given function

    ('A' to 'G').all.mapIdx(_ + "=" + _, 1).lp  // Prints ~(1=A, 2=B, 3=C, 4=D, 5=E, 6=F, 7=G)
    f

    the conversion function which also accepts element index in the sequence

    start

    the starting value of indexing

    Definition Classes
    _map
  16. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. final def notify(): Unit
    Definition Classes
    AnyRef
  18. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  19. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  20. def toString(): String
    Definition Classes
    AnyRef → Any
  21. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  22. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  23. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Operator

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any