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

 

1. Alphabetic
2. By Inheritance

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

1.  new ProcInstr(target: String, proctext: String)

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.  def andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]
19.  def apply(f: (Node) ⇒ Boolean): NodeSeq
20.  def apply(i: Int): Node
21.  def applyOrElse[A1 <: Int, B1 >: Node](x: A1, default: (A1) ⇒ B1): B1
22.  final def asInstanceOf[T0]: T0
23.  final def attribute(uri: String, key: String): Option[Seq[Node]]
24.  final def attribute(key: String): Option[Seq[Node]]
25.  final def attributes: Null.type
26.  def basisForHashCode: Seq[Any]
27.  def buildString(sb: StringBuilder): collection.mutable.StringBuilder
28.  def buildString(stripComments: Boolean): String
29.  def canEqual(other: Any): Boolean
30.  final def child: collection.immutable.Nil.type
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 copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
40.  def copyToArray[B >: Node](xs: Array[B]): Unit
41.  def copyToArray[B >: Node](xs: Array[B], start: Int): Unit
42.  def copyToBuffer[B >: Node](dest: Buffer[B]): Unit
43.  def corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
44.  def count(p: (Node) ⇒ Boolean): Int
45.  def descendant: List[Node]
46.  def descendant_or_self: List[Node]
47.  def diff[B >: Node](that: GenSeq[B]): NodeSeq
48.  def distinct: NodeSeq
49.  final def doCollectNamespaces: Boolean
50.  final def doTransform: Boolean
51.  def drop(n: Int): NodeSeq
52.  def dropRight(n: Int): NodeSeq
53.  def dropWhile(p: (Node) ⇒ Boolean): NodeSeq
54.  def endsWith[B](that: GenSeq[B]): Boolean
55.  final def eq(arg0: AnyRef): Boolean
56.  def equals(other: Any): Boolean
57.  def exists(p: (Node) ⇒ Boolean): Boolean
58.  def filter(p: (Node) ⇒ Boolean): NodeSeq
59.  def filterNot(p: (Node) ⇒ Boolean): NodeSeq
60.  def finalize(): Unit
61.  def find(p: (Node) ⇒ Boolean): Option[Node]
62.  def flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
63.  def flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[B]
64.  def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
65.  def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
66.  def foldRight[B](z: B)(op: (Node, B) ⇒ B): B
67.  def forall(p: (Node) ⇒ Boolean): Boolean
68.  def foreach[U](f: (Node) ⇒ U): Unit
69.  def genericBuilder[B]: Builder[B, collection.immutable.Seq[B]]
70.  final def getClass(): Class[_]
71.  def getNamespace(pre: String): String
72.  def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
73.  def grouped(size: Int): collection.Iterator[NodeSeq]
74.  def hasDefiniteSize: Boolean
75.  def hashCode(): Int
76.  def head: Node
77.  def headOption: Option[Node]
78.  def indexOf[B >: Node](elem: B, from: Int): Int
79.  def indexOf[B >: Node](elem: B): Int
80.  def indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
81.  def indexOfSlice[B >: Node](that: GenSeq[B]): Int
82.  def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
83.  def indexWhere(p: (Node) ⇒ Boolean): Int
84.  def indices: collection.immutable.Range
85.  def init: NodeSeq
86.  def inits: collection.Iterator[NodeSeq]
87.  def intersect[B >: Node](that: GenSeq[B]): NodeSeq
88.  def isAtom: Boolean
89.  def isDefinedAt(idx: Int): Boolean
90.  def isEmpty: Boolean
91.  final def isInstanceOf[T0]: Boolean
92.  final def isTraversableAgain: Boolean
93.  def iterator: collection.Iterator[Node]
94.  final def label: String
95.  def last: Node
96.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
97.  def lastIndexOf[B >: Node](elem: B): Int
98.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
99.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
100.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
101.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
102.  def lastOption: Option[Node]
103.  def length: Int
104.  def lengthCompare(len: Int): Int
105.  def lift: (Int) ⇒ Option[Node]
106.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
107.  def max[B >: Node](implicit cmp: Ordering[B]): Node
108.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
109.  def min[B >: Node](implicit cmp: Ordering[B]): Node
110.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
111.  def mkString: String
112.  def mkString(sep: String): String
113.  def mkString(start: String, sep: String, end: String): String
114.  def nameToString(sb: StringBuilder): StringBuilder
115.  final def namespace: Null
116.  final def ne(arg0: AnyRef): Boolean
117.  def newBuilder: Builder[Node, NodeSeq]
118.  def nonEmpty: Boolean
119.  def nonEmptyChildren: Seq[Node]
120.  final def notify(): Unit
121.  final def notifyAll(): Unit
122.  def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
123.  def padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
124.  def par: ParSeq[Node]
125.  def parCombiner: Combiner[Node, ParSeq[Node]]
126.  def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
127.  def patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
128.  def permutations: collection.Iterator[NodeSeq]
129.  def prefix: String
130.  def prefixLength(p: (Node) ⇒ Boolean): Int
131.  val proctext: String
132.  def product[B >: Node](implicit num: Numeric[B]): B
133.  def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
134.  def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
135.  def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
136.  def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
137.  def reduceRight[B >: Node](op: (Node, B) ⇒ B): B
138.  def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
139.  def repr: NodeSeq
140.  def reverse: NodeSeq
141.  def reverseIterator: collection.Iterator[Node]
142.  def reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
143.  def reversed: List[Node]
144.  def runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
145.  def sameElements[B >: Node](that: GenIterable[B]): Boolean
146.  def scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
147.  def scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
148.  def scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
149.  def scope: NamespaceBinding
150.  def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
151.  def seq: collection.immutable.Seq[Node]
152.  def size: Int
153.  def sizeHintIfCheap: Int
154.  def slice(from: Int, until: Int): NodeSeq
155.  def sliding(size: Int, step: Int): collection.Iterator[NodeSeq]
156.  def sliding(size: Int): collection.Iterator[NodeSeq]
157.  def sortBy[B](f: (Node) ⇒ B)(implicit ord: math.Ordering[B]): NodeSeq
158.  def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
159.  def sorted[B >: Node](implicit ord: math.Ordering[B]): NodeSeq
160.  def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
161.  def splitAt(n: Int): (NodeSeq, NodeSeq)
162.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
163.  def startsWith[B](that: GenSeq[B]): Boolean
164.  def strict_!=(other: Equality): Boolean
165.  def strict_==(other: Equality): Boolean
166.  def stringPrefix: String
167.  def sum[B >: Node](implicit num: Numeric[B]): B
168.  final def synchronized[T0](arg0: ⇒ T0): T0
169.  def tail: NodeSeq
170.  def tails: collection.Iterator[NodeSeq]
171.  def take(n: Int): NodeSeq
172.  def takeRight(n: Int): NodeSeq
173.  def takeWhile(p: (Node) ⇒ Boolean): NodeSeq
174.  val target: String
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