microsite
API
Generated with
microsite/izumi/izumi.fundamentals/izumi.fundamentals.collections/izumi.fundamentals.collections.nonempty/NEString

NEString

izumi.fundamentals.collections.nonempty.NEString
See theNEString companion object
final class NEString extends AnyVal

A non-empty list: an ordered, immutable, non-empty collection of elements with LinearSeq performance characteristics.

The purpose of NEString is to allow you to express in a type that a String is non-empty, thereby eliminating the need for (and potential exception from) a run-time check for non-emptiness. For a non-empty sequence with IndexedSeq performance, see Vector.

== Constructing NEStrings ==

You can construct a NEString by passing one or more elements to the NEString.apply factory method:

scala> NEString(1, 2, 3)
res0: org.scalactic.anyvals.NEString[Int] = NEString(1, 2, 3)

Alternatively you can cons elements onto the End singleton object, similar to making a String starting with Nil:

scala> 1 :: 2 :: 3 :: Nil
res0: String[Int] = String(1, 2, 3)

scala> 1 :: 2 :: 3 :: End
res1: org.scalactic.NEString[Int] = NEString(1, 2, 3)

Note that although Nil is a String[Nothing], End is not a NEString[Nothing], because no empty NEString exists. (A non-empty list is a series of connected links; if you have no links, you have no non-empty list.)

scala> val nil: String[Nothing] = Nil
nil: String[Nothing] = String()

scala> val nada: NEString[Nothing] = End
<console>:16: error: type mismatch;
found   : org.scalactic.anyvals.End.type
required: org.scalactic.anyvals.NEString[Nothing]
      val nada: NEString[Nothing] = End
                                        ^

== Working with NEStrings ==

NEString does not extend Scala's Seq or Traversable traits because these require that implementations may be empty. For example, if you invoke tail on a Seq that contains just one element, you'll get an empty Seq:

scala> String(1).tail
res6: String[Int] = String()

On the other hand, many useful methods exist on Seq that when invoked on a non-empty Seq are guaranteed to not result in an empty Seq. For convenience, NEString defines a method corresponding to every such Seq method. Here are some examples:

NEString(1, 2, 3).map(_ + 1)                        // Result: NEString(2, 3, 4)
NEString(1).map(_ + 1)                              // Result: NEString(2)
NEString(1, 2, 3).containsSlice(NEString(2, 3)) // Result: true
NEString(1, 2, 3).containsSlice(NEString(3, 4)) // Result: false
NEString(-1, -2, 3, 4, 5).minBy(_.abs)              // Result: -1

NEString does not currently define any methods corresponding to Seq methods that could result in an empty Seq. However, an implicit converison from NEString to String is defined in the NEString companion object that will be applied if you attempt to call one of the missing methods. As a result, you can invoke filter on an NEString, even though filter could result in an empty sequence—but the result type will be String instead of NEString:

NEString(1, 2, 3).filter(_ < 10) // Result: String(1, 2, 3)
NEString(1, 2, 3).filter(_ > 10) // Result: String()

You can use NEStrings in for expressions. The result will be an NEString unless you use a filter (an if clause). Because filters are desugared to invocations of filter, the result type will switch to a String at that point. Here are some examples:

scala> import org.scalactic.anyvals._
import org.scalactic.anyvals._

scala> for (i <- NEString(1, 2, 3)) yield i + 1
res0: org.scalactic.anyvals.NEString[Int] = NEString(2, 3, 4)

scala> for (i <- NEString(1, 2, 3) if i < 10) yield i + 1
res1: String[Int] = String(2, 3, 4)

scala> for {
    |   i <- NEString(1, 2, 3)
    |   j <- NEString('a', 'b', 'c')
    | } yield (i, j)
res3: org.scalactic.anyvals.NEString[(Int, Char)] =
       NEString((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))

scala> for {
    |   i <- NEString(1, 2, 3) if i < 10
    |   j <- NEString('a', 'b', 'c')
    | } yield (i, j)
res6: String[(Int, Char)] =
       String((1,a), (1,b), (1,c), (2,a), (2,b), (2,c), (3,a), (3,b), (3,c))

Attributes

Companion
object
Graph
Supertypes
class AnyVal
trait Matchable
class Any

Members list

Value members

Concrete methods

def ++(other: NEString): NEString

Returns a new NEString containing this NEString followed by the passed NEString.

Returns a new NEString containing this NEString followed by the passed NEString.

Value parameters

other

the NEString to append

Attributes

Returns

a new NEString that contains this NEString followed by other.

def ++(other: Vector[Char]): NEString

Returns a new NEString containing this NEString followed by the characters of the passed Vector.

Returns a new NEString containing this NEString followed by the characters of the passed Vector.

Value parameters

other

the Vector of Char to append

Attributes

Returns

a new NEString that contains this NEString followed by all characters of other.

def ++(other: IterableOnce[Char]): NEString

Returns a new NEString containing this NEString followed by the characters of the passed TraversableOnce.

Returns a new NEString containing this NEString followed by the characters of the passed TraversableOnce.

Value parameters

other

the TraversableOnce of Char to append

Attributes

Returns

a new NEString that contains this NEString followed by all characters of other.

def +:(c: Char): NEString

Returns a new NEString with the given character prepended.

Returns a new NEString with the given character prepended.

Note that :-ending operators are right associative. A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Value parameters

c

the character to prepend to this NEString

Attributes

Returns

a new NEString consisting of c followed by all characters of this NEString.

def :+(c: Char): NEString

Returns a new NEString with the given character appended.

Returns a new NEString with the given character appended.

Note a mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

Value parameters

c

the character to append to this NEString

Attributes

Returns

a new NEString consisting of all characters of this NEString followed by the given c.

def addString(sb: StringBuilder): StringBuilder

Appends all characters of this NEString to a string builder. The written text will consist of a concatenation of the result of invoking toString on of every element of this NEString, without any separator string.

Appends all characters of this NEString to a string builder. The written text will consist of a concatenation of the result of invoking toString on of every element of this NEString, without any separator string.

Value parameters

sb

the string builder to which characters will be appended

Attributes

Returns

the string builder, sb, to which elements were appended.

def addString(sb: StringBuilder, sep: String): StringBuilder

Appends all characters of this NEString to a string builder using a separator string. The written text will consist of a concatenation of the result of invoking toString on of every character of this NEString, separated by the string sep.

Appends all characters of this NEString to a string builder using a separator string. The written text will consist of a concatenation of the result of invoking toString on of every character of this NEString, separated by the string sep.

Value parameters

sb

the string builder to which characters will be appended

sep

the separator string

Attributes

Returns

the string builder, sb, to which characters were appended.

def addString(sb: StringBuilder, start: String, sep: String, end: String): StringBuilder

Appends all characters of this NEString to a string builder using start, end, and separator strings. The written text will consist of a concatenation of the string start; the result of invoking toString on all characters of this NEString, separated by the string sep; and the string end

Appends all characters of this NEString to a string builder using start, end, and separator strings. The written text will consist of a concatenation of the string start; the result of invoking toString on all characters of this NEString, separated by the string sep; and the string end

Value parameters

end

the ending string

sb

the string builder to which characters will be appended

sep

the separator string

start

the starting string

Attributes

Returns

the string builder, sb, to which characters were appended.

def apply(idx: Int): Char

Selects a character by its index in the NEString.

Selects a character by its index in the NEString.

Attributes

Returns

the character of this NEString at index idx, where 0 indicates the first element.

def charAt(idx: Int): Char

Gets a character by its index in the NEString.

Gets a character by its index in the NEString.

Attributes

Returns

the character of this NEString at index idx, where 0 indicates the first element.

def collectFirst[U](pf: PartialFunction[Char, U]): Option[U]

Finds the first character of this NEString for which the given partial function is defined, if any, and applies the partial function to it.

Finds the first character of this NEString for which the given partial function is defined, if any, and applies the partial function to it.

Value parameters

pf

the partial function

Attributes

Returns

an Option containing pf applied to the first character for which it is defined, or None if the partial function was not defined for any character.

infix def contains(c: Char): Boolean

Indicates whether this NEString contains a given value as an character.

Indicates whether this NEString contains a given value as an character.

Value parameters

c

the element to look for

Attributes

Returns

true if this NEString has an character that is equal (as determined by ==) to c, false otherwise.

def containsSlice(that: Seq[Char]): Boolean

Indicates whether this NEString contains a given Seq of characters as a slice.

Indicates whether this NEString contains a given Seq of characters as a slice.

Value parameters

that

the Seq character slice to look for

Attributes

Returns

true if this NEString contains a slice with the same characters as that, otherwise false.

def containsSlice(that: Vector[Char]): Boolean

Indicates whether this NEString contains a given Vector of character as a slice.

Indicates whether this NEString contains a given Vector of character as a slice.

Value parameters

that

the Vector character slice to look for

Attributes

Returns

true if this NEString contains a character slice with the same characters as that, otherwise false.

def containsSlice(that: NEString): Boolean

Indicates whether this NEString contains a given NEString as a slice.

Indicates whether this NEString contains a given NEString as a slice.

Value parameters

that

the NEString slice to look for

Attributes

Returns

true if this NEString contains a slice with the same characters as that, otherwise false.

def copyToArray(arr: Array[Char]): Unit

Copies characters of this NEString to an array. Fills the given array arr with characters of this NEString. Copying will stop once either the end of the current NEString is reached, or the end of the array is reached.

Copies characters of this NEString to an array. Fills the given array arr with characters of this NEString. Copying will stop once either the end of the current NEString is reached, or the end of the array is reached.

Value parameters

arr

the array to fill

Attributes

def copyToArray(arr: Array[Char], start: Int): Unit

Copies characters of this NEString to an array. Fills the given array arr with characters of this NEString, beginning at index start. Copying will stop once either the end of the current NEString is reached, or the end of the array is reached.

Copies characters of this NEString to an array. Fills the given array arr with characters of this NEString, beginning at index start. Copying will stop once either the end of the current NEString is reached, or the end of the array is reached.

Value parameters

arr

the array to fill

start

the starting index

Attributes

def copyToArray(arr: Array[Char], start: Int, len: Int): Unit

Copies characters of this NEString to an array. Fills the given array arr with at most len characters of this NEString, beginning at index start. Copying will stop once either the end of the current NEString is reached, the end of the array is reached, or len elements have been copied.

Copies characters of this NEString to an array. Fills the given array arr with at most len characters of this NEString, beginning at index start. Copying will stop once either the end of the current NEString is reached, the end of the array is reached, or len elements have been copied.

Value parameters

arr

the array to fill

len

the maximum number of elements to copy

start

the starting index

Attributes

def copyToBuffer(buf: Buffer[Char]): Unit

Copies all characters of this NEString to a buffer.

Copies all characters of this NEString to a buffer.

Value parameters

buf

the buffer to which characters are copied

Attributes

def corresponds[B](that: Seq[B])(p: (Char, B) => Boolean): Boolean

Indicates whether every character of this NEString relates to the corresponding element of a given Seq by satisfying a given predicate.

Indicates whether every character of this NEString relates to the corresponding element of a given Seq by satisfying a given predicate.

Type parameters

B

the type of the elements of that

Value parameters

p

the predicate, which relates elements from this NEString and the passed Seq

that

the Seq to compare for correspondence

Attributes

Returns

true if this NEString and the passed Seq have the same length and p(x, y) is true for all corresponding elements x of this NEString and y of that, otherwise false.

def corresponds[B](that: Vector[B])(p: (Char, B) => Boolean): Boolean

Indicates whether every character of this NEString relates to the corresponding element of a given Vector by satisfying a given predicate.

Indicates whether every character of this NEString relates to the corresponding element of a given Vector by satisfying a given predicate.

Type parameters

B

the type of the elements of that

Value parameters

p

the predicate, which relates elements from this NEString and the passed Vector

that

the Vector to compare for correspondence

Attributes

Returns

true if this NEString and the passed Vector have the same length and p(x, y) is true for all corresponding elements x of this NEString and y of that, otherwise false.

def corresponds(that: NEString)(p: (Char, Char) => Boolean): Boolean

Indicates whether every character of this NEString relates to the corresponding character of a given NEString by satisfying a given predicate.

Indicates whether every character of this NEString relates to the corresponding character of a given NEString by satisfying a given predicate.

Value parameters

p

the predicate, which relates elements from this and the passed NEString

that

the NEString to compare for correspondence

Attributes

Returns

true if this and the passed NEString have the same length and p(x, y) is true for all corresponding characters x of this NEString and y of that, otherwise false.

def count(p: Char => Boolean): Int

Counts the number of characters in this NEString that satisfy a predicate.

Counts the number of characters in this NEString that satisfy a predicate.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

the number of characters satisfying the predicate p.

def distinct: NEString

Builds a new NEString from this NEString without any duplicate characters.

Builds a new NEString from this NEString without any duplicate characters.

Attributes

Returns

A new NEString that contains the first occurrence of every character of this NEString.

def endsWith[B](that: Seq[B]): Boolean

Indicates whether this NEString ends with the given Seq of Char.

Indicates whether this NEString ends with the given Seq of Char.

Value parameters

that

the sequence to test

Attributes

Returns

true if this NEString has that as a suffix, false otherwise.

def endsWith[B](that: Vector[B]): Boolean

Indicates whether this NEString ends with the given Vector.

Indicates whether this NEString ends with the given Vector.

Value parameters

that

the Vector to test

Attributes

Returns

true if this NEString has that as a suffix, false otherwise.

def endsWith(that: NEString): Boolean

Indicates whether this NEString ends with the given NEString.

Indicates whether this NEString ends with the given NEString.

Value parameters

that

the NEString to test

Attributes

Returns

true if this NEString has that as a suffix, false otherwise.

def exists(p: Char => Boolean): Boolean

Indicates whether a predicate holds for at least one of the characters of this NEString.

Indicates whether a predicate holds for at least one of the characters of this NEString.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

true if the given predicate p holds for some of the elements of this NEString, otherwise false.

def find(p: Char => Boolean): Option[Char]

Finds the first character of this NEString that satisfies the given predicate, if any.

Finds the first character of this NEString that satisfies the given predicate, if any.

Value parameters

p

the predicate used to test characters

Attributes

Returns

an Some containing the first character in this NEString that satisfies p, or None if none exists.

def flatMap(f: Char => NEString): NEString

Builds a new NEString by applying a function to all characters of this NEString and using the characters of the resulting NEStrings.

Builds a new NEString by applying a function to all characters of this NEString and using the characters of the resulting NEStrings.

Value parameters

f

the function to apply to each character.

Attributes

Returns

a new NEString containing characters obtained by applying the given function f to each character of this NEString and concatenating the characters of resulting NEStrings.

def fold(z: Char)(op: (Char, Char) => Char): Char

Folds the characters of this NEString using the specified associative binary operator.

Folds the characters of this NEString using the specified associative binary operator.

The order in which operations are performed on characters is unspecified and may be nondeterministic.

Value parameters

op

a binary operator that must be associative

z

a neutral character for the fold operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.)

Attributes

Returns

the result of applying fold operator op between all the elements and z

def foldLeft[B](z: B)(op: (B, Char) => B): B

Applies a binary operator to a start value and all characters of this NEString, going left to right.

Applies a binary operator to a start value and all characters of this NEString, going left to right.

Type parameters

B

the result type of the binary operator.

Value parameters

op

the binary operator.

z

the start value.

Attributes

Returns

the result of inserting op between consecutive characters of this NEString, going left to right, with the start value, z, on the left:

op(...op(op(z, x_1), x_2), ..., x_n)

where x1, ..., xn are the elements of this NEString.

def foldRight[B](z: B)(op: (Char, B) => B): B

Applies a binary operator to all characters of this NEString and a start value, going right to left.

Applies a binary operator to all characters of this NEString and a start value, going right to left.

Type parameters

B

the result of the binary operator

Value parameters

op

the binary operator

z

the start value

Attributes

Returns

the result of inserting op between consecutive characters of this NEString, going right to left, with the start value, z, on the right:

op(x_1, op(x_2, ... op(x_n, z)...))

where x1, ..., xn are the elements of this NEString.

def forall(p: Char => Boolean): Boolean

Indicates whether a predicate holds for all characters of this NEString.

Indicates whether a predicate holds for all characters of this NEString.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

true if the given predicate p holds for all characters of this NEString, otherwise false.

def foreach(f: Char => Unit): Unit

Applies a function f to all characters of this NEString.

Applies a function f to all characters of this NEString.

Value parameters

f

the function that is applied for its side-effect to every character. The result of function f is discarded.

Attributes

def groupBy[K](f: Char => K): Map[K, NEString]

Partitions this NEString into a map of NEStrings according to some discriminator function.

Partitions this NEString into a map of NEStrings according to some discriminator function.

Type parameters

K

the type of keys returned by the discriminator function.

Value parameters

f

the discriminator function.

Attributes

Returns

A map from keys to NEStrings such that the following invariant holds:

(NEString.toString partition f)(k) = xs filter (x => f(x) == k)

That is, every key k is bound to a NEString of those elements x for which f(x) equals k.

def grouped(size: Int): Iterator[NEString]

Partitions characters into fixed size NEStrings.

Partitions characters into fixed size NEStrings.

Value parameters

size

the number of characters per group

Attributes

Returns

An iterator producing NEStrings of size size, except the last will be truncated if the characters don't divide evenly.

def hasDefiniteSize: Boolean

Returns true to indicate this NEString has a definite size, since all NEStrings are strict collections.

Returns true to indicate this NEString has a definite size, since all NEStrings are strict collections.

Attributes

def head: Char

Selects the first character of this NEString.

Selects the first character of this NEString.

Attributes

Returns

the first character of this NEString.

def indexOf(c: Char): Int

Finds index of first occurrence of some value in this NEString.

Finds index of first occurrence of some value in this NEString.

Value parameters

c

the character value to search for.

Attributes

Returns

the index of the first character of this NEString that is equal (as determined by ==) to c, or -1, if none exists.

def indexOf(c: Char, from: Int): Int

Finds index of first occurrence of some value in this NEString after or at some start index.

Finds index of first occurrence of some value in this NEString after or at some start index.

Value parameters

c

the character value to search for.

from

the start index

Attributes

Returns

the index >= from of the first element of this NEString that is equal (as determined by ==) to elem, or -1, if none exists.

def indexOfSlice(that: Seq[Char]): Int

Finds first index where this NEString contains a given Seq[Char] as a slice.

Finds first index where this NEString contains a given Seq[Char] as a slice.

Value parameters

that

the Seq[Char] defining the slice to look for

Attributes

Returns

the first index at which the elements of this NEString starting at that index match the characters of Seq that, or -1 of no such subsequence exists.

def indexOfSlice(that: Seq[Char], from: Int): Int

Finds first index after or at a start index where this NEString contains a given Seq[Char] as a slice.

Finds first index after or at a start index where this NEString contains a given Seq[Char] as a slice.

Value parameters

from

the start index

that

the Seq[Char] defining the slice to look for

Attributes

Returns

the first index >= from at which the characters of this NEString starting at that index match the characters of Seq[Char] that, or -1 of no such subsequence exists.

def indexOfSlice(that: Vector[Char]): Int

Finds first index where this NEString contains a given Vector as a slice.

Finds first index where this NEString contains a given Vector as a slice.

Value parameters

that

the Vector defining the slice to look for

Attributes

Returns

the first index such that the characters of this NEString starting at this index match the characters of Vector that, or -1 of no such subsequence exists.

def indexOfSlice(that: NEString): Int

Finds first index where this NEString contains a given NEString as a slice.

Finds first index where this NEString contains a given NEString as a slice.

Value parameters

that

the NEString defining the slice to look for

Attributes

Returns

the first index such that the characters of this NEString starting at this index match the characters of NEString that, or -1 of no such subsequence exists.

def indexOfSlice(that: Vector[Char], from: Int): Int

Finds first index after or at a start index where this NEString contains a given Vector as a slice.

Finds first index after or at a start index where this NEString contains a given Vector as a slice.

Value parameters

from

the start index

that

the Vector defining the slice to look for

Attributes

Returns

the first index >= from such that the characters of this NEString starting at this index match the characters of Vector that, or -1 of no such subsequence exists.

def indexOfSlice(that: NEString, from: Int): Int

Finds first index after or at a start index where this NEString contains a given NEString as a slice.

Finds first index after or at a start index where this NEString contains a given NEString as a slice.

Value parameters

from

the start index

that

the NEString defining the slice to look for

Attributes

Returns

the first index >= from such that the characters of this NEString starting at this index match the characters of NEString that, or -1 of no such subsequence exists.

def indexWhere(p: Char => Boolean): Int

Finds index of the first character satisfying some predicate.

Finds index of the first character satisfying some predicate.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

the index of the first character of this NEString that satisfies the predicate p, or -1, if none exists.

def indexWhere(p: Char => Boolean, from: Int): Int

Finds index of the first character satisfying some predicate after or at some start index.

Finds index of the first character satisfying some predicate after or at some start index.

Value parameters

from

the start index

p

the predicate used to test characters.

Attributes

Returns

the index >= from of the first character of this NEString that satisfies the predicate p, or -1, if none exists.

def indices: Range

Produces the range of all indices of this NEString.

Produces the range of all indices of this NEString.

Attributes

Returns

a Range value from 0 to one less than the length of this NEString.

def isDefinedAt(idx: Int): Boolean

Tests whether this NEString contains given index.

Tests whether this NEString contains given index.

Value parameters

idx

the index to test

Attributes

Returns

true if this NEString contains an character at position idx, false otherwise.

def isEmpty: Boolean

Returns false to indicate this NEString, like all NEStrings, is non-empty.

Returns false to indicate this NEString, like all NEStrings, is non-empty.

Attributes

Returns

false

def isTraversableAgain: Boolean

Returns true to indicate this NEString, like all NEStrings, can be traversed repeatedly.

Returns true to indicate this NEString, like all NEStrings, can be traversed repeatedly.

Attributes

Returns

true

def iterator: Iterator[Char]

Creates and returns a new iterator over all characters contained in this NEString.

Creates and returns a new iterator over all characters contained in this NEString.

Attributes

Returns

the new iterator

def last: Char

Selects the last character of this NEString.

Selects the last character of this NEString.

Attributes

Returns

the last character of this NEString.

def lastIndexOf(c: Char): Int

Finds the index of the last occurrence of some value in this NEString.

Finds the index of the last occurrence of some value in this NEString.

Value parameters

c

the character value to search for.

Attributes

Returns

the index of the last character of this NEString that is equal (as determined by ==) to c, or -1, if none exists.

def lastIndexOf(c: Char, end: Int): Int

Finds the index of the last occurrence of some value in this NEString before or at a given end index.

Finds the index of the last occurrence of some value in this NEString before or at a given end index.

Value parameters

c

the character value to search for.

end

the end index.

Attributes

Returns

the index >= end of the last character of this NEString that is equal (as determined by ==) to elem, or -1, if none exists.

def lastIndexOfSlice(that: Seq[Char]): Int

Finds the last index where this NEString contains a given Seq as a slice.

Finds the last index where this NEString contains a given Seq as a slice.

Value parameters

that

the Seq defining the slice to look for

Attributes

Returns

the last index at which the elements of this NEString starting at that index match the characters of Seq that, or -1 of no such subsequence exists.

def lastIndexOfSlice(that: Seq[Char], end: Int): Int

Finds the last index before or at a given end index where this NEString contains a given Seq as a slice.

Finds the last index before or at a given end index where this NEString contains a given Seq as a slice.

Value parameters

end

the end index

that

the Seq defining the slice to look for

Attributes

Returns

the last index >= end at which the elements of this NEString starting at that index match the characters of Seq that, or -1 of no such subsequence exists.

def lastIndexOfSlice(that: Vector[Char]): Int

Finds the last index where this NEString contains a given Vector as a slice.

Finds the last index where this NEString contains a given Vector as a slice.

Value parameters

that

the Vector defining the slice to look for

Attributes

Returns

the last index at which the elements of this NEString starting at that index match the characters of Vector that, or -1 of no such subsequence exists.

def lastIndexOfSlice(that: NEString): Int

Finds the last index where this NEString contains a given NEString as a slice.

Finds the last index where this NEString contains a given NEString as a slice.

Value parameters

that

the NEString defining the slice to look for

Attributes

Returns

the last index at which the elements of this NEString starting at that index match the characters of NEString that, or -1 of no such subsequence exists.

def lastIndexOfSlice(that: Vector[Char], end: Int): Int

Finds the last index before or at a given end index where this NEString contains a given Vector as a slice.

Finds the last index before or at a given end index where this NEString contains a given Vector as a slice.

Value parameters

end

the end index

that

the Vector defining the slice to look for

Attributes

Returns

the last index >= end at which the elements of this NEString starting at that index match the characters of Vector that, or -1 of no such subsequence exists.

def lastIndexOfSlice(that: NEString, end: Int): Int

Finds the last index before or at a given end index where this NEString contains a given NEString as a slice.

Finds the last index before or at a given end index where this NEString contains a given NEString as a slice.

Value parameters

end

the end index

that

the NEString defining the slice to look for

Attributes

Returns

the last index >= end at which the characters of this NEString starting at that index match the characters of NEString that, or -1 of no such subsequence exists.

def lastIndexWhere(p: Char => Boolean): Int

Finds index of last character satisfying some predicate.

Finds index of last character satisfying some predicate.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

the index of the last character of this NEString that satisfies the predicate p, or -1, if none exists.

def lastIndexWhere(p: Char => Boolean, end: Int): Int

Finds index of last character satisfying some predicate before or at given end index.

Finds index of last character satisfying some predicate before or at given end index.

Value parameters

end

the end index

p

the predicate used to test characters.

Attributes

Returns

the index >= end of the last character of this NEString that satisfies the predicate p, or -1, if none exists.

def length: Int

The length of this NEString.

The length of this NEString.

Attributes

Returns

the number of characters in this NEString.

Note

length and size yield the same result, which will be >= 1.

def lengthCompare(len: Int): Int

Compares the length of this NEString to a test value.

Compares the length of this NEString to a test value.

Value parameters

len

the test value that gets compared with the length.

Attributes

Returns

a value x where

x < 0 if this.length < len
x == 0 if this.length == len
x > 0 if this.length > len
def map[U](f: Char => U): NEString

Builds a new NEString by applying a function to all characters of this NEString.

Builds a new NEString by applying a function to all characters of this NEString.

Type parameters

U

the character type of the returned NEString.

Value parameters

f

the function to apply to each character.

Attributes

Returns

a new NEString resulting from applying the given function f to each character of this NEString and collecting the results.

def max(implicit cmp: Ordering[Char]): Char

Finds the largest character.

Finds the largest character.

Attributes

Returns

the largest element of this NEString.

def maxBy[U](f: Char => U)(implicit cmp: Ordering[U]): Char

Finds the largest result after applying the given function to every character.

Finds the largest result after applying the given function to every character.

Attributes

Returns

the largest result of applying the given function to every character of this NEString.

def min(implicit cmp: Ordering[Char]): Char

Finds the smallest character.

Finds the smallest character.

Attributes

Returns

the smallest character of this NEString.

def minBy[U](f: Char => U)(implicit cmp: Ordering[U]): Char

Finds the smallest result after applying the given function to every character.

Finds the smallest result after applying the given function to every character.

Attributes

Returns

the smallest result of applying the given function to every character of this NEString.

def mkString: String

Displays all characters of this NEString in a string.

Displays all characters of this NEString in a string.

Attributes

Returns

a string representation of this NEString. In the resulting string, the result of invoking toString on all characters of this NEString follow each other without any separator string.

def mkString(sep: String): String

Displays all elements of this NEString in a string using a separator string.

Displays all elements of this NEString in a string using a separator string.

Value parameters

sep

the separator string

Attributes

Returns

a string representation of this NEString. In the resulting string, the result of invoking toString on all elements of this NEString are separated by the string sep.

def mkString(start: String, sep: String, end: String): String

Displays all characters of this NEString in a string using start, end, and separator strings.

Displays all characters of this NEString in a string using start, end, and separator strings.

Value parameters

end

the ending string.

sep

the separator string.

start

the starting string.

Attributes

Returns

a string representation of this NEString. The resulting string begins with the string start and ends with the string end. Inside, In the resulting string, the result of invoking toString on all characters of this NEString are separated by the string sep.

def nonEmpty: Boolean

Returns true to indicate this NEString, like all NEStrings, is non-empty.

Returns true to indicate this NEString, like all NEStrings, is non-empty.

Attributes

Returns

true

def padTo(len: Int, c: Char): NEString

A copy of this NEString with an element value appended until a given target length is reached.

A copy of this NEString with an element value appended until a given target length is reached.

Value parameters

c

the padding character

len

the target length

Attributes

Returns

a new NEString consisting of all characters of this NEString followed by the minimal number of occurrences of elem so that the resulting NEString has a length of at least len.

def patch(from: Int, that: NEString, replaced: Int): NEString

Produces a new NEString where a slice of characters in this NEString is replaced by another NEString

Produces a new NEString where a slice of characters in this NEString is replaced by another NEString

Value parameters

from

the index of the first replaced character

replaced

the number of characters to drop in the original NEString

that

the NEString whose characters should replace a slice in this NEString

Attributes

def permutations: Iterator[NEString]

Iterates over distinct permutations.

Iterates over distinct permutations.

Here's an example:

NEString("abb").permutations.toList == list(NEString("abb"), NEString("bab"), NEString("bba"))

Attributes

Returns

an iterator that traverses the distinct permutations of this NEString.

def prefixLength(p: Char => Boolean): Int

Returns the length of the longest prefix whose characters all satisfy some predicate.

Returns the length of the longest prefix whose characters all satisfy some predicate.

Value parameters

p

the predicate used to test characters.

Attributes

Returns

the length of the longest prefix of this NEString such that every characters of the segment satisfies the predicate p.

def product(implicit num: Numeric[Char]): Char

The result of multiplying all the characters of this NEString.

The result of multiplying all the characters of this NEString.

This method can be invoked for any NEString for which an implicit Numeric[T] exists.

Attributes

Returns

the product of all elements

def reduce(op: (Char, Char) => Char): Char

Reduces the elements of this NEString using the specified associative binary operator.

Reduces the elements of this NEString using the specified associative binary operator.

The order in which operations are performed on characters is unspecified and may be nondeterministic.

Value parameters

op

a binary operator that must be associative.

Attributes

Returns

the result of applying reduce operator op between all the characters of this NEString.

def reduceLeft(op: (Char, Char) => Char): Char

Applies a binary operator to all characters of this NEString, going left to right.

Applies a binary operator to all characters of this NEString, going left to right.

Value parameters

op

the binary operator.

Attributes

Returns

the result of inserting op between consecutive characters of this NEString, going left to right:

op(...op(op(x_1, x_2), x_3), ..., x_n)

where x1, ..., xn are the characters of this NEString.

def reduceLeftOption(op: (Char, Char) => Char): Option[Char]

Applies a binary operator to all characters of this NEString, going left to right, returning the result in a Some.

Applies a binary operator to all characters of this NEString, going left to right, returning the result in a Some.

Value parameters

op

the binary operator.

Attributes

Returns

a Some containing the result of reduceLeft(op)

def reduceOption(op: (Char, Char) => Char): Option[Char]
def reduceRight(op: (Char, Char) => Char): Char

Applies a binary operator to all characters of this NEString, going right to left.

Applies a binary operator to all characters of this NEString, going right to left.

Value parameters

op

the binary operator

Attributes

Returns

the result of inserting op between consecutive characters of this NEString, going right to left:

op(x_1, op(x_2, ... op(x_{n-1}, x_n)...))

where x1, ..., xn are the elements of this NEString.

def reduceRightOption(op: (Char, Char) => Char): Option[Char]

Applies a binary operator to all elements of this NEString, going right to left, returning the result in a Some.

Applies a binary operator to all elements of this NEString, going right to left, returning the result in a Some.

Value parameters

op

the binary operator

Attributes

Returns

a Some containing the result of reduceRight(op)

def reverse: NEString

Returns new NEString with characters in reverse order.

Returns new NEString with characters in reverse order.

Attributes

Returns

a new NEString with all characters of this NEString in reversed order.

def reverseIterator: Iterator[Char]

An iterator yielding characters in reverse order.

An iterator yielding characters in reverse order.

Attributes

Returns

an iterator yielding the characters of this NEString in reversed order

Note

NEString.reverseIterator is the same as NEString.reverse.iterator, but might be more efficient.

def reverseMap[U](f: Char => U): Iterable[U]

Builds a new Iterable by applying a function to all characters of this NEString and collecting the results in reverse order.

Builds a new Iterable by applying a function to all characters of this NEString and collecting the results in reverse order.

Type parameters

U

the element type of the returned Iterable.

Value parameters

f

the function to apply to each character.

Attributes

Returns

a new Iterable resulting from applying the given function f to each character of this NEString and collecting the results in reverse order.

Note

NEString.reverseMap(f) is the same as NEString.reverse.map(f), but might be more efficient.

def sameElements(that: Iterable[Char]): Boolean

Checks if the given Iterable contains the same characters in the same order as this NEString.

Checks if the given Iterable contains the same characters in the same order as this NEString.

Value parameters

that

the Iterable with which to compare

Attributes

Returns

true, if both this NEString and the given Iterable contain the same characters in the same order, false otherwise.

def sameElements(that: Vector[Char]): Boolean

Checks if the given Vector contains the same characters in the same order as this NEString.

Checks if the given Vector contains the same characters in the same order as this NEString.

Value parameters

that

the Vector with which to compare

Attributes

Returns

true, if both this and the given Vector contain the same characters in the same order, false otherwise.

def sameElements(that: NEString): Boolean

Checks if the given NEString contains the same characters in the same order as this NEString.

Checks if the given NEString contains the same characters in the same order as this NEString.

Value parameters

that

the NEString with which to compare

Attributes

Returns

true, if both this and the given NEString contain the same characters in the same order, false otherwise.

def scan(z: Char)(op: (Char, Char) => Char): NEString

Computes a prefix scan of the characters of this NEString.

Computes a prefix scan of the characters of this NEString.

Value parameters

op

a binary operator that must be associative

z

a neutral element for the scan operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication.)

Attributes

Returns

a new NEString containing the prefix scan of the elements in this NEString

Note

The neutral character z may be applied more than once. Here are some examples:

NEString("123").scan(0)(_ + _) == NEString(0, 1, 3, 6)
NEString("123").scan("z")(_ + _.toString) == NEString("z", "z1", "z12", "z123")
def scanLeft[B](z: B)(op: (B, Char) => B): Iterable[B]

Produces a NEString containing cumulative results of applying the operator going left to right.

Produces a NEString containing cumulative results of applying the operator going left to right.

Here are some examples:

NEString("123").scanLeft(0)(_ + _.toString.toInt) == Vector(0, 1, 3, 6)
NEString("123").scanLeft("z")(_ + _) == Vector("z", "z1", "z12", "z123")

Type parameters

B

the result type of the binary operator and type of the resulting NEString

Value parameters

op

the binary operator.

z

the start value.

Attributes

Returns

a new NEString containing the intermediate results of inserting op between consecutive characters of this NEString, going left to right, with the start value, z, on the left.

def scanRight[B](z: B)(op: (Char, B) => B): Iterable[B]

Produces a NEString containing cumulative results of applying the operator going right to left.

Produces a NEString containing cumulative results of applying the operator going right to left.

Here are some examples:

NEString("123").scanRight(0)(_.toString.toInt + _) == NEString(6, 5, 3, 0)
NEString("123").scanRight("z")(_ + _) == NEString("123z", "23z", "3z", "z")

Type parameters

B

the result of the binary operator and type of the resulting NEString

Value parameters

op

the binary operator

z

the start value

Attributes

Returns

a new NEString containing the intermediate results of inserting op between consecutive characters of this NEString, going right to left, with the start value, z, on the right.

def segmentLength(p: Char => Boolean, from: Int): Int

Computes length of longest segment whose characters all satisfy some predicate.

Computes length of longest segment whose characters all satisfy some predicate.

Value parameters

from

the index where the search starts.

p

the predicate used to test elements.

Attributes

Returns

the length of the longest segment of this NEString starting from index from such that every character of the segment satisfies the predicate p.

def size: Int

The size of this NEString.

The size of this NEString.

Attributes

Returns

the number of characters in this NEString.

Note

length and size yield the same result, which will be >= 1.

def sliding(size: Int): Iterator[NEString]

Groups characters in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.)

Groups characters in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.)

Value parameters

size

the number of characters per group

Attributes

Returns

an iterator producing NEStrings of size size, except the last and the only element will be truncated if there are fewer characters than size.

def sliding(size: Int, step: Int): Iterator[NEString]

Groups characters in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.), moving the sliding window by a given step each time.

Groups characters in fixed size blocks by passing a “sliding window” over them (as opposed to partitioning them, as is done in grouped.), moving the sliding window by a given step each time.

Value parameters

size

the number of characters per group

step

the distance between the first characters of successive groups

Attributes

Returns

an iterator producing NEStrings of size size, except the last and the only character will be truncated if there are fewer characters than size.

def sortBy[U](f: Char => U)(implicit ord: Ordering[U]): NEString

Sorts this NEString according to the Ordering of the result of applying the given function to every character.

Sorts this NEString according to the Ordering of the result of applying the given function to every character.

Type parameters

U

the target type of the transformation f, and the type where the Ordering ord is defined.

Value parameters

f

the transformation function mapping elements to some other domain U.

ord

the ordering assumed on domain U.

Attributes

Returns

a NEString consisting of the elements of this NEString sorted according to the Ordering where x < y if ord.lt(f(x), f(y)).

def sortWith(lt: (Char, Char) => Boolean): NEString

Sorts this NEString according to a comparison function.

Sorts this NEString according to a comparison function.

The sort is stable. That is, characters that are equal (as determined by lt) appear in the same order in the sorted NEString as in the original.

Value parameters

lt

the comparison function that tests whether its first argument precedes its second argument in the desired ordering.

Attributes

Returns

a NEString consisting of the elements of this NEString sorted according to the comparison function lt.

def sorted(implicit ord: Ordering[Char]): NEString

Sorts this NEString according to an Ordering.

Sorts this NEString according to an Ordering.

The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted NEString as in the original.

Value parameters

ord

the Ordering to be used to compare elements.

Attributes

Returns

a NEString consisting of the characters of this NEString sorted according to the ordering defined by ord.

def startsWith(that: Seq[Char]): Boolean

Indicates whether this NEString starts with the given Seq.

Indicates whether this NEString starts with the given Seq.

Value parameters

that

the Seq slice to look for in this NEString

Attributes

Returns

true if this NEString has that as a prefix, false otherwise.

def startsWith(that: Seq[Char], offset: Int): Boolean

Indicates whether this NEString starts with the given Seq at the given index.

Indicates whether this NEString starts with the given Seq at the given index.

Value parameters

offset

the index at which this NEString is searched.

that

the Seq slice to look for in this NEString

Attributes

Returns

true if this NEString has that as a slice at the index offset, false otherwise.

def startsWith(that: Vector[Char]): Boolean

Indicates whether this NEString starts with the given Vector.

Indicates whether this NEString starts with the given Vector.

Value parameters

that

the Vector to test

Attributes

Returns

true if this collection has that as a prefix, false otherwise.

def startsWith(that: NEString): Boolean

Indicates whether this NEString starts with the given NEString.

Indicates whether this NEString starts with the given NEString.

Value parameters

that

the NEString to test

Attributes

Returns

true if this collection has that as a prefix, false otherwise.

def startsWith(that: Vector[Char], offset: Int): Boolean

Indicates whether this NEString starts with the given Vector at the given index.

Indicates whether this NEString starts with the given Vector at the given index.

Value parameters

offset

the index at which this NEString is searched.

that

the Vector slice to look for in this NEString

Attributes

Returns

true if this NEString has that as a slice at the index offset, false otherwise.

def startsWith(that: NEString, offset: Int): Boolean

Indicates whether this NEString starts with the given NEString at the given index.

Indicates whether this NEString starts with the given NEString at the given index.

Value parameters

offset

the index at which this NEString is searched.

that

the NEString slice to look for in this NEString

Attributes

Returns

true if this NEString has that as a slice at the index offset, false otherwise.

def stringPrefix: String

Returns "NEString", the prefix of this object's toString representation.

Returns "NEString", the prefix of this object's toString representation.

Attributes

Returns

the string "NEString"

def sum(implicit num: Numeric[Long]): Long

The result of summing all the characters of this NEString.

The result of summing all the characters of this NEString.

This method can be invoked for any NEString for which an implicit Numeric[Char] exists.

Attributes

Returns

the sum of all elements

def tail: String
def to[C1](factory: Factory[Char, C1]): C1

Converts this NEString into a collection of type Col by copying all elements.

Converts this NEString into a collection of type Col by copying all elements.

Type parameters

C1

the collection type to build.

Attributes

Returns

a new collection containing all elements of this NEString.

def toArray(implicit classTag: ClassTag[Char]): Array[Char]

Converts this NEString to an array.

Converts this NEString to an array.

Attributes

Returns

an array containing all characters of this NEString. A ClassTag must be available for the element type of this NEString.

def toBuffer: Buffer[Char]

Converts this NEString to a mutable buffer.

Converts this NEString to a mutable buffer.

Attributes

Returns

a buffer containing all characters of this NEString.

def toIndexedSeq: IndexedSeq[Char]

Converts this NEString to an immutable IndexedSeq.

Converts this NEString to an immutable IndexedSeq.

Attributes

Returns

an immutable IndexedSeq containing all characters of this NEString.

def toIterable: Iterable[Char]

Converts this NEString to an iterable collection.

Converts this NEString to an iterable collection.

Attributes

Returns

an Iterable containing all characters of this NEString.

def toIterator: Iterator[Char]

Returns an Iterator over the elements in this NEString.

Returns an Iterator over the elements in this NEString.

Attributes

Returns

an Iterator containing all characters of this NEString.

def toMap: Map[Int, Char]

Converts this NEString to a map.

Converts this NEString to a map.

This method is unavailable unless the elements are members of Tuple2, each ((K, V)) becoming a key-value pair in the map. Duplicate keys will be overwritten by later keys.

Attributes

Returns

a map of type immutable.Map[Int, Char] containing all index/character pairs of type (Int, Char) of this NEString.

def toSeq: Seq[Char]

Converts this NEString to an immutable IndexedSeq.

Converts this NEString to an immutable IndexedSeq.

Attributes

Returns

an immutable IndexedSeq containing all characters of this NEString.

def toSet: Set[Char]

Converts this NEString to a set.

Converts this NEString to a set.

Attributes

Returns

a set containing all characters of this NEString.

override def toString: String

Returns a string representation of this NEString.

Returns a string representation of this NEString.

Attributes

Returns

the string "NEString" followed by the result of invoking toString on this NEString's elements, surrounded by parentheses.

Definition Classes
Any
def toVector: Vector[Char]

Converts this NEString to a Vector.

Converts this NEString to a Vector.

Attributes

Returns

a Vector containing all characters of this NEString.

def union(that: Vector[Char]): NEString

Produces a new NEString that contains all characters of this NEString and also all characters of a given Vector.

Produces a new NEString that contains all characters of this NEString and also all characters of a given Vector.

NEStringX union everyY is equivalent to NEStringX ++ everyY.

Another way to express this is that NEStringX union everyY computes the order-presevring multi-set union of NEStringX and everyY. This union method is hence a counter-part of diff and intersect that also work on multi-sets.

Value parameters

that

the Vector to add.

Attributes

Returns

a new NEString that contains all characters of this NEString followed by all characters of that Vector.

def union(that: NEString): NEString

Produces a new NEString that contains all characters of this NEString and also all characters of a given NEString.

Produces a new NEString that contains all characters of this NEString and also all characters of a given NEString.

NEStringX union NEStringY is equivalent to NEStringX ++ NEStringY.

Another way to express this is that NEStringX union NEStringY computes the order-presevring multi-set union of NEStringX and NEStringY. This union method is hence a counter-part of diff and intersect that also work on multi-sets.

Value parameters

that

the NEString to add.

Attributes

Returns

a new NEString that contains all elements of this NEString followed by all characters of that.

def union(that: Seq[Char]): NEString

Produces a new NEString that contains all characters of this NEString and also all characters of a given Seq.

Produces a new NEString that contains all characters of this NEString and also all characters of a given Seq.

NEStringX union ys is equivalent to NEStringX ++ ys.

Another way to express this is that NEStringX union ys computes the order-presevring multi-set union of NEStringX and ys. This union method is hence a counter-part of diff and intersect that also work on multi-sets.

Value parameters

that

the Seq to add.

Attributes

Returns

a new NEString that contains all elements of this NEString followed by all elements of that Seq.

def unzip[L, R](implicit asPair: Char => (L, R)): (Iterable[L], Iterable[R])

Converts this NEString of pairs into two NEStrings of the first and second half of each pair.

Converts this NEString of pairs into two NEStrings of the first and second half of each pair.

Type parameters

L

the type of the first half of the character pairs

R

the type of the second half of the character pairs

Value parameters

asPair

an implicit conversion that asserts that the character type of this NEString is a pair.

Attributes

Returns

a pair of NEStrings, containing the first and second half, respectively, of each character pair of this NEString.

def unzip3[L, M, R](implicit asTriple: Char => (L, M, R)): (Iterable[L], Iterable[M], Iterable[R])

Converts this NEString of triples into three NEStrings of the first, second, and and third character of each triple.

Converts this NEString of triples into three NEStrings of the first, second, and and third character of each triple.

Type parameters

L

the type of the first member of the character triples

R

the type of the third member of the character triples

Value parameters

asTriple

an implicit conversion that character that the character type of this NEString is a triple.

Attributes

Returns

a triple of NEStrings, containing the first, second, and third member, respectively, of each character triple of this NEString.

def updated(idx: Int, c: Char): NEString

A copy of this NEString with one single replaced character.

A copy of this NEString with one single replaced character.

Value parameters

c

the replacing character

idx

the position of the replacement

Attributes

Returns

a copy of this NEString with the character at position idx replaced by c.

Throws
IndexOutOfBoundsException

if the passed index is greater than or equal to the length of this NEString

def zipAll[O](other: Iterable[O], thisElem: Char, otherElem: O): Iterable[(Char, O)]

Returns a NEString formed from this NEString and an iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements will be used to extend the shorter collection to the length of the longer.

Returns a NEString formed from this NEString and an iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements will be used to extend the shorter collection to the length of the longer.

Type parameters

O

the element type of the other

Value parameters

other

the Iterable providing the second half of each result pair

otherElem

the element to be used to fill up the result if that Iterable is shorter than this NEString.

thisElem

the element to be used to fill up the result if this NEString is shorter than that Iterable.

Attributes

Returns

a new NEString containing pairs consisting of corresponding characters of this NEString and that. The length of the returned collection is the maximum of the lengths of this NEString and that. If this NEString is shorter than that, thisElem values are used to pad the result. If that is shorter than this NEString, thatElem values are used to pad the result.

def zipAll(other: NEString, thisElem: Char, otherElem: Char): Iterable[(Char, Char)]

Returns a NEString formed from this NEString and another NEString combining corresponding elements in pairs. If one of the two is shorter than the other, placeholder elements will be used to extend the shorter collection to the length of the longer.

Returns a NEString formed from this NEString and another NEString combining corresponding elements in pairs. If one of the two is shorter than the other, placeholder elements will be used to extend the shorter collection to the length of the longer.

Value parameters

other

the NEString providing the second half of each result pair

otherElem

the character to be used to fill up the result if that Iterable is shorter than this NEString.

thisElem

the character to be used to fill up the result if this NEString is shorter than that NEString.

Attributes

Returns

a new NEString containing pairs consisting of corresponding characters of this NEString and that. The length of the returned collection is the maximum of the lengths of this NEString and that. If this NEString is shorter than that, thisElem values are used to pad the result. If that is shorter than this NEString, thatElem values are used to pad the result.

def zipWithIndex: Iterable[(Char, Int)]

Zips this NEString with its indices.

Zips this NEString with its indices.

Attributes

Returns

A new NEString containing pairs consisting of all elements of this NEString paired with their index. Indices start at 0.

Concrete fields

val theString: String
Generated with