Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.scala-lang.org/api/2.12.4/scala-xml/scala/xml/Document.html below:

 

1. Alphabetic
2. By Inheritance

1. Document
2. Serializable
3. Serializable
4. XMLEvent
5. NodeSeq
6. Equality
7. Seq
8. Iterable
9. Traversable
10. Immutable
11. AbstractSeq
12. Seq
13. SeqLike
14. GenSeq
15. GenSeqLike
16. PartialFunction
17. Function1
18. AbstractIterable
19. Iterable
20. IterableLike
21. Equals
22. GenIterable
23. GenIterableLike
24. AbstractTraversable
25. Traversable
26. GenTraversable
27. GenericTraversableTemplate
28. TraversableLike
29. GenTraversableLike
30. Parallelizable
31. TraversableOnce
32. GenTraversableOnce
33. FilterMonadic
34. HasNewBuilder
35. AnyRef
36. Any

1.  new Document()

1.  type Self = NodeSeq
2.  class WithFilter extends FilterMonadic[A, Repr]

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def ++[B >: Node, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
4.  def ++:[B >: Node, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
5.  def ++:[B >: Node, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
6.  def +:[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
7.  def /:[B](z: B)(op: (B, Node) ⇒ B): B
8.  def :+[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
9.  def :\[B](z: B)(op: (Node, B) ⇒ B): B
10.  final def ==(arg0: Any): Boolean
11.  def \(that: String): NodeSeq
12.  def \@(attributeName: String): String
13.  def \\(that: String): NodeSeq
14.  def addString(b: StringBuilder): StringBuilder
15.  def addString(b: StringBuilder, sep: String): StringBuilder
16.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
17.  def aggregate[B](z: ⇒ B)(seqop: (B, Node) ⇒ B, combop: (B, B) ⇒ B): B
18.  var allDeclarationsProcessed: Boolean
19.  def andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]
20.  def apply(f: (Node) ⇒ Boolean): NodeSeq
21.  def apply(i: Int): Node
22.  def applyOrElse[A1 <: Int, B1 >: Node](x: A1, default: (A1) ⇒ B1): B1
23.  final def asInstanceOf[T0]: T0
24.  var baseURI: String
25.  def basisForHashCode: Seq[Any]
26.  def canEqual(other: Any): Boolean
27.  var children: Seq[Node]
28.  def clone(): AnyRef
29.  def collect[B, That](pf: PartialFunction[Node, B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
30.  def collectFirst[B](pf: PartialFunction[Node, B]): Option[B]
31.  def combinations(n: Int): collection.Iterator[NodeSeq]
32.  def companion: GenericCompanion[collection.immutable.Seq]
33.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Node
34.  def contains[A1 >: Node](elem: A1): Boolean
35.  def containsSlice[B](that: GenSeq[B]): Boolean
36.  def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
37.  def copyToArray[B >: Node](xs: Array[B]): Unit
38.  def copyToArray[B >: Node](xs: Array[B], start: Int): Unit
39.  def copyToBuffer[B >: Node](dest: Buffer[B]): Unit
40.  def corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
41.  def count(p: (Node) ⇒ Boolean): Int
42.  def diff[B >: Node](that: GenSeq[B]): NodeSeq
43.  def distinct: NodeSeq
44.  var docElem: Node
45.  def drop(n: Int): NodeSeq
46.  def dropRight(n: Int): NodeSeq
47.  def dropWhile(p: (Node) ⇒ Boolean): NodeSeq
48.  var dtd: DTD
49.  var encoding: Option[String]
50.  def endsWith[B](that: GenSeq[B]): Boolean
51.  final def eq(arg0: AnyRef): Boolean
52.  def equals(other: Any): Boolean
53.  def exists(p: (Node) ⇒ Boolean): Boolean
54.  def filter(p: (Node) ⇒ Boolean): NodeSeq
55.  def filterNot(p: (Node) ⇒ Boolean): NodeSeq
56.  def finalize(): Unit
57.  def find(p: (Node) ⇒ Boolean): Option[Node]
58.  def flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
59.  def flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[B]
60.  def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
61.  def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
62.  def foldRight[B](z: B)(op: (Node, B) ⇒ B): B
63.  def forall(p: (Node) ⇒ Boolean): Boolean
64.  def foreach[U](f: (Node) ⇒ U): Unit
65.  def genericBuilder[B]: Builder[B, collection.immutable.Seq[B]]
66.  final def getClass(): Class[_]
67.  def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
68.  def grouped(size: Int): collection.Iterator[NodeSeq]
69.  def hasDefiniteSize: Boolean
70.  def hashCode(): Int
71.  def head: Node
72.  def headOption: Option[Node]
73.  def indexOf[B >: Node](elem: B, from: Int): Int
74.  def indexOf[B >: Node](elem: B): Int
75.  def indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
76.  def indexOfSlice[B >: Node](that: GenSeq[B]): Int
77.  def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
78.  def indexWhere(p: (Node) ⇒ Boolean): Int
79.  def indices: collection.immutable.Range
80.  def init: NodeSeq
81.  def inits: collection.Iterator[NodeSeq]
82.  def intersect[B >: Node](that: GenSeq[B]): NodeSeq
83.  def isDefinedAt(idx: Int): Boolean
84.  def isEmpty: Boolean
85.  final def isInstanceOf[T0]: Boolean
86.  final def isTraversableAgain: Boolean
87.  def iterator: collection.Iterator[Node]
88.  def last: Node
89.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
90.  def lastIndexOf[B >: Node](elem: B): Int
91.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
92.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
93.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
94.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
95.  def lastOption: Option[Node]
96.  def length: Int
97.  def lengthCompare(len: Int): Int
98.  def lift: (Int) ⇒ Option[Node]
99.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
100.  def max[B >: Node](implicit cmp: Ordering[B]): Node
101.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
102.  def min[B >: Node](implicit cmp: Ordering[B]): Node
103.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
104.  def mkString: String
105.  def mkString(sep: String): String
106.  def mkString(start: String, sep: String, end: String): String
107.  final def ne(arg0: AnyRef): Boolean
108.  def newBuilder: Builder[Node, NodeSeq]
109.  def nonEmpty: Boolean
110.  def notations: Seq[NotationDecl]
111.  final def notify(): Unit
112.  final def notifyAll(): Unit
113.  def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
114.  def padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
115.  def par: ParSeq[Node]
116.  def parCombiner: Combiner[Node, ParSeq[Node]]
117.  def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
118.  def patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
119.  def permutations: collection.Iterator[NodeSeq]
120.  def prefixLength(p: (Node) ⇒ Boolean): Int
121.  def product[B >: Node](implicit num: Numeric[B]): B
122.  def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
123.  def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
124.  def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
125.  def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
126.  def reduceRight[B >: Node](op: (Node, B) ⇒ B): B
127.  def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
128.  def repr: NodeSeq
129.  def reverse: NodeSeq
130.  def reverseIterator: collection.Iterator[Node]
131.  def reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
132.  def reversed: List[Node]
133.  def runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
134.  def sameElements[B >: Node](that: GenIterable[B]): Boolean
135.  def scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
136.  def scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
137.  def scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
138.  def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
139.  def seq: collection.immutable.Seq[Node]
140.  def size: Int
141.  def sizeHintIfCheap: Int
142.  def slice(from: Int, until: Int): NodeSeq
143.  def sliding(size: Int, step: Int): collection.Iterator[NodeSeq]
144.  def sliding(size: Int): collection.Iterator[NodeSeq]
145.  def sortBy[B](f: (Node) ⇒ B)(implicit ord: math.Ordering[B]): NodeSeq
146.  def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
147.  def sorted[B >: Node](implicit ord: math.Ordering[B]): NodeSeq
148.  def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
149.  def splitAt(n: Int): (NodeSeq, NodeSeq)
150.  var standAlone: Option[Boolean]
151.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
152.  def startsWith[B](that: GenSeq[B]): Boolean
153.  def strict_!=(other: Equality): Boolean
154.  def strict_==(other: Equality): Boolean
155.  def stringPrefix: String
156.  def sum[B >: Node](implicit num: Numeric[B]): B
157.  final def synchronized[T0](arg0: ⇒ T0): T0
158.  def tail: NodeSeq
159.  def tails: collection.Iterator[NodeSeq]
160.  def take(n: Int): NodeSeq
161.  def takeRight(n: Int): NodeSeq
162.  def takeWhile(p: (Node) ⇒ Boolean): NodeSeq
163.  def text: String
164.  def theSeq: Seq[Node]
165.  def thisCollection: collection.Seq[Node]
166.  def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]
167.  def toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]
168.  def toBuffer[B >: Node]: Buffer[B]
169.  def toCollection(repr: NodeSeq): collection.Seq[Node]
170.  def toIndexedSeq: collection.immutable.IndexedSeq[Node]
171.  def toIterable: collection.Iterable[Node]
172.  def toIterator: collection.Iterator[Node]
173.  def toList: List[Node]
174.  def toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]
175.  def toSeq: collection.immutable.Seq[Node]
176.  def toSet[B >: Node]: Set[B]
177.  def toStream: collection.immutable.Stream[Node]
178.  def toString(): String
179.  def toTraversable: collection.Traversable[Node]
180.  def toVector: Vector[Node]
181.  def transpose[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[collection.immutable.Seq[B]]
182.  def union[B >: Node, That](that: GenSeq[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
183.  def unparsedEntities: Seq[EntityDecl]
184.  def unzip[A1, A2](implicit asPair: (Node) ⇒ (A1, A2)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2])
185.  def unzip3[A1, A2, A3](implicit asTriple: (Node) ⇒ (A1, A2, A3)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2], collection.immutable.Seq[A3])
186.  def updated[B >: Node, That](index: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
187.  var version: Option[String]
188.  def view(from: Int, until: Int): SeqView[Node, NodeSeq]
189.  def view: SeqView[Node, NodeSeq]
190.  final def wait(): Unit
191.  final def wait(arg0: Long, arg1: Int): Unit
192.  final def wait(arg0: Long): Unit
193.  def withFilter(p: (Node) ⇒ Boolean): FilterMonadic[Node, NodeSeq]
194.  final def xml_!=(other: Any): Boolean
195.  final def xml_==(other: Any): Boolean
196.  def xml_sameElements[A](that: Iterable[A]): Boolean
197.  def zip[A1 >: Node, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
198.  def zipAll[B, A1 >: Node, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
199.  def zipWithIndex[A1 >: Node, That](implicit bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4