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/Elem.html below:

 

1. Alphabetic
2. By Inheritance

1. Elem
2. Serializable
3. Serializable
4. Node
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.  type Self = NodeSeq
2.  class WithFilter extends FilterMonadic[A, Repr]

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