Scala Standard Library 2.13.1 - scala.collection.mutable.StringBuilder (original) (raw)

final class StringBuilder extends AbstractSeq[Char] with ReusableBuilder[Char, String] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, StringBuilder] with IterableFactoryDefaults[Char, IndexedSeq] with CharSequence with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. StringBuilder
2. Serializable
3. CharSequence
4. IndexedSeq
5. IndexedSeqOps
6. IndexedSeq
7. IndexedSeqOps
8. ReusableBuilder
9. Builder
10. Growable
11. Clearable
12. AbstractSeq
13. Seq
14. SeqOps
15. Cloneable
16. Cloneable
17. Iterable
18. AbstractSeq
19. Seq
20. Equals
21. SeqOps
22. PartialFunction
23. Function1
24. AbstractIterable
25. Iterable
26. IterableFactoryDefaults
27. IterableOps
28. IterableOnceOps
29. IterableOnce
30. AnyRef
31. Any

Implicitly

1. by SeqCharSequence

2. by iterableOnceExtensionMethods

3. by any2stringadd

4. by StringFormat

5. by Ensuring

6. by ArrowAssoc

7. Hide All

8. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new StringBuilder(initCapacity: Int, initValue: String)
2.  new StringBuilder(str: String)
3.  new StringBuilder(capacity: Int)
4.  new StringBuilder()
5.  new StringBuilder(underlying: java.lang.StringBuilder)

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  final def ++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
5.  final def ++:[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
6.  def ++=(s: String): StringBuilder.this.type
7.  final def ++=(xs: IterableOnce[Char]): StringBuilder.this.type
8.  final def +:[B >: Char](elem: B): IndexedSeq[B]
9.  final def +=(elem: Char): StringBuilder.this.type
10.  def ->[B](y: B): (StringBuilder, B)
11.  final def :+[B >: Char](elem: B): IndexedSeq[B]
12.  final def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
13.  final def ==(arg0: Any): Boolean
14.  def addAll(s: String): StringBuilder.this.type
15.  def addAll(xs: IterableOnce[Char]): StringBuilder.this.type
16.  def addOne(x: Char): StringBuilder.this.type
17.  final def addString(b: StringBuilder): StringBuilder
18.  final def addString(b: StringBuilder, sep: String): StringBuilder
19.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
20.  def andThen[C](k: PartialFunction[Char, C]): PartialFunction[Int, C]
21.  def andThen[C](k: (Char) => C): PartialFunction[Int, C]
22.  def append(x: Char): StringBuilder
23.  def append(x: Double): StringBuilder
24.  def append(x: Float): StringBuilder
25.  def append(x: Long): StringBuilder
26.  def append(x: Int): StringBuilder
27.  def append(x: Short): StringBuilder
28.  def append(x: Byte): StringBuilder
29.  def append(x: Boolean): StringBuilder
30.  def append(s: StringBuilder): StringBuilder
31.  def append(cs: CharSequence): StringBuilder
32.  def append(s: String): StringBuilder
33.  def append(x: Any): StringBuilder
34.  def appendAll(xs: Array[Char], offset: Int, len: Int): StringBuilder
35.  def appendAll(xs: Array[Char]): StringBuilder
36.  def appendAll(xs: IterableOnce[Char]): StringBuilder
37.  def appendAll(xs: String): StringBuilder
38.  def appended[B >: Char](elem: B): IndexedSeq[B]
39.  def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
40.  def apply(i: Int): Char
41.  def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: (A1) => B1): B1
42.  final def asInstanceOf[T0]: T0
43.  def canEqual(that: Any): Boolean
44.  def capacity: Int
45.  def charAt(index: Int): Char
46.  def chars(): IntStream
47.  def className: String
48.  def clear(): Unit
49.  def clone(): StringBuilder
50.  def codePoints(): IntStream
51.  final def coll: StringBuilder.this.type
52.  def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]
53.  def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]
54.  def combinations(n: Int): Iterator[StringBuilder]
55.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Char]
56.  def compose[A](g: (A) => Int): (A) => Char
57.  final def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
58.  def contains[A1 >: Char](elem: A1): Boolean
59.  def containsSlice[B](that: collection.Seq[B]): Boolean
60.  def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int
61.  def copyToArray[B >: Char](xs: Array[B], start: Int): Int
62.  def copyToArray[B >: Char](xs: Array[B]): Int
63.  def corresponds[B](that: collection.Seq[B])(p: (Char, B) => Boolean): Boolean
64.  def corresponds[B](that: IterableOnce[B])(p: (Char, B) => Boolean): Boolean
65.  def count(p: (Char) => Boolean): Int
66.  def delete(start: Int, end: Int): StringBuilder
67.  def deleteCharAt(index: Int): StringBuilder.this.type
68.  def diff[B >: Char](that: collection.Seq[B]): StringBuilder
69.  def distinct: StringBuilder
70.  def distinctBy[B](f: (Char) => B): StringBuilder
71.  def drop(n: Int): StringBuilder
72.  def dropRight(n: Int): StringBuilder
73.  def dropWhile(p: (Char) => Boolean): StringBuilder
74.  def elementWise: ElementWiseExtractor[Int, Char]
75.  def empty: StringBuilder
76.  def endsWith[B >: Char](that: collection.Iterable[B]): Boolean
77.  def ensureCapacity(newCapacity: Int): Unit
78.  def ensuring(cond: (StringBuilder) => Boolean, msg: => Any): StringBuilder
79.  def ensuring(cond: (StringBuilder) => Boolean): StringBuilder
80.  def ensuring(cond: Boolean, msg: => Any): StringBuilder
81.  def ensuring(cond: Boolean): StringBuilder
82.  final def eq(arg0: AnyRef): Boolean
83.  def equals(o: Any): Boolean
84.  def exists(p: (Char) => Boolean): Boolean
85.  def filter(pred: (Char) => Boolean): StringBuilder
86.  def filterNot(pred: (Char) => Boolean): StringBuilder
87.  def finalize(): Unit
88.  def find(p: (Char) => Boolean): Option[Char]
89.  def findLast(p: (Char) => Boolean): Option[Char]
90.  def flatMap[B](f: (Char) => IterableOnce[B]): IndexedSeq[B]
91.  def flatten[B](implicit asIterable: (Char) => IterableOnce[B]): IndexedSeq[B]
92.  def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
93.  def foldLeft[B](z: B)(op: (B, Char) => B): B
94.  def foldRight[B](z: B)(op: (Char, B) => B): B
95.  def forall(p: (Char) => Boolean): Boolean
96.  def foreach[U](f: (Char) => U): Unit
97.  def formatted(fmtstr: String): String
98.  def fromSpecific(coll: IterableOnce[Char]): StringBuilder
99.  final def getClass(): Class[_ <: AnyRef]
100.  def groupBy[K](f: (Char) => K): immutable.Map[K, StringBuilder]
101.  def groupMap[K, B](key: (Char) => K)(f: (Char) => B): immutable.Map[K, IndexedSeq[B]]
102.  def groupMapReduce[K, B](key: (Char) => K)(f: (Char) => B)(reduce: (B, B) => B): immutable.Map[K, B]
103.  def grouped(size: Int): Iterator[StringBuilder]
104.  def hashCode(): Int
105.  def head: Char
106.  def headOption: Option[Char]
107.  def indexOf(str: String, fromIndex: Int): Int
108.  def indexOf(str: String): Int
109.  def indexOf[B >: Char](elem: B): Int
110.  def indexOf[B >: Char](elem: B, from: Int): Int
111.  def indexOfSlice[B >: Char](that: collection.Seq[B]): Int
112.  def indexOfSlice[B >: Char](that: collection.Seq[B], from: Int): Int
113.  def indexWhere(p: (Char) => Boolean): Int
114.  def indexWhere(p: (Char) => Boolean, from: Int): Int
115.  def indices: immutable.Range
116.  def init: StringBuilder
117.  def inits: Iterator[StringBuilder]
118.  def insert(index: Int, x: Char): StringBuilder
119.  def insert(index: Int, x: Double): StringBuilder
120.  def insert(index: Int, x: Float): StringBuilder
121.  def insert(index: Int, x: Long): StringBuilder
122.  def insert(index: Int, x: Int): StringBuilder
123.  def insert(index: Int, x: Short): StringBuilder
124.  def insert(index: Int, x: Byte): StringBuilder
125.  def insert(index: Int, x: Boolean): StringBuilder
126.  def insert(index: Int, x: String): StringBuilder
127.  def insert(index: Int, x: Any): StringBuilder
128.  def insertAll(index: Int, xs: Array[Char]): StringBuilder
129.  def insertAll(index: Int, xs: IterableOnce[Char]): StringBuilder
130.  def insertAll(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder
131.  def intersect[B >: Char](that: collection.Seq[B]): StringBuilder
132.  def isDefinedAt(idx: Int): Boolean
133.  def isEmpty: Boolean
134.  final def isInstanceOf[T0]: Boolean
135.  def isTraversableAgain: Boolean
136.  def iterableFactory: SeqFactory[IndexedSeq]
137.  def iterator: Iterator[Char]
138.  def knownSize: Int
139.  def last: Char
140.  def lastIndexOf(str: String, fromIndex: Int): Int
141.  def lastIndexOf(str: String): Int
142.  def lastIndexOf[B >: Char](elem: B, end: Int = length - 1): Int
143.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B]): Int
144.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B], end: Int): Int
145.  def lastIndexWhere(p: (Char) => Boolean): Int
146.  def lastIndexWhere(p: (Char) => Boolean, end: Int): Int
147.  def lastOption: Option[Char]
148.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[Char, B, StringBuilder.this.type]
149.  def length(): Int
150.  final def lengthCompare(that: collection.Iterable[_]): Int
151.  final def lengthCompare(len: Int): Int
152.  final def lengthIs: SizeCompareOps
153.  def length_=(n: Int): Unit
154.  def lift: (Int) => Option[Char]
155.  def map[B](f: (Char) => B): IndexedSeq[B]
156.  def mapInPlace(f: (Char) => Char): StringBuilder.this.type
157.  def mapResult[NewTo](f: (String) => NewTo): Builder[Char, NewTo]
158.  def max[B >: Char](implicit ord: math.Ordering[B]): Char
159.  def maxBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
160.  def maxByOption[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Option[Char]
161.  def maxOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
162.  def min[B >: Char](implicit ord: math.Ordering[B]): Char
163.  def minBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
164.  def minByOption[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Option[Char]
165.  def minOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
166.  final def mkString: String
167.  final def mkString(sep: String): String
168.  final def mkString(start: String, sep: String, end: String): String
169.  final def ne(arg0: AnyRef): Boolean
170.  def newSpecificBuilder: Builder[Char, StringBuilder]
171.  def nonEmpty: Boolean
172.  final def notify(): Unit
173.  final def notifyAll(): Unit
174.  def occCounts[B](sq: collection.Seq[B]): Map[B, Int]
175.  def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
176.  def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]
177.  def partition(p: (Char) => Boolean): (StringBuilder, StringBuilder)
178.  def partitionMap[A1, A2](f: (Char) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
179.  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
180.  def permutations: Iterator[StringBuilder]
181.  def prepended[B >: Char](elem: B): IndexedSeq[B]
182.  def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
183.  def product[B >: Char](implicit num: math.Numeric[B]): B
184.  def reduce[B >: Char](op: (B, B) => B): B
185.  def reduceLeft[B >: Char](op: (B, Char) => B): B
186.  def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]
187.  def reduceOption[B >: Char](op: (B, B) => B): Option[B]
188.  def reduceRight[B >: Char](op: (Char, B) => B): B
189.  def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]
190.  def replace(start: Int, end: Int, str: String): StringBuilder
191.  def result(): String
192.  def reverse: StringBuilder
193.  def reverseInPlace(): StringBuilder.this.type
194.  def reverseIterator: Iterator[Char]
195.  def reversed: collection.Iterable[Char]
196.  def runWith[U](action: (Char) => U): (Int) => Boolean
197.  def sameElements[B >: Char](that: IterableOnce[B]): Boolean
198.  def scan[B >: Char](z: B)(op: (B, B) => B): IndexedSeq[B]
199.  def scanLeft[B](z: B)(op: (B, Char) => B): IndexedSeq[B]
200.  def scanRight[B](z: B)(op: (Char, B) => B): IndexedSeq[B]
201.  def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
202.  def search[B >: Char](elem: B)(implicit ord: math.Ordering[B]): SearchResult
203.  def segmentLength(p: (Char) => Boolean, from: Int): Int
204.  final def segmentLength(p: (Char) => Boolean): Int
205.  def setCharAt(index: Int, ch: Char): StringBuilder.this.type
206.  def setLength(len: Int): Unit
207.  final def size: Int
208.  final def sizeCompare(that: collection.Iterable[_]): Int
209.  final def sizeCompare(otherSize: Int): Int
210.  final def sizeHint(coll: IterableOnce[_], delta: Int = 0): Unit
211.  def sizeHint(size: Int): Unit
212.  final def sizeHintBounded(size: Int, boundingColl: collection.Iterable[_]): Unit
213.  final def sizeIs: SizeCompareOps
214.  def slice(from: Int, until: Int): StringBuilder
215.  def sliding(size: Int, step: Int): Iterator[StringBuilder]
216.  def sliding(size: Int): Iterator[StringBuilder]
217.  def sortBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder
218.  def sortInPlace[B >: Char]()(implicit ord: Ordering[B]): StringBuilder.this.type
219.  def sortInPlaceBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder.this.type
220.  def sortInPlaceWith(lt: (Char, Char) => Boolean): StringBuilder.this.type
221.  def sortWith(lt: (Char, Char) => Boolean): StringBuilder
222.  def sorted[B >: Char](implicit ord: Ordering[B]): StringBuilder
223.  def span(p: (Char) => Boolean): (StringBuilder, StringBuilder)
224.  def splitAt(n: Int): (StringBuilder, StringBuilder)
225.  def startsWith[B >: Char](that: IterableOnce[B], offset: Int = 0): Boolean
226.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit
227.  def stringPrefix: String
228.  def subSequence(start: Int, end: Int): CharSequence
229.  def substring(start: Int, end: Int): String
230.  def substring(start: Int): String
231.  def sum[B >: Char](implicit num: math.Numeric[B]): B
232.  final def synchronized[T0](arg0: => T0): T0
233.  def tail: StringBuilder
234.  def tails: Iterator[StringBuilder]
235.  def take(n: Int): StringBuilder
236.  def takeRight(n: Int): StringBuilder
237.  def takeWhile(p: (Char) => Boolean): StringBuilder
238.  def tapEach[U](f: (Char) => U): StringBuilder
239.  def to[C1](factory: Factory[Char, C1]): C1
240.  def toArray[B >: Char](implicit ct: ClassTag[B]): Array[B]
241.  final def toBuffer[B >: Char]: Buffer[B]
242.  def toCharArray: Array[Char]
243.  def toIndexedSeq: immutable.IndexedSeq[Char]
244.  final def toIterable: StringBuilder.this.type
245.  def toList: immutable.List[Char]
246.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): immutable.Map[K, V]
247.  def toSeq: immutable.Seq[Char]
248.  def toSet[B >: Char]: immutable.Set[B]
249.  def toString(): String
250.  def toVector: immutable.Vector[Char]
251.  def transpose[B](implicit asIterable: (Char) => collection.Iterable[B]): IndexedSeq[IndexedSeq[B]]
252.  def unapply(a: Int): Option[Char]
253.  val underlying: java.lang.StringBuilder
254.  def unzip[A1, A2](implicit asPair: (Char) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
255.  def unzip3[A1, A2, A3](implicit asTriple: (Char) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
256.  def update(idx: Int, elem: Char): Unit
257.  def updated[B >: Char](index: Int, elem: B): IndexedSeq[B]
258.  def view: IndexedSeqView[Char]
259.  final def wait(): Unit
260.  final def wait(arg0: Long, arg1: Int): Unit
261.  final def wait(arg0: Long): Unit
262.  def withFilter(p: (Char) => Boolean): WithFilter[Char, [_]IndexedSeq[_]]
263.  def zip[B](that: IterableOnce[B]): IndexedSeq[(Char, B)]
264.  def zipAll[A1 >: Char, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
265.  def zipWithIndex: IndexedSeq[(Char, Int)]

Deprecated Value Members

1.  final def +=(elem1: Char, elem2: Char, elems: Char*): StringBuilder.this.type
2.  def /:[B](z: B)(op: (B, Char) => B): B
3.  final def /:[B](z: B)(op: (B, Char) => B): B
4.  def :\[B](z: B)(op: (Char, B) => B): B
5.  final def :\[B](z: B)(op: (Char, B) => B): B
6.  def aggregate[B](z: => B)(seqop: (B, Char) => B, combop: (B, B) => B): B
7.  def collectFirst[B](f: PartialFunction[Char, B]): Option[B]
8.  def companion: IterableFactory[[_]IndexedSeq[_]]
9.  def copyToBuffer(dest: Buffer[Char]): Unit
10.  final def copyToBuffer[B >: Char](dest: Buffer[B]): Unit
11.  def count(f: (Char) => Boolean): Int
12.  def exists(f: (Char) => Boolean): Boolean
13.  def filter(f: (Char) => Boolean): Iterator[Char]
14.  def find(p: (Char) => Boolean): Option[Char]
15.  def flatMap[B](f: (Char) => IterableOnce[B]): IterableOnce[B]
16.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
17.  def foldLeft[B](z: B)(op: (B, Char) => B): B
18.  def foldRight[B](z: B)(op: (Char, B) => B): B
19.  def forall(f: (Char) => Boolean): Boolean
20.  def foreach[U](f: (Char) => U): Unit
21.  def hasDefiniteSize: Boolean
22.  def isEmpty: Boolean
23.  def map[B](f: (Char) => B): IterableOnce[B]
24.  def max(implicit ord: math.Ordering[Char]): Char
25.  def maxBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
26.  def min(implicit ord: math.Ordering[Char]): Char
27.  def minBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
28.  def mkString: String
29.  def mkString(sep: String): String
30.  def mkString(start: String, sep: String, end: String): String
31.  def nonEmpty: Boolean
32.  final def prefixLength(p: (Char) => Boolean): Int
33.  def product(implicit num: math.Numeric[Char]): Char
34.  def reduce(f: (Char, Char) => Char): Char
35.  def reduceLeft(f: (Char, Char) => Char): Char
36.  def reduceLeftOption(f: (Char, Char) => Char): Option[Char]
37.  def reduceOption(f: (Char, Char) => Char): Option[Char]
38.  def reduceRight(f: (Char, Char) => Char): Char
39.  def reduceRightOption(f: (Char, Char) => Char): Option[Char]
40.  final def repr: StringBuilder
41.  final def reverseContents(): StringBuilder.this.type
42.  def reverseMap[B](f: (Char) => B): IndexedSeq[B]
43.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
44.  def seq: StringBuilder.this.type
45.  def size: Int
46.  def sum(implicit num: math.Numeric[Char]): Char
47.  def to[C1](factory: Factory[Char, C1]): C1
48.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
49.  def toBuffer[B >: A]: Buffer[B]
50.  def toIndexedSeq: collection.IndexedSeq[Char]
51.  final def toIterable: collection.Iterable[Char]
52.  def toIterator: Iterator[Char]
53.  final def toIterator: Iterator[Char]
54.  def toList: immutable.List[Char]
55.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): immutable.Map[K, V]
56.  def toSeq: immutable.Seq[Char]
57.  def toSet[B >: A]: immutable.Set[B]
58.  def toStream: immutable.Stream[Char]
59.  final def toStream: immutable.Stream[Char]
60.  final def toTraversable: collection.Traversable[Char]
61.  final def toTraversable: collection.Traversable[Char]
62.  def toVector: immutable.Vector[Char]
63.  final def transform(f: (Char) => Char): StringBuilder.this.type
64.  final def union[B >: Char](that: collection.Seq[B]): IndexedSeq[B]
65.  def view(from: Int, until: Int): IndexedSeqView[Char]
66.  def withFilter(f: (Char) => Boolean): Iterator[Char]
67.  def →[B](y: B): (StringBuilder, B)

Inherited from java.io.Serializable

Inherited from CharSequence

Inherited from IndexedSeq[Char]

Inherited from IndexedSeqOps[Char, IndexedSeq, StringBuilder]

Inherited from collection.IndexedSeq[Char]

Inherited from collection.IndexedSeqOps[Char, [_]IndexedSeq[_], StringBuilder]

Inherited from ReusableBuilder[Char, String]

Inherited from Builder[Char, String]

Inherited from Growable[Char]

Inherited from Clearable

Inherited from AbstractSeq[Char]

Inherited from Seq[Char]

Inherited from SeqOps[Char, [_]IndexedSeq[_], StringBuilder]

Inherited from Cloneable[StringBuilder]

Inherited from java.lang.Cloneable

Inherited from Iterable[Char]

Inherited from collection.AbstractSeq[Char]

Inherited from collection.Seq[Char]

Inherited from Equals

Inherited from collection.SeqOps[Char, [_]IndexedSeq[_], StringBuilder]

Inherited from PartialFunction[Int, Char]

Inherited from (Int) => Char

Inherited from collection.AbstractIterable[Char]

Inherited from collection.Iterable[Char]

Inherited from IterableFactoryDefaults[Char, [x]IndexedSeq[x]]

Inherited from IterableOps[Char, [_]IndexedSeq[_], StringBuilder]

Inherited from IterableOnceOps[Char, [_]IndexedSeq[_], StringBuilder]

Inherited from IterableOnce[Char]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion SeqCharSequence fromStringBuilder to SeqCharSequence

Inherited by implicit conversion iterableOnceExtensionMethods fromStringBuilder to IterableOnceExtensionMethods[Char]

Inherited by implicit conversion any2stringadd fromStringBuilder to any2stringadd[StringBuilder]

Inherited by implicit conversion StringFormat fromStringBuilder to StringFormat[StringBuilder]

Inherited by implicit conversion Ensuring fromStringBuilder to Ensuring[StringBuilder]

Inherited by implicit conversion ArrowAssoc fromStringBuilder to ArrowAssoc[StringBuilder]

Ungrouped