Seg

Instance Constructors

new Seg()

Abstract Value Members

abstract def ++[B >: A](seg: Seg[B]): Seg[B]

Append a segment to this segment
Append a segment to this segment
Complexity is O(lmin) effective, where lmin is the length of the smallest segment.
seg
the segment
abstract def +:[B >: A](b: B): Seg[B]

Prepend an message to this segment
Prepend an message to this segment
b
the message
abstract def :+[B >: A](b: B): Seg[B]

Append an message to this segment
Append an message to this segment
b
the message
abstract def copyTo[B >: A, That](builder: Builder[B, That]): Builder[B, That]
abstract def drop(n: Int)(implicit m: Message[A]): Seg[A]

Drops n elements from the head of this segment.
Drops n elements from the head of this segment.
n
The number of elements to drop.
m
A message typeclass used to poison messages dropped.
returns
a segment whose n first elements have been dropped.
abstract def dropRightWhile(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

Drops longest suffix of messages that satisfy a predicate.
Drops longest suffix of messages that satisfy a predicate.
p
The predicate used to test messages.
m
A message typeclass used to poison messages dropped.
returns
the longest prefix of this segment whose first message does not satisfy the predicate p.
abstract def dropWhile(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

Drops longest prefix of messages that satisfy a predicate.
Drops longest prefix of messages that satisfy a predicate.
p
The predicate used to test messages.
m
A message typeclass used to poison messages dropped.
returns
the longest suffix of this segment whose first message does not satisfy the predicate p.
abstract def exists(p: (A) ⇒ Boolean): Boolean

Tests whether a predicate holds for some of the messages of this segment.
Tests whether a predicate holds for some of the messages of this segment.
p
the predicate used to test messages.
returns
true if the given predicate p holds for some of the messages of this segment, otherwise false.
abstract def filter(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

Selects all messages of this segment which satisfy a predicate.
Selects all messages of this segment which satisfy a predicate.
p
the predicate used to test messages.
m
a message typeclass used to poison messages filtered out (i.e. messages that do not satisfy p).
returns
a new segment consisting of all messages of this segment that satisfy the given predicate p. Their order may not be preserved.
abstract def foldLeft[B](z: B)(f: (B, A) ⇒ B): B

Applies a binary operator to a start value and all messages of this segment, going left to right.
Applies a binary operator to a start value and all messages of this segment, going left to right.
B
the result type of the binary operator.
z
the start value.
returns
the result of inserting op between consecutive messages of this segment, going left to right with the start value z on the left:
```
op(...op(z, x,,1,,), x,,2,,, ..., x,,n,,)
```
where x₁, ..., x_n are the messages of this segment.
abstract def head: A

Selects the first message of this segment.
Selects the first message of this segment.
returns
the first message of this segment.

Exceptions thrown
`NoSuchmessageException` if the segment is empty.
abstract def init: Seg[A]

Selects all messages except the last.
Selects all messages except the last.
returns
a segment consisting of all messages of this segment except the last one.

Exceptions thrown
`UnsupportedOperationException` if the segment is empty.
abstract def isEmpty: Boolean

Tests whether this segment is empty.
Tests whether this segment is empty.
returns
true if the segment contain no messages, false otherwise.
abstract def last: A

Selects all messages except the first.
Selects all messages except the first.
returns
a segment consisting of all messages of this segment except the first one.

Exceptions thrown
`UnsupportedOperationException` if the segment is empty.
abstract def length: Int

The length of the segment.
The length of the segment.
Note: xs.length and xs.size yield the same result.
returns
the number of messages in this segment.
abstract def pop: (VSeg[A], Seg[A])

Returns a tuple containing the head of this segment as a value segment and the tail of the segment.
Returns a tuple containing the head of this segment as a value segment and the tail of the segment.
returns
a tuple containing the head of this segment as a value segment and the tail of the segment.
abstract def scanLeft[B](z: B)(op: (B, A) ⇒ B): Seg[B]

Produces a collection containing cummulative results of applying the operator going left to right.
Produces a collection containing cummulative results of applying the operator going left to right.
B
the type of the messages in the resulting collection
z
the initial value
op
the binary operator applied to the intermediate result and the message
returns
a segment with the intermediate results, incuding the initial value.
abstract def smap[S, B](z: S)(f: (S, A) ⇒ (S, B)): (S, Seg[B])

Produces a collection containing cummulative results of applying the operator going left to right.
Produces a collection containing cummulative results of applying the operator going left to right.
B
the type of the messages in the resulting collection
z
the initial state
returns
a segment with the intermediate results.
abstract def span(p: (A) ⇒ Boolean): (Seg[A], Seg[A])

Splits this segment into a prefix/suffix pair according to a predicate.
Splits this segment into a prefix/suffix pair according to a predicate.
Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects.
p
the test predicate
returns
a pair consisting of the longest prefix of this segment whose messages all satisfy p, and the rest of this segment.
abstract def splitAt(n: Int): (Seg[A], Seg[A])

Splits this segment into two at a given position.
Splits this segment into two at a given position. Note: c splitAt n is equivalent to (but possibly more efficient than) (c take n, c drop n).
n
the position at which to split.
returns
a pair of segments consisting of the first n messages of this segment, and the other messages.
abstract def step[B](empty: ⇒ B, more: (A, Seg[A]) ⇒ B): B

Catamorphism.
Catamorphism.
B
the return type of the arguments.
empty
the value returned if the segment is empty.
more
the function applied to the head and the tail of the segment if it is not empty.
returns
the value returned by 'empty' or 'more' depending on if the segment is empty or not.
abstract def tail: Seg[A]

Selects all messages except the first.
Selects all messages except the first.
returns
a segment consisting of all messages of this segment except the first one.

Exceptions thrown
`UnsupportedOperationException` if the segment is empty.
abstract def toVector: Vector[A]

Copies values of this segment to a vector.
abstract def zip[B](seg: Seg[B]): (Seg[(A, B)], Option[Either[Seg[A], Seg[B]]])

Returns a pair containing:
Returns a pair containing:
- the segment formed from this segment and another segment by combining corresponding elements in pairs.
- An optional segment containing the remaining elements if one of the two segments is longer than the other.
B
the type of the second half of the returned pairs
returns
a new segment containing pairs consisting of corresponding elements of this segment and seg and an optional segment containing the remaining elements if one of the two segments is longer than the other

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def break(p: (A) ⇒ Boolean): (Seg[A], Seg[A])

Split a collection at the message that satisfies the predicate.
Split a collection at the message that satisfies the predicate.
p
the test predicate
returns
a pair consisting of the longest prefix of this segment whose messages do not satisfy p, and the rest of this segment.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
abstract def collect[B](pf: PartialFunction[A, B]): Seg[B]

[use case]
[use case]
B
the message type of the returned collection.
pf
the partial function which filters and maps the segment.
returns
a new segment resulting from applying the given partial function pf to each message on which it is defined and collecting the results. The order of the messages is preserved.

Full Signature
abstract def collect[B](pf: PartialFunction[A, B])(implicit m: Message[A]): Seg[B]
abstract def concat[B]: Seg[B]

[use case]
[use case]
B
the type of the messages of each traversable collection.
returns
a new segment resulting from concatenating all segments.

Full Signature
abstract def concat[B](implicit asSeg: (A) ⇒ Seg[B]): Seg[B]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
abstract def flatMap[B](f: (A) ⇒ Seg[B]): Seg[B]

[use case]
[use case]
B
the message type of the returned collection.
f
the function to apply to each message.
returns
a new segment resulting from applying the given collection-valued function f to each message of this segment and concatenating the results.

Full Signature
abstract def flatMap[B](f: (A) ⇒ Seg[B]): Seg[B]
abstract def flatMapTraversable[B](f: (A) ⇒ Traversable[B]): Seg[B]

[use case]
[use case]
B
the message type of the returned collection.
f
the function to apply to each message.
returns
a new segment resulting from applying the given collection-valued function f to each message of this segment and concatenating the results.

Full Signature
abstract def flatMapTraversable[B](f: (A) ⇒ Traversable[B]): Seg[B]
abstract def flatten[B]: Seg[B]

[use case]
[use case]
B
the type of the messages of each traversable collection.
returns
a new segment resulting from concatenating all message.

Full Signature
abstract def flatten[B](implicit asTraversable: (A) ⇒ Traversable[B]): Seg[B]
abstract def foreach(f: (A) ⇒ Unit): Unit

[use case]
[use case]
f
the function that is applied for its side-effect to every message. The result of function f is discarded.

Full Signature
abstract def foreach[U](f: (A) ⇒ U): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (A) ⇒ K): Map[K, Seg[A]]
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
abstract def map[B](f: (A) ⇒ B): Seg[B]

[use case]
[use case]
B
the message type of the returned collection.
f
the function to apply to each message.
returns
a new segment resulting from applying the given function f to each message of this segment and collecting the results.

Full Signature
abstract def map[B](f: (A) ⇒ B): Seg[B]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def poison(signal: Signal)(implicit m: Message[A]): Unit

Poison all messages in this segment
Poison all messages in this segment
m
a message typeclass used to poison every message in this segment.
final def size: Int

The size of the segment.
The size of the segment.
Note: xs.length and xs.size yield the same result.
returns
the number of messages in this segment.

Annotations
@inline()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Seg | package seg

abstract class Seg[+A] extends AnyRef

Instance Constructors

new Seg()

Abstract Value Members

abstract def ++[B >: A](seg: Seg[B]): Seg[B]

abstract def +:[B >: A](b: B): Seg[B]

abstract def :+[B >: A](b: B): Seg[B]

abstract def copyTo[B >: A, That](builder: Builder[B, That]): Builder[B, That]

abstract def drop(n: Int)(implicit m: Message[A]): Seg[A]

abstract def dropRightWhile(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

abstract def dropWhile(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

abstract def exists(p: (A) ⇒ Boolean): Boolean

abstract def filter(p: (A) ⇒ Boolean)(implicit m: Message[A]): Seg[A]

abstract def foldLeft[B](z: B)(f: (B, A) ⇒ B): B

abstract def head: A

abstract def init: Seg[A]

abstract def isEmpty: Boolean

abstract def last: A

abstract def length: Int

abstract def pop: (VSeg[A], Seg[A])

abstract def scanLeft[B](z: B)(op: (B, A) ⇒ B): Seg[B]

abstract def smap[S, B](z: S)(f: (S, A) ⇒ (S, B)): (S, Seg[B])

abstract def span(p: (A) ⇒ Boolean): (Seg[A], Seg[A])

abstract def splitAt(n: Int): (Seg[A], Seg[A])

abstract def step[B](empty: ⇒ B, more: (A, Seg[A]) ⇒ B): B

abstract def tail: Seg[A]

abstract def toVector: Vector[A]

abstract def zip[B](seg: Seg[B]): (Seg[(A, B)], Option[Either[Seg[A], Seg[B]]])

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def break(p: (A) ⇒ Boolean): (Seg[A], Seg[A])

def clone(): AnyRef

abstract def collect[B](pf: PartialFunction[A, B]): Seg[B]

abstract def collect[B](pf: PartialFunction[A, B])(implicit m: Message[A]): Seg[B]

abstract def concat[B]: Seg[B]

abstract def concat[B](implicit asSeg: (A) ⇒ Seg[B]): Seg[B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

abstract def flatMap[B](f: (A) ⇒ Seg[B]): Seg[B]

abstract def flatMap[B](f: (A) ⇒ Seg[B]): Seg[B]

abstract def flatMapTraversable[B](f: (A) ⇒ Traversable[B]): Seg[B]

abstract def flatMapTraversable[B](f: (A) ⇒ Traversable[B]): Seg[B]

abstract def flatten[B]: Seg[B]

abstract def flatten[B](implicit asTraversable: (A) ⇒ Traversable[B]): Seg[B]

abstract def foreach(f: (A) ⇒ Unit): Unit

abstract def foreach[U](f: (A) ⇒ U): Unit

final def getClass(): Class[_]

def groupBy[K](f: (A) ⇒ K): Map[K, Seg[A]]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

abstract def map[B](f: (A) ⇒ B): Seg[B]

abstract def map[B](f: (A) ⇒ B): Seg[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def poison(signal: Signal)(implicit m: Message[A]): Unit

final def size: Int

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped