Range

A range (or "interval") defines the boundaries around a contiguous span of values of some type which an Ordering exists; for example, "integers from 1 to 100 inclusive." Note that it is not possible to iterate over these contained values. To do so, pass this range instance and an appropriate DiscreteDomain to ContiguousSet#create.

Types of ranges

Each end of the range may be bounded or unbounded. If bounded, there is an associated endpoint value, and the range is considered to be either open (does not include the endpoint) or closed (includes the endpoint) on that side. With three possibilities on each side, this yields nine basic types of ranges, enumerated below. (Notation: a square bracket [ ] indicates that the range is closed on that side; a parenthesis ( ) means it is either open or unbounded. The construct {x | statement} is read "the set of all x such that statement.")

Notation      Definition         Factory method
(a..b)        {x | a < x < b}    Range#open
[a..b]        {x | a <= x <= b}  Range#closed
(a..b]        {x | a < x <= b}   Range#openClosed
[a..b)        {x | a <= x < b}   Range#closedOpen
(a..+inf)     {x | x > a}        Range#greaterThan
[a..+inf)     {x | x >= a}       Range#atLeast
(-inf..b)     {x | x < b}        Range#lessThan
(-inf..b]     {x | x <= b}       Range#atMost
(-inf..+inf)  {x}                Range#all

When both endpoints exist, the upper endpoint may not be less than the lower. The endpoints may be equal only if at least one of the bounds is closed:

[a..a] : a singleton range
[a..a); (a..a] : empty ranges; also valid
(a..a) : invalid; an exception will be thrown

Warnings

Use immutable value types only, if at all possible. If you must use a mutable type, do not allow the endpoint instances to mutate after the range is created!
Your value type's comparison method should be consistent with equals if at all possible. Otherwise, be aware that concepts used throughout this documentation such as "equal", "same", "unique" and so on actually refer to whether Ordering#compare returns zero, not whether equals returns true.

Other notes

Instances of this type are obtained using the static factory methods in this class.
Ranges are convex: whenever two values are contained, all values in between them must also be contained. More formally, for any c1 <= c2 <= c3 of type C, r.contains(c1) && r.contains(c3) implies r.contains(c2)). This means that a Range[Int,Ordering[Int] can never be used to represent, say, "all prime numbers from 1 to 100."
When evaluated as a predicate, a range yields the same result as invoking #contains.
Terminology note: a range a is said to be the maximal range having property P if, for all ranges b also having property P, a.encloses(b). Likewise, a is minimal when b.encloses(a) for all b having property P. See, for example, the definition of intersection.

Pattern matching

Extractors are defined for general ranges with finite and infinite bounds. For example:

val range = Range.atLeast(6) // Range[Int,math.Ordering.Int.type] = [6..inf)
range match {
   case Range(FiniteBound(lower, lowerType),InfiniteBound) =>
   // matches lower = 6
   //         lowerType = Closed
}

Difference between Mango and Guava implementation

Since most Scala classes don't implement Ordered a Range of type T needs a "companion" type class of Ordering[T].

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def all[T, O <: Ordering[T]]()(implicit ord: O): Range[T, O]

Returns a range that contains every value of type T.
Returns a range that contains every value of type T.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atLeast[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values greater than or equal to endpoint.
Returns a range that contains all values greater than or equal to endpoint.
def atMost[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values less than or equal to endpoint.
Returns a range that contains all values less than or equal to endpoint.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def closed[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values greater than or equal to lower and less than or equal to upper.
Returns a range that contains all values greater than or equal to lower and less than or equal to upper.

Annotations
@throws( ... )
Exceptions thrown
IllegalArgumentException if lower is greater than upper
def closedOpen[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values greater than or equal to lower and strictly less than upper.
Returns a range that contains all values greater than or equal to lower and strictly less than upper.

Annotations
@throws( ... )
Exceptions thrown
IllegalArgumentException if lower is greater than upper
def downTo[T, O <: Ordering[T]](endpoint: T, boundType: BoundType)(implicit ord: O): Range[T, O]

Returns a range from the given endpoint, which may be either inclusive (closed) or exclusive (open), with no upper bound.
def encloseAll[T, O <: Ordering[T]](values: Iterable[T])(implicit ord: O): Range[T, O]

Returns the minimal range that contains all of the given values.
Returns the minimal range that contains all of the given values. The returned range is closed on both ends.

Annotations
@throws( ... ) @throws( ... )
Exceptions thrown
ClassCastException if the parameters are not mutually comparable
NoSuchElementException if values is empty
NullPointerException if any of values is null
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def greaterThan[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values strictly greater than endpoint.
Returns a range that contains all values strictly greater than endpoint.
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lessThan[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values strictly less than endpoint.
Returns a range that contains all values strictly less than endpoint.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def open[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values strictly greater than lower and strictly less than upper.
Returns a range that contains all values strictly greater than lower and strictly less than upper.

Annotations
@throws( ... )
Exceptions thrown
IllegalArgumentException if lower is greater than or equal to upper
def openClosed[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

Returns a range that contains all values strictly greater than lower and less than or equal to upper.
Returns a range that contains all values strictly greater than lower and less than or equal to upper.

Annotations
@throws( ... )
Exceptions thrown
IllegalArgumentException if lower is greater than upper
def range[T, O <: Ordering[T]](lower: T, lowerType: BoundType, upper: T, upperType: BoundType)(implicit ord: O): Range[T, O]

Returns a range that contains any value from lower to upper, where each endpoint may be either inclusive (closed) or exclusive (open).
Returns a range that contains any value from lower to upper, where each endpoint may be either inclusive (closed) or exclusive (open).

Annotations
@throws( ... )
Exceptions thrown
IllegalArgumentException if lower is greater than upper
def singleton[T, O <: Ordering[T]](value: T)(implicit ord: O): Range[T, O]

Returns a range that contains only the given value.
Returns a range that contains only the given value. The returned range is closed on both ends.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any

def unapply[T, O <: Ordering[T]](range: Range[T, O]): Option[(Bound[T], Bound[T])]

Extractor to pattern match Range

For example:

val range = Range.atLeast(6) // Range[Int,math.Ordering.Int.type] = [6..inf)
range match {
   case Range(FiniteBound(lower, lowerType),InfiniteBound) =>
   // matches lower = 6
   //         lowerType = Closed
}

def upTo[T, O <: Ordering[T]](endpoint: T, boundType: BoundType)(implicit ord: O): Range[T, O]

Returns a range with no lower bound up to the given endpoint, which may be either inclusive (closed) or exclusive (open).
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: class Range | package collect

object Range extends Serializable

Types of ranges

Warnings

Other notes

Pattern matching

Difference between Mango and Guava implementation

Further reading

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def all[T, O <: Ordering[T]]()(implicit ord: O): Range[T, O]

final def asInstanceOf[T0]: T0

def atLeast[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

def atMost[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

def clone(): AnyRef

def closed[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

def closedOpen[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

def downTo[T, O <: Ordering[T]](endpoint: T, boundType: BoundType)(implicit ord: O): Range[T, O]

def encloseAll[T, O <: Ordering[T]](values: Iterable[T])(implicit ord: O): Range[T, O]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def greaterThan[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lessThan[T, O <: Ordering[T]](endpoint: T)(implicit ord: O): Range[T, O]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def open[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

def openClosed[T, O <: Ordering[T]](lower: T, upper: T)(implicit ord: O): Range[T, O]

def range[T, O <: Ordering[T]](lower: T, lowerType: BoundType, upper: T, upperType: BoundType)(implicit ord: O): Range[T, O]

def singleton[T, O <: Ordering[T]](value: T)(implicit ord: O): Range[T, O]

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

def toString(): String

def unapply[T, O <: Ordering[T]](range: Range[T, O]): Option[(Bound[T], Bound[T])]

def upTo[T, O <: Ordering[T]](endpoint: T, boundType: BoundType)(implicit ord: O): Range[T, O]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped