Класс scala.collection.immutable.WrappedString

@SerialVersionUID(3L)

final class WrappedString(self: String) extends AbstractSeq[Char] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, WrappedString] with Serializable

Этот класс служит оболочкой, дополняющей String всеми операциями, которые есть у индексированных последовательностей.

Разница между этим классом и StringOps заключается в том, что вызов методов трансформации, таких как filter и map, вернёт объект типа WrappedString, а не String.

Конкретные методы

Исходный код

override def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

Исходный код

def apply(i: Int): Char

Исходный код

override def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int

Исходный код

override def empty: WrappedString

Исходный код

override def endsWith[B >: Char](that: Iterable[B]): Boolean

Исходный код

override def equals(other: Any): Boolean

Source

override def indexOf[B >: Char](elem: B, from: Int): Int

Source

override def lastIndexOf[B >: Char](elem: B, end: Int): Int

Source

override def length: Int

Source

override def sameElements[B >: Char](o: IterableOnce[B]): Boolean

Source

override def slice(from: Int, until: Int): WrappedString

Source

override def startsWith[B >: Char](that: IterableOnce[B], offset: Int): Boolean

Source

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S & EfficientSplit

Source

override def toString: String

Источник

def unwrap: String

Источник

override def view: StringView

Наследованные методы

Источник@inline

final def ++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для concat

Источник@inline

final override def ++:[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для prependedAll

Источник@inline

final def +:[B >: Char](elem: B): IndexedSeq[B]

Псевдоним для prepended.

Обратите внимание, что операторы с окончанием «:» являются правоассоциативными (см. пример). Мнемоника для +: по сравнению с :+ заключается в том, что двоеточие ставится с «коллекцией».

Источник@inline

final def :+[B >: Char](elem: B): IndexedSeq[B]

Псевдоним для appended

Обратите внимание, что операторы с окончанием «:» являются правоассоциативными (см. пример). Мнемоника для +: по сравнению с :+ заключается в том, что двоеточие ставится с «коллекцией».

Источник@inline

final def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

Псевдоним для appendedAll

Источник@inline

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строковый буфер. Записываемый текст состоит из строковых представлений (с учётом метода toString) всех элементов этой коллекции без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Источник@inline

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

Добавляет все элементы этой коллекции в строковый буфер с использованием разделительной строки. Записываемый текст состоит из строковых представлений (с учётом метода toString) всех элементов этой коллекции, разделённых строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Источник

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

Добавляет все элементы этой коллекции в строковый буфер с использованием начальной, конечной и разделительной строк. Записываемый текст начинается со строки start и заканчивается строкой end. Внутри, строковые представления (с учётом метода toString) всех элементов этой коллекции разделяются строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Источник

def andThen[C](k: PartialFunction[Char, C]): PartialFunction[Int, C]

Компонует эту частичную функцию с другой частичной функцией, которая применяется к результатам этой частичной функции.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Источник

override def andThen[C](k: Char => C): PartialFunction[Int, C]

Компонует эту частичную функцию с функцией преобразования, которая применяется к результатам этой частичной функции.

Если тип функции во время выполнения является PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

Источник

def appended[B >: Char](elem: B): IndexedSeq[B]

Копия этой последовательности с добавленным элементом.

Примечание: не завершится для последовательностей бесконечного размера.

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Источник

def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: A1 => B1): B1

Применяет эту частичную функцию к заданному аргументу, когда он содержится в области определения функции. Применяет функцию обратного вызова, когда эта частичная функция не определена.

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех литералов частичных функций компилятор генерирует реализацию applyOrElse, которая избегает двойного вычисления соответствий с образцом и защитных условий. Это делает applyOrElse основой для эффективной реализации многих операций и сценариев, таких как:

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерному вычислению apply/isDefinedAt - lift и unlift не вычисляют исходные функции дважды при каждом вызове - runWith позволяет эффективно комбинировать частичные функции в императивном стиле с применением действий при определенных условиях

Для классов частичных функций, которые не являются литералами, и у которых метод isDefinedAt имеет нетривиальную реализацию, рекомендуется переопределить метод applyOrElse с пользовательской реализацией, которая избегает двойного вычисления isDefinedAt. Это может привести к улучшению производительности и более предсказуемому поведению относительно побочных эффектов.

Источник

override def canEqual(that: Any): Boolean

Источник

def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]

Источник

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

Находит первый элемент в коллекции, для которого заданная частичная функция определена, и применяет частичную функцию к нему.

Примечание: может не завершиться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Источник

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

Итерируется по комбинациям. _Комбинация_ длины n — это подпоследовательность исходной последовательности, с элементами, взятыми в порядке следования. Таким образом, "xy" и "yy" — обе комбинации длины 2 из "xyy", но "yx" таковой не является. Если существует более одного способа сгенерировать одну и ту же подпоследовательность, будет возвращена только одна.

Например, "xyyy" имеет три различных способа сгенерировать "xy" в зависимости от того, какой первый, второй или третий "y" был выбран. Однако, так как все они идентичны, будет выбран только один. Какой из трёх будет выбран — это деталь реализации, которая не определена.

Примечание: даже при применении к представлению или ленивой коллекции все элементы будут всегда принудительно вычислены.

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Char]

Компонует другую частичную функцию k с этой частичной функцией таким образом, что эта частичная функция применяется к результатам k.

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется вызывать applyOrElse вместо isDefinedAt или apply.

Источник@unspecialized

def compose[A](g: A => Int): A => Char

Компонует две части Function1 в новую Function1, где эта функция применяется последней.

Источник@inline

final override def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]

Источник

def contains[A1 >: Char](elem: A1): Boolean

Проверяет, содержит ли эта последовательность заданное значение в качестве элемента.

Примечание: может не завершиться для коллекций бесконечного размера.

Источник

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

Проверяет, содержит ли эта последовательность заданную последовательность в качестве слайса.

Примечание: может не завершиться для коллекций бесконечного размера.

Источник@deprecatedOverriding("Это всегда должно пересылать в 3-аргументную версию этого метода", since = "2.13.4")

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

Копирование элементов в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs, начиная с индекса start, значениями этой коллекции.

Копирование завершится, как только будут скопированы все элементы этой коллекции или будет достигнут конец массива.

Источник@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")

def copyToArray[B >: Char](xs: Array[B]): Int

Копирование элементов в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs, начиная с индекса start, значениями этой коллекции.

Копирование завершится, как только будут скопированы все элементы этой коллекции или будет достигнут конец массива.

Источник

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

Проверяет, соответствует ли каждый элемент этой последовательности соответствующему элементу другой последовательности, удовлетворяя предикату теста.

Источник

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

Проверяет, соответствует ли каждый элемент итератора этой коллекции соответствующему элементу другой коллекции, удовлетворяя предикату теста.

Примечание: не завершится для коллекций бесконечного размера.

Source

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

Подсчитывает количество элементов в коллекции, удовлетворяющих предикату.

Примечание: не завершится для коллекций бесконечного размера.

Source

def diff[B >: Char](that: Seq[B]): WrappedString

Вычисляет разность множеств между этой последовательностью и другой последовательностью.

Source

def distinct: WrappedString

Выбирает все элементы этой последовательности, игнорируя дубликаты.

Source

def distinctBy[B](f: Char => B): WrappedString

Выбирает все элементы этой последовательности, игнорируя дубликаты, как определено == после применения преобразующей функции f.

Source

override def drop(n: Int): WrappedString

Source

override def dropRight(n: Int): WrappedString

Source

def dropWhile(p: Char => Boolean): WrappedString

Source

def elementWise: ElementWiseExtractor[Int, Char]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Source

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

Проверяет, выполняется ли предикат хотя бы для одного элемента этого набора.

Примечание: может не завершиться для коллекций бесконечного размера.

Source

def filter(pred: Char => Boolean): WrappedString

Source

def filterNot(pred: Char => Boolean): WrappedString

Source

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

Находит первый элемент в коллекции, удовлетворяющий предикату, если таковой существует.

Примечание: может не завершиться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Source

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

Находит последний элемент в последовательности, удовлетворяющий предикату, если таковой существует.

Примечание: не завершится для коллекций бесконечного размера.

Source

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

Source

def flatten[B](implicit asIterable: Char => IterableOnce[B]): IndexedSeq[B]

Source

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

Складывает элементы этой коллекции с использованием заданного ассоциативного бинарного оператора. Реализация по умолчанию в IterableOnce эквивалентна foldLeft, но может быть переопределена для более эффективных порядков обхода.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Примечание: не завершится для коллекций бесконечного размера.

Source

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

Применяет бинарный оператор к начальному значению и всем элементам этой коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если только тип базовой коллекции не упорядочен или оператор не является ассоциативным и коммутативным.

Source

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

Source

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

Проверяет, выполняется ли предикат для всех элементов этой коллекции.

Примечание: может не завершиться для коллекций бесконечного размера.

Source

def foreach[U](f: Char => U): Unit

Применяет f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи в выводе типов scalac.

Source

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

Разбивает эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с некоторой функцией-дискриминатором.

Примечание: Даже при применении к представлению или ленивому набору он всегда будет принудительно вызывать элементы.

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Исходный код

def groupMap[K, B](key: Char => K)(f: Char => B): Map[K, IndexedSeq[B]]

Разделяет этот итерируемый набор на карту итерируемых наборов в соответствии с функцией-дискриминатором key. Каждый элемент в группе преобразуется в значение типа B с помощью функции value.

Это эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

Примечание: Даже при применении к представлению или ленивому набору он всегда будет принудительно вызывать элементы.

Исходный код

def groupMapReduce[K, B](key: Char => K)(f: Char => B)(reduce: (B, B) => B): Map[K, B]

Разделяет этот итерируемый набор на карту в соответствии с функцией-дискриминатором key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются с помощью функции f, а затем сводятся к одному значению с помощью функции reduce.

Это эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

Примечание: Даже при применении к представлению или ленивому набору он всегда будет принудительно вызывать элементы.

Исходный код

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

Разделяет элементы на итерируемые наборы фиксированного размера.

Исходный код

override def hashCode(): Int

Исходный код

override def head: Char

Исходный код

override def headOption: Option[Char]

Исходный код@deprecatedOverriding("Override indexOf(elem, from) instead - indexOf(elem) calls indexOf(elem, 0)", "2.13.0")

def indexOf[B >: Char](elem: B): Int

Находит индекс первого вхождения некоторого значения в эту последовательность.

Исходный код@deprecatedOverriding("Override indexOfSlice(that, from) instead - indexOfSlice(that) calls indexOfSlice(that, 0)", "2.13.0")

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

Находит первый индекс, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для бесконечных коллекций.

Исходный код

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

Находит первый индекс после или на стартовом индексе, где эта последовательность содержит заданную последовательность как срез.

Примечание: может не завершаться для бесконечных коллекций.

Исходный код@deprecatedOverriding("Override indexWhere(p, from) instead - indexWhere(p) calls indexWhere(p, 0)", "2.13.0")

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

Находит индекс первого элемента, удовлетворяющего некоторому предикату.

Примечание: может не завершаться для бесконечных коллекций.

Исходный код

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

Находит индекс первого элемента, удовлетворяющего некоторому предикату после или на некотором стартовом индексе.

Примечание: может не завершаться для бесконечных коллекций.

Источник

def indices: Range

Создаёт диапазон всех индексов этой последовательности.

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно вычислять элементы.

Источник

def init: WrappedString

Первая часть коллекции без её последнего элемента.

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно вычислять элементы.

Источник

def inits: Iterator[WrappedString]

Итерируется по начальным частям (inits) этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее — пустой итерируемой коллекцией. Промежуточные значения — результаты последовательного применения init.

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно вычислять элементы.

Источник

def intersect[B >: Char](that: Seq[B]): WrappedString

Вычисляет пересечение множеств элементов этой последовательности и другой последовательности.

Источник

def isDefinedAt(idx: Int): Boolean

Проверяет, содержит ли эта последовательность данный индекс.

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

Источник

override def isEmpty: Boolean

Источник

override def isTraversableAgain: Boolean

Источник

override def iterableFactory: SeqFactory[IndexedSeq]

Источник

def iterator: Iterator[Char]

Источник

override def knownSize: Int

Источник

override def last: Char

Источник@deprecatedOverriding("Override lastIndexOfSlice(that, end) instead - lastIndexOfSlice(that) calls lastIndexOfSlice(that, Int.MaxValue)", "2.13.0")

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

Находит последний индекс, где эта последовательность содержит заданную последовательность в виде слайса.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник

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

Находит последний индекс до или на заданном конечном индексе, где эта последовательность содержит заданную последовательность в виде слайса.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник@deprecatedOverriding("Override lastIndexWhere(p, end) instead - lastIndexWhere(p) calls lastIndexWhere(p, Int.MaxValue)", "2.13.0")

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

Находит индекс последнего элемента, удовлетворяющего некоторому предикату.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

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

Находит индекс последнего элемента, удовлетворяющего некоторому предикату перед или в указанном индексе.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

def lastOption: Option[Char]

Выбирает последний элемент необязательно.

Примечание: может возвращать разные результаты для разных запусков, если только тип базовой коллекции не упорядочен.

Исходный код

def lazyZip[B](that: Iterable[B]): LazyZip2[Char, B, WrappedString]

Аналогично zip, за исключением того, что элементы в каждой коллекции не потребляются до тех пор, пока на возвращенном декораторе LazyZip2 не будет вызвано строгое действие.

Вызовы lazyZip могут быть объединены для поддержки более высоких арностей (до 4) без дополнительных затрат на создание и деконструирование промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Исходный код

final override def lengthCompare(that: Iterable[_]): Int

Исходный код

final override def lengthCompare(len: Int): Int

Исходный код@inline

final def lengthIs: SizeCompareOps

Возвращает значение класса, содержащего операции для сравнения длины этой последовательности со значением теста.

Эти операции реализуются с помощью lengthCompare(Int) и позволяют использовать следующие более удобочитаемые выражения:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Исходный код

def lift: Int => Option[Char]

Преобразует эту частичную функцию в обычную функцию, возвращающую Option результат.

Исходный код

override def map[B](f: Char => B): IndexedSeq[B]

Исходный код

def max[B >: Char](implicit ord: Ordering[B]): Char

Находит наибольший элемент.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

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

Находит первый элемент, который дает наибольшее значение, измеренное функцией f.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

def maxByOption[B](f: Char => B)(implicit cmp: Ordering[B]): Option[Char]

Находит первый элемент, который дает наибольшее значение, измеренное функцией f.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

def maxOption[B >: Char](implicit ord: Ordering[B]): Option[Char]

Находит наибольший элемент.

Примечание: не будет завершаться для коллекций бесконечного размера.

Исходный код

def min[B >: Char](implicit ord: Ordering[B]): Char

Находит наименьший элемент.

Примечание: не завершится для наборов бесконечного размера.

Исходный код

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

Находит первый элемент, который дает наименьшее значение, измеряемое функцией f.

Примечание: не завершится для наборов бесконечного размера.

Исходный код

def minByOption[B](f: Char => B)(implicit cmp: Ordering[B]): Option[Char]

Находит первый элемент, который дает наименьшее значение, измеряемое функцией f.

Примечание: не завершится для наборов бесконечного размера.

Исходный код

def minOption[B >: Char](implicit ord: Ordering[B]): Option[Char]

Находит наименьший элемент.

Примечание: не завершится для наборов бесконечного размера.

Исходный код@inline

final def mkString: String

Отображает все элементы этого набора в строке.

Делегируется addString, который можно переопределить.

Исходный код@inline

final def mkString(sep: String): String

Отображает все элементы этого набора в строке с использованием разделительной строки.

Делегируется addString, который можно переопределить.

Исходный код

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

Отображает все элементы этого набора в строке с использованием начальной, конечной и разделительной строк.

Делегируется addString, который можно переопределить.

Исходный код@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")

def nonEmpty: Boolean

Проверяет, не пуст ли набор.

Исходный код

def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Компонует эту частичную функцию с частичной функцией-заместителем, которая применяется в тех случаях, когда эта частичная функция не определена.

Исходный код

def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]

Копия этого набора с добавленным элементом, пока не будет достигнута заданная целевая длина.

Источник

def partition(p: Char => Boolean): (WrappedString, WrappedString)

Пара, где первый элемент — все элементы, удовлетворяющие предикату p, а второй — все элементы, которые не удовлетворяют ему. Интересно, потому что разбивает коллекцию на две части.

Указанная здесь реализация по умолчанию должна пройтись по коллекции дважды. Строгие коллекции имеют переопределённую версию partition в StrictOptimizedIterableOps, которая требует только одного прохода.

Источник

def partitionMap[A1, A2](f: Char => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])

Применяет функцию f к каждому элементу итерируемой коллекции и возвращает пару итерируемых коллекций: первая содержит значения, возвращённые f и заключённые в scala.util.Left, а вторая — значения, заключённые в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Источник

def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]

Создаёт новую последовательность, где фрагмент элементов в этой последовательности заменяется другой последовательностью.

Замена по отрицательным индексам эквивалентна замене, начинающейся с 0. Замена по индексам, равным или большим длины исходной последовательности, добавляет замену в конец. Если заменяется больше значений, чем фактически существует, избыток игнорируется.

Источник

def permutations: Iterator[WrappedString]

Итерирует по различным перестановкам.

Примечание: даже когда применяется к представлению или ленивой коллекции, она всегда форсирует элементы.

Источник

override def prepended[B >: Char](elem: B): IndexedSeq[B]

Источник

def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]

Так же, как и :++, возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда.

Отличается от :++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мемоирическое правило: двоеточие стоит со стороны нового типа коллекции.

Источник

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

Умножает элементы этой коллекции.

Примечание: не завершится для коллекций бесконечного размера.

Источник

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

Сводит элементы этой коллекции с помощью указанной ассоциативной бинарной операции.

Порядок выполнения операций над элементами не определён и может быть не детерминированным.

Источник

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

Применяет бинарную операцию ко всем элементам этой коллекции слева направо.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип основной коллекции не упорядочен или оператор не ассоциативен и коммутативен.

Source

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

Возвращает значение, полученное при применении бинарного оператора ко всем элементам коллекции слева направо, если коллекция непуста, иначе None.

Примечание: не завершится для коллекций бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип коллекции не упорядочен или оператор не ассоциативен и коммутативен.

Source

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

Применяет указанный ассоциативный бинарный оператор ко всем элементам коллекции (если таковые имеются).

Порядок выполнения операций над элементами не определен и может быть недетерминированным.

Source

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

Применяет бинарный оператор ко всем элементам коллекции справа налево.

Примечание: не завершится для коллекций бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип коллекции не упорядочен или оператор не ассоциативен и коммутативен.

Source

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

Возвращает значение Option, полученное при применении бинарного оператора ко всем элементам коллекции справа налево, если коллекция непуста, иначе None.

Примечание: не завершится для коллекций бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип коллекции не упорядочен или оператор не ассоциативен и коммутативен.

Source

override def reverse: WrappedString

Source

override def reverseIterator: Iterator[Char]

Source

override protected def reversed: Iterable[Char]

Source

def runWith[U](action: Char => U): Int => Boolean

Компонует эту частичную функцию с функцией действия, которая применяется к результатам этой частичной функции. Функция действия вызывается только для побочных эффектов; её результат игнорируется.

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

за исключением того, что runWith реализовано через applyOrElse и, следовательно, потенциально более эффективно. Использование runWith позволяет избежать двойного вычисления совпадений с шаблонами и условий для частичных функций-литералов.

Source

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

Вычисляет префиксное сканирование элементов коллекции.

Примечание: нейтральный элемент z может применяться более одного раза.

Source

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

Source

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

Создаёт коллекцию, содержащую кумулятивные результаты применения оператора справа налево. Голова коллекции — это последний кумулятивный результат.

Примечание: не завершится для коллекций бесконечного размера.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Примечание: даже при применении к представлению или ленивой коллекции всегда будет принудительно вычислять элементы.

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

Исходный код

override def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

Исходный код

override def search[B >: Char](elem: B)(implicit ord: Ordering[B]): SearchResult

Исходный код

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

Вычисляет длину самой длинной последовательности, начинающейся с определенного индекса, элементы которой удовлетворяют заданному предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

Исходный код

final def segmentLength(p: Char => Boolean): Int

Вычисляет длину самой длинной последовательности, начинающейся с первого элемента, элементы которой удовлетворяют заданному предикату.

Примечание: может не завершиться для коллекций бесконечного размера.

Исходный код

final override def size: Int

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

Исходный код

final override def sizeCompare(otherSize: Int): Int

Исходный код@inline

final def sizeIs: SizeCompareOps

Возвращает значение, содержащее операции для сравнения размера этой итерируемой коллекции с тестовым значением.

Эти операции реализованы с помощью sizeCompare(Int) и позволяют использовать более удобочитаемые выражения:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Исходный код

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

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разделения на части, как в grouped.)

Возвращаемый итератор будет пустым при вызове на пустой коллекции. Последний элемент, который производит итератор, может быть меньше размера окна, если исходная коллекция не исчерпана окном до конца и ее последний элемент не пропущен шагом перед ним.

Исходный код

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

Группирует элементы в блоки фиксированного размера, перемещая "скользящее окно" по ним (в отличие от разделения на части, как в grouped.)

Пустая коллекция возвращает пустой итератор, а ненулевая коллекция, содержащая меньше элементов, чем размер окна, возвращает итератор, который произведёт исходную коллекцию как свой единственный элемент.

Исходный код

def sortBy[B](f: Char => B)(implicit ord: Ordering[B]): WrappedString

Сортирует эту последовательность в соответствии с упорядочиванием, полученным из преобразования заданного неявно упорядочивания с помощью функции преобразования.

Примечание: не завершается для коллекций бесконечного размера.

Примечание: даже при применении к представлению или ленивой коллекции всегда будет принудительно обрабатывать элементы.

Сортировка стабильна. То есть, элементы, которые равны (как определяется ord.compare), отображаются в том же порядке в отсортированной последовательности, что и в исходной.

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Исходный код

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

Сортирует эту последовательность в соответствии с функцией сравнения.

Примечание: не будет завершаться для коллекций бесконечного размера.

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно форсировать элементы.

Сортировка является стабильной. То есть элементы, которые равны (как определено lt), появляются в том же порядке в отсортированной последовательности, что и в оригинальной.

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

def sorted[B >: Char](implicit ord: Ordering[B]): WrappedString

Сортирует эту последовательность в соответствии с Ordering.

Сортировка является стабильной. То есть элементы, которые равны (как определено ord.compare), появляются в том же порядке в отсортированной последовательности, что и в оригинальной.

Источник

def span(p: Char => Boolean): (WrappedString, WrappedString)

Источник

override def splitAt(n: Int): (WrappedString, WrappedString)

Источник

def sum[B >: Char](implicit num: Numeric[B]): B

Суммирует элементы этой коллекции.

Примечание: не будет завершаться для коллекций бесконечного размера.

Источник

def tail: WrappedString

Остаток коллекции без первого элемента.

Источник

def tails: Iterator[WrappedString]

Итерируется по хвостам этой итерируемой коллекции. Первое значение будет этой итерируемой коллекцией, а последнее — пустой итерируемой коллекцией, а промежуточные значения будут результатами последовательных применений tail.

Источник

override def take(n: Int): WrappedString

Источник

override def takeRight(n: Int): WrappedString

Источник

def takeWhile(p: Char => Boolean): WrappedString

Возвращает самый длинный префикс элементов, удовлетворяющих предикату.

Примечание: может возвращать разные результаты при разных запусках, если тип базовой коллекции не упорядочен.

Источник

override def tapEach[U](f: Char => U): WrappedString

Источник

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

При заданном фабричном методе коллекции factory преобразуйте эту коллекцию в соответствующее представление для текущего типа элемента A. Примеры использования:

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Источник

def toArray[B >: Char : ClassTag]: Array[B]

Преобразовать коллекцию в массив.

Примечание к реализации: НЕ вызывайте Array.from из этого метода.

Источник@inline

final def toBuffer[B >: Char]: Buffer[B]

Источник

final override def toIndexedSeq: IndexedSeq[Char]

Источник

def toList: List[Char]

Source

def toMap[K, V](implicit ev: Char <:< (K, V)): Map[K, V]

Source

final override def toSeq: WrappedString

Source

def toSet[B >: Char]: Set[B]

Source

def toVector: Vector[Char]

Source

def transpose[B](implicit asIterable: Char => Iterable[B]): IndexedSeq[IndexedSeq[B]]

Транспонирует эту итерируемую коллекцию итерируемых коллекций в итерируемую коллекцию итерируемых коллекций.

Тип результирующей коллекции будет определяться статическим типом итерируемой коллекции. Например:

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

Примечание: даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

def unapply(a: Int): Option[Char]

Попытка извлечь B из A в выражении сопоставления с образцом.

Source

def unzip[A1, A2](implicit asPair: Char => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

Преобразует эту итерируемую коллекцию пар в две коллекции первой и второй половины каждой пары.

val xs = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

def unzip3[A1, A2, A3](implicit asTriple: Char => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])

Преобразует эту итерируемую коллекцию троек в три коллекции первого, второго и третьего элемента каждой тройки.

val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))

Source

def updated[B >: Char](index: Int, elem: B): IndexedSeq[B]

Копия последовательности с одним заменённым элементом.

Source

def withFilter(p: Char => Boolean): WithFilter[Char, IndexedSeq]

Создаёт нестрогий фильтр этой итерируемой коллекции.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создаёт новую коллекцию, а второй только ограничивает область действия последующих map, flatMap, foreach и withFilter операций.

Примечание: может возвращать разные результаты для разных запусков, если только тип базовой коллекции не упорядочен.

Source

def zip[B](that: IterableOnce[B]): IndexedSeq[(Char, B)]

Возвращает итерируемую коллекцию, сформированную из этой итерируемой коллекции и другой итерируемой коллекции путём объединения соответствующих элементов в пары. Если одна из двух коллекций длиннее другой, её оставшиеся элементы игнорируются.

Source

def zipAll[A1 >: Char, B](that: Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]

Возвращает итерируемую коллекцию, образованную из этой итерируемой коллекции и другой итерируемой коллекции путём объединения соответствующих элементов парами. Если одна из двух коллекций короче другой, элементы-заполнители используются для расширения более короткой коллекции до длины более длинной.

Источник

def zipWithIndex: IndexedSeq[(Char, Int)]