Scalactic 3.2.15/org.scalactic.anyvals/NonZeroFloat

NonZeroFloat

final class NonZeroFloat extends AnyVal

An AnyVal for non-zero Floats.

Note: a NonZeroFloat may not equal 0.0.

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

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

scala> import anyvals._
import anyvals._

scala> NonZeroFloat(1.1F)
res0: org.scalactic.anyvals.NonZeroFloat = NonZeroFloat(1.1)

scala> NonZeroFloat(0.0F)
<console>:14: error: NonZeroFloat.apply can only be invoked on a non-zero (i != 0.0f && !i.isNaN) floating point literal, like NonZeroFloat(1.1F).
             NonZeroFloat(1.1F)
                     ^

NonZeroFloat.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 NonZeroFloat.apply, you'll get a compiler error that suggests you use a different factor method, NonZeroFloat.from, instead:

scala> val x = 1.1F
x: Float = 1.1

scala> NonZeroFloat(x)
<console>:15: error: NonZeroFloat.apply can only be invoked on a floating point literal, like NonZeroFloat(1.1F). Please use NonZeroFloat.from instead.
             NonZeroFloat(x)
                     ^

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

scala> NonZeroFloat.from(x)
res3: Option[org.scalactic.anyvals.NonZeroFloat] = Some(NonZeroFloat(1.1))

scala> val y = 0.0F
y: Float = 0.0

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

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

scala> def invert(pos: NonZeroFloat): Float = Float.MaxValue - pos
invert: (pos: org.scalactic.anyvals.NonZeroFloat)Float

scala> invert(1.1F)
res5: Float = 3.4028235E38

scala> invert(Float.MaxValue)
res6: Float = 0.0

scala> invert(0.0F)
<console>:15: error: NonZeroFloat.apply can only be invoked on a non-zero (i != 0.0f && !i.isNaN) floating point literal, like NonZeroFloat(1.1F).
             invert(0.0F)
                    ^

scala> invert(0.0F)
<console>:15: error: NonZeroFloat.apply can only be invoked on a non-zero (i != 0.0f && !i.isNaN) floating point literal, like NonZeroFloat(1.1F).
             invert(0.0F)
                     ^

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

Value parameters:

value: The Float value underlying this NonZeroFloat.

Companion:

object

Source:

NonZeroFloat.scala

class AnyVal

trait Matchable

class Any

NonZeroFloat

Value members

Concrete methods

Concrete fields