RelationLike

abstract def companion: RelationFactory[Repr]

A companion object that provides factory methods for this kind of relation.

abstract def graph: Vector[(T, U)]

The graph of this relation.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(t: T): Vector[U]

Apply this relation (same as image).

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[V, W](f: ==>[(T, U), (V, W)]): Repr[V, W]

Build a new relation by collecting pairs produced by the partial function f wherever it is defined on pairs of this relation.

def compose[S](st: RelationLike[S, T, Repr]): Repr[S, U]

Compose this relation with st.

def containsInDomain(t: T): Boolean

Does the domain of this relation contain the value t?

def containsInRange(u: U): Boolean

Does the range of this relation contain the value u?

lazy val domain: Vector[T]

The domain of this relation.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def image(t: T): Vector[U]

The image of a value of the relation's domain is a set of the values in the range that are related to that domain value.

lazy val index: Repr[U, Int]

A relation that maps each element of the range to its position (starting counting at zero).

lazy val inverse: Repr[U, T]

Invert this relation.

lazy val isEmpty: Boolean

Is this relation empty (i.

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

object pair

An auxiliary extractor for this relation that matches pairs.

def preImage(u: U): Vector[T]

The preImage of a value of the relation's range is a set of the values in the domain that are related to that range value.

lazy val preIndex: Repr[T, Int]

A relation that maps each element of the domain to its position starting at zero.

lazy val projDomain: Repr[T, Vector[U]]

Domain projection, i.

lazy val projRange: Repr[U, Vector[T]]

Range projection, i.

lazy val range: Vector[U]

The range of this relation.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def unapply(t: T): Option[U]

A relation can be used as an extractor that matches if and only if the matched value t has a unique image in the relation.

def unapplySeq(t: T): Option[Vector[U]]

A relation can be used as an extractor that returns the image for a given domain value t.

def union(r: RelationLike[T, U, Repr]): Repr[T, U]

Union this relation with r.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withDomain(t: T): Repr[T, U]

Return the sub-relation of this relation that contains just those pairs that have t as their domain element.

def withRange(u: U): Repr[T, U]

Return the sub-relation of this relation that contains just those pairs that have u as their range element.