class
ExpressionSet extends Set[Expression]
Instance Constructors
-
new
ExpressionSet(baseSet: Set[Expression] = ..., originals: Buffer[Expression] = ...)
Type Members
-
-
class
WithFilter extends FilterMonadic[A, Repr]
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
-
-
-
-
def
++(elems: GenTraversableOnce[Expression]): Set[Expression]
-
def
++[B >: Expression, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
def
++:[B >: Expression, That](that: Traversable[B])(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
def
++:[B >: Expression, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
-
-
-
def
/:[B](z: B)(op: (B, Expression) ⇒ B): B
-
def
:\[B](z: B)(op: (Expression, B) ⇒ B): B
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
-
-
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
-
def
aggregate[B](z: B)(seqop: (B, Expression) ⇒ B, combop: (B, B) ⇒ B): B
-
def
andThen[A](g: (Boolean) ⇒ A): (Expression) ⇒ A
-
def
apply(elem: Expression): Boolean
-
final
def
asInstanceOf[T0]: T0
-
-
def
canEqual(that: Any): Boolean
-
def
clone(): AnyRef
-
def
collect[B, That](pf: PartialFunction[Expression, B])(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
def
collectFirst[B](pf: PartialFunction[Expression, B]): Option[B]
-
def
companion: GenericCompanion[Set]
-
def
compose[A](g: (A) ⇒ Expression): (A) ⇒ Boolean
-
def
contains(elem: Expression): Boolean
-
def
copyToArray[B >: Expression](xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray[B >: Expression](xs: Array[B]): Unit
-
def
copyToArray[B >: Expression](xs: Array[B], start: Int): Unit
-
def
copyToBuffer[B >: Expression](dest: Buffer[B]): Unit
-
def
count(p: (Expression) ⇒ Boolean): Int
-
-
def
drop(n: Int): Set[Expression]
-
def
dropRight(n: Int): Set[Expression]
-
-
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
def
exists(p: (Expression) ⇒ Boolean): Boolean
-
-
-
def
finalize(): Unit
-
-
def
flatMap[B, That](f: (Expression) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
def
flatten[B](implicit asTraversable: (Expression) ⇒ GenTraversableOnce[B]): Set[B]
-
def
fold[A1 >: Expression](z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft[B](z: B)(op: (B, Expression) ⇒ B): B
-
def
foldRight[B](z: B)(op: (Expression, B) ⇒ B): B
-
def
forall(p: (Expression) ⇒ Boolean): Boolean
-
def
foreach[U](f: (Expression) ⇒ U): Unit
-
def
genericBuilder[B]: Builder[B, Set[B]]
-
final
def
getClass(): Class[_]
-
-
def
grouped(size: Int): Iterator[Set[Expression]]
-
def
hasDefiniteSize: Boolean
-
def
hashCode(): Int
-
-
def
headOption: Option[Expression]
-
-
def
inits: Iterator[Set[Expression]]
-
-
def
isEmpty: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
isTraversableAgain: Boolean
-
-
-
def
lastOption: Option[Expression]
-
def
map[B, That](f: (Expression) ⇒ B)(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
-
-
-
-
def
mkString: String
-
def
mkString(sep: String): String
-
def
mkString(start: String, sep: String, end: String): String
-
final
def
ne(arg0: AnyRef): Boolean
-
-
def
nonEmpty: Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
val
originals: Buffer[Expression]
-
-
-
-
def
product[B >: Expression](implicit num: Numeric[B]): B
-
def
reduce[A1 >: Expression](op: (A1, A1) ⇒ A1): A1
-
-
def
reduceLeftOption[B >: Expression](op: (B, Expression) ⇒ B): Option[B]
-
def
reduceOption[A1 >: Expression](op: (A1, A1) ⇒ A1): Option[A1]
-
-
def
reduceRightOption[B >: Expression](op: (Expression, B) ⇒ B): Option[B]
-
-
-
def
sameElements[B >: Expression](that: GenIterable[B]): Boolean
-
def
scan[B >: Expression, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Set[Expression], B, That]): That
-
def
scanLeft[B, That](z: B)(op: (B, Expression) ⇒ B)(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
def
scanRight[B, That](z: B)(op: (Expression, B) ⇒ B)(implicit bf: CanBuildFrom[Set[Expression], B, That]): That
-
-
def
size: Int
-
def
slice(from: Int, until: Int): Set[Expression]
-
def
sliding(size: Int, step: Int): Iterator[Set[Expression]]
-
def
sliding(size: Int): Iterator[Set[Expression]]
-
-
-
def
stringPrefix: String
-
def
subsetOf(that: GenSet[Expression]): Boolean
-
def
subsets: Iterator[Set[Expression]]
-
def
subsets(len: Int): Iterator[Set[Expression]]
-
def
sum[B >: Expression](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
def
tails: Iterator[Set[Expression]]
-
def
take(n: Int): Set[Expression]
-
def
takeRight(n: Int): Set[Expression]
-
-
def
thisCollection: Iterable[Expression]
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Expression, Col[Expression]]): Col[Expression]
-
def
toArray[B >: Expression](implicit arg0: ClassTag[B]): Array[B]
-
def
toBuffer[A1 >: Expression]: Buffer[A1]
-
def
toCollection(repr: Set[Expression]): Iterable[Expression]
-
def
toDebugString: String
-
def
toIndexedSeq: IndexedSeq[Expression]
-
def
toIterable: Iterable[Expression]
-
def
toIterator: Iterator[Expression]
-
-
def
toMap[T, U](implicit ev: <:<[Expression, (T, U)]): Map[T, U]
-
-
def
toSet[B >: Expression]: Set[B]
-
def
toStream: Stream[Expression]
-
def
toString(): String
-
def
toTraversable: Traversable[Expression]
-
-
def
transpose[B](implicit asTraversable: (Expression) ⇒ GenTraversableOnce[B]): Set[Set[B]]
-
-
def
unzip[A1, A2](implicit asPair: (Expression) ⇒ (A1, A2)): (Set[A1], Set[A2])
-
def
unzip3[A1, A2, A3](implicit asTriple: (Expression) ⇒ (A1, A2, A3)): (Set[A1], Set[A2], Set[A3])
-
def
view(from: Int, until: Int): IterableView[Expression, Set[Expression]]
-
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
-
def
zip[A1 >: Expression, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Set[Expression], (A1, B), That]): That
-
def
zipAll[B, A1 >: Expression, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Set[Expression], (A1, B), That]): That
-
def
zipWithIndex[A1 >: Expression, That](implicit bf: CanBuildFrom[Set[Expression], (A1, Int), That]): That
-
Deprecated Value Members
-
def
/:\[A1 >: Expression](z: A1)(op: (A1, A1) ⇒ A1): A1
Inherited from GenericSetTemplate[Expression, Set]
Inherited from Equals
Inherited from Immutable
Inherited from GenericTraversableTemplate[Expression, Set]
Inherited from Any
A Set where membership is determined based on a canonical representation of an Expression (i.e. one that attempts to ignore cosmetic differences). See Canonicalize for more details.
Internally this set uses the canonical representation, but keeps also track of the original expressions to ease debugging. Since different expressions can share the same canonical representation, this means that operations that extract expressions from this set are only guaranteed to see at least one such expression. For example: