NEString

Companion object NEString

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 `NEString`s

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 `NEString`s

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))

Linear Supertypes

AnyVal, Any

Ordering

Alphabetic
By Inheritance

Inherited

NEString
AnyVal
Any

Hide All
Show All

Visibility

Public
Protected

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
Any
final def ##: Int
Definition Classes
Any
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.
other
the TraversableOnce of Char to append
returns
a new NEString that contains this NEString followed by all characters of 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.
other
the Vector of Char to append
returns
a new NEString that contains this NEString followed by all characters of other.
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.
other
the NEString to append
returns
a new NEString that contains this NEString followed by 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.
c
the character to prepend to this NEString
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.
c
the character to append to this NEString
returns
a new NEString consisting of all characters of this NEString followed by the given c.
final def ==(arg0: Any): Boolean
Definition Classes
Any
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.
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
sb
the string builder to which characters will be appended
start
the starting string
sep
the separator string
end
the ending string
returns
the string builder, sb, to which characters were appended.
def addString(sb: StringBuilder, sep: String): StringBuilder
Appends all characters of this NEString to a string builder using a separator string.
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.
sb
the string builder to which characters will be appended
sep
the separator string
returns
the string builder, sb, to which characters were appended.
def addString(sb: StringBuilder): StringBuilder
Appends all characters of this NEString to a string builder.
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.
sb
the string builder to which characters will be appended
returns
the string builder, sb, to which elements 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.
returns
the character of this NEString at index idx, where 0 indicates the first element.
final def asInstanceOf[T0]: T0
Definition Classes
Any
def charAt(idx: Int): Char
Gets a character by its index in the NEString.
Gets a character by its index in the NEString.
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.
pf
the partial function
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.
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.
c
the element to look for
returns
true if this NEString has an character that is equal (as determined by ==) to c, false otherwise.
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.
that
the NEString slice to look for
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.
that
the Vector character slice to look for
returns
true if this NEString contains a character slice with the same characters as that, otherwise false.
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.
that
the Seq character slice to look for
returns
true if this NEString contains a slice with the same characters as that, otherwise false.
def copyToArray(arr: Array[Char], start: Int, len: Int): Unit
Copies characters of this NEString to an array.
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.
arr
the array to fill
start
the starting index
len
the maximum number of elements to copy
def copyToArray(arr: Array[Char], start: Int): Unit
Copies characters of this NEString to an array.
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.
arr
the array to fill
start
the starting index
def copyToArray(arr: Array[Char]): Unit
Copies characters of this NEString to an array.
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.
arr
the array to fill
def copyToBuffer(buf: Buffer[Char]): Unit
Copies all characters of this NEString to a buffer.
Copies all characters of this NEString to a buffer.
buf
the buffer to which characters are copied
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.
that
the NEString to compare for correspondence
p
the predicate, which relates elements from this and the passed NEString
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 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.
B
the type of the elements of that
that
the Vector to compare for correspondence
p
the predicate, which relates elements from this NEString and the passed Vector
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[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.
B
the type of the elements of that
that
the Seq to compare for correspondence
p
the predicate, which relates elements from this NEString and the passed Seq
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 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.
p
the predicate used to test characters.
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.
returns
A new NEString that contains the first occurrence of every character of this NEString.
def endsWith(that: NEString): Boolean
Indicates whether this NEString ends with the given NEString.
Indicates whether this NEString ends with the given NEString.
that
the NEString to test
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.
that
the Vector to test
returns
true if this NEString has that as a suffix, false otherwise.
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.
that
the sequence to test
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.
p
the predicate used to test characters.
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.
p
the predicate used to test characters
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.
f
the function to apply to each character.
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.
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.)
op
a binary operator that must be associative
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.
B
the result type of the binary operator.
z
the start value.
op
the binary operator.
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 x₁, ..., x_n 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.
B
the result of the binary operator
z
the start value
op
the binary operator
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 x₁, ..., x_n 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.
p
the predicate used to test characters.
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.
f
the function that is applied for its side-effect to every character. The result of function f is discarded.
def getClass(): Class[_ <: AnyVal]
Definition Classes
AnyVal → Any
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.
K
the type of keys returned by the discriminator function.
f
the discriminator function.
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.
size
the number of characters per group
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.
def head: Char
Selects the first character of this NEString.
Selects the first character of this NEString.
returns
the first character of this NEString.
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.
c
the character value to search for.
from
the start index
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 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.
c
the character value to search for.
returns
the index of the first character of this NEString that is equal (as determined by ==) to c, or -1, if none 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.
that
the NEString defining the slice to look for
from
the start index
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 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.
that
the Vector defining the slice to look for
from
the start index
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): 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.
that
the NEString defining the slice to look for
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]): 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.
that
the Vector defining the slice to look for
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: 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.
that
the Seq[Char] defining the slice to look for
from
the start index
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: 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.
that
the Seq[Char] defining the slice to look for
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 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.
p
the predicate used to test characters.
from
the start index
returns
the index >= from of the first character of this NEString that satisfies the predicate p, or -1, if none 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.
p
the predicate used to test characters.
returns
the index 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.
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.
idx
the index to test
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.
returns
false
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
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.
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.
returns
the new iterator
def last: Char
Selects the last character of this NEString.
Selects the last character of this NEString.
returns
the last character of this NEString.
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.
c
the character value to search for.
end
the end index.
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 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.
c
the character value to search for.
returns
the index of the last character of this NEString that is equal (as determined by ==) to c, or -1, if none 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.
that
the NEString defining the slice to look for
end
the end index
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 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.
that
the Vector defining the slice to look for
end
the end index
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): 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.
that
the NEString defining the slice to look for
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]): 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.
that
the Vector defining the slice to look for
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: 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.
that
the Seq defining the slice to look for
end
the end index
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: 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.
that
the Seq defining the slice to look for
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 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.
p
the predicate used to test characters.
end
the end index
returns
the index >= end of the last character of this NEString that satisfies the predicate p, or -1, if none exists.
def lastIndexWhere(p: (Char) => Boolean): Int
Finds index of last character satisfying some predicate.
Finds index of last character satisfying some predicate.
p
the predicate used to test characters.
returns
the index 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.
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.
len
the test value that gets compared with the length.
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.
U
the character type of the returned NEString.
f
the function to apply to each character.
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.
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.
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.
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.
returns
the smallest result of applying the given function to every character of this NEString.
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.
start
the starting string.
sep
the separator string.
end
the ending string.
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 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.
sep
the separator string
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: String
Displays all characters of this NEString in a string.
Displays all characters of this NEString in a string.
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 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.
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.
len
the target length
c
the padding character
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
from
the index of the first replaced character
that
the NEString whose characters should replace a slice in this NEString
replaced
the number of characters to drop in the original NEString
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"))
```
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.
p
the predicate used to test characters.
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.
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.
op
a binary operator that must be associative.
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.
op
the binary operator.
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 x₁, ..., x_n 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.
op
the binary operator.
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.
op
the binary operator
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 x₁, ..., x_n 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.
op
the binary operator
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.
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.
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.
U
the element type of the returned Iterable.
f
the function to apply to each character.
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: 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.
that
the NEString with which to compare
returns
true, if both this and the given NEString 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.
that
the Vector with which to compare
returns
true, if both this and the given Vector contain the same characters in the same order, false otherwise.
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.
that
the Iterable with which to compare
returns
true, if both this NEString and the given Iterable 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.
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.)
op
a binary operator that must be associative
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")
```
B
the result type of the binary operator and type of the resulting NEString
z
the start value.
op
the binary operator.
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")
```
B
the result of the binary operator and type of the resulting NEString
z
the start value
op
the binary operator
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.
p
the predicate used to test elements.
from
the index where the search starts.
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.
returns
the number of characters in this NEString.
Note
length and size yield the same result, which will be >= 1.
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.
size
the number of characters per group
step
the distance between the first characters of successive groups
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 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.)
size
the number of characters per group
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 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.
U
the target type of the transformation f, and the type where the Ordering ord is defined.
f
the transformation function mapping elements to some other domain U.
ord
the ordering assumed on domain U.
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.
lt
the comparison function that tests whether its first argument precedes its second argument in the desired ordering.
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.
ord
the Ordering to be used to compare elements.
returns
a NEString consisting of the characters of this NEString sorted according to the ordering defined by ord.
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.
that
the NEString slice to look for in this NEString
offset
the index at which this NEString is searched.
returns
true if this NEString has that as a slice at the index offset, 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.
that
the Vector slice to look for in this NEString
offset
the index at which this NEString is searched.
returns
true if this NEString has that as a slice at the index offset, 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.
that
the NEString to test
returns
true if this collection has that as a prefix, 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.
that
the Vector to test
returns
true if this collection 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.
that
the Seq slice to look for in this NEString
offset
the index at which this NEString is searched.
returns
true if this NEString has that as a slice at the index offset, false otherwise.
def startsWith(that: Seq[Char]): Boolean
Indicates whether this NEString starts with the given Seq.
Indicates whether this NEString starts with the given Seq.
that
the Seq slice to look for in this NEString
returns
true if this NEString has that as a prefix, 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.
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.
returns
the sum of all elements
def tail: String
val theString: 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.
C1
the collection type to build.
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.
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.
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.
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.
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.
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.
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.
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.
returns
a set containing all characters of this NEString.
def toString(): String
Returns a string representation of this NEString.
Returns a string representation of this NEString.
returns
the string "NEString" followed by the result of invoking toString on this NEString's elements, surrounded by parentheses.
Definition Classes
NEString → Any
def toVector: Vector[Char]
Converts this NEString to a Vector.
Converts this NEString to a Vector.
returns
a Vector containing all characters of this NEString.
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.
that
the Seq to add.
returns
a new NEString that contains all elements of this NEString followed by all elements of that Seq.
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.
that
the NEString to add.
returns
a new NEString that contains all elements of this NEString followed by all characters of that.
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.
that
the Vector to add.
returns
a new NEString that contains all characters of this NEString followed by all characters of that Vector.
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.
L
the type of the first half of the character pairs
R
the type of the second half of the character pairs
asPair
an implicit conversion that asserts that the character type of this NEString is a pair.
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.
L
the type of the first member of the character triples
R
the type of the third member of the character triples
asTriple
an implicit conversion that character that the character type of this NEString is a triple.
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.
idx
the position of the replacement
c
the replacing character
returns
a copy of this NEString with the character at position idx replaced by c.
Exceptions thrown
IndexOutOfBoundsException if the passed index is greater than or equal to the length of this NEString
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.
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.
other
the NEString providing the second half of each result pair
thisElem
the character to be used to fill up the result if this NEString is shorter than that NEString.
otherElem
the character to be used to fill up the result if that Iterable is shorter than this NEString.
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[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.
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.
O
the element type of the other
other
the Iterable providing the second half of each result pair
thisElem
the element to be used to fill up the result if this NEString is shorter than that Iterable.
otherElem
the element to be used to fill up the result if that Iterable is shorter than this NEString.
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.
returns
A new NEString containing pairs consisting of all elements of this NEString paired with their index. Indices start at 0.

Packages

NEString

Companion object NEString

final class NEString extends AnyVal

Constructing `NEString`s

Working with `NEString`s

Value Members

Inherited from AnyVal

Inherited from Any

Ungrouped

Packages

NEString

Companion object NEString

final class NEString extends AnyVal

Constructing NEStrings

Working with NEStrings

Value Members

Inherited from AnyVal

Inherited from Any

Ungrouped

NEString

Constructing `NEString`s

Working with `NEString`s