t

Stream._extend._group

trait _group[A] extends AnyRef

Element Grouping Interface

Self Type
Stream[A]
Ordering
  1. Alphabetic
Inherited
  1. Stream._extend._group
  2. scala.AnyRef
  3. 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. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  4. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  6. def group(test: (A, A) ⇒ Boolean, peekSplit: (A, Boolean) ⇒ Any = \/): ~[~[A]]

    Group by test

    Group by test

    Puts elements in the same group based on a function test for every two consecutive elements

    test

    function for two consecutive elements. if 'false' is returned, the second tested element will start a new group

    peekSplit

    function to run for each piped element. Boolean parameter indicates if the element starts a new group

    Definition Classes
    _group
    Example:
    1. // Putting Ints into groups of 3
      (0 <> 20).all.group(_ / 3 == _ / 3).tp
      
      // Output
      
      ---------------
      ?
      ---------------
      ~(0, 1, 2)
      ~(3, 4, 5)
      ~(6, 7, 8)
      ~(9, 10, 11)
      ~(12, 13, 14)
      ~(15, 16, 17)
      ~(18, 19, 20)
      ---------------
  7. def group: ~[~[A]]

    Simple grouping

    Simple grouping

    Puts consecutive elements in the same group if they are equal

    Note: Non consecutive equal elements will end up in different groups. Prior ordering might be needed

    Definition Classes
    _group
    Example:
    1. def all =  ~.*(1, 2, 3).flatMap(_.I.repeat(3))
      
      all.lp
      
      all.group.tp
      
      // Output
      ~(1, 1, 1, 2, 2, 2, 3, 3, 3)
      
      ------------
      ?
      ------------
      ~(1, 1, 1)
      ~(2, 2, 2)
      ~(3, 3, 3)
      ------------
  8. def groupBy(properties: Mapping[A, Any]*): ~[~[A]]

    Grouping on properties

    Grouping on properties

    Puts consecutive elements in the same group if all the specified properties are equal

    When properties change, a new group is started

    properties

    a set of functions, each indicating an element property

    Definition Classes
    _group
    Example:
    1.  ('#' <> '|').all.groupBy(_.isLetter, _.isDigit).tp
      
      // Output
      ---------------------------------------------------------------------------------
      ?
      ---------------------------------------------------------------------------------
      ~(#, $, %, &, ', (, ), *, +, ,, -, ., /)
      ~(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
      ~(:, ;, <, =, >, ?, @)
      ~(A, B, C, D, E, F, G, H, Stream, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
      ~([, \, ], ^, _, `)
      ~(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
      ~({, |)
      ---------------------------------------------------------------------------------
  9. def groupBySize(size: Int): ~[~[A]]

    Fixed size groups

    Fixed size groups

    Puts consecutive elements into fixed size groups

    size

    of groups. Cannot be less than 1.

    Definition Classes
    _group
    Example:
    1. 0.I.repeat(30).groupBySize(8).toText.lp
      
      // Output
      
      -------------------------
      ?
      -------------------------
      ~(0, 0, 0, 0, 0, 0, 0, 0)
      ~(0, 0, 0, 0, 0, 0, 0, 0)
      ~(0, 0, 0, 0, 0, 0, 0, 0)
      ~(0, 0, 0, 0, 0, 0)
      -------------------------
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  11. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  12. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. final def notify(): Unit
    Definition Classes
    AnyRef
  14. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  15. def partition(groupFilters: Filter[A]*): ~[~[A]]

    Multi-filter grouping

    Multi-filter grouping

    All stream elements are grouped by specified filters

    Filters are applied in sequence, thus if an element is accepted into a group, it will not be evaluated by the rest of the filters

    If there are elements, which are left without a group, one extra group is created

    groupFilters

    a set of filters, to specify groups

    Definition Classes
    _group
    Example:
    1. // Age groups
      (1 <> 80).all.partition(_ <= 12, 13 <> 19, _ < 30, 30 <> 40, _ < 50, _ < 65).tp
      
      // Output
      -------------------------------------------------------------------
      ?
      -------------------------------------------------------------------
      ~(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
      ~(13, 14, 15, 16, 17, 18, 19)
      ~(20, 21, 22, 23, 24, 25, 26, 27, 28, 29)
      ~(30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40)
      ~(41, 42, 43, 44, 45, 46, 47, 48, 49)
      ~(50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64)
      ~(65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80)
      -------------------------------------------------------------------
  16. def sliding(size: Int, step: Int = 1): ~[~[A]]

    Sliding group view

    Sliding group view

    Example: group size 3 with step 1

    ('a' <> 'g').all.sliding(3).tp
    
    // Output
    ----------
    ?
    ----------
    ~(a, b, c)
    ~(b, c, d)
    ~(c, d, e)
    ~(d, e, f)
    ~(e, f, g)
    ----------

    Example: group size 4 with step 2

    ('a' <> 'g').all.sliding(4,2).tp
    
    // Output
    -------------
    ?
    -------------
    ~(a, b, c, d)
    ~(c, d, e, f)
    ~(e, f, g)
    -------------
    Definition Classes
    _group
  17. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  18. def toString(): String
    Definition Classes
    AnyRef → Any
  19. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  20. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. 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
Linear Supertypes
AnyRef, Any
Source: _group.scala