NegZLong

Companion object NegZLong

final class NegZLong extends AnyVal

An AnyVal for non-positive Longs.

Because NegZLong is an AnyVal it will usually be as efficient as an Long, being boxed only when an Long would have been boxed.

The NegZLong.apply factory method is implemented in terms of a macro that checks literals for validity at compile time. Calling NegZLong.apply with a literal Long value will either produce a valid NegZLong instance at run time or an error at compile time. Here's an example:

scala> import anyvals._
import anyvals._

scala> NegZLong(-42L)
res0: org.scalactic.anyvals.NegZLong = NegZLong(-42L)

scala> NegZLong(-1L)
<console>:14: error: NegZLong.apply can only be invoked on a non-positive (i <= 0L) integer literal, like NegZLong(-42L).
              NegZLong(-1L)
                     ^

NegZLong.apply cannot be used if the value being passed is a variable (i.e., not a literal), because the macro cannot determine the validity of variables at compile time (just literals). If you try to pass a variable to NegZLong.apply, you'll get a compiler error that suggests you use a different factor method, NegZLong.from, instead:

scala> val x = -42L
x: Long = -42

scala> NegZLong(x)
<console>:15: error: NegZLong.apply can only be invoked on an long literal, like NegZLong(-42L). Please use NegZLong.from instead.
              NegZLong(x)
                     ^

The NegZLong.from factory method will inspect the value at runtime and return an Option[NegZLong]. If the value is valid, NegZLong.from will return a Some[NegZLong], else it will return a None. Here's an example:

scala> NegZLong.from(x)
res3: Option[org.scalactic.anyvals.NegZLong] = Some(NegZLong(-42))

scala> val y = 1L
y: Long = 1

scala> NegZLong.from(y)
res4: Option[org.scalactic.anyvals.NegZLong] = None

The NegZLong.apply factory method is marked implicit, so that you can pass literal Longs into methods that require NegZLong, and get the same compile-time checking you get when calling NegZLong.apply explicitly. Here's an example:

scala> def invert(pos: NegZLong): Long = Long.MaxValue - pos
invert: (pos: org.scalactic.anyvals.NegZLong)Long

scala> invert(1L)
res5: Long = 9223372036854775806

scala> invert(Long.MaxValue)
res6: Long = 0

scala> invert(1L)
<console>:15: error: NegZLong.apply can only be invoked on a non-positive (i <= 0L) integer literal, like NegZLong(-42L).
              invert(1L)
                     ^

This example also demonstrates that the NegZLong companion object also defines implicit widening conversions when either no loss of precision will occur or a similar conversion is provided in Scala. (For example, the implicit conversion from Long to Double in Scala can lose precision.) This makes it convenient to use a NegZLong where a Long or wider type is needed. An example is the subtraction in the body of the invert method defined above, Long.MaxValue - pos. Although Long.MaxValue is a Long, which has no - method that takes a NegZLong (the type of pos), you can still subtract pos, because the NegZLong will be implicitly widened to Long.

Source: NegZLong.scala

Linear Supertypes

AnyVal, Any

Ordering

Alphabetic
By Inheritance

Inherited

NegZLong
AnyVal
Any

Hide All
Show All

Visibility

Public
Protected