org.scalactic.anyvals.PosZInt.scala Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2001-2014 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalactic.anyvals

import scala.collection.immutable.Range

/**
 * An AnyVal for non-negative Ints.
 *
 * 
 * Because PosZInt is an AnyVal it will usually be
 * as efficient as an Int, being boxed only when an
 * Int would have been boxed.
 * 
 * 
 * 
 * The PosZInt.apply factory method is implemented in terms of a
 * macro that checks literals for validity at compile time. Calling
 * PosZInt.apply with a literal Int value will either
 * produce a valid PosZInt instance at run time or an error at
 * compile time. Here's an example:
 * 
 * 
 *  * scala> import anyvals._
 * import anyvals._
 *
 * scala> PosZInt(1)
 * res0: org.scalactic.anyvals.PosZInt = PosZInt(1)
 *
 * scala> PosZInt(0)
 * res1: org.scalactic.anyvals.PosZInt = PosZInt(0)
 *
 * scala> PosZInt(-1)
 * <console>:14: error: PosZInt.apply can only be invoked on a non-negative (i >= 0) integer literal, like PosZInt(42).
 *               PosZInt(-1)
 *                      ^
 * 
 *
 * 
 * PosZInt.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 PosZInt.apply, you'll get a compiler error
 * that suggests you use a different factor method, PosZInt.from,
 * instead:
 * 
 *
 *  * scala> val x = 1
 * x: Int = 1
 *
 * scala> PosZInt(x)
 * <console>:15: error: PosZInt.apply can only be invoked on an integer literal, like PosZInt(42). Please use PosZInt.from instead.
 *               PosZInt(x)
 *                      ^
 * 
 *
 * 
 * The PosZInt.from factory method will inspect the value at runtime and return an Option[PosZInt]. If
 * the value is valid, PosZInt.from will return a Some[PosZInt], else it will return a None.
 * Here's an example:
 * 
 *
 *  * scala> PosZInt.from(x)
 * res4: Option[org.scalactic.anyvals.PosZInt] = Some(PosZInt(1))
 *
 * scala> val y = -1
 * y: Int = -1
 *
 * scala> PosZInt.from(y)
 * res5: Option[org.scalactic.anyvals.PosZInt] = None
 * 
 * 
 * 
 * The PosZInt.apply factory method is marked implicit, so that
 * you can pass literal Ints into methods that require
 * PosZInt, and get the same compile-time checking you get when
 * calling PosZInt.apply explicitly. Here's an example:
 * 
 *
 *  * scala> def invert(pos: PosZInt): Int = Int.MaxValue - pos
 * invert: (pos: org.scalactic.anyvals.PosZInt)Int
 *
 * scala> invert(0)
 * res7: Int = 2147483647
 *
 * scala> invert(Int.MaxValue)
 * res8: Int = 0
 *
 * scala> invert(-1)
 * <console>:15: error: PosZInt.apply can only be invoked on a non-negative (i >= 0) integer literal, like PosZInt(42).
 *               invert(-1)
 *                       ^
 * 
 *
 * 
 * This example also demonstrates that the PosZInt
 * 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 Int to Float in
 * Scala can lose precision.) This makes it convenient to use a
 * PosZInt where an Int or wider type
 * is needed. An example is the subtraction in the body of the
 * invert method defined above, Int.MaxValue
 * - pos. Although Int.MaxValue is an
 * Int, which has no - method that
 * takes a PosZInt (the type of pos),
 * you can still subtract pos, because the
 * PosZInt will be implicitly widened to
 * Int.
 * 
 *
 * @param value The Int value underlying this PosZInt.
 */ 
final class PosZInt private (val value: Int) extends AnyVal {

  /**
   * A string representation of this PosZInt.
   */
  override def toString: String = s"PosZInt($value)"

  /**
   * Converts this PosZInt to a Byte.
   */
  def toByte: Byte = value.toByte

  /**
   * Converts this PosZInt to a Short.
   */
  def toShort: Short = value.toShort

  /**
   * Converts this PosZInt to a Char.
   */
  def toChar: Char = value.toChar

  /**
   * Converts this PosZInt to an Int.
   */
  def toInt: Int = value.toInt

  /**
   * Converts this PosZInt to a Long.
   */
  def toLong: Long = value.toLong

  /**
   * Converts this PosZInt to a Float.
   */
  def toFloat: Float = value.toFloat

  /**
   * Converts this PosZInt to a Double.
   */
  def toDouble: Double = value.toDouble
  /**
  * Returns the bitwise negation of this value.
  * @example {{{
  * ~5 == -6
  * // in binary: ~00000101 ==
  * // 11111010
  * }}}
  */
  def unary_~ : Int = ~value
  /** Returns this value, unmodified. */
  def unary_+ : PosZInt = this
  /** Returns the negation of this value. */
  def unary_- : Int = -value
  /**
   * Converts this PosZInt's value to a string then concatenates the given string.
   */
  def +(x: String): String = value + x
  /**
  * Returns this value bit-shifted left by the specified number of bits,
  * filling in the new right bits with zeroes.
  * @example {{{ 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 }}}
  */
  def <<(x: Int): Int = value << x
  /**
  * Returns this value bit-shifted left by the specified number of bits,
  * filling in the new right bits with zeroes.
  * @example {{{ 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 }}}
  */
  def <<(x: Long): Int = value << x
  /**
  * Returns this value bit-shifted right by the specified number of bits,
  * filling the new left bits with zeroes.
  * @example {{{ 21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010 }}}
  * @example {{{
  * -21 >>> 3 == 536870909
  * // in binary: 11111111 11111111 11111111 11101011 >>> 3 ==
  * // 00011111 11111111 11111111 11111101
  * }}}
  */
  def >>>(x: Int): Int = value >>> x
  /**
  * Returns this value bit-shifted right by the specified number of bits,
  * filling the new left bits with zeroes.
  * @example {{{ 21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010 }}}
  * @example {{{
  * -21 >>> 3 == 536870909
  * // in binary: 11111111 11111111 11111111 11101011 >>> 3 ==
  * // 00011111 11111111 11111111 11111101
  * }}}
  */
  def >>>(x: Long): Int = value >>> x
  /**
  * Returns this value bit-shifted left by the specified number of bits,
  * filling in the right bits with the same value as the left-most bit of this.
  * The effect of this is to retain the sign of the value.
  * @example {{{
  * -21 >> 3 == -3
  * // in binary: 11111111 11111111 11111111 11101011 >> 3 ==
  * // 11111111 11111111 11111111 11111101
  * }}}
  */
  def >>(x: Int): Int = value >> x
  /**
  * Returns this value bit-shifted left by the specified number of bits,
  * filling in the right bits with the same value as the left-most bit of this.
  * The effect of this is to retain the sign of the value.
  * @example {{{
  * -21 >> 3 == -3
  * // in binary: 11111111 11111111 11111111 11101011 >> 3 ==
  * // 11111111 11111111 11111111 11111101
  * }}}
  */
  def >>(x: Long): Int = value >> x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Byte): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Short): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Char): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Int): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Long): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Float): Boolean = value < x
  /** Returns `true` if this value is less than x, `false` otherwise. */
  def <(x: Double): Boolean = value < x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Byte): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Short): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Char): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Int): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Long): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Float): Boolean = value <= x
  /** Returns `true` if this value is less than or equal to x, `false` otherwise. */
  def <=(x: Double): Boolean = value <= x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Byte): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Short): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Char): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Int): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Long): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Float): Boolean = value > x
  /** Returns `true` if this value is greater than x, `false` otherwise. */
  def >(x: Double): Boolean = value > x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Byte): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Short): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Char): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Int): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Long): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Float): Boolean = value >= x
  /** Returns `true` if this value is greater than or equal to x, `false` otherwise. */
  def >=(x: Double): Boolean = value >= x
  /**
  * Returns the bitwise OR of this value and `x`.
  * @example {{{
  * (0xf0 | 0xaa) == 0xfa
  * // in binary: 11110000
  * // | 10101010
  * // --------
  * // 11111010
  * }}}
  */
  def |(x: Byte): Int = value | x
  /**
  * Returns the bitwise OR of this value and `x`.
  * @example {{{
  * (0xf0 | 0xaa) == 0xfa
  * // in binary: 11110000
  * // | 10101010
  * // --------
  * // 11111010
  * }}}
  */
  def |(x: Short): Int = value | x
  /**
  * Returns the bitwise OR of this value and `x`.
  * @example {{{
  * (0xf0 | 0xaa) == 0xfa
  * // in binary: 11110000
  * // | 10101010
  * // --------
  * // 11111010
  * }}}
  */
  def |(x: Char): Int = value | x
  /**
  * Returns the bitwise OR of this value and `x`.
  * @example {{{
  * (0xf0 | 0xaa) == 0xfa
  * // in binary: 11110000
  * // | 10101010
  * // --------
  * // 11111010
  * }}}
  */
  def |(x: Int): Int = value | x
  /**
  * Returns the bitwise OR of this value and `x`.
  * @example {{{
  * (0xf0 | 0xaa) == 0xfa
  * // in binary: 11110000
  * // | 10101010
  * // --------
  * // 11111010
  * }}}
  */
  def |(x: Long): Long = value | x
  /**
  * Returns the bitwise AND of this value and `x`.
  * @example {{{
  * (0xf0 & 0xaa) == 0xa0
  * // in binary: 11110000
  * // & 10101010
  * // --------
  * // 10100000
  * }}}
  */
  def &(x: Byte): Int = value & x
  /**
  * Returns the bitwise AND of this value and `x`.
  * @example {{{
  * (0xf0 & 0xaa) == 0xa0
  * // in binary: 11110000
  * // & 10101010
  * // --------
  * // 10100000
  * }}}
  */
  def &(x: Short): Int = value & x
  /**
  * Returns the bitwise AND of this value and `x`.
  * @example {{{
  * (0xf0 & 0xaa) == 0xa0
  * // in binary: 11110000
  * // & 10101010
  * // --------
  * // 10100000
  * }}}
  */
  def &(x: Char): Int = value & x
  /**
  * Returns the bitwise AND of this value and `x`.
  * @example {{{
  * (0xf0 & 0xaa) == 0xa0
  * // in binary: 11110000
  * // & 10101010
  * // --------
  * // 10100000
  * }}}
  */
  def &(x: Int): Int = value & x
  /**
  * Returns the bitwise AND of this value and `x`.
  * @example {{{
  * (0xf0 & 0xaa) == 0xa0
  * // in binary: 11110000
  * // & 10101010
  * // --------
  * // 10100000
  * }}}
  */
  def &(x: Long): Long = value & x
  /**
  * Returns the bitwise XOR of this value and `x`.
  * @example {{{
  * (0xf0 ^ 0xaa) == 0x5a
  * // in binary: 11110000
  * // ^ 10101010
  * // --------
  * // 01011010
  * }}}
  */
  def ^(x: Byte): Int = value ^ x
  /**
  * Returns the bitwise XOR of this value and `x`.
  * @example {{{
  * (0xf0 ^ 0xaa) == 0x5a
  * // in binary: 11110000
  * // ^ 10101010
  * // --------
  * // 01011010
  * }}}
  */
  def ^(x: Short): Int = value ^ x
  /**
  * Returns the bitwise XOR of this value and `x`.
  * @example {{{
  * (0xf0 ^ 0xaa) == 0x5a
  * // in binary: 11110000
  * // ^ 10101010
  * // --------
  * // 01011010
  * }}}
  */
  def ^(x: Char): Int = value ^ x
  /**
  * Returns the bitwise XOR of this value and `x`.
  * @example {{{
  * (0xf0 ^ 0xaa) == 0x5a
  * // in binary: 11110000
  * // ^ 10101010
  * // --------
  * // 01011010
  * }}}
  */
  def ^(x: Int): Int = value ^ x
  /**
  * Returns the bitwise XOR of this value and `x`.
  * @example {{{
  * (0xf0 ^ 0xaa) == 0x5a
  * // in binary: 11110000
  * // ^ 10101010
  * // --------
  * // 01011010
  * }}}
  */
  def ^(x: Long): Long = value ^ x
  /** Returns the sum of this value and `x`. */
  def +(x: Byte): Int = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Short): Int = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Char): Int = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Int): Int = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Long): Long = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Float): Float = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Double): Double = value + x
  /** Returns the difference of this value and `x`. */
  def -(x: Byte): Int = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Short): Int = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Char): Int = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Int): Int = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Long): Long = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Float): Float = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Double): Double = value - x
  /** Returns the product of this value and `x`. */
  def *(x: Byte): Int = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Short): Int = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Char): Int = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Int): Int = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Long): Long = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Float): Float = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Double): Double = value * x
  /** Returns the quotient of this value and `x`. */
  def /(x: Byte): Int = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Short): Int = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Char): Int = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Int): Int = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Long): Long = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Float): Float = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Double): Double = value / x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Byte): Int = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Short): Int = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Char): Int = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Int): Int = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Long): Long = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Float): Float = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Double): Double = value % x

  // Stuff from Richint:
  /**
   * Returns a string representation of this PosZInt's underlying Int as an
   * unsigned integer in base 2.
   *
   * 
   * The unsigned integer value is the argument plus 2³²
   * if this PosZInt's underlying Int is negative; otherwise it is equal to the
   * underlying Int.  This value is converted to a string of ASCII digits
   * in binary (base 2) with no extra leading 0s.
   * If the unsigned magnitude is zero, it is represented by a
   * single zero character '0'
   * ('\u0030'); otherwise, the first character of
   * the representation of the unsigned magnitude will not be the
   * zero character. The characters '0'
   * ('\u0030') and '1'
   * ('\u0031') are used as binary digits.
   * 
   *
   * @return  the string representation of the unsigned integer value
   *          represented by this PosZInt's underlying Int in binary (base 2).
   */
  def toBinaryString: String = java.lang.Integer.toBinaryString(value)

  /**
   * Returns a string representation of this PosZInt's underlying Int as an
   * unsigned integer in base 16.
   *
   * 
   * The unsigned integer value is the argument plus 2³²
   * if this PosZInt's underlying Int is negative; otherwise, it is equal to the
   * this PosZInt's underlying Int  This value is converted to a string of ASCII digits
   * in hexadecimal (base 16) with no extra leading
   * 0s. If the unsigned magnitude is zero, it is
   * represented by a single zero character '0'
   * ('\u0030'); otherwise, the first character of
   * the representation of the unsigned magnitude will not be the
   * zero character. The following characters are used as
   * hexadecimal digits:
   * 
   *
   * 
   *  0123456789abcdef
   * 
   *
   * These are the characters '\u0030' through
   * '\u0039' and '\u0061' through
   * '\u0066'. If uppercase letters are
   * desired, the toUpperCase method may
   * be called on the result.
   *
   * @return  the string representation of the unsigned integer value
   *          represented by this PosZInt's underlying Int in hexadecimal (base 16).
   */
  def toHexString: String = java.lang.Integer.toHexString(value)

  /**
   * Returns a string representation of this PosZInt's underlying Int as an
   * unsigned integer in base 8.
   *
   * The unsigned integer value is this PosZInt's underlying Int plus 2³²
   * if the underlying Int is negative; otherwise, it is equal to the
   * underlying Int.  This value is converted to a string of ASCII digits
   * in octal (base 8) with no extra leading 0s.
   *
   * 
If the unsigned magnitude is zero, it is represented by a
   * single zero character '0'
   * ('\u0030'); otherwise, the first character of
   * the representation of the unsigned magnitude will not be the
   * zero character. The following characters are used as octal
   * digits:
   *
   * 

   * 01234567
   * 
   *
   * These are the characters '\u0030' through
   * '\u0037'.
   *
   * @return  the string representation of the unsigned integer value
   *          represented by this PosZInt's underlying Int in octal (base 8).
   */
  def toOctalString: String = java.lang.Integer.toOctalString(value)

  /**
  * Create a Range from this PosZInt value
  * until the specified end (exclusive) with step value 1.
  *
  * @param end The final bound of the range to make.
  * @return A [[scala.collection.immutable.Range]] from `this` up to but
  * not including `end`.
  */
  def until(end: Int): Range = Range(value, end)

  /**
  * Create a Range from this PosZInt value
  * until the specified end (exclusive) with the specified step value.
  *
  * @param end The final bound of the range to make.
  * @param step The number to increase by for each step of the range.
  * @return A [[scala.collection.immutable.Range]] from `this` up to but
  * not including `end`.
  */
  def until(end: Int, step: Int): Range = Range(value, end, step)

  /**
  * Create an inclusive Range from this PosZInt value
  * to the specified end with step value 1.
  *
  * @param end The final bound of the range to make.
  * @return A [[scala.collection.immutable.Range]] from `'''this'''` up to
  * and including `end`.
  */
  def to(end: Int): Range.Inclusive = Range.inclusive(value, end)

  /**
  * Create an inclusive Range from this PosZInt value
  * to the specified end with the specified step value.
  *
  * @param end The final bound of the range to make.
  * @param step The number to increase by for each step of the range.
  * @return A [[scala.collection.immutable.Range]] from `'''this'''` up to
  * and including `end`.
  */
  def to(end: Int, step: Int): Range.Inclusive = Range.inclusive(value, end, step)

  // No point to call abs on a PosZInt.
  /**
  * Returns this if this > that or that otherwise.
  */
  def max(that: PosZInt): PosZInt = if (math.max(value, that.value) == value) this else that

  /**
  * Returns this if this < that or that otherwise.
  */
  def min(that: PosZInt): PosZInt = if (math.min(value, that.value) == value) this else that
}

/**
 * The companion object for PosZInt that offers
 * factory methods that produce PosZInts, implicit
 * widening conversions from PosZInt to other
 * numeric types, and maximum and minimum constant values for
 * PosZInt.
 */
object PosZInt {
  /**
   * The largest value representable as a non-negative Int,
   * which is PosZInt(2147483647).
   */
  final val MaxValue: PosZInt = PosZInt.from(Int.MaxValue).get

  /**
   * The smallest value representable as a non-negative Int,
   * which is PosZInt(0).
   */
  final val MinValue: PosZInt = PosZInt.from(0).get // Can't use the macro here

  /**
   * A factory method that produces an Option[PosZInt] given an
   * Int value.
   *
   * 
   * This method will inspect the passed Int value
   * and if it is a non-negative Int,
   * i.e., a value greater than or equal to 0, it will
   * return a PosZInt representing that value,
   * wrapped in a Some. Otherwise, the passed
   * Int value is negative, so this method
   * will return None.
   * 
   *
   * 
   * This factory method differs from the apply
   * factory method in that apply is implemented
   * via a macro that inspects Int literals at
   * compile time, whereas from inspects
   * Int values at run time.
   * 
   *
   * @param value the Int to inspect, and if non-negative, return
   *     wrapped in a Some[PosZInt].
   * @return the specified Int value wrapped
   *     in a Some[PosZInt], if it is positive, else
   *     None.
   */
  def from(value: Int): Option[PosZInt] =
    if (value >= 0) Some(new PosZInt(value)) else None

  import language.experimental.macros
  import scala.language.implicitConversions

  /**
   * A factory method, implemented via a macro, that produces a
   * PosZInt if passed a valid Int
   * literal, otherwise a compile time error.
   *
   * 
   * The macro that implements this method will inspect the
   * specified Int expression at compile time. If
   * the expression is a non-negative Int literal,
   * i.e., with a value greater than or equal to 0, it will return
   * a PosZInt representing that value.  Otherwise,
   * the passed Int expression is either a literal
   * that is negative, or is not a literal, so this method
   * will give a compiler error.
   * 
   *
   * 
   * This factory method differs from the from
   * factory method in that this method is implemented via a
   * macro that inspects Int literals at compile
   * time, whereas from inspects Int
   * values at run time.
   * 
   *
   * @param value the Int literal expression to inspect at
   *     compile time, and if non-negative, to return wrapped in a
   *     PosZInt at run time.
   * @return the specified, valid Int literal value wrapped
   *     in a PosZInt. (If the specified expression is not a valid
   *     Int literal, the invocation of this method will not
   *     compile.)
   */
  implicit def apply(value: Int): PosZInt = macro PosZIntMacro.apply

  /**
   * Implicit widening conversion from PosZInt to
   * Int.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt.
   */
  implicit def widenToInt(poz: PosZInt): Int = poz.value

  /**
   * Implicit widening conversion from PosZInt to
   * Long.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Long.
   */
  implicit def widenToLong(poz: PosZInt): Long = poz.value

  /**
   * Implicit widening conversion from PosZInt to
   * Float.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Float.
   */
  implicit def widenToFloat(poz: PosZInt): Float = poz.value

  /**
   * Implicit widening conversion from PosZInt to
   * Double.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Double.
   */
  implicit def widenToDouble(poz: PosZInt): Double = poz.value

  /**
   * Implicit widening conversion from PosZInt to
   * PosZLong.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Long and
   *     wrapped in a PosZLong.
   */
  implicit def widenToPosZLong(poz: PosZInt): PosZLong = PosZLong.from(poz.value).get

  /**
   * Implicit widening conversion from PosZInt to
   * PosZFloat.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Float and
   *     wrapped in a PosZFloat.
   */
  implicit def widenToPosZFloat(poz: PosZInt): PosZFloat = PosZFloat.from(poz.value).get

  /**
   * Implicit widening conversion from PosZInt to
   * PosZDouble.
   *
   * @param pos the PosZInt to widen
   * @return the Int value underlying the specified
   *     PosZInt, widened to Double
   *     and wrapped in a PosZDouble.
   */
  implicit def widenToPosZDouble(poz: PosZInt): PosZDouble = PosZDouble.from(poz.value).get

  /**
   * Implicit Ordering instance.
   */
  implicit val posZIntOrd: Ordering[PosZInt] =
    new Ordering[PosZInt] {
      def compare(x: PosZInt, y: PosZInt): Int = x - y
    } 
}