NumericString

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
Any
def *(n: Int): NumericString

Return a NumericString consisting of the current NumericString concatenated n times.
Return a NumericString consisting of the current NumericString concatenated n times.
def ++(that: String): String

Returns a new String concatenating this NumericString with the passed String.
Returns a new String concatenating this NumericString with the passed String.
that
the String to append
returns
a new String which contains all elements of this NumericString followed by all elements of that
def ++:(that: String): String

Returns a new String consisting of this NumericString prepended by the passed String.
Returns a new String consisting of this NumericString prepended by the passed String.
that
the String to append
returns
a new String which contains all elements of that followed by all elements of this NumericString
def +:(elem: Char): String

Returns a new String consisting of this NumericString prepended by the passed Char.
Returns a new String consisting of this NumericString prepended by the passed Char.
elem
the prepended Char
returns
a new String consisting of elem followed by all characters from this NumericString
def /:(z: Int)(op: (Int, Char) ⇒ Int): Int

Applies a binary operator to a start value and all elements of this NumericString, going left to right.
Applies a binary operator to a start value and all elements of this NumericString, going left to right.
Note: /: is alternate syntax for foldLeft; z /: xs is the same as xs foldLeft z.
z
the start value
op
the binary operator
returns
the result of inserting op between consecutive Chars of this NumericString, 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 characters of this NumericString.
def :+(elem: Char): String

Returns a new String consisting of this NumericString with the passed Char appended.
Returns a new String consisting of this NumericString with the passed Char appended.
elem
the appended Char
returns
a new String consisting of all elements of this NumericString followed by elem
def :\(z: Int)(op: (Char, Int) ⇒ Int): Int

Applies a binary operator to all elements of this NumericString and a start value, going right to left.
Applies a binary operator to all elements of this NumericString and a start value, going right to left.
Note: :\ is alternate syntax for foldRight; xs :\ z is the same as xs foldRight z.
z
the start value
op
the binary operator
returns
the result of inserting op between consecutive characters of this NumericString, 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 characters of this NumericString.
def <(that: String): Boolean

Returns true if this is less than that
def <=(that: String): Boolean

Returns true if this is less than or equal to that
final def ==(arg0: Any): Boolean

Definition Classes
Any
def >(that: String): Boolean

Returns true if this is greater than that
def >=(that: String): Boolean

Returns true if this is greater than or equal to that
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Appends character elements of this NumericString to a string builder using start, separator, and end strings.
Appends character elements of this NumericString to a string builder using start, separator, and end strings. The written text begins with the string start and ends with the string end. Inside, the characters of this NumericString are separated by the string sep.
b
the string builder to which elements are appended
start
the starting string
sep
the separator string
end
the ending string
returns
the string builder b to which elements were appended
def addString(b: StringBuilder, sep: String): StringBuilder

Appends character elements of this NumericString to a string builder using a separator string.
Appends character elements of this NumericString to a string builder using a separator string.
b
the string builder to which elements are appended
sep
the separator string
returns
the string builder b to which elements were appended
def addString(b: StringBuilder): StringBuilder

Appends string value of this NumericString to a string builder.
Appends string value of this NumericString to a string builder.
b
the string builder to which this NumericString gets appended
returns
the string builder b to which this NumericString was appended
def aggregate[B](z: ⇒ B)(seqop: (B, Char) ⇒ B, combop: (B, B) ⇒ B): B

Aggregates the results of applying an operator to subsequent elements of this NumericString.
Aggregates the results of applying an operator to subsequent elements of this NumericString.
This is a more general form of fold and reduce. It is similar to foldLeft in that it doesn't require the result to be a supertype of the element type.
aggregate splits the elements of this NumericString into partitions and processes each partition by sequentially applying seqop, starting with z (like foldLeft). Those intermediate results are then combined by using combop (like fold). The implementation of this operation may operate on an arbitrary number of collection partitions (even 1), so combop may be invoked an arbitrary number of times (even 0).
As an example, consider summing up the integer values the character elements. The initial value for the sum is 0. First, seqop transforms each input character to an Int and adds it to the sum (of the partition). Then, combop just needs to sum up the intermediate results of the partitions:
```
NumericString("123").aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })
```
z
the initial value for the accumulated result of the partition - this will typically be the neutral element for the seqop operator (e.g. Nil for list concatenation or 0 for summation) and may be evaluated more than once
seqop
an operator used to accumulate results within a partition
combop
an associative operator used to combine results within a partition
def apply(index: Int): Char

Return character at index index.
Return character at index index.
returns
the character of this string at index index, where 0 indicates the first element.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(that: Any): Boolean

Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.
Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.
that
the object with which this NumericString should be compared
returns
true if this NumericString can possibly equal that, false otherwise. The test takes into consideration only the run-time types of objects but ignores their elements.
def capitalize: String

Returns this string with first character converted to upper case (i.
Returns this string with first character converted to upper case (i.e. unchanged for a NumericString).
returns
the string value of this NumericString.
def charAt(index: Int): Char

Returns the character at the zero-based index within the NumericString.
Returns the character at the zero-based index within the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
index
zero-based offset within NumericString
returns
character found at index
def codePointAt(index: Int): Int

Returns the integer value of the Unicode code point at the zero-based index within the NumericString.
Returns the integer value of the Unicode code point at the zero-based index within the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
index
zero-based offset within NumericString
returns
Unicode code point found at 'index'
def codePointBefore(index: Int): Int

Returns the integer value of the Unicode code point immediately prior to the zero-based index within the NumericString.
Returns the integer value of the Unicode code point immediately prior to the zero-based index within the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
index
zero-based offset within NumericString
returns
Unicode code point found immediately prior to 'index'
def codePointCount(beginIndex: Int, endIndex: Int): Int

Returns the count of complete Unicode code points beginning at zero-based beginIndex and ending at (but not including) zero-based endIndex.
Returns the count of complete Unicode code points beginning at zero-based beginIndex and ending at (but not including) zero-based endIndex.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
beginIndex
zero-based starting offset within NumericString
endIndex
zero-based ending offset within NumericString, one-past character range of interest
returns
count of complete Unicode code points found from BeginIndex, up to endIndex
def collect(pf: PartialFunction[Char, Char]): String

Builds a new collection by applying a partial function to all characters of this NumericString on which the function is defined.
Builds a new collection by applying a partial function to all characters of this NumericString on which the function is defined.
pf
the partial function which filters and maps the elements.
returns
a new String resulting from applying the partial function pf to each element on which it is defined and collecting the results. The order of the elements is preserved.
def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]

Finds the first character of the NumericString for which the given partial function is defined, and applies the partial function to it.
Finds the first character of the NumericString for which the given partial function is defined, and applies the partial function to it.
pf
the partial function
returns
an option value containing pf applied to the first value for which it is defined, or None if none exists.
def combinations(n: Int): Iterator[String]

Iterates over combinations.
Iterates over combinations. A _combination_ of length n is a subsequence of the original sequence, with the elements taken in order. Thus, "xy" and "yy" are both length-2 combinations of "xyy", but "yx" is not. If there is more than one way to generate the same subsequence, only one will be returned.
For example, "xyyy" has three different ways to generate "xy" depending on whether the first, second, or third "y" is selected. However, since all are identical, only one will be chosen. Which of the three will be taken is an implementation detail that is not defined.
returns
An Iterator which traverses the possible n-element combinations of this NumericString.
Example:
1. NumericString("12223").combinations(2) = Iterator(12, 13, 22, 23)
def compare(that: String): Int

Result of comparing this with operand that.
Result of comparing this with operand that.
Implement this method to determine how instances of A will be sorted.
Returns x where:
- x < 0 when this < that
- x == 0 when this == that
- x > 0 when this > that
def compareTo(anotherString: String): Int

Compares the NumericString to anotherString, returning an integer <0 if NumericString is less than the supplied string, 0 if identical, and >0 if NumericString is greater than the supplied string.
Compares the NumericString to anotherString, returning an integer <0 if NumericString is less than the supplied string, 0 if identical, and >0 if NumericString is greater than the supplied string.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
anotherString
other string we compare NumericString against
returns
integer <0, 0 or >0 corresponding to lexicographic ordering of NumericString vs. anotherString
def concat(str: String): String

Concatenates supplied string str onto the tail end of the NumericString and returns the resulting String.
Concatenates supplied string str onto the tail end of the NumericString and returns the resulting String.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
str
additional string to concatenate onto NumericString
returns
string resulting from the concatenation
def concatNumericString(that: NumericString): NumericString

Returns a new NumericString concatenating this NumericString with the passed NumericString.
Returns a new NumericString concatenating this NumericString with the passed NumericString.
that
the NumericString to append
returns
a new NumericString that concatenates this NumericString with that.
def contains(s: CharSequence): Boolean

Tests whether this NumericString contains a given value as an element.
Tests whether this NumericString contains a given value as an element.
s
the element to test.
returns
true if this NumericString has an element that is equal (as determined by ==) to elem, false otherwise.
def containsSlice[B](that: GenSeq[B]): Boolean

Tests whether this NumericString contains a given sequence as a slice.
Tests whether this NumericString contains a given sequence as a slice.
that
the sequence to test
returns
true if this NumericString contains a slice with the same elements as that, otherwise false.
def contentEquals(cs: CharSequence): Boolean

Returns true if the NumericString content is the same as the supplied character sequence cs, otherwise returns false.
Returns true if the NumericString content is the same as the supplied character sequence cs, otherwise returns false.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
cs
character sequence for comparison
returns
true if NumericString content is the same as cs false otherwise.
def copyToArray(xs: Array[Char], start: Int): Unit

Copies the elements of this NumericString to an array.
Copies the elements of this NumericString to an array. Fills the given array xs with values of this NumericString, beginning at index start. Copying will stop once either the end of the current NumericString is reached, or the end of the target array is reached.
xs
the array to fill.
start
the starting index.
def copyToArray(xs: Array[Char]): Unit

Copies the elements of this NumericString to an array.
Copies the elements of this NumericString to an array. Fills the given array xs with values of this NumericString Copying will stop once either the end of the current NumericString is reached, or the end of the target array is reached.
xs
the array to fill.
def copyToArray(xs: Array[Char], start: Int, len: Int): Unit

Copies the elements of this NumericString to an array.
Copies the elements of this NumericString to an array. Fills the given array xs with at most len elements of this NumericString, starting at position start. Copying will stop once either the end of the current NumericString is reached, or the end of the target array is reached, or len elements have been copied.
xs
the array to fill.
start
the starting index.
len
the maximal number of elements to copy.
def copyToBuffer[B >: Char](dest: Buffer[B]): Unit

Copies all elements of this NumericString to a buffer.
Copies all elements of this NumericString to a buffer.
dest
The buffer to which elements are copied.
def corresponds[B](that: GenSeq[B])(p: (Char, B) ⇒ Boolean): Boolean

Tests whether every element of this NumericString relates to the corresponding element of another sequence by satisfying a test predicate.
Tests whether every element of this NumericString relates to the corresponding element of another sequence by satisfying a test predicate.
B
the type of the elements of that
that
the other sequence
p
the test predicate, which relates elements from both sequences
returns
true if both sequences have the same length and p(x, y) is true for all corresponding elements x of this NumericString and y of that, otherwise false.
def count(p: (Char) ⇒ Boolean): Int

Counts the number of elements in the NumericString which satisfy a predicate.
Counts the number of elements in the NumericString which satisfy a predicate.
p
the predicate used to test elements.
returns
the number of elements satisfying the predicate p.
def diff(that: Seq[Char]): String

Computes the multiset difference between this NumericString and another sequence.
Computes the multiset difference between this NumericString and another sequence.
that
the sequence of elements to remove
returns
a new string which contains all elements of this NumericString except some occurrences of elements that also appear in that. If an element value x appears n times in that, then the first n occurrences of x will not form part of the result, but any following occurrences will.
def distinct: String

Builds a new NumericString from this NumericString without any duplicate elements.
Builds a new NumericString from this NumericString without any duplicate elements.
returns
A new string which contains the first occurrence of every character of this NumericString.
def drop(n: Int): String

Selects all elements except first n ones.
Selects all elements except first n ones.
n
the number of elements to drop from this NumericString.
returns
a string consisting of all elements of this NumericString except the first n ones, or else the empty string if this NumericString has less than n elements.
def dropRight(n: Int): String

Selects all elements except last n ones.
Selects all elements except last n ones.
n
The number of elements to take
returns
a string consisting of all elements of this NumericString except the last n ones, or else the empty string, if this NumericString has less than n elements.
def dropWhile(p: (Char) ⇒ Boolean): String

Drops longest prefix of elements that satisfy a predicate.
Drops longest prefix of elements that satisfy a predicate.
p
The predicate used to test elements.
returns
the longest suffix of this NumericString whose first element does not satisfy the predicate p.
def endsWith[B](that: GenSeq[B]): Boolean

Tests whether this NumericString ends with the given sequence.
Tests whether this NumericString ends with the given sequence.
that
the sequence to test
returns
true if this NumericString has that as a suffix, false otherwise.
def endsWith(suffix: String): Boolean

Returns true if the NumericString content completely matches the supplied suffix, when both strings are aligned at their endpoints.
Returns true if the NumericString content completely matches the supplied suffix, when both strings are aligned at their endpoints.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
suffix
string for comparison as a suffix
returns
true if NumericString content completely matches the supplied suffix false otherwise.
def ensuringValid(f: (String) ⇒ String): NumericString

Applies the passed String => String function to the underlying String value, and if the result is a numeric string, returns the result wrapped in a NumericString, else throws AssertionError.
Applies the passed String => String function to the underlying String value, and if the result is a numeric string, returns the result wrapped in a NumericString, else throws AssertionError.
A factory/assertion method that produces a NumericString given a valid String value, or throws AssertionError, if given an invalid String value.
Note: you should use this method only when you are convinced that it will always succeed, i.e., never throw an exception. It is good practice to add a comment near the invocation of this method indicating why you think it will always succeed to document your reasoning. If you are not sure an ensuringValid call will always succeed, you should use one of the other factory or validation methods provided on this object instead: isValid, tryingValid, passOrElse, goodOrElse, or rightOrElse.
This method will inspect the result of applying the given function to this NumericString's underlying String value and if the result is a valid numeric string, it will return a NumericString representing that value. Otherwise, the String value returned by the given function is not a valid numeric string, so this method will throw AssertionError.
This method differs from a vanilla assert or ensuring call in that you get something you didn't already have if the assertion succeeds: a type that promises a String contains only numeric digit characters. With this method, you are asserting that you are convinced the result of the computation represented by applying the given function to this NumericString's value will produce a valid numeric string. Instead of producing an invalid NumericString, this method will signal an invalid result with a loud AssertionError.
f
the String => String function to apply to this NumericString's underlying String value.
returns
the result of applying this NumericString's underlying String value to to the passed function, wrapped in a NumericString if it is a valid numeric string (else throws AssertionError).

Exceptions thrown
AssertionError
if the result of applying this NumericString's underlying String value to to the passed function contains non-digit characters.
def equalsIgnoreCase(arg0: String): Boolean

Returns true if the supplied arg0 string is considered equal to this NumericString.
Returns true if the supplied arg0 string is considered equal to this NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
arg0
string for comparison
returns
true if NumericString content is the same as arg0 false otherwise.
def exists(p: (Char) ⇒ Boolean): Boolean

Tests whether a predicate holds for at least one element of this NumericString.
Tests whether a predicate holds for at least one element of this NumericString.
p
the predicate used to test elements.
returns
true if the given predicate p is satisfied by at least one character of this NumericString, otherwise false
def filter(p: (Char) ⇒ Boolean): String

Selects all elements of this NumericString which satisfy a predicate.
Selects all elements of this NumericString which satisfy a predicate.
p
the predicate used to test elements.
returns
a string consisting of all characters of this NumericString that satisfy the given predicate p. Their order may not be preserved.
def filterNot(p: (Char) ⇒ Boolean): String

Selects all elements of this NumericString which do not satisfy a predicate.
Selects all elements of this NumericString which do not satisfy a predicate.
returns
a string consisting of all characters of this NumericString that do not satisfy the given predicate p. Their order may not be preserved.
def find(p: (Char) ⇒ Boolean): Option[Char]

Finds the first element of the NumericString satisfying a predicate, if any.
Finds the first element of the NumericString satisfying a predicate, if any.
p
the predicate used to test elements.
returns
an option value containing the first character of the NumericString that satisfies p, or None if none exists.
def flatMap[B](f: (Char) ⇒ IterableOnce[B]): IndexedSeq[B]

Builds a new collection by applying a function to all elements of this NumericString and using the elements of the resulting collections.
Builds a new collection by applying a function to all elements of this NumericString and using the elements of the resulting collections.
B
the element type of the returned collection.
f
the function to apply to each element.
returns
a new string resulting from applying the given collection-valued function f to each element of this NumericString and concatenating the results.
def fold[A1 >: Char](z: A1)(op: (A1, A1) ⇒ A1): A1

Folds the elements of this NumericString using the specified associative binary operator.
Folds the elements of this NumericString using the specified associative binary operator.
A1
a type parameter for the binary operator, a supertype of A.
z
a neutral element 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 the fold operator op between all the elements and z, or z if this NumericString is empty.
def foldLeft[B](z: B)(op: (B, Char) ⇒ B): B

Applies a binary operator to a start value and all elements of this NumericString, going left to right.
Applies a binary operator to a start value and all elements of this NumericString, 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 elements of this NumericString, going left to right with the start value z on the left:
```
op(...op(z, x_1), x_2, ..., x_n)
```
where x₁, ..., x_n are the elements of this NumericString. Returns z if this NumericString is empty.
def foldRight[B](z: B)(op: (Char, B) ⇒ B): B

Applies a binary operator to all elements of this NumericString and a start value, going right to left.
Applies a binary operator to all elements of this NumericString and a start value, going right to left.
B
the result type of the binary operator.
z
the start value.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this NumericString, 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 NumericString. Returns z if this NumericString is empty.
def forall(p: (Char) ⇒ Boolean): Boolean

Tests whether a predicate holds for all elements of this NumericString.
Tests whether a predicate holds for all elements of this NumericString.
p
the predicate used to test elements.
returns
true if this NumericString is empty or the given predicate p holds for all elements of this NumericString, otherwise false.
def foreach(f: (Char) ⇒ Unit): Unit

Applies a function f to all elements of this NumericString.
Applies a function f to all elements of this NumericString.
f
the function that is applied for its side-effect to every element. The result of function f is discarded.
def getBytes(charsetName: String): Array[Byte]

Returns an array of bytes corresponding to the NumericString characters, interpreted via the named charsetName Charset-mapping of Unicode code points.
Returns an array of bytes corresponding to the NumericString characters, interpreted via the named charsetName Charset-mapping of Unicode code points.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
charsetName
string that names an already-known mapping of Unicode code points to bytes
returns
array of bytes corresponding to NumericString characters
def getBytes(charset: Charset): Array[Byte]

Returns an array of bytes corresponding to the NumericString characters, interpreted via the supplied charset mapping of Unicode code points.
Returns an array of bytes corresponding to the NumericString characters, interpreted via the supplied charset mapping of Unicode code points.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
charset
a mapping of Unicode code points to bytes
returns
array of bytes corresponding to NumericString characters
def getBytes: Array[Byte]

Returns an array of bytes corresponding to the NumericString characters, interpreted via the platform's default Charset-mapping of Unicode code points.
Returns an array of bytes corresponding to the NumericString characters, interpreted via the platform's default Charset-mapping of Unicode code points.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
array of bytes corresponding to NumericString characters
def getChars(srcBegin: Int, srcEnd: Int, dst: Array[Char], dstBegin: Int): Unit

Extracts the range of NumericString characters beginning at zero-based srcBegin through but not including srcEnd, into the supplied character array dst, writing the characters at the zero-based dstBegin index forward within that array.
Extracts the range of NumericString characters beginning at zero-based srcBegin through but not including srcEnd, into the supplied character array dst, writing the characters at the zero-based dstBegin index forward within that array.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
srcBegin
zero-based index where to begin extracting characters from NumericString
srcEnd
zero-based limit before which to stop extracting characters from NumericString
dst
supplied character array to write extracted characters into
dstBegin
zero-based index within destination array at which to begin writing
returns
Unit -- this function modifies the supplied dst array
def getClass(): Class[_ <: AnyVal]

Definition Classes
AnyVal → Any
def groupBy[K](f: (Char) ⇒ K): Map[K, String]

Partitions this NumericString into a map of strings according to some discriminator function.
Partitions this NumericString into a map of strings 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 strings such that the following invariant holds:
```
(xs groupBy f)(k) = xs filter (x => f(x) == k)
```
That is, every key k is bound to a string of those elements x for which f(x) equals k.
def grouped(size: Int): Iterator[String]

Partitions elements in fixed size strings.
Partitions elements in fixed size strings.
size
the number of elements per group
returns
An iterator producing strings of size size, except the last will be less than size size if the elements don't divide evenly.

See also
scala.collection.Iterator, method grouped
def hasDefiniteSize: Boolean

Tests whether this NumericString is known to have a finite size.
Tests whether this NumericString is known to have a finite size. Always true for NumericString.
returns
true if this collection is known to have finite size, false otherwise.
def head: Char

Selects the first element of this NumericString.
Selects the first element of this NumericString.
returns
the first element of this NumericString.

Exceptions thrown
NoSuchElementException
if the NumericString is empty.
def headOption: Option[Char]

Optionally selects the first element.
Optionally selects the first element.
returns
the first element of this NumericString if it is nonempty, None if it is empty.
def indexOf(str: String, fromIndex: Int): Int

Returns zero-based index (in Unicode code units: logical index of characters) of starting-character position of first-encountered match of str within NumericString, beginning search at zero-based index fromIndex; returns -1 if no fully-matching substring is found, or if fromIndex is outside the bounds of NumericString.
Returns zero-based index (in Unicode code units: logical index of characters) of starting-character position of first-encountered match of str within NumericString, beginning search at zero-based index fromIndex; returns -1 if no fully-matching substring is found, or if fromIndex is outside the bounds of NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
str
Unicode string to look for
fromIndex
zero-based integer index at which to begin search for match of str string
returns
zero-based integer index in Unicode code units, of starting position of first-encountered instance of str in NumericString at/beyond fromIndex
def indexOf(str: String): Int

Returns zero-based index (in Unicode code units: logical index of characters) of starting-character position of first-encountered match of str within NumericString; returns -1 if no fully-matching substring is found.
Returns zero-based index (in Unicode code units: logical index of characters) of starting-character position of first-encountered match of str within NumericString; returns -1 if no fully-matching substring is found.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
str
Unicode string to look for
returns
zero-based integer index in Unicode code units, of starting position of first-encountered instance of str in NumericString
def indexOf(ch: Int, fromIndex: Int): Int

Returns zero-based index (in Unicode code units: logical index of characters) of first-encountered NumericString character matching supplied Unicode ch, beginning search at zero-based index fromIndex; returns -1 if no matching character is found or if fromIndex is outside the bounds of NumericString.
Returns zero-based index (in Unicode code units: logical index of characters) of first-encountered NumericString character matching supplied Unicode ch, beginning search at zero-based index fromIndex; returns -1 if no matching character is found or if fromIndex is outside the bounds of NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
ch
Unicode character to look for
fromIndex
zero-based integer index at which to begin search for match of ch character
returns
zero-based integer index in Unicode code units of first-encountered instance of ch at/beyond fromIndex
def indexOf(ch: Int): Int

Returns zero-based index in Unicode code units (logical index of characters) of first-encountered NumericString character matching the supplied Unicode ch; returns -1 if no matching character is found.
Returns zero-based index in Unicode code units (logical index of characters) of first-encountered NumericString character matching the supplied Unicode ch; returns -1 if no matching character is found.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
ch
Unicode character to look for
returns
zero-based integer index in Unicode code units of first-encountered instance of ch
def indexOfSlice[B >: Char](that: GenSeq[B]): Int

Finds first index where this NumericString contains a given sequence as a slice.
Finds first index where this NumericString contains a given sequence as a slice.
that
the sequence to test
returns
the first index such that the elements of this NumericString starting at this index match the elements of sequence that, or -1 of no such subsequence exists.
def indexOfSlice[B >: Char](that: GenSeq[B], from: Int): Int

Finds first index after or at a start index where this NumericString contains a given sequence as a slice.
Finds first index after or at a start index where this NumericString contains a given sequence as a slice.
that
the sequence to test
from
the start index
returns
the first index >= from such that the elements of this NumericString starting at this index match the elements of sequence that, or -1 of no such subsequence exists.
def indexWhere(p: (Char) ⇒ Boolean): Int

Finds index of first element satisfying some predicate.
Finds index of first element satisfying some predicate.
p
the predicate used to test elements.
returns
the index of the first element of this NumericString that satisfies the predicate p, or -1, if none exists.
def indexWhere(p: (Char) ⇒ Boolean, from: Int): Int

Finds index of the first element satisfying some predicate after or at some start index.
Finds index of the first element satisfying some predicate after or at some start index.
p
the predicate used to test elements.
from
the start index
returns
the index >= from of the first element of this NumericString that satisfies the predicate p, or -1, if none exists.
def indices: Range

Produces the range of all indices of this sequence.
Produces the range of all indices of this sequence.
returns
a Range value from 0 to one less than the length of this NumericString.
def init: String

Selects all elements except the last.
Selects all elements except the last.
returns
a string consisting of all elements of this NumericString except the last one.

Exceptions thrown
UnsupportedOperationException
if the NumericString is empty.
def inits: Iterator[String]

Iterates over the inits of this NumericString.
Iterates over the inits of this NumericString. The first value will be the string for this NumericString and the final one will be an empty string, with the intervening values the results of successive applications of init.
returns
an iterator over all the inits of this NumericString
Example:
1. NumericString("123").inits = Iterator(123, 12, 1, "")
def intern: String

Add this immutable NumericString's String value to the pool of interned strings, so there is only one copy of the string's representation in memory, shared among all instances.
Add this immutable NumericString's String value to the pool of interned strings, so there is only one copy of the string's representation in memory, shared among all instances.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
String which is now in the pool of interned strings
def intersect(that: Seq[Char]): String

Computes the multiset intersection between this NumericString and another sequence.
Computes the multiset intersection between this NumericString and another sequence.
that
the sequence of elements to intersect with.
returns
a new string which contains all elements of this NumericString which also appear in that. If an element value x appears n times in that, then the first n occurrences of x will be retained in the result, but any following occurrences will be omitted.
def isDefinedAt(idx: Int): Boolean

Tests whether this NumericString contains given index.
Tests whether this NumericString contains given index.
idx
the index to test
returns
true if this NumericString contains an element at position idx, false otherwise.
def isEmpty: Boolean

Returns true if NumericString contains no characters (not even whitespace); otherwise returns false.
Returns true if NumericString contains no characters (not even whitespace); otherwise returns false.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
true if NumericString contains no characters (not even whitespace) false otherwise.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterator: Iterator[Char]

Creates a new iterator over all elements contained in this iterable object.
Creates a new iterator over all elements contained in this iterable object.
returns
the new iterator
def last: Char

Selects the last element.
Selects the last element.
returns
The last element of this NumericString.

Exceptions thrown
NoSuchElementException
If the NumericString is empty.
def lastIndexOf(str: String, fromIndex: Int): Int

Returns zero-based index from the beginning of NumericString of the first character position for where the string str fully matched rightmost within NumericString, with search beginning at zero-based fromIndex and proceeding backwards.
Returns zero-based index from the beginning of NumericString of the first character position for where the string str fully matched rightmost within NumericString, with search beginning at zero-based fromIndex and proceeding backwards.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
str
string for comparison
fromIndex
zero-based index of starting position
returns
zero-based integer index of first character position of where str fully matched rightmost within NumericString; -1 if not found
def lastIndexOf(str: String): Int

Returns zero-based index from the beginning of NumericString of the first character position for where the string str fully matched rightmost within NumericString.
Returns zero-based index from the beginning of NumericString of the first character position for where the string str fully matched rightmost within NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
str
string for comparison
returns
zero-based integer index of first character position of where str fully matched rightmost within NumericString; -1 if not found
def lastIndexOf(ch: Int, fromIndex: Int): Int

Returns zero-based index of the final occurrence of the Unicode character ch in the NumericString, with search beginning at zero-based fromIndex and proceeding backwards.
Returns zero-based index of the final occurrence of the Unicode character ch in the NumericString, with search beginning at zero-based fromIndex and proceeding backwards.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
ch
Unicode character for which to search backwards
fromIndex
zero-based index of starting position
returns
zero-based index of the final (rightmost) occurrence of this character in NumericString; -1 if not found
def lastIndexOf(ch: Int): Int

Returns zero-based index of the final occurrence of the Unicode character ch in the NumericString.
Returns zero-based index of the final occurrence of the Unicode character ch in the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
ch
Unicode character for which to search backwards
returns
zero-based integer index of the final occurrence of this character in NumericString; -1 if not found
def lastIndexOfSlice[B >: Char](that: GenSeq[B]): Int

Finds last index where this NumericString contains a given sequence as a slice.
Finds last index where this NumericString contains a given sequence as a slice.
that
the sequence to test
returns
the last index such that the elements of this NumericString starting a this index match the elements of sequence that, or -1 of no such subsequence exists.
def lastIndexOfSlice[B >: Char](that: GenSeq[B], end: Int): Int

Finds last index before or at a given end index where this NumericString contains a given sequence as a slice.
Finds last index before or at a given end index where this NumericString contains a given sequence as a slice.
that
the sequence to test
end
the end index
returns
the last index <= end such that the elements of this NumericString starting at this index match the elements of sequence that, or -1 of no such subsequence exists.
def lastIndexWhere(p: (Char) ⇒ Boolean): Int

Finds index of last element satisfying some predicate.
Finds index of last element satisfying some predicate.
p
the predicate used to test elements.
returns
the index of the last element of this NumericString that satisfies the predicate p, or -1, if none exists.
def lastIndexWhere(p: (Char) ⇒ Boolean, end: Int): Int

Finds index of last element satisfying some predicate before or at given end index.
Finds index of last element satisfying some predicate before or at given end index.
p
the predicate used to test elements.
returns
the index <= end of the last element of this NumericString that satisfies the predicate p, or -1, if none exists.
def lastOption: Option[Char]

Optionally selects the last element.
Optionally selects the last element.
returns
the last element of this NumericString if it is nonempty, None if it is empty.
def length: Int

Returns length of this NumericString in Unicode characters.
Returns length of this NumericString in Unicode characters.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
length of this NumericString
def lengthCompare(len: Int): Int

Compares the length of this NumericString to a test value.
Compares the length of this NumericString 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
```
The method as implemented here does not call length directly; its running time is O(length min len) instead of O(length). The method should be overwritten if computing length is cheap.
def lines: Iterator[String]

Return all lines in this NumericString in an iterator.
Return all lines in this NumericString in an iterator. Always returns a single string for NumericString.
def linesWithSeparators: Iterator[String]

Return all lines in this NumericString in an iterator, including trailing line end characters.
Return all lines in this NumericString in an iterator, including trailing line end characters. Always returns a single string with no endline, for NumericString.
def map(f: (Char) ⇒ Char): String

Builds a new string by applying a function to all elements of this NumericString.
Builds a new string by applying a function to all elements of this NumericString.
f
the function to apply to each element.
returns
a new string resulting from applying the given function f to each character of this NumericString and collecting the results.
def matches(regex: String): Boolean

Returns true if the this NumericString's String value matches the supplied regular expression, regex; otherwise returns false.
Returns true if the this NumericString's String value matches the supplied regular expression, regex; otherwise returns false.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
regex
regular-expression string
returns
true if NumericString content matches supplied regular expression regex; false otherwise.
def max: Char

Finds the largest element.
Finds the largest element.
returns
the largest character of this NumericString.
def maxBy[B](f: (Char) ⇒ B)(implicit cmp: Ordering[B]): Char

Finds the first element which yields the largest value measured by function f.
Finds the first element which yields the largest value measured by function f.
B
The result type of the function f.
f
The measuring function.
cmp
An ordering to be used for comparing elements.
returns
the first element of this NumericString with the largest value measured by function f with respect to the ordering cmp.
def min: Char

Finds the smallest element.
Finds the smallest element.
returns
the smallest element of this NumericString.
def minBy[B](f: (Char) ⇒ B)(implicit cmp: Ordering[B]): Char

Finds the first element which yields the smallest value measured by function f.
Finds the first element which yields the smallest value measured by function f.
B
The result type of the function f.
f
The measuring function.
cmp
An ordering to be used for comparing elements.
returns
the first element of this NumericString with the smallest value measured by function f with respect to the ordering cmp.
def mkString(start: String, sep: String, end: String): String

Displays all elements of this NumericString in a string using start, end, and separator strings.
Displays all elements of this NumericString 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 NumericString. The resulting string begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this NumericString are separated by the string sep.
Example:
1. NumericString("123").mkString("(", "; ", ")") = "(1; 2; 3)"
def mkString(sep: String): String

Displays all elements of this NumericString in a string using a separator string.
Displays all elements of this NumericString in a string using a separator string.
sep
the separator string.
returns
a string representation of this NumericString. In the resulting string the string representations (w.r.t. the method toString) of all elements of this NumericString are separated by the string sep.
Example:
1. NumericString("123").mkString("|") = "1|2|3"
def mkString: String

Displays all elements of this NumericString in a string.
Displays all elements of this NumericString in a string.
returns
a string representation of this NumericString. In the resulting string the string representations (w.r.t. the method toString) of all elements of this NumericString follow each other without any separator string.
def nonEmpty: Boolean

Tests whether the NumericString is not empty.
Tests whether the NumericString is not empty.
returns
true if the NumericString contains at least one element, false otherwise.
def offsetByCodePoints(index: Int, codePointOffset: Int): Int

Returns the "byte distance" required from start of string, to reach the position of the supplied byte index plus the number of codePointOffset points further.
Returns the "byte distance" required from start of string, to reach the position of the supplied byte index plus the number of codePointOffset points further.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
index
byte index of start position in spacing computation
codePointOffset
how many code points to advance (may be variable length per code point)
returns
zero-based offset in bytes from start of NumericString, to reach the designated position
def padTo(len: Int, elem: Char): String

A string copy of this NumericString with an element value appended until a given target length is reached.
A string copy of this NumericString with an element value appended until a given target length is reached.
len
the target length
elem
the padding value
returns
a new string consisting of all elements of this NumericString followed by the minimal number of occurrences of elem so that the resulting string has a length of at least len.
def partition(p: (Char) ⇒ Boolean): (String, String)

Partitions this NumericString in two strings according to a predicate.
Partitions this NumericString in two strings according to a predicate.
returns
a pair of strings -- the first string consists of all elements that satisfy the predicate p and the second string consists of all elements that don't. The relative order of the elements in the resulting strings may not be preserved.
def patch(from: Int, that: GenSeq[Char], replaced: Int): String

Produces a new string where a slice of elements in this NumericString is replaced by another sequence.
Produces a new string where a slice of elements in this NumericString is replaced by another sequence.
from
the index of the first replaced element
replaced
the number of elements to drop in the original NumericString
returns
a new string consisting of all elements of this NumericString except that replaced elements starting from from are replaced by patch.
def permutations: Iterator[String]

Iterates over distinct permutations.
Iterates over distinct permutations.
returns
An Iterator which traverses the distinct permutations of this NumericString.
Example:
1. NumericString("122").permutations = Iterator(122, 212, 221)
def prefixLength(p: (Char) ⇒ Boolean): Int

Returns the length of the longest prefix whose elements all satisfy some predicate.
Returns the length of the longest prefix whose elements all satisfy some predicate.
p
the predicate used to test elements.
returns
the length of the longest prefix of this NumericString such that every element of the segment satisfies the predicate p.
def product[B >: Char](implicit num: Numeric[B]): B

Multiplies up the elements of this collection.
Multiplies up the elements of this collection.
B
the result type of the * operator.
num
an implicit parameter defining a set of numeric operations which includes the * operator to be used in forming the product.
returns
the product of all elements of this NumericString with respect to the * operator in num.
def r: Regex

You can follow a NumericString with .r, turning it into a Regex.
You can follow a NumericString with .r, turning it into a Regex.
This is not particularly useful for a NumericString, given the limitations on its content.
def r(groupNames: String*): Regex

You can follow a NumericString with .r(g1, ... , gn), turning it into a Regex, with group names g1 through gn.
You can follow a NumericString with .r(g1, ... , gn), turning it into a Regex, with group names g1 through gn.
This is not particularly useful for a NumericString, given the limitations on its content.
groupNames
The names of the groups in the pattern, in the order they appear.
def reduce[A1 >: Char](op: (A1, A1) ⇒ A1): A1

Reduces the elements of this NumericString using the specified associative binary operator.
Reduces the elements of this NumericString using the specified associative binary operator.
A1
A type parameter for the binary operator, a supertype of A.
op
A binary operator that must be associative.
returns
The result of applying reduce operator op between all the elements if the NumericString is nonempty.

Exceptions thrown
UnsupportedOperationException
if this NumericString is empty.
def reduceLeft[B >: Char](op: (B, Char) ⇒ B): B

Applies a binary operator to all elements of this NumericString, going left to right.
Applies a binary operator to all elements of this NumericString, going left to right.
B
the result type of the binary operator.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this NumericString, going left to right:
```
op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)
```
where x₁, ..., x_n are the elements of this NumericString.
Exceptions thrown
UnsupportedOperationException
if this NumericString is empty.
def reduceLeftOption[B >: Char](op: (B, Char) ⇒ B): Option[B]

Optionally applies a binary operator to all elements of this NumericString, going left to right.
Optionally applies a binary operator to all elements of this NumericString, going left to right.
B
the result type of the binary operator.
op
the binary operator.
returns
an option value containing the result of reduceLeft(op) if this NumericString is nonempty, None otherwise.
def reduceOption[A1 >: Char](op: (A1, A1) ⇒ A1): Option[A1]

Reduces the elements of this NumericString, if any, using the specified associative binary operator.
Reduces the elements of this NumericString, if any, using the specified associative binary operator.
A1
A type parameter for the binary operator, a supertype of A.
op
A binary operator that must be associative.
returns
An option value containing result of applying reduce operator op between all the elements if the collection is nonempty, and None otherwise.
def reduceRight[B >: Char](op: (Char, B) ⇒ B): B

Applies a binary operator to all elements of this NumericString, going right to left.
Applies a binary operator to all elements of this NumericString, going right to left.
B
the result type of the binary operator.
op
the binary operator.
returns
the result of inserting op between consecutive elements of this NumericString, 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 NumericString.
Exceptions thrown
UnsupportedOperationException
if this NumericString is empty.
def reduceRightOption[B >: Char](op: (Char, B) ⇒ B): Option[B]

Optionally applies a binary operator to all elements of this NumericString, going right to left.
Optionally applies a binary operator to all elements of this NumericString, going right to left.
B
the result type of the binary operator.
op
the binary operator.
returns
an option value containing the result of reduceRight(op) if this NumericString is nonempty, None otherwise.
def regionMatches(toffset: Int, other: String, ooffset: Int, len: Int): Boolean

Returns true if the given region of text matches completely for the len characters beginning at toffset in the NumericString text and at ooffset in the supplied other string text; otherwise returns false.
Returns true if the given region of text matches completely for the len characters beginning at toffset in the NumericString text and at ooffset in the supplied other string text; otherwise returns false.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
toffset
zero-based offset of start point of comparison in NumericString text
other
string supplied for comparison
ooffset
zero-based offset of start point of comparison in other string text
len
length of comparison, in characters
returns
true if region of text matches completely for given length; false otherwise.
def regionMatches(ignoreCase: Boolean, toffset: Int, other: String, ooffset: Int, len: Int): Boolean

Returns true if the given region of text matches completely for the len characters beginning at toffset in the NumericString text and at ooffset in the supplied other string text, with the option to ignoreCase during matching; otherwise returns false.
Returns true if the given region of text matches completely for the len characters beginning at toffset in the NumericString text and at ooffset in the supplied other string text, with the option to ignoreCase during matching; otherwise returns false.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
ignoreCase
if nonzero, comparison ignores case
toffset
zero-based offset of start point of comparison in NumericString text
other
string supplied for comparison
ooffset
zero-based offset of start point of comparison in other string text
len
length of comparison, in characters
returns
true if region of text matches completely for given length; false otherwise.
def replace(target: CharSequence, replacement: CharSequence): String

Returns the new String resulting from replacing all occurrences of CharSequence target with replacement.
Returns the new String resulting from replacing all occurrences of CharSequence target with replacement.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
target
character sequence to replace
replacement
character sequence that will take its place
returns
string resulting from zero or more replacement(s)
def replace(oldChar: Char, newChar: Char): String

Returns the new String resulting from replacing all occurrences of oldChar with newChar.
Returns the new String resulting from replacing all occurrences of oldChar with newChar.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
oldChar
character to replace
newChar
character that will take its place
returns
string resulting from zero or more replacement(s)
def replaceAll(regex: String, replacement: String): String

Returns the new String resulting from replacing all regex string matches with the replacement string.
Returns the new String resulting from replacing all regex string matches with the replacement string.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
regex
regular expression string
replacement
string to replace in place of any regular expression matches in the original NumericString
returns
string resulting from zero or more replacement(s)
def replaceAllLiterally(literal: String, replacement: String): String

Replace all literal occurrences of literal with the string replacement.
Replace all literal occurrences of literal with the string replacement. This is equivalent to java.lang.String#replaceAll except that both arguments are appropriately quoted to avoid being interpreted as metacharacters.
literal
the string which should be replaced everywhere it occurs
replacement
the replacement string
returns
the resulting string
def replaceFirst(regex: String, replacement: String): String

Returns the new String resulting from replacing the first-found regex string match with the replacement string.
Returns the new String resulting from replacing the first-found regex string match with the replacement string.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
regex
regular expression string
replacement
string to replace in place of first regular expression match in the original NumericString
returns
string resulting from zero or one replacement(s)
def reverse: String

Returns new string with elements in reversed order.
Returns new string with elements in reversed order.
returns
A new string with all elements of this NumericString in reversed order.
def reverseIterator: Iterator[Char]

An iterator yielding elements in reversed order.
An iterator yielding elements in reversed order.
Note: xs.reverseIterator is the same as xs.reverse.iterator but might be more efficient.
returns
an iterator yielding the elements of this NumericString in reversed order
def reverseMap[B](f: (Char) ⇒ B): IndexedSeq[B]

Builds a new collection by applying a function to all elements of this NumericString and collecting the results in reversed order.
Builds a new collection by applying a function to all elements of this NumericString and collecting the results in reversed order.
B
the element type of the returned collection.
f
the function to apply to each element.
returns
a new collection resulting from applying the given function f to each element of this NumericString and collecting the results in reversed order.
def sameElements[B >: Char](that: GenIterable[B]): Boolean

Checks if the other iterable collection contains the same elements in the same order as this NumericString.
Checks if the other iterable collection contains the same elements in the same order as this NumericString.
that
the collection to compare with.
returns
true, if both collections contain the same elements in the same order, false otherwise.
def scan(z: Char)(op: (Char, Char) ⇒ Char): String

Computes a prefix scan of the elements of the collection.
Computes a prefix scan of the elements of the collection.
Note: The neutral element z may be applied more than once.
z
neutral element for the operator op
op
the associative operator for the scan
returns
a new string containing the prefix scan of the elements in this NumericString
def scanLeft(z: String)(op: (String, Char) ⇒ String): IndexedSeq[String]

Produces a collection containing cumulative results of applying the operator going left to right.
Produces a collection containing cumulative results of applying the operator going left to right.
z
the initial value
op
the binary operator applied to the intermediate result and the element
returns
collection with intermediate results
def scanRight(z: String)(op: (Char, String) ⇒ String): IndexedSeq[String]

Produces a collection containing cumulative results of applying the operator going right to left.
Produces a collection containing cumulative results of applying the operator going right to left. The head of the collection is the last cumulative result.
z
the initial value
op
the binary operator applied to the intermediate result and the element
returns
collection with intermediate results
def segmentLength(p: (Char) ⇒ Boolean, from: Int): Int

Computes length of longest segment whose elements all satisfy some predicate.
Computes length of longest segment whose elements 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 NumericString starting from index from such that every element of the segment satisfies the predicate p.
def seq: WrappedString

A version of this collection with all of the operations implemented sequentially (i.
A version of this collection with all of the operations implemented sequentially (i.e., in a single-threaded manner).
This method returns a reference to this collection. In parallel collections, it is redefined to return a sequential implementation of this collection. In both cases, it has O(1) complexity.
returns
a sequential view of the collection.
def size: Int

The size of this NumericString.
The size of this NumericString.
returns
the number of elements in this NumericString.
def slice(from: Int, until: Int): String

Selects an interval of elements.
Selects an interval of elements. The returned collection is made up of all elements x which satisfy the invariant:
```
from <= indexOf(x) < until
```
from
the lowest index to include from this NumericString.
until
the lowest index to EXCLUDE from this NumericString.
returns
a string containing the elements greater than or equal to index from extending up to (but not including) index until of this NumericString.
def sliding(size: Int): Iterator[String]

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.) "Sliding window" step is 1 by default.
size
the number of elements per group
returns
An iterator producing strings of size size, except the last and the only element will be truncated if there are fewer elements than size.

See also
scala.collection.Iterator, method sliding
def sliding(size: Int, step: Int): Iterator[String]

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
Groups elements 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 elements per group
step
the distance between the first elements of successive groups
returns
An iterator producing strings of size size, except the last and the only element will be truncated if there are fewer elements than size.

See also
scala.collection.Iterator, method sliding
def sortBy[B](f: (Char) ⇒ B)(implicit ord: Ordering[B]): String

Sorts this NumericString according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.
Sorts this NumericString according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.
B
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 B.
ord
the ordering assumed on domain B.
returns
a string consisting of the elements of this NumericString sorted according to the ordering where x < y if ord.lt(f(x), f(y)).
Example:
1. NumericString("212").sortBy(_.toInt) res13: String = 122
See also
scala.math.Ordering
def sortWith(lt: (Char, Char) ⇒ Boolean): String

Sorts this NumericString according to a comparison function.
Sorts this NumericString according to a comparison function.
The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.
lt
the comparison function which tests whether its first argument precedes its second argument in the desired ordering.
returns
a string consisting of the elements of this NumericString sorted according to the comparison function lt.
Example:
1. NumericString("212").sortWith(_.compareTo(_) < 0) res14: String = 122
def sorted[B >: Char](implicit ord: Ordering[B]): String

Sorts this NumericString according to an Ordering.
Sorts this NumericString 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 sequence as in the original.
ord
the ordering to be used to compare elements.
returns
a string consisting of the elements of this NumericString sorted according to the ordering ord.

See also
scala.math.Ordering
def span(p: (Char) ⇒ Boolean): (String, String)

Splits this NumericString into a prefix/suffix pair according to a predicate.
Splits this NumericString into a prefix/suffix pair according to a predicate.
Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects.
p
the test predicate
returns
a pair of strings consisting of the longest prefix of this NumericString whose elements all satisfy p, and the rest of this NumericString.

def split(separator: Char): Array[String]

Split this NumericString around the separator character

If this NumericString is the empty string, returns an array of strings that contains a single empty string.

If this NumericString is not the empty string, returns an array containing the substrings terminated by the start of the string, the end of the string or the separator character, excluding empty trailing substrings

The behaviour follows, and is implemented in terms of String.split(re: String)

separator: the character used as a delimiter

Example:

scala> NumericString("1234").split('3')
res15: Array[String] = Array(12, 4)
//
//splitting the empty string always returns the array with a single
//empty string
scala> NumericString("").split('3')
res16: Array[String] = Array("")
//
//only trailing empty substrings are removed
scala> NumericString("1234").split('4')
res17: Array[String] = Array(123)
//
scala> NumericString("1234").split('1')
res18: Array[String] = Array("", 234)
//
scala> NumericString("12341").split('1')
res19: Array[String] = Array("", 234)
//
scala> NumericString("11211").split('1')
res20: Array[String] = Array("", "", 2)
//
//all parts are empty and trailing
scala> NumericString("1").split('1')
res21: Array[String] = Array()
//
scala> NumericString("11").split('1')
res22: Array[String] = Array()

def split(separators: Array[Char]): Array[String]

Returns an array of Strings resulting from splitting this NumericString at all points where one of the separators characters is encountered.
Returns an array of Strings resulting from splitting this NumericString at all points where one of the separators characters is encountered.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
separators
array of characters, any of which are valid split triggers
returns
array of strings, after splitting NumericString at all points where one of the separators characters is encountered
def split(regex: String, limit: Int): Array[String]

Returns an array of strings produced by splitting NumericString at up to limit locations matching the supplied regex; the regex-matching characters are omitted from the output.
Returns an array of strings produced by splitting NumericString at up to limit locations matching the supplied regex; the regex-matching characters are omitted from the output.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
regex
string for pattern matching
limit
maximum number of split output strings that will be generated by this function; further potential splits get ignored
returns
array of strings produced by splitting NumericString at every location matching supplied regex, up to limit occurrences
def split(regex: String): Array[String]

Returns an array of strings produced by splitting NumericString at every location matching the supplied regex; the regex-matching characters are omitted from the output.
Returns an array of strings produced by splitting NumericString at every location matching the supplied regex; the regex-matching characters are omitted from the output.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
regex
string for pattern matching
returns
array of strings produced by splitting NumericString at every location matching supplied regex
def splitAt(n: Int): (String, String)

Splits this NumericString into two at a given position.
Splits this NumericString into two at a given position. Note: c splitAt n is equivalent to (but possibly more efficient than) (c take n, c drop n).
n
the position at which to split.
returns
a pair of strings consisting of the first n elements of this NumericString, and the other elements.
def startsWith(prefix: String, toffset: Int): Boolean

Returns true if the NumericString content completely matches the supplied prefix, starting at toffset characters in the NumericString.
Returns true if the NumericString content completely matches the supplied prefix, starting at toffset characters in the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
prefix
string for comparison as prefix
toffset
zero-based integer start point for comparison within the NumericString
returns
true if NumericString content is the same as prefix for the entire length of prefix shifted over, false otherwise.
def startsWith(prefix: String): Boolean

Returns true if the NumericString content completely matches the supplied prefix, when both strings are aligned at their startpoints up to the length of prefix.
Returns true if the NumericString content completely matches the supplied prefix, when both strings are aligned at their startpoints up to the length of prefix.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
prefix
string for comparison as prefix
returns
true if NumericString content is the same as prefix for the entire length of prefix false otherwise.
def stringPrefix: String

Defines the prefix of this object's toString representation.
Defines the prefix of this object's toString representation.
returns
a string representation which starts the result of toString applied to this NumericString. By default the string prefix is the simple name of the collection class NumericString.
def stripLineEnd: String

Strip trailing line end character from this string if it has one.
Strip trailing line end character from this string if it has one.
A line end character is one of
- LF - line feed (0x0A hex)
- FF - form feed (0x0C hex)
If a line feed character LF is preceded by a carriage return CR (0x0D hex), the CR character is also stripped (Windows convention).
def stripMargin(marginChar: Char): String

Strip a leading prefix consisting of blanks or control characters followed by marginChar from the line.
def stripMargin: String

Strip a leading prefix consisting of blanks or control characters followed by | from the line.
def stripPrefix(prefix: String): String

Returns this NumericString as a string with the given prefix stripped.
Returns this NumericString as a string with the given prefix stripped. If this NumericString does not start with prefix, it is returned unchanged.
def stripSuffix(suffix: String): String

Returns this NumericString as a string with the given suffix stripped.
Returns this NumericString as a string with the given suffix stripped. If this NumericString does not end with suffix, it is returned unchanged.
def subSequence(beginIndex: Int, endIndex: Int): CharSequence

Returns the character sequence extracted from NumericString beginning at zero-based offset beginIndex and continuing until (but not including) offset endIndex.
Returns the character sequence extracted from NumericString beginning at zero-based offset beginIndex and continuing until (but not including) offset endIndex.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
beginIndex
zero-based integer offset at which character extraction begins
endIndex
zero-based integer offset before which character extraction ends
returns
CharSequence of zero or more extracted characters
def substring(beginIndex: Int, endIndex: Int): String

Returns a string extracted NumericString starting from the zero-based beginIndex through but not including the zero-based endIndex offset.
Returns a string extracted NumericString starting from the zero-based beginIndex through but not including the zero-based endIndex offset.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
beginIndex
zero-based integer offset at which substring extraction begins
endIndex
zero-based integer offset before which substring extraction ends
returns
returns string extracted from NumericString
def substring(beginIndex: Int): String

Returns a string extracted from NumericString from the zero-based beginIndex through the end of the string.
Returns a string extracted from NumericString from the zero-based beginIndex through the end of the string.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
beginIndex
zero-based integer offset at which substring extraction begins (continues through end of NumericIndex string)
returns
returns string extracted from NumericString
def sum[B >: Char](implicit num: Numeric[B]): B

Sums up the elements of this collection.
Sums up the elements of this collection.
returns
the sum of all character values in this NumericString
def tail: String

Selects all elements except the first.
Selects all elements except the first.
returns
a string consisting of all elements of this NumericString except the first one.

Exceptions thrown
UnsupportedOperationException
if the NumericString is empty.
def tails: Iterator[String]

Iterates over the tails of this NumericString.
Iterates over the tails of this NumericString. The first value will be this NumericString as a string and the final one will be an empty string, with the intervening values the results of successive applications of tail.
returns
an iterator over all the tails of this NumericString
Example:
1. scala> NumericString("123").tails.toList res31: List[String] = List(123, 23, 3, "")
def take(n: Int): String

Selects first n elements.
Selects first n elements.
n
the number of elements to take from this NumericString.
returns
a string consisting only of the first n elements of this NumericString, or else the whole NumericString, if it has less than n elements.
def takeRight(n: Int): String

Selects last n elements.
Selects last n elements.
n
the number of elements to take
returns
a string consisting only of the last n elements of this NumericString, or else the whole NumericString, if it has less than n elements.
def takeWhile(p: (Char) ⇒ Boolean): String

Takes longest prefix of elements that satisfy a predicate.
Takes longest prefix of elements that satisfy a predicate.
p
The predicate used to test elements.
returns
the longest prefix of this NumericString whose elements all satisfy the predicate p.
def toArray: Array[Char]

Converts this NumericString to an array.
Converts this NumericString to an array.
returns
an array containing all elements of this NumericString.
def toBuffer[A1 >: Char]: Buffer[A1]

Uses the contents of this NumericString to create a new mutable buffer.
Uses the contents of this NumericString to create a new mutable buffer.
returns
a buffer containing all elements of this NumericString.
def toByte: Byte

Parse as a Byte
Parse as a Byte

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Byte.
def toCharArray: Array[Char]

Returns an array of Unicode characters corresponding to the NumericString.
Returns an array of Unicode characters corresponding to the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
array of Unicode characters corresponding to the NumericString
def toDouble: Double

Parse as a Double.
Parse as a Double.

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Double.
def toFloat: Float

Parse as a Float.
Parse as a Float.

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Float.
def toIndexedSeq: IndexedSeq[Char]

Converts this NumericString to an indexed sequence.
Converts this NumericString to an indexed sequence.
returns
an indexed sequence containing all elements of this NumericString.
def toInt: Int

Parse as an Int
Parse as an Int

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Int.
def toIterable: Iterable[Char]

Converts this NumericString to an iterable collection.
Converts this NumericString to an iterable collection.
returns
an Iterable containing all elements of this NumericString.
def toIterator: Iterator[Char]

Returns an Iterator over the elements in this NumericString.
Returns an Iterator over the elements in this NumericString.
returns
an Iterator containing all elements of this NumericString.
def toList: List[Char]

Converts this NumericString to a list.
Converts this NumericString to a list.
returns
a list containing all elements of this NumericString.
def toLong: Long

Parse as a Long.
Parse as a Long.

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Long.
def toSeq: Seq[Char]

Converts this NumericString to a sequence.
Converts this NumericString to a sequence.
returns
a sequence containing all elements of this NumericString.
def toSet[B >: Char]: Set[B]

Converts this NumericString to a set.
Converts this NumericString to a set.
returns
a set containing all elements of this NumericString.
def toShort: Short

Parse as a Short.
Parse as a Short.

Exceptions thrown
java.lang.NumberFormatException
If the string does not contain a parsable Short.
def toStream: Stream[Char]

Converts this NumericString to a stream.
Converts this NumericString to a stream.
returns
a stream containing all elements of this NumericString.
def toString(): String

A string representation of this NumericString.
A string representation of this NumericString.

Definition Classes
NumericString → Any
def toVector: Vector[Char]

Converts this NumericString to a Vector.
Converts this NumericString to a Vector.
returns
a vector containing all elements of this NumericString.
def trim: String

Return new string resulting from removing any whitespace characters from the start and end of the NumericString.
Return new string resulting from removing any whitespace characters from the start and end of the NumericString.
For more detail, see the documentation for the corresponding method in the Javadoc documentation for java.lang.String.
returns
string resulting from removing any whitespace characters from start and end of original string
def union(that: Seq[Char]): String

Produces a new sequence which contains all elements of this NumericString and also all elements of a given sequence.
Produces a new sequence which contains all elements of this NumericString and also all elements of a given sequence. xs union ys is equivalent to xs ++ ys.
Another way to express this is that xs union ys computes the order-preserving multi-set union of xs and ys. union is hence a counter-part of diff and intersect which also work on multi-sets.
returns
a new string which contains all elements of this NumericString followed by all elements of that.
def updated(index: Int, elem: NumericChar): NumericString

A copy of this NumericString with one single replaced element.
A copy of this NumericString with one single replaced element.
index
the position of the replacement
elem
the replacing element
returns
a string copy of this NumericString with the element at position index replaced by elem.

Exceptions thrown
IndexOutOfBoundsException
if index does not satisfy 0 <= index < length.
val value: String

The String value underlying this NumericString.
The String value underlying this NumericString.
def view: SeqView[Char, String]

Creates a non-strict view of this NumericString.
Creates a non-strict view of this NumericString.
returns
a non-strict view of this NumericString.
def withFilter(p: (Char) ⇒ Boolean): FilterMonadic[Char, String]

Creates a non-strict filter of this NumericString.
Creates a non-strict filter of this NumericString.
Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations.
p
the predicate used to test elements.
returns
an object of class WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this NumericString which satisfy the predicate p.
def zip[B](that: Iterable[B]): Iterable[(Char, B)]

Returns a Iterable of pairs formed from this NumericString and another iterable collection by combining corresponding elements in pairs.
Returns a Iterable of pairs formed from this NumericString and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
B
the type of the second half of the returned pairs
that
The iterable providing the second half of each result pair
returns
a collection containing pairs consisting of corresponding elements of this NumericString and that. The length of the returned collection is the minimum of the lengths of this NumericString and that.
def zipAll[A1 >: Char, B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]

Returns a collection of pairs formed from this NumericString and another iterable collection by combining corresponding elements in pairs.
Returns a collection of pairs formed from this NumericString and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
B
the type of the second half of the returned pairs
that
the iterable providing the second half of each result pair
thisElem
the element to be used to fill up the result if this NumericString is shorter than that.
thatElem
the element to be used to fill up the result if that is shorter than this NumericString.
returns
a new Iterable consisting of corresponding elements of this NumericString and that. The length of the returned collection is the maximum of the lengths of this NumericString and that. If this NumericString is shorter than that, thisElem values are used to pad the result. If that is shorter than this NumericString, thatElem values are used to pad the result.
def zipWithIndex: Iterable[(Char, Int)]

Zips this NumericString with its indices.
Zips this NumericString with its indices.
returns
A new Iterable containing pairs consisting of all characters of this NumericString paired with their index. Indices start at 0.
Example:
1. scala> NumericString("123").zipWithIndex res41: scala.collection.immutable.IndexedSeq[(Char, Int)] = Vector((1,0), (2,1), (3,2))

final class NumericString extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(n: Int): NumericString

def ++(that: String): String

def ++:(that: String): String

def +:(elem: Char): String

def /:(z: Int)(op: (Int, Char) ⇒ Int): Int

def :+(elem: Char): String

def :\(z: Int)(op: (Char, Int) ⇒ Int): Int

def <(that: String): Boolean

def <=(that: String): Boolean

final def ==(arg0: Any): Boolean

def >(that: String): Boolean

def >=(that: String): Boolean

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

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

def addString(b: StringBuilder): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, Char) ⇒ B, combop: (B, B) ⇒ B): B

def apply(index: Int): Char

final def asInstanceOf[T0]: T0

def canEqual(that: Any): Boolean

def capitalize: String

def charAt(index: Int): Char

def codePointAt(index: Int): Int

def codePointBefore(index: Int): Int

def codePointCount(beginIndex: Int, endIndex: Int): Int

def collect(pf: PartialFunction[Char, Char]): String

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

def combinations(n: Int): Iterator[String]

def compare(that: String): Int

def compareTo(anotherString: String): Int

def concat(str: String): String

def concatNumericString(that: NumericString): NumericString

def contains(s: CharSequence): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def contentEquals(cs: CharSequence): Boolean

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

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

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

def copyToBuffer[B >: Char](dest: Buffer[B]): Unit

def corresponds[B](that: GenSeq[B])(p: (Char, B) ⇒ Boolean): Boolean

def count(p: (Char) ⇒ Boolean): Int

def diff(that: Seq[Char]): String

def distinct: String

def drop(n: Int): String

def dropRight(n: Int): String

def dropWhile(p: (Char) ⇒ Boolean): String

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

def endsWith(suffix: String): Boolean

def ensuringValid(f: (String) ⇒ String): NumericString

def equalsIgnoreCase(arg0: String): Boolean

def exists(p: (Char) ⇒ Boolean): Boolean

def filter(p: (Char) ⇒ Boolean): String

def filterNot(p: (Char) ⇒ Boolean): String

def find(p: (Char) ⇒ Boolean): Option[Char]

def flatMap[B](f: (Char) ⇒ IterableOnce[B]): IndexedSeq[B]

def fold[A1 >: Char](z: A1)(op: (A1, A1) ⇒ A1): A1

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

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

def forall(p: (Char) ⇒ Boolean): Boolean

def foreach(f: (Char) ⇒ Unit): Unit

def getBytes(charsetName: String): Array[Byte]

def getBytes(charset: Charset): Array[Byte]

def getBytes: Array[Byte]

def getChars(srcBegin: Int, srcEnd: Int, dst: Array[Char], dstBegin: Int): Unit

def getClass(): Class[_ <: AnyVal]

def groupBy[K](f: (Char) ⇒ K): Map[K, String]

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

def hasDefiniteSize: Boolean

def head: Char

def headOption: Option[Char]

def indexOf(str: String, fromIndex: Int): Int

def indexOf(str: String): Int

def indexOf(ch: Int, fromIndex: Int): Int

def indexOf(ch: Int): Int

def indexOfSlice[B >: Char](that: GenSeq[B]): Int

def indexOfSlice[B >: Char](that: GenSeq[B], from: Int): Int