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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest-app_3 Show documentation
scalatest-app
The newest version!
/*
 * Copyright 2001-2016 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.NumericRange
import scala.language.implicitConversions
import scala.util.{Try, Success, Failure}

import org.scalactic.{Validation, Pass, Fail}
import org.scalactic.{Or, Good, Bad}

/**
 * An AnyVal for negative Longs.
 *
 * Note: a NegLong may not equal 0. If you want negative number or 0, use [[NegZLong]].
 *
 * 
 * Because NegLong is an AnyVal it
 * will usually be as efficient as an Long, being
 * boxed only when an Long would have been boxed.
 * 
 *
 * 
 * The NegLong.apply factory method is implemented
 * in terms of a macro that checks literals for validity at
 * compile time. Calling NegLong.apply with a
 * literal Long value will either produce a valid
 * NegLong instance at run time or an error at
 * compile time. Here's an example:
 * 
 *
 *  * scala> import anyvals._
 * import anyvals._
 *
 * scala> NegLong(-42L)
 * res0: org.scalactic.anyvals.NegLong = NegLong(-42L)
 *
 * scala> NegLong(0L)
 * <console>:14: error: NegLong.apply can only be invoked on a negative (i < 0L) integer literal, like NegLong(-42L).
 *               NegLong(0L)
 *                      ^
 * 
 *
 * 
 * NegLong.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 NegLong.apply, you'll get a compiler error
 * that suggests you use a different factor method,
 * NegLong.from, instead:
 * 
 *
 *  * scala> val x = -42LL
 * x: Long = -42L
 *
 * scala> NegLong(x)
 * <console>:15: error: NegLong.apply can only be invoked on an long literal, like NegLong(-42L). Please use NegLong.from instead.
 *               NegLong(x)
 *                      ^
 * 
 *
 * 
 * The NegLong.from factory method will inspect the
 * value at runtime and return an
 * Option[NegLong]. If the value is valid,
 * NegLong.from will return a
 * Some[NegLong], else it will return a
 * None.  Here's an example:
 * 
 *
 *  * scala> NegLong.from(x)
 * res3: Option[org.scalactic.anyvals.NegLong] = Some(NegLong(-42L))
 *
 * scala> val y = 0LL
 * y: Long = 0L
 *
 * scala> NegLong.from(y)
 * res4: Option[org.scalactic.anyvals.NegLong] = None
 * 
 *
 * 
 * The NegLong.apply factory method is marked
 * implicit, so that you can pass literal Longs
 * into methods that require NegLong, and get the
 * same compile-time checking you get when calling
 * NegLong.apply explicitly. Here's an example:
 * 
 *
 *  * scala> def invert(pos: NegLong): Long = Long.MaxValue - pos
 * invert: (pos: org.scalactic.anyvals.NegLong)Long
 *
 * scala> invert(1L)
 * res5: Long = 9223372036854775806
 *
 * scala> invert(Long.MaxValue)
 * res6: Long = 0
 *
 * scala> invert(0LL)
 * <console>:15: error: NegLong.apply can only be invoked on a negative (i < 0L) integer literal, like NegLong(-42LL).
 *               invert(0LL)
 *                      ^
 *
 * 
 *
 * 
 * This example also demonstrates that the NegLong
 * 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
 * NegLong 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 NegLong (the type of pos),
 * you can still subtract pos, because the
 * NegLong will be implicitly widened to
 * Long.
 * 
 *
 * @param value The Long value underlying this NegLong.
 */
final class NegLong private (val value: Long) extends AnyVal {

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

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

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

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

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

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

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

  /**
   * Converts this NegLong to a Double.
   */
  def toDouble: Double = value.toDouble

 /**
  * Returns the bitwise negation of this value.
  * @example {{{
  * ~5 == -6
  * // in binary: ~00000101 ==
  * //             11111010
  * }}}
  */
  def unary_~ : Long = ~value
  /** Returns this value, unmodified. */
  def unary_+ : NegLong = this
  /** Returns the negation of this value. */
  def unary_- : Long = -value

  /**
   * Converts this NegLong's value to a string then concatenates the given string.
   */
  def +(x: String): String = s"${value.toString()}$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): Long = 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): Long = 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): Long = 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): Long = 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): Long = 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): Long = 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): Long = value | x
  /**
   * Returns the bitwise OR of this value and `x`.
   * @example {{{
   * (0xf0 | 0xaa) == 0xfa
   * // in binary:   11110000
   * //            | 10101010
   * //              --------
   * //              11111010
   * }}}
   */
  def |(x: Short): Long = value | x
  /**
   * Returns the bitwise OR of this value and `x`.
   * @example {{{
   * (0xf0 | 0xaa) == 0xfa
   * // in binary:   11110000
   * //            | 10101010
   * //              --------
   * //              11111010
   * }}}
   */
  def |(x: Char): Long = value | x
  /**
   * Returns the bitwise OR of this value and `x`.
   * @example {{{
   * (0xf0 | 0xaa) == 0xfa
   * // in binary:   11110000
   * //            | 10101010
   * //              --------
   * //              11111010
   * }}}
   */
  def |(x: Int): Long = 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): Long = value & x
  /**
   * Returns the bitwise AND of this value and `x`.
   * @example {{{
   * (0xf0 & 0xaa) == 0xa0
   * // in binary:   11110000
   * //            & 10101010
   * //              --------
   * //              10100000
   * }}}
   */
  def &(x: Short): Long = value & x
  /**
   * Returns the bitwise AND of this value and `x`.
   * @example {{{
   * (0xf0 & 0xaa) == 0xa0
   * // in binary:   11110000
   * //            & 10101010
   * //              --------
   * //              10100000
   * }}}
   */
  def &(x: Char): Long = value & x
  /**
   * Returns the bitwise AND of this value and `x`.
   * @example {{{
   * (0xf0 & 0xaa) == 0xa0
   * // in binary:   11110000
   * //            & 10101010
   * //              --------
   * //              10100000
   * }}}
   */
  def &(x: Int): Long = 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): Long = value ^ x
  /**
   * Returns the bitwise XOR of this value and `x`.
   * @example {{{
   * (0xf0 ^ 0xaa) == 0x5a
   * // in binary:   11110000
   * //            ^ 10101010
   * //              --------
   * //              01011010
   * }}}
   */
  def ^(x: Short): Long = value ^ x
  /**
   * Returns the bitwise XOR of this value and `x`.
   * @example {{{
   * (0xf0 ^ 0xaa) == 0x5a
   * // in binary:   11110000
   * //            ^ 10101010
   * //              --------
   * //              01011010
   * }}}
   */
  def ^(x: Char): Long = value ^ x
  /**
   * Returns the bitwise XOR of this value and `x`.
   * @example {{{
   * (0xf0 ^ 0xaa) == 0x5a
   * // in binary:   11110000
   * //            ^ 10101010
   * //              --------
   * //              01011010
   * }}}
   */
  def ^(x: Int): Long = 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): Long = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Short): Long = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Char): Long = value + x
  /** Returns the sum of this value and `x`. */
  def +(x: Int): Long = 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): Long = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Short): Long = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Char): Long = value - x
  /** Returns the difference of this value and `x`. */
  def -(x: Int): Long = 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): Long = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Short): Long = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Char): Long = value * x
  /** Returns the product of this value and `x`. */
  def *(x: Int): Long = 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): Long = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Short): Long = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Char): Long = value / x
  /** Returns the quotient of this value and `x`. */
  def /(x: Int): Long = 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): Long = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Short): Long = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Char): Long = value % x
  /** Returns the remainder of the division of this value by `x`. */
  def %(x: Int): Long = 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 RichLong:
  /**
   * Returns a string representation of this NegLong's underlying Long
   * as an unsigned integer in base 2.
   *
   * 
   * The unsigned long value is this NegLong's underlying Long plus
   * 2⁶⁴ if the underlying Long is negative; otherwise, it is
   * equal to the underlying Long.  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 long
   *          value represented by this NegLong's underlying Long in binary (base 2).
   */
  def toBinaryString: String = java.lang.Long.toBinaryString(value)

  /**
   * Returns a string representation of this NegLong's underlying Long
   * as an unsigned integer in base 16.
   *
   * 
   * The unsigned long value is this NegLong's underlying Long plus
   * 2⁶⁴ if the underlying Long is negative; otherwise, it is
   * equal to the underlying Long.  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 long
   *          value represented by this NegLong's underlying Long in hexadecimal
   *          (base 16).
   */
  def toHexString: String = java.lang.Long.toHexString(value)

  /**
   * Returns a string representation of this NegLong's underlying Long
   * as an unsigned integer in base 8.
   *
   * 
   * The unsigned long value is this NegLong's underlying Long plus
   * 2⁶⁴ if the underlying Long is negative; otherwise, it is
   * equal to the underlying Long.  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 long
   *          value represented by this NegLong's underlying Long in octal (base 8).
   */
  def toOctalString: String = java.lang.Long.toOctalString(value)

  /**
   * Returns this if this > that or that otherwise.
   */
  def max(that: NegLong): NegLong = if (math.max(value, that.value) == value) this else that

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

  // adapted from RichInt:
  /**
   * Create a Range from this NegLong 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.NumericRange.Exclusive[Long]]] from `this` up to but
   * not including `end`.
   */
  def until(end: Long): NumericRange.Exclusive[Long] = value.until(end)

  /**
   * Create a Range from this NegLong value
   * until the specified end (exclusive) with the specified step value.
   *
   * @param end The final bound of the range to make.
   * @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.NumericRange.Exclusive[Long]]] from `this` up to but
   * not including `end`.
   */
  def until(end: Long, step: Long): NumericRange.Exclusive[Long] =
    value.until(end, step)

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

  /**
   * Create an inclusive Range from this NegLong 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.NumericRange.Inclusive[Long]]] from `'''this'''` up to
   * and including `end`.
   */
  def to(end: Long, step: Long): NumericRange.Inclusive[Long] =
    value.to(end, step)

  /**
   * Applies the passed Long => Long function to the underlying Long
   * value, and if the result is positive, returns the result wrapped in a NegLong,
   * else throws AssertionError.
   *
   * 
   * This method will inspect the result of applying the given function to this
   * NegLong's underlying Long value and if the result
   * is negative, it will return a NegLong representing that value.
   * Otherwise, the Long value returned by the given function is
   * not negative, this method will throw AssertionError.
   * 
   *
   * 
   * This method differs from a vanilla assert or ensuring
   * call in that you get something you didn't already have if the assertion
   * succeeds: a type that promises an Long is negative.
   * With this method, you are asserting that you are convinced the result of
   * the computation represented by applying the given function to this NegLong's
   * value will not overflow. Instead of overflowing silently like Long, this
   * method will signal an overflow with a loud AssertionError.
   * 
   *
   * @param f the Long => Long function to apply to this NegLong's
   *     underlying Long value.
   * @return the result of applying this NegLong's underlying Long value to
   *     to the passed function, wrapped in a NegLong if it is negative (else throws AssertionError).
   * @throws AssertionError if the result of applying this NegLong's underlying Long value to
   *     to the passed function is not positive.
   */
  def ensuringValid(f: Long => Long): NegLong = {
    val candidateResult: Long = f(value)
    if (NegLongMacro.isValid(candidateResult)) new NegLong(candidateResult)
    else throw new AssertionError(s"${candidateResult.toString()}, the result of applying the passed function to ${value.toString()}, was not a valid NegLong")
  }
}

/**
 * The companion object for NegLong that offers
 * factory methods that produce NegLongs, implicit
 * widening conversions from NegLong to other
 * numeric types, and maximum and minimum constant values for
 * NegLong.
 */
object NegLong {
  /**
   * The largest value representable as a negative
   * Long, which is NegLong(-1L).
   */
  final val MaxValue: NegLong = NegLong.ensuringValid(-1L)

  /**
   * The smallest value representable as a positive
   * Long, which is NegLong(-9223372036854775808).
   */
  final val MinValue: NegLong = NegLong.ensuringValid(Long.MinValue) // Can't use the macro here

  /**
   * A factory method that produces an Option[NegLong] given a
   * Long value.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a NegLong representing that value,
   * wrapped in a Some. Otherwise, the passed Long
   * value is not 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 Long literals at
   * compile time, whereas from inspects
   * Long values at run time.
   * 
   *
   * @param value the Long to inspect, and if negative, return
   *     wrapped in a Some[NegLong].
   * @return the specified Long value wrapped in a
   *     Some[NegLong], if it is negative, else
   *     None.
   */
  def from(value: Long): Option[NegLong] =
    if (NegLongMacro.isValid(value)) Some(new NegLong(value)) else None

  /**
   * A factory/assertion method that produces an NegLong given a
   * valid Long value, or throws AssertionError,
   * if given an invalid Long value.
   *
   * Note: you should use this method only when you are convinced that it will
   * always succeed, i.e., never throw an exception. It is good practice to
   * add a comment near the invocation of this method indicating ''why'' you think
   * it will always succeed to document your reasoning. If you are not sure an
   * `ensuringValid` call will always succeed, you should use one of the other
   * factory or validation methods provided on this object instead: `isValid`,
   * `tryingValid`, `passOrElse`, `goodOrElse`, or `rightOrElse`.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a NegLong representing that value.
   * Otherwise, the passed Long value is not negative, so
   * this method will throw AssertionError.
   * 
   *
   * 
   * This factory method differs from the apply
   * factory method in that apply is implemented
   * via a macro that inspects Long literals at
   * compile time, whereas from inspects
   * Long values at run time.
   * It differs from a vanilla assert or ensuring
   * call in that you get something you didn't already have if the assertion
   * succeeds: a type that promises a Long is positive.
   * 
   *
   * @param value the Long to inspect, and if negative, return
   *     wrapped in a NegLong.
   * @return the specified Long value wrapped in a
   *     NegLong, if it is negative, else
   *     throws AssertionError.
   * @throws AssertionError if the passed value is not negative
   */
  def ensuringValid(value: Long): NegLong =
    if (NegLongMacro.isValid(value)) new NegLong(value) else {
      throw new AssertionError(s"${value.toString()}  was not a valid NegLong")
    }

  /**
   * A factory/validation method that produces a NegLong, wrapped
   * in a Success, given a valid Long value, or if the
   * given Long is invalid, an AssertionError, wrapped
   * in a Failure.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a NegLong
   * representing that value, wrapped in a Success.
   * Otherwise, the passed Long value is not negative, so this
   * method will return an AssertionError, wrapped in a Failure.
   * 
   *
   * 
   * This factory method differs from the apply factory method
   * in that apply is implemented via a macro that inspects
   * Long literals at compile time, whereas this method inspects
   * Long values at run time.
   * 
   *
   * @param value the Long to inspect, and if negative, return
   *     wrapped in a Success(NegLong).
   * @return the specified Long value wrapped
   *     in a Success(NegLong), if it is negative, else a Failure(AssertionError).
   */
   def tryingValid(value: Long): Try[NegLong] =
     if (NegLongMacro.isValid(value))
       Success(new NegLong(value))
     else
       Failure(new AssertionError(s"${value.toString()} was not a valid NegLong"))

  /**
   * A validation method that produces a Pass
   * given a valid Long value, or
   * an error value of type E produced by passing the
   * given invalid Int value
   * to the given function f, wrapped in a Fail.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a Pass.
   * Otherwise, the passed Long value is negative, so this
   * method will return a result of type E obtained by passing
   * the invalid Long value to the given function f,
   * wrapped in a `Fail`.
   * 
   *
   * 
   * This factory method differs from the apply factory method
   * in that apply is implemented via a macro that inspects
   * Long literals at compile time, whereas this method inspects
   * Long values at run time.
   * 
   *
   * @param value the `Long` to validate that it is negative.
   * @return a `Pass` if the specified `Long` value is negative,
   *   else a `Fail` containing an error value produced by passing the
   *   specified `Long` to the given function `f`.
   */
  def passOrElse[E](value: Long)(f: Long => E): Validation[E] =
    if (NegLongMacro.isValid(value)) Pass else Fail(f(value))

  /**
   * A factory/validation method that produces a NegLong, wrapped
   * in a Good, given a valid Long value, or if the
   * given Long is invalid, an error value of type B
   * produced by passing the given invalid Long value
   * to the given function f, wrapped in a Bad.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a NegLong
   * representing that value, wrapped in a Good.
   * Otherwise, the passed Long value is not negative, so this
   * method will return a result of type B obtained by passing
   * the invalid Long value to the given function f,
   * wrapped in a `Bad`.
   * 
   *
   * 
   * This factory method differs from the apply factory method
   * in that apply is implemented via a macro that inspects
   * Long literals at compile time, whereas this method inspects
   * Long values at run time.
   * 
   *
   * @param value the Long to inspect, and if negative, return
   *     wrapped in a Good(NegLong).
   * @return the specified Long value wrapped
   *     in a Good(NegLong), if it is negative, else a Bad(f(value)).
   */
  def goodOrElse[B](value: Long)(f: Long => B): NegLong Or B =
    if (NegLongMacro.isValid(value)) Good(NegLong.ensuringValid(value)) else Bad(f(value))

  /**
   * A factory/validation method that produces a NegLong, wrapped
   * in a Right, given a valid Int value, or if the
   * given Int is invalid, an error value of type L
   * produced by passing the given invalid Int value
   * to the given function f, wrapped in a Left.
   *
   * 
   * This method will inspect the passed Int value and if
   * it is a negative Int, it will return a NegLong
   * representing that value, wrapped in a Right.
   * Otherwise, the passed Int value is not negative, so this
   * method will return a result of type L obtained by passing
   * the invalid Int value to the given function f,
   * wrapped in a `Left`.
   * 
   *
   * 
   * 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 this method inspects
   * Int values at run time.
   * 
   *
   * @param value the Int to inspect, and if negative, return
   *     wrapped in a Right(NegLong).
   * @return the specified Int value wrapped
   *     in a Right(NegLong), if it is negative, else a Left(f(value)).
   */
  def rightOrElse[L](value: Long)(f: Long => L): Either[L, NegLong] =
    if (NegLongMacro.isValid(value)) Right(NegLong.ensuringValid(value)) else Left(f(value))

  /**
   * A predicate method that returns true if a given
   * Long value is negative.
   *
   * @param value the Long to inspect, and if negative, return true.
   * @return true if the specified Long is negative, else false.
   */
  def isValid(value: Long): Boolean = NegLongMacro.isValid(value)

  /**
   * A factory method that produces a NegLong given a
   * Long value and a default NegLong.
   *
   * 
   * This method will inspect the passed Long value and if
   * it is a negative Long, it will return a NegLong representing that value.
   * Otherwise, the passed Long value is not negative, so this
   * method will return the passed default value.
   * 
   *
   * 
   * This factory method differs from the apply
   * factory method in that apply is implemented
   * via a macro that inspects Long literals at
   * compile time, whereas from inspects
   * Long values at run time.
   * 
   *
   * @param value the Long to inspect, and if negative, return.
   * @param default the NegLong to return if the passed
   *     Long value is not negative.
   * @return the specified Long value wrapped in a
   *     NegLong, if it is negative, else the
   *     default NegLong value.
   */
  def fromOrElse(value: Long, default: => NegLong): NegLong =
    if (NegLongMacro.isValid(value)) new NegLong(value) else default

  import language.experimental.macros

  /**
   * A factory method, implemented via a macro, that produces a
   * NegLong if passed a valid Long
   * literal, otherwise a compile time error.
   *
   * 
   * The macro that implements this method will inspect the
   * specified Long expression at compile time. If
   * the expression is a negative Long literal,
   * it will return a NegLong representing that value.
   * Otherwise, the passed Long expression is either a literal
   * that is not 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 Long literals at compile
   * time, whereas from inspects Long
   * values at run time.
   * 
   *
   * @param value the Long literal expression to
   *     inspect at compile time, and if negative, to return
   *     wrapped in a NegLong at run time.
   * @return the specified, valid Long literal
   *     value wrapped in a NegLong. (If the
   *     specified expression is not a valid Long
   *     literal, the invocation of this method will not
   *     compile.)
   */
  inline implicit def apply(value: => Long): NegLong = ${ NegLongMacro('{value}) }

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

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

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


  /**
   * Implicit widening conversion from NegLong to NegFloat.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Float and wrapped in a NegFloat.
   */
  implicit def widenToNegFloat(pos: NegLong): NegFloat = NegFloat.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NegDouble.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Double and wrapped in a NegDouble.
   */
  implicit def widenToNegDouble(pos: NegLong): NegDouble = NegDouble.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NegZLong.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Long and wrapped in a NegZLong.
   */
  implicit def widenToNegZLong(pos: NegLong): NegZLong = NegZLong.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NegZFloat.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Float and wrapped in a NegZFloat.
   */
  implicit def widenToNegZFloat(pos: NegLong): NegZFloat = NegZFloat.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NegZDouble.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Double and wrapped in a NegZDouble.
   */
  implicit def widenToNegZDouble(pos: NegLong): NegZDouble = NegZDouble.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NonZeroLong.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Long and wrapped in a NonZeroLong.
   */
  implicit def widenToNonZeroLong(pos: NegLong): NonZeroLong = NonZeroLong.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NonZeroFloat.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Float and wrapped in a NonZeroFloat.
   */
  implicit def widenToNonZeroFloat(pos: NegLong): NonZeroFloat = NonZeroFloat.ensuringValid(pos.value)

  /**
   * Implicit widening conversion from NegLong to NonZeroDouble.
   *
   * @param pos the NegLong to widen
   * @return the Long value underlying the specified NegLong,
   *     widened to Double and wrapped in a NonZeroDouble.
   */
  implicit def widenToNonZeroDouble(pos: NegLong): NonZeroDouble = NonZeroDouble.ensuringValid(pos.value)


  /**
   * Implicit Ordering instance.
   */
  implicit val ordering: Ordering[NegLong] =
    new Ordering[NegLong] {
      def compare(x: NegLong, y: NegLong): Int = x.toLong.compare(y)
    }

  
}