scala implicit methods for gs-collection interface function

GsCollections.scala

package kesti4s.core.collections

import com.gs.collections.api.block.function._
import com.gs.collections.api.block.function.primitive._
import com.gs.collections.api.block.predicate._
import com.gs.collections.api.block.predicate.primitive._
import com.gs.collections.api.block.procedure._
import com.gs.collections.api.block.procedure.primitive._

/**
  * gs-collections 를 scala lambda expression 으로 사용하기 위한 implicit methods 을 제공합니다
  *
  * {{{
  *   import kesti4s.core.collections.GsCollections.Implicits._
  *
  *   ...
  * }}}
  *
  * @author [email protected]
  * @since 2016. 1. 17.
  */
object GsCollections {

  object Implicits {

    // region << Function converters >>

    implicit def functionToFunction[T, V](func: T => V): Function[T, V] = {
      new Function[T, V] {
        override def valueOf(input: T): V = func.apply(input)
      }
    }
    implicit def function0ToFunction0[R](func0: => R): Function0[R] = {
      new Function0[R] {
        override def value(): R = func0
      }
    }
    implicit def function2ToFunction2[T1, T2, R](func2: (T1, T2) => R): Function2[T1, T2, R] = {
      new Function2[T1, T2, R] {
        override def value(v1: T1, v2: T2): R = func2.apply(v1, v2)
      }
    }
    implicit def function3ToFunction3[T1, T2, T3, R](func3: (T1, T2, T3) => R): Function3[T1, T2, T3, R] = {
      new Function3[T1, T2, T3, R] {
        override def value(v1: T1, v2: T2, v3: T3): R = func3.apply(v1, v2, v3)
      }
    }

    //region << Primitive Boolean Functions >>

    implicit def booleanFunction[T](func: T => Boolean): BooleanFunction[T] = {
      new BooleanFunction[T] {
        override def booleanValueOf(anObject: T): Boolean = func.apply(anObject)
      }
    }
    implicit def booleanFunction0(func: => Boolean): BooleanFunction0 = {
      new BooleanFunction0 {
        override def value(): Boolean = func
      }
    }
    implicit def booleanObjectToBooleanFunction[T](func: (Boolean, T) => Boolean): BooleanObjectToBooleanFunction[T] = {
      new BooleanObjectToBooleanFunction[T] {
        override def booleanValueOf(booleanParameter: Boolean, objectParameter: T): Boolean =
          func.apply(booleanParameter, objectParameter)
      }
    }
    implicit def booleanToBooleanFunction(func: Boolean => Boolean): BooleanToBooleanFunction = {
      new BooleanToBooleanFunction {
        override def valueOf(booleanParameter: Boolean): Boolean = func(booleanParameter)
      }
    }
    implicit def booleanToByteFunction(func: Boolean => Byte): BooleanToByteFunction = {
      new BooleanToByteFunction {
        override def valueOf(booleanParameter: Boolean): Byte = func.apply(booleanParameter)
      }
    }
    implicit def booleanToCharFunction(func: Boolean => Char): BooleanToCharFunction = {
      new BooleanToCharFunction {
        override def valueOf(booleanParameter: Boolean): Char = func.apply(booleanParameter)
      }
    }
    implicit def booleanToDoubleFunction(func: Boolean => Double): BooleanToDoubleFunction = {
      new BooleanToDoubleFunction {
        override def valueOf(booleanParameter: Boolean): Double = func.apply(booleanParameter)
      }
    }
    implicit def booleanToFloatFunction(func: Boolean => Float): BooleanToFloatFunction = {
      new BooleanToFloatFunction {
        override def valueOf(booleanParameter: Boolean): Float = func.apply(booleanParameter)
      }
    }
    implicit def booleanToIntFunction(func: Boolean => Int): BooleanToIntFunction = {
      new BooleanToIntFunction {
        override def valueOf(booleanParameter: Boolean): Int = func.apply(booleanParameter)
      }
    }
    implicit def booleanToLongFunction(func: Boolean => Long): BooleanToLongFunction = {
      new BooleanToLongFunction {
        override def valueOf(booleanParameter: Boolean): Long = func.apply(booleanParameter)
      }
    }
    implicit def booleanToObjectFunction[V](func: Boolean => V): BooleanToObjectFunction[V] = {
      new BooleanToObjectFunction[V] {
        override def valueOf(booleanParameter: Boolean): V = func.apply(booleanParameter)
      }
    }
    implicit def booleanToShortFunction(func: Boolean => Short): BooleanToShortFunction = {
      new BooleanToShortFunction {
        override def valueOf(booleanParameter: Boolean): Short = func.apply(booleanParameter)
      }
    }

    // endregion

    //region << Primitive Byte Functions >>

    implicit def byteFunction[T](func: T => Byte): ByteFunction[T] = {
      new ByteFunction[T] {
        override def byteValueOf(anObject: T): Byte = func.apply(anObject)
      }
    }
    implicit def byteFunction0(func: => Byte): ByteFunction0 = {
      new ByteFunction0 {
        override def value(): Byte = func
      }
    }
    implicit def byteObjectToByteFunction[T](func: (Byte, T) => Byte): ByteObjectToByteFunction[T] = {
      new ByteObjectToByteFunction[T] {
        override def byteValueOf(byteParameter: Byte, objectParameter: T): Byte =
          func.apply(byteParameter, objectParameter)
      }
    }
    implicit def byteToBooleanFunction(func: Byte => Boolean): ByteToBooleanFunction = {
      new ByteToBooleanFunction {
        override def valueOf(byteParameter: Byte): Boolean = func(byteParameter)
      }
    }
    implicit def byteToByteFunction(func: Byte => Byte): ByteToByteFunction = {
      new ByteToByteFunction {
        override def valueOf(byteParameter: Byte): Byte = func.apply(byteParameter)
      }
    }
    implicit def byteToCharFunction(func: Byte => Char): ByteToCharFunction = {
      new ByteToCharFunction {
        override def valueOf(byteParameter: Byte): Char = func.apply(byteParameter)
      }
    }
    implicit def byteToDoubleFunction(func: Byte => Double): ByteToDoubleFunction = {
      new ByteToDoubleFunction {
        override def valueOf(byteParameter: Byte): Double = func.apply(byteParameter)
      }
    }
    implicit def byteToFloatFunction(func: Byte => Float): ByteToFloatFunction = {
      new ByteToFloatFunction {
        override def valueOf(byteParameter: Byte): Float = func.apply(byteParameter)
      }
    }
    implicit def byteToIntFunction(func: Byte => Int): ByteToIntFunction = {
      new ByteToIntFunction {
        override def valueOf(byteParameter: Byte): Int = func.apply(byteParameter)
      }
    }
    implicit def byteToLongFunction(func: Byte => Long): ByteToLongFunction = {
      new ByteToLongFunction {
        override def valueOf(byteParameter: Byte): Long = func.apply(byteParameter)
      }
    }
    implicit def byteToObjectFunction[V](func: Byte => V): ByteToObjectFunction[V] = {
      new ByteToObjectFunction[V] {
        override def valueOf(byteParameter: Byte): V = func.apply(byteParameter)
      }
    }
    implicit def byteToShortFunction(func: Byte => Short): ByteToShortFunction = {
      new ByteToShortFunction {
        override def valueOf(byteParameter: Byte): Short = func.apply(byteParameter)
      }
    }

    //endregion

    //region << Primitive Char Functions >>

    implicit def charFunction[T](func: T => Char): CharFunction[T] = {
      new CharFunction[T] {
        override def charValueOf(anObject: T): Char = func.apply(anObject)
      }
    }
    implicit def charFunction0(func: => Char): CharFunction0 = {
      new CharFunction0 {
        override def value(): Char = func
      }
    }
    implicit def charObjectToCharFunction[T](func: (Char, T) => Char): CharObjectToCharFunction[T] = {
      new CharObjectToCharFunction[T] {
        override def charValueOf(charParameter: Char, objectParameter: T): Char =
          func.apply(charParameter, objectParameter)
      }
    }
    implicit def charToBooleanFunction(func: Char => Boolean): CharToBooleanFunction = {
      new CharToBooleanFunction {
        override def valueOf(charParameter: Char): Boolean = func(charParameter)
      }
    }
    implicit def charToByteFunction(func: Char => Byte): CharToByteFunction = {
      new CharToByteFunction {
        override def valueOf(charParameter: Char): Byte = func.apply(charParameter)
      }
    }
    implicit def charToCharFunction(func: Char => Char): CharToCharFunction = {
      new CharToCharFunction {
        override def valueOf(charParameter: Char): Char = func.apply(charParameter)
      }
    }
    implicit def charToDoubleFunction(func: Char => Double): CharToDoubleFunction = {
      new CharToDoubleFunction {
        override def valueOf(charParameter: Char): Double = func.apply(charParameter)
      }
    }
    implicit def charToFloatFunction(func: Char => Float): CharToFloatFunction = {
      new CharToFloatFunction {
        override def valueOf(charParameter: Char): Float = func.apply(charParameter)
      }
    }
    implicit def charToIntFunction(func: Char => Int): CharToIntFunction = {
      new CharToIntFunction {
        override def valueOf(charParameter: Char): Int = func.apply(charParameter)
      }
    }
    implicit def charToLongFunction(func: Char => Long): CharToLongFunction = {
      new CharToLongFunction {
        override def valueOf(charParameter: Char): Long = func.apply(charParameter)
      }
    }
    implicit def charToObjectFunction[V](func: Char => V): CharToObjectFunction[V] = {
      new CharToObjectFunction[V] {
        override def valueOf(charParameter: Char): V = func.apply(charParameter)
      }
    }
    implicit def charToShortFunction(func: Char => Short): CharToShortFunction = {
      new CharToShortFunction {
        override def valueOf(charParameter: Char): Short = func.apply(charParameter)
      }
    }

    //endregion

    //region << Primitive Double Functions >>

    implicit def doubleFunction[T](func: T => Double): DoubleFunction[T] = {
      new DoubleFunction[T] {
        override def doubleValueOf(anObject: T): Double = func.apply(anObject)
      }
    }
    implicit def doubleFunction0(func: => Double): DoubleFunction0 = {
      new DoubleFunction0 {
        override def value(): Double = func
      }
    }
    implicit def doubleObjectToDoubleFunction[T](func: (Double, T) => Double): DoubleObjectToDoubleFunction[T] = {
      new DoubleObjectToDoubleFunction[T] {
        override def doubleValueOf(doubleParameter: Double, objectParameter: T): Double =
          func.apply(doubleParameter, objectParameter)
      }
    }
    implicit def doubleToBooleanFunction(func: Double => Boolean): DoubleToBooleanFunction = {
      new DoubleToBooleanFunction {
        override def valueOf(doubleParameter: Double): Boolean = func(doubleParameter)
      }
    }
    implicit def doubleToByteFunction(func: Double => Byte): DoubleToByteFunction = {
      new DoubleToByteFunction {
        override def valueOf(doubleParameter: Double): Byte = func.apply(doubleParameter)
      }
    }
    implicit def doubleToCharFunction(func: Double => Char): DoubleToCharFunction = {
      new DoubleToCharFunction {
        override def valueOf(doubleParameter: Double): Char = func.apply(doubleParameter)
      }
    }
    implicit def doubleToDoubleFunction(func: Double => Double): DoubleToDoubleFunction = {
      new DoubleToDoubleFunction {
        override def valueOf(doubleParameter: Double): Double = func.apply(doubleParameter)
      }
    }
    implicit def doubleToFloatFunction(func: Double => Float): DoubleToFloatFunction = {
      new DoubleToFloatFunction {
        override def valueOf(doubleParameter: Double): Float = func.apply(doubleParameter)
      }
    }
    implicit def doubleToIntFunction(func: Double => Int): DoubleToIntFunction = {
      new DoubleToIntFunction {
        override def valueOf(doubleParameter: Double): Int = func.apply(doubleParameter)
      }
    }
    implicit def doubleToLongFunction(func: Double => Long): DoubleToLongFunction = {
      new DoubleToLongFunction {
        override def valueOf(doubleParameter: Double): Long = func.apply(doubleParameter)
      }
    }
    implicit def doubleToObjectFunction[V](func: Double => V): DoubleToObjectFunction[V] = {
      new DoubleToObjectFunction[V] {
        override def valueOf(doubleParameter: Double): V = func.apply(doubleParameter)
      }
    }
    implicit def doubleToShortFunction(func: Double => Short): DoubleToShortFunction = {
      new DoubleToShortFunction {
        override def valueOf(doubleParameter: Double): Short = func.apply(doubleParameter)
      }
    }

    //endregion

    //region << Primitive Float Functions >>

    implicit def floatFunction[T](func: T => Float): FloatFunction[T] = {
      new FloatFunction[T] {
        override def floatValueOf(anObject: T): Float = func.apply(anObject)
      }
    }
    implicit def floatFunction0(func: => Float): FloatFunction0 = {
      new FloatFunction0 {
        override def value(): Float = func
      }
    }
    implicit def floatObjectToFloatFunction[T](func: (Float, T) => Float): FloatObjectToFloatFunction[T] = {
      new FloatObjectToFloatFunction[T] {
        override def floatValueOf(floatParameter: Float, objectParameter: T): Float =
          func.apply(floatParameter, objectParameter)
      }
    }
    implicit def floatToBooleanFunction(func: Float => Boolean): FloatToBooleanFunction = {
      new FloatToBooleanFunction {
        override def valueOf(floatParameter: Float): Boolean = func(floatParameter)
      }
    }
    implicit def floatToByteFunction(func: Float => Byte): FloatToByteFunction = {
      new FloatToByteFunction {
        override def valueOf(floatParameter: Float): Byte = func.apply(floatParameter)
      }
    }
    implicit def floatToCharFunction(func: Float => Char): FloatToCharFunction = {
      new FloatToCharFunction {
        override def valueOf(floatParameter: Float): Char = func.apply(floatParameter)
      }
    }
    implicit def floatToDoubleFunction(func: Float => Double): FloatToDoubleFunction = {
      new FloatToDoubleFunction {
        override def valueOf(floatParameter: Float): Double = func.apply(floatParameter)
      }
    }
    implicit def floatToFloatFunction(func: Float => Float): FloatToFloatFunction = {
      new FloatToFloatFunction {
        override def valueOf(floatParameter: Float): Float = func.apply(floatParameter)
      }
    }
    implicit def floatToIntFunction(func: Float => Int): FloatToIntFunction = {
      new FloatToIntFunction {
        override def valueOf(floatParameter: Float): Int = func.apply(floatParameter)
      }
    }
    implicit def floatToLongFunction(func: Float => Long): FloatToLongFunction = {
      new FloatToLongFunction {
        override def valueOf(floatParameter: Float): Long = func.apply(floatParameter)
      }
    }
    implicit def floatToObjectFunction[V](func: Float => V): FloatToObjectFunction[V] = {
      new FloatToObjectFunction[V] {
        override def valueOf(floatParameter: Float): V = func.apply(floatParameter)
      }
    }
    implicit def floatToShortFunction(func: Float => Short): FloatToShortFunction = {
      new FloatToShortFunction {
        override def valueOf(floatParameter: Float): Short = func.apply(floatParameter)
      }
    }

    //endregion

    //region << Primitive Int Functions >>

    implicit def intFunction[T](func: T => Int): IntFunction[T] = {
      new IntFunction[T] {
        override def intValueOf(anObject: T): Int = func.apply(anObject)
      }
    }
    implicit def intFunction0(func: => Int): IntFunction0 = {
      new IntFunction0 {
        override def value(): Int = func
      }
    }
    implicit def intObjectToIntFunction[T](func: (Int, T) => Int): IntObjectToIntFunction[T] = {
      new IntObjectToIntFunction[T] {
        override def intValueOf(intParameter: Int, objectParameter: T): Int =
          func.apply(intParameter, objectParameter)
      }
    }
    implicit def intToBooleanFunction(func: Int => Boolean): IntToBooleanFunction = {
      new IntToBooleanFunction {
        override def valueOf(intParameter: Int): Boolean = func(intParameter)
      }
    }
    implicit def intToByteFunction(func: Int => Byte): IntToByteFunction = {
      new IntToByteFunction {
        override def valueOf(intParameter: Int): Byte = func.apply(intParameter)
      }
    }
    implicit def intToCharFunction(func: Int => Char): IntToCharFunction = {
      new IntToCharFunction {
        override def valueOf(intParameter: Int): Char = func.apply(intParameter)
      }
    }
    implicit def intToDoubleFunction(func: Int => Double): IntToDoubleFunction = {
      new IntToDoubleFunction {
        override def valueOf(intParameter: Int): Double = func.apply(intParameter)
      }
    }
    implicit def intToFloatFunction(func: Int => Float): IntToFloatFunction = {
      new IntToFloatFunction {
        override def valueOf(intParameter: Int): Float = func.apply(intParameter)
      }
    }
    implicit def intToIntFunction(func: Int => Int): IntToIntFunction = {
      new IntToIntFunction {
        override def valueOf(intParameter: Int): Int = func.apply(intParameter)
      }
    }
    implicit def intToLongFunction(func: Int => Long): IntToLongFunction = {
      new IntToLongFunction {
        override def valueOf(intParameter: Int): Long = func.apply(intParameter)
      }
    }
    implicit def intToObjectFunction[V](func: Int => V): IntToObjectFunction[V] = {
      new IntToObjectFunction[V] {
        override def valueOf(intParameter: Int): V = func.apply(intParameter)
      }
    }
    implicit def intToShortFunction(func: Int => Short): IntToShortFunction = {
      new IntToShortFunction {
        override def valueOf(intParameter: Int): Short = func.apply(intParameter)
      }
    }

    //endregion

    //region << Primitive Long Functions >>

    implicit def longFunction[T](func: T => Long): LongFunction[T] = {
      new LongFunction[T] {
        override def longValueOf(anObject: T): Long = func.apply(anObject)
      }
    }
    implicit def longFunction0(func: => Long): LongFunction0 = {
      new LongFunction0 {
        override def value(): Long = func
      }
    }
    implicit def longObjectToLongFunction[T](func: (Long, T) => Long): LongObjectToLongFunction[T] = {
      new LongObjectToLongFunction[T] {
        override def longValueOf(longParameter: Long, objectParameter: T): Long =
          func.apply(longParameter, objectParameter)
      }
    }
    implicit def longToBooleanFunction(func: Long => Boolean): LongToBooleanFunction = {
      new LongToBooleanFunction {
        override def valueOf(longParameter: Long): Boolean = func(longParameter)
      }
    }
    implicit def longToByteFunction(func: Long => Byte): LongToByteFunction = {
      new LongToByteFunction {
        override def valueOf(longParameter: Long): Byte = func.apply(longParameter)
      }
    }
    implicit def longToCharFunction(func: Long => Char): LongToCharFunction = {
      new LongToCharFunction {
        override def valueOf(longParameter: Long): Char = func.apply(longParameter)
      }
    }
    implicit def longToDoubleFunction(func: Long => Double): LongToDoubleFunction = {
      new LongToDoubleFunction {
        override def valueOf(longParameter: Long): Double = func.apply(longParameter)
      }
    }
    implicit def longToFloatFunction(func: Long => Float): LongToFloatFunction = {
      new LongToFloatFunction {
        override def valueOf(longParameter: Long): Float = func.apply(longParameter)
      }
    }
    implicit def longToIntFunction(func: Long => Int): LongToIntFunction = {
      new LongToIntFunction {
        override def valueOf(longParameter: Long): Int = func.apply(longParameter)
      }
    }
    implicit def longToLongFunction(func: Long => Long): LongToLongFunction = {
      new LongToLongFunction {
        override def valueOf(longParameter: Long): Long = func.apply(longParameter)
      }
    }
    implicit def longToObjectFunction[V](func: Long => V): LongToObjectFunction[V] = {
      new LongToObjectFunction[V] {
        override def valueOf(longParameter: Long): V = func.apply(longParameter)
      }
    }
    implicit def longToShortFunction(func: Long => Short): LongToShortFunction = {
      new LongToShortFunction {
        override def valueOf(longParameter: Long): Short = func.apply(longParameter)
      }
    }

    //endregion

    // region << Primitive Object Functions >>

    implicit def objectBooleanIntToObjectFunction[T, R](func: (T, Boolean, Int) => R): ObjectBooleanIntToObjectFunction[T, R] = {
      new ObjectBooleanIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Boolean, index: Int): R = func.apply(obj, value, index)
      }
    }

    implicit def objectBooleanToObjectFunction[T, R](func: (T, Boolean) => R): ObjectBooleanToObjectFunction[T, R] = {
      new ObjectBooleanToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Boolean): R = func.apply(obj, value)
      }
    }

    implicit def objectByteIntToObjectFunction[T, R](func: (T, Byte, Int) => R): ObjectByteIntToObjectFunction[T, R] = {
      new ObjectByteIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Byte, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectByteToObjectFunction[T, R](func: (T, Byte) => R): ObjectByteToObjectFunction[T, R] = {
      new ObjectByteToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Byte): R = func.apply(obj, value)
      }
    }
    implicit def objectCharIntToObjectFunction[T, R](func: (T, Char, Int) => R): ObjectCharIntToObjectFunction[T, R] = {
      new ObjectCharIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Char, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectCharToObjectFunction[T, R](func: (T, Char) => R): ObjectCharToObjectFunction[T, R] = {
      new ObjectCharToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Char): R = func.apply(obj, value)
      }
    }
    implicit def objectDoubleIntToObjectFunction[T, R](func: (T, Double, Int) => R): ObjectDoubleIntToObjectFunction[T, R] = {
      new ObjectDoubleIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Double, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectDoubleToObjectFunction[T, R](func: (T, Double) => R): ObjectDoubleToObjectFunction[T, R] = {
      new ObjectDoubleToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Double): R = func.apply(obj, value)
      }
    }
    implicit def objectFloatIntToObjectFunction[T, R](func: (T, Float, Int) => R): ObjectFloatIntToObjectFunction[T, R] = {
      new ObjectFloatIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Float, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectFloatToObjectFunction[T, R](func: (T, Float) => R): ObjectFloatToObjectFunction[T, R] = {
      new ObjectFloatToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Float): R = func.apply(obj, value)
      }
    }
    implicit def objectIntIntToObjectFunction[T, R](func: (T, Int, Int) => R): ObjectIntIntToObjectFunction[T, R] = {
      new ObjectIntIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Int, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectIntToObjectFunction[T, R](func: (T, Int) => R): ObjectIntToObjectFunction[T, R] = {
      new ObjectIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Int): R = func.apply(obj, value)
      }
    }
    implicit def objectLongIntToObjectFunction[T, R](func: (T, Long, Int) => R): ObjectLongIntToObjectFunction[T, R] = {
      new ObjectLongIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Long, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectLongToObjectFunction[T, R](func: (T, Long) => R): ObjectLongToObjectFunction[T, R] = {
      new ObjectLongToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Long): R = func.apply(obj, value)
      }
    }
    implicit def objectShortIntToObjectFunction[T, R](func: (T, Short, Int) => R): ObjectShortIntToObjectFunction[T, R] = {
      new ObjectShortIntToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Short, index: Int): R = func.apply(obj, value, index)
      }
    }
    implicit def objectShortToObjectFunction[T, R](func: (T, Short) => R): ObjectShortToObjectFunction[T, R] = {
      new ObjectShortToObjectFunction[T, R] {
        override def valueOf(obj: T, value: Short): R = func.apply(obj, value)
      }
    }


    // endregion

    //region << Primitive Short Functions >>

    implicit def shortFunction[T](func: T => Short): ShortFunction[T] = {
      new ShortFunction[T] {
        override def shortValueOf(anObject: T): Short = func.apply(anObject)
      }
    }
    implicit def shortFunction0(func: => Short): ShortFunction0 = {
      new ShortFunction0 {
        override def value(): Short = func
      }
    }
    implicit def shortObjectToShortFunction[T](func: (Short, T) => Short): ShortObjectToShortFunction[T] = {
      new ShortObjectToShortFunction[T] {
        override def shortValueOf(shortParameter: Short, objectParameter: T): Short =
          func.apply(shortParameter, objectParameter)
      }
    }
    implicit def shortToBooleanFunction(func: Short => Boolean): ShortToBooleanFunction = {
      new ShortToBooleanFunction {
        override def valueOf(shortParameter: Short): Boolean = func(shortParameter)
      }
    }
    implicit def shortToByteFunction(func: Short => Byte): ShortToByteFunction = {
      new ShortToByteFunction {
        override def valueOf(shortParameter: Short): Byte = func.apply(shortParameter)
      }
    }
    implicit def shortToCharFunction(func: Short => Char): ShortToCharFunction = {
      new ShortToCharFunction {
        override def valueOf(shortParameter: Short): Char = func.apply(shortParameter)
      }
    }
    implicit def shortToDoubleFunction(func: Short => Double): ShortToDoubleFunction = {
      new ShortToDoubleFunction {
        override def valueOf(shortParameter: Short): Double = func.apply(shortParameter)
      }
    }
    implicit def shortToFloatFunction(func: Short => Float): ShortToFloatFunction = {
      new ShortToFloatFunction {
        override def valueOf(shortParameter: Short): Float = func.apply(shortParameter)
      }
    }
    implicit def shortToIntFunction(func: Short => Int): ShortToIntFunction = {
      new ShortToIntFunction {
        override def valueOf(shortParameter: Short): Int = func.apply(shortParameter)
      }
    }
    implicit def shortToLongFunction(func: Short => Long): ShortToLongFunction = {
      new ShortToLongFunction {
        override def valueOf(shortParameter: Short): Long = func.apply(shortParameter)
      }
    }
    implicit def shortToObjectFunction[V](func: Short => V): ShortToObjectFunction[V] = {
      new ShortToObjectFunction[V] {
        override def valueOf(shortParameter: Short): V = func.apply(shortParameter)
      }
    }
    implicit def shortToShortFunction(func: Short => Short): ShortToShortFunction = {
      new ShortToShortFunction {
        override def valueOf(shortParameter: Short): Short = func.apply(shortParameter)
      }
    }

    //endregion

    // endregion

    // region << Predicate converters >>

    implicit def predicateToPredicate[T](predicate: T => Boolean): Predicate[T] = {
      new Predicate[T] {
        override def accept(each: T): Boolean = predicate.apply(each)
      }
    }
    implicit def predicate2[T1, T2](predicate: (T1, T2) => Boolean): Predicate2[T1, T2] = {
      new Predicate2[T1, T2] {
        override def accept(arg1: T1, arg2: T2): Boolean = predicate.apply(arg1, arg2)
      }
    }

    // region << Boolean Predicate >>

    implicit def booleanBooleanPredicate(predicate: (Boolean, Boolean) => Boolean): BooleanBooleanPredicate = {
      new BooleanBooleanPredicate {
        override def accept(v1: Boolean, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanBytePredicate(predicate: (Boolean, Byte) => Boolean): BooleanBytePredicate = {
      new BooleanBytePredicate {
        override def accept(v1: Boolean, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanCharPredicate(predicate: (Boolean, Char) => Boolean): BooleanCharPredicate = {
      new BooleanCharPredicate {
        override def accept(v1: Boolean, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanDoublePredicate(predicate: (Boolean, Double) => Boolean): BooleanDoublePredicate = {
      new BooleanDoublePredicate {
        override def accept(v1: Boolean, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanFloatPredicate(predicate: (Boolean, Float) => Boolean): BooleanFloatPredicate = {
      new BooleanFloatPredicate {
        override def accept(v1: Boolean, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanIntPredicate(predicate: (Boolean, Int) => Boolean): BooleanIntPredicate = {
      new BooleanIntPredicate {
        override def accept(v1: Boolean, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanLongPredicate(predicate: (Boolean, Long) => Boolean): BooleanLongPredicate = {
      new BooleanLongPredicate {
        override def accept(v1: Boolean, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanObjectPredicate[T](predicate: (Boolean, T) => Boolean): BooleanObjectPredicate[T] = {
      new BooleanObjectPredicate[T] {
        override def accept(v1: Boolean, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def booleanPredicate(predicate: Boolean => Boolean): BooleanPredicate = {
      new BooleanPredicate {
        override def accept(v: Boolean): Boolean = predicate.apply(v)
      }
    }
    implicit def booleanShortPredicate(predicate: (Boolean, Short) => Boolean): BooleanShortPredicate = {
      new BooleanShortPredicate {
        override def accept(v1: Boolean, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Byte Predicate >>

    implicit def byteBooleanPredicate(predicate: (Byte, Boolean) => Boolean): ByteBooleanPredicate = {
      new ByteBooleanPredicate {
        override def accept(v1: Byte, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteBytePredicate(predicate: (Byte, Byte) => Boolean): ByteBytePredicate = {
      new ByteBytePredicate {
        override def accept(v1: Byte, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteCharPredicate(predicate: (Byte, Char) => Boolean): ByteCharPredicate = {
      new ByteCharPredicate {
        override def accept(v1: Byte, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteDoublePredicate(predicate: (Byte, Double) => Boolean): ByteDoublePredicate = {
      new ByteDoublePredicate {
        override def accept(v1: Byte, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteFloatPredicate(predicate: (Byte, Float) => Boolean): ByteFloatPredicate = {
      new ByteFloatPredicate {
        override def accept(v1: Byte, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteIntPredicate(predicate: (Byte, Int) => Boolean): ByteIntPredicate = {
      new ByteIntPredicate {
        override def accept(v1: Byte, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteLongPredicate(predicate: (Byte, Long) => Boolean): ByteLongPredicate = {
      new ByteLongPredicate {
        override def accept(v1: Byte, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def byteObjectPredicate[T](predicate: (Byte, T) => Boolean): ByteObjectPredicate[T] = {
      new ByteObjectPredicate[T] {
        override def accept(v1: Byte, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def bytePredicate(predicate: Byte => Boolean): BytePredicate = {
      new BytePredicate {
        override def accept(v: Byte): Boolean = predicate.apply(v)
      }
    }
    implicit def byteShortPredicate(predicate: (Byte, Short) => Boolean): ByteShortPredicate = {
      new ByteShortPredicate {
        override def accept(v1: Byte, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Char Predicate >>

    implicit def charBooleanPredicate(predicate: (Char, Boolean) => Boolean): CharBooleanPredicate = {
      new CharBooleanPredicate {
        override def accept(v1: Char, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charBytePredicate(predicate: (Char, Char) => Boolean): CharCharPredicate = {
      new CharCharPredicate {
        override def accept(v1: Char, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charCharPredicate(predicate: (Char, Char) => Boolean): CharCharPredicate = {
      new CharCharPredicate {
        override def accept(v1: Char, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charDoublePredicate(predicate: (Char, Double) => Boolean): CharDoublePredicate = {
      new CharDoublePredicate {
        override def accept(v1: Char, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charFloatPredicate(predicate: (Char, Float) => Boolean): CharFloatPredicate = {
      new CharFloatPredicate {
        override def accept(v1: Char, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charIntPredicate(predicate: (Char, Int) => Boolean): CharIntPredicate = {
      new CharIntPredicate {
        override def accept(v1: Char, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charLongPredicate(predicate: (Char, Long) => Boolean): CharLongPredicate = {
      new CharLongPredicate {
        override def accept(v1: Char, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charObjectPredicate[T](predicate: (Char, T) => Boolean): CharObjectPredicate[T] = {
      new CharObjectPredicate[T] {
        override def accept(v1: Char, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def charPredicate(predicate: Char => Boolean): CharPredicate = {
      new CharPredicate {
        override def accept(v: Char): Boolean = predicate.apply(v)
      }
    }
    implicit def charShortPredicate(predicate: (Char, Short) => Boolean): CharShortPredicate = {
      new CharShortPredicate {
        override def accept(v1: Char, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Double Predicate >>

    implicit def doubleBooleanPredicate(predicate: (Double, Boolean) => Boolean): DoubleBooleanPredicate = {
      new DoubleBooleanPredicate {
        override def accept(v1: Double, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleBytePredicate(predicate: (Double, Byte) => Boolean): DoubleBytePredicate = {
      new DoubleBytePredicate {
        override def accept(v1: Double, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleCharPredicate(predicate: (Double, Char) => Boolean): DoubleCharPredicate = {
      new DoubleCharPredicate {
        override def accept(v1: Double, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleDoublePredicate(predicate: (Double, Double) => Boolean): DoubleDoublePredicate = {
      new DoubleDoublePredicate {
        override def accept(v1: Double, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleFloatPredicate(predicate: (Double, Float) => Boolean): DoubleFloatPredicate = {
      new DoubleFloatPredicate {
        override def accept(v1: Double, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleIntPredicate(predicate: (Double, Int) => Boolean): DoubleIntPredicate = {
      new DoubleIntPredicate {
        override def accept(v1: Double, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleLongPredicate(predicate: (Double, Long) => Boolean): DoubleLongPredicate = {
      new DoubleLongPredicate {
        override def accept(v1: Double, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doubleObjectPredicate[T](predicate: (Double, T) => Boolean): DoubleObjectPredicate[T] = {
      new DoubleObjectPredicate[T] {
        override def accept(v1: Double, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def doublePredicate(predicate: Double => Boolean): DoublePredicate = {
      new DoublePredicate {
        override def accept(v: Double): Boolean = predicate.apply(v)
      }
    }
    implicit def doubleShortPredicate(predicate: (Double, Short) => Boolean): DoubleShortPredicate = {
      new DoubleShortPredicate {
        override def accept(v1: Double, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion   \

    // region << Float Predicate >>

    implicit def floatBooleanPredicate(predicate: (Float, Boolean) => Boolean): FloatBooleanPredicate = {
      new FloatBooleanPredicate {
        override def accept(v1: Float, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatBytePredicate(predicate: (Float, Byte) => Boolean): FloatBytePredicate = {
      new FloatBytePredicate {
        override def accept(v1: Float, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatCharPredicate(predicate: (Float, Char) => Boolean): FloatCharPredicate = {
      new FloatCharPredicate {
        override def accept(v1: Float, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatDoublePredicate(predicate: (Float, Double) => Boolean): FloatDoublePredicate = {
      new FloatDoublePredicate {
        override def accept(v1: Float, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatFloatPredicate(predicate: (Float, Float) => Boolean): FloatFloatPredicate = {
      new FloatFloatPredicate {
        override def accept(v1: Float, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatIntPredicate(predicate: (Float, Int) => Boolean): FloatIntPredicate = {
      new FloatIntPredicate {
        override def accept(v1: Float, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatLongPredicate(predicate: (Float, Long) => Boolean): FloatLongPredicate = {
      new FloatLongPredicate {
        override def accept(v1: Float, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatObjectPredicate[T](predicate: (Float, T) => Boolean): FloatObjectPredicate[T] = {
      new FloatObjectPredicate[T] {
        override def accept(v1: Float, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def floatPredicate(predicate: Float => Boolean): FloatPredicate = {
      new FloatPredicate {
        override def accept(v: Float): Boolean = predicate.apply(v)
      }
    }
    implicit def floatShortPredicate(predicate: (Float, Short) => Boolean): FloatShortPredicate = {
      new FloatShortPredicate {
        override def accept(v1: Float, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Int Predicate >>

    implicit def intBooleanPredicate(predicate: (Int, Boolean) => Boolean): IntBooleanPredicate = {
      new IntBooleanPredicate {
        override def accept(v1: Int, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intBytePredicate(predicate: (Int, Byte) => Boolean): IntBytePredicate = {
      new IntBytePredicate {
        override def accept(v1: Int, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intCharPredicate(predicate: (Int, Char) => Boolean): IntCharPredicate = {
      new IntCharPredicate {
        override def accept(v1: Int, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intDoublePredicate(predicate: (Int, Double) => Boolean): IntDoublePredicate = {
      new IntDoublePredicate {
        override def accept(v1: Int, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intFloatPredicate(predicate: (Int, Float) => Boolean): IntFloatPredicate = {
      new IntFloatPredicate {
        override def accept(v1: Int, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intIntPredicate(predicate: (Int, Int) => Boolean): IntIntPredicate = {
      new IntIntPredicate {
        override def accept(v1: Int, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intLongPredicate(predicate: (Int, Long) => Boolean): IntLongPredicate = {
      new IntLongPredicate {
        override def accept(v1: Int, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intObjectPredicate[T](predicate: (Int, T) => Boolean): IntObjectPredicate[T] = {
      new IntObjectPredicate[T] {
        override def accept(v1: Int, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def intPredicate(predicate: Int => Boolean): IntPredicate = {
      new IntPredicate {
        override def accept(v: Int): Boolean = predicate.apply(v)
      }
    }
    implicit def intShortPredicate(predicate: (Int, Short) => Boolean): IntShortPredicate = {
      new IntShortPredicate {
        override def accept(v1: Int, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Long Predicate >>

    implicit def longBooleanPredicate(predicate: (Long, Boolean) => Boolean): LongBooleanPredicate = {
      new LongBooleanPredicate {
        override def accept(v1: Long, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longBytePredicate(predicate: (Long, Byte) => Boolean): LongBytePredicate = {
      new LongBytePredicate {
        override def accept(v1: Long, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longCharPredicate(predicate: (Long, Char) => Boolean): LongCharPredicate = {
      new LongCharPredicate {
        override def accept(v1: Long, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longDoublePredicate(predicate: (Long, Double) => Boolean): LongDoublePredicate = {
      new LongDoublePredicate {
        override def accept(v1: Long, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longFloatPredicate(predicate: (Long, Float) => Boolean): LongFloatPredicate = {
      new LongFloatPredicate {
        override def accept(v1: Long, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longIntPredicate(predicate: (Long, Int) => Boolean): LongIntPredicate = {
      new LongIntPredicate {
        override def accept(v1: Long, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longLongPredicate(predicate: (Long, Long) => Boolean): LongLongPredicate = {
      new LongLongPredicate {
        override def accept(v1: Long, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longObjectPredicate[T](predicate: (Long, T) => Boolean): LongObjectPredicate[T] = {
      new LongObjectPredicate[T] {
        override def accept(v1: Long, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def longPredicate(predicate: Long => Boolean): LongPredicate = {
      new LongPredicate {
        override def accept(v: Long): Boolean = predicate.apply(v)
      }
    }
    implicit def longShortPredicate(predicate: (Long, Short) => Boolean): LongShortPredicate = {
      new LongShortPredicate {
        override def accept(v1: Long, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Object Predicate >>

    implicit def objectBooleanPredicate[T](predicate: (T, Boolean) => Boolean): ObjectBooleanPredicate[T] = {
      new ObjectBooleanPredicate[T] {
        override def accept(v1: T, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectBytePredicate[T](predicate: (T, Byte) => Boolean): ObjectBytePredicate[T] = {
      new ObjectBytePredicate[T] {
        override def accept(v1: T, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectCharPredicate[T](predicate: (T, Char) => Boolean): ObjectCharPredicate[T] = {
      new ObjectCharPredicate[T] {
        override def accept(v1: T, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectDoublePredicate[T](predicate: (T, Double) => Boolean): ObjectDoublePredicate[T] = {
      new ObjectDoublePredicate[T] {
        override def accept(v1: T, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectFloatPredicate[T](predicate: (T, Float) => Boolean): ObjectFloatPredicate[T] = {
      new ObjectFloatPredicate[T] {
        override def accept(v1: T, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectIntPredicate[T](predicate: (T, Int) => Boolean): ObjectIntPredicate[T] = {
      new ObjectIntPredicate[T] {
        override def accept(v1: T, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectLongPredicate[T](predicate: (T, Long) => Boolean): ObjectLongPredicate[T] = {
      new ObjectLongPredicate[T] {
        override def accept(v1: T, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def objectShortPredicate[T](predicate: (T, Short) => Boolean): ObjectShortPredicate[T] = {
      new ObjectShortPredicate[T] {
        override def accept(v1: T, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion

    // region << Short Predicate >>

    implicit def shortBooleanPredicate(predicate: (Short, Boolean) => Boolean): ShortBooleanPredicate = {
      new ShortBooleanPredicate {
        override def accept(v1: Short, v2: Boolean): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortBytePredicate(predicate: (Short, Byte) => Boolean): ShortBytePredicate = {
      new ShortBytePredicate {
        override def accept(v1: Short, v2: Byte): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortCharPredicate(predicate: (Short, Char) => Boolean): ShortCharPredicate = {
      new ShortCharPredicate {
        override def accept(v1: Short, v2: Char): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortDoublePredicate(predicate: (Short, Double) => Boolean): ShortDoublePredicate = {
      new ShortDoublePredicate {
        override def accept(v1: Short, v2: Double): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortFloatPredicate(predicate: (Short, Float) => Boolean): ShortFloatPredicate = {
      new ShortFloatPredicate {
        override def accept(v1: Short, v2: Float): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortIntPredicate(predicate: (Short, Int) => Boolean): ShortIntPredicate = {
      new ShortIntPredicate {
        override def accept(v1: Short, v2: Int): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortLongPredicate(predicate: (Short, Long) => Boolean): ShortLongPredicate = {
      new ShortLongPredicate {
        override def accept(v1: Short, v2: Long): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortObjectPredicate[T](predicate: (Short, T) => Boolean): ShortObjectPredicate[T] = {
      new ShortObjectPredicate[T] {
        override def accept(v1: Short, v2: T): Boolean = predicate.apply(v1, v2)
      }
    }
    implicit def shortPredicate(predicate: Short => Boolean): ShortPredicate = {
      new ShortPredicate {
        override def accept(v: Short): Boolean = predicate.apply(v)
      }
    }
    implicit def shortShortPredicate(predicate: (Short, Short) => Boolean): ShortShortPredicate = {
      new ShortShortPredicate {
        override def accept(v1: Short, v2: Short): Boolean = predicate.apply(v1, v2)
      }
    }

    // endregion


    // endregion

    // region << Procedure converters >>

    implicit def procedure[T](procedure: T => Unit): Procedure[T] = {
      new Procedure[T] {
        override def value(each: T): Unit = procedure.apply(each)
      }
    }
    implicit def procedure2[T1, T2](procedure: (T1, T2) => Unit): Procedure2[T1, T2] = {
      new Procedure2[T1, T2] {
        override def value(arg1: T1, arg2: T2): Unit = procedure.apply(arg1, arg2)
      }
    }

    // region << Boolean Procedure >>

    implicit def booleanBooleanProcedure(procedure: (Boolean, Boolean) => Unit): BooleanBooleanProcedure = {
      new BooleanBooleanProcedure {
        override def value(v1: Boolean, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanByteProcedure(procedure: (Boolean, Byte) => Unit): BooleanByteProcedure = {
      new BooleanByteProcedure {
        override def value(v1: Boolean, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanCharProcedure(procedure: (Boolean, Char) => Unit): BooleanCharProcedure = {
      new BooleanCharProcedure {
        override def value(v1: Boolean, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanDoubleProcedure(procedure: (Boolean, Double) => Unit): BooleanDoubleProcedure = {
      new BooleanDoubleProcedure {
        override def value(v1: Boolean, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanFloatProcedure(procedure: (Boolean, Float) => Unit): BooleanFloatProcedure = {
      new BooleanFloatProcedure {
        override def value(v1: Boolean, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanIntProcedure(procedure: (Boolean, Int) => Unit): BooleanIntProcedure = {
      new BooleanIntProcedure {
        override def value(v1: Boolean, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanLongProcedure(procedure: (Boolean, Long) => Unit): BooleanLongProcedure = {
      new BooleanLongProcedure {
        override def value(v1: Boolean, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanObjectProcedure[T](procedure: (Boolean, T) => Unit): BooleanObjectProcedure[T] = {
      new BooleanObjectProcedure[T] {
        override def value(v1: Boolean, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def booleanProcedure(procedure: Unit => Unit): BooleanProcedure = {
      new BooleanProcedure {
        override def value(v: Boolean): Unit = procedure.apply(v)
      }
    }
    implicit def booleanShortProcedure(procedure: (Boolean, Short) => Unit): BooleanShortProcedure = {
      new BooleanShortProcedure {
        override def value(v1: Boolean, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Byte Procedure >>

    implicit def byteBooleanProcedure(procedure: (Byte, Boolean) => Unit): ByteBooleanProcedure = {
      new ByteBooleanProcedure {
        override def value(v1: Byte, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteByteProcedure(procedure: (Byte, Byte) => Unit): ByteByteProcedure = {
      new ByteByteProcedure {
        override def value(v1: Byte, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteCharProcedure(procedure: (Byte, Char) => Unit): ByteCharProcedure = {
      new ByteCharProcedure {
        override def value(v1: Byte, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteDoubleProcedure(procedure: (Byte, Double) => Unit): ByteDoubleProcedure = {
      new ByteDoubleProcedure {
        override def value(v1: Byte, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteFloatProcedure(procedure: (Byte, Float) => Unit): ByteFloatProcedure = {
      new ByteFloatProcedure {
        override def value(v1: Byte, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteIntProcedure(procedure: (Byte, Int) => Unit): ByteIntProcedure = {
      new ByteIntProcedure {
        override def value(v1: Byte, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteLongProcedure(procedure: (Byte, Long) => Unit): ByteLongProcedure = {
      new ByteLongProcedure {
        override def value(v1: Byte, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteObjectProcedure[T](procedure: (Byte, T) => Unit): ByteObjectProcedure[T] = {
      new ByteObjectProcedure[T] {
        override def value(v1: Byte, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def byteProcedure(procedure: Byte => Unit): ByteProcedure = {
      new ByteProcedure {
        override def value(v: Byte): Unit = procedure.apply(v)
      }
    }
    implicit def byteShortProcedure(procedure: (Byte, Short) => Unit): ByteShortProcedure = {
      new ByteShortProcedure {
        override def value(v1: Byte, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Char Procedure >>

    implicit def charBooleanProcedure(procedure: (Char, Boolean) => Unit): CharBooleanProcedure = {
      new CharBooleanProcedure {
        override def value(v1: Char, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charByteProcedure(procedure: (Char, Char) => Unit): CharCharProcedure = {
      new CharCharProcedure {
        override def value(v1: Char, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charCharProcedure(procedure: (Char, Char) => Unit): CharCharProcedure = {
      new CharCharProcedure {
        override def value(v1: Char, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charDoubleProcedure(procedure: (Char, Double) => Unit): CharDoubleProcedure = {
      new CharDoubleProcedure {
        override def value(v1: Char, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charFloatProcedure(procedure: (Char, Float) => Unit): CharFloatProcedure = {
      new CharFloatProcedure {
        override def value(v1: Char, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charIntProcedure(procedure: (Char, Int) => Unit): CharIntProcedure = {
      new CharIntProcedure {
        override def value(v1: Char, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charLongProcedure(procedure: (Char, Long) => Unit): CharLongProcedure = {
      new CharLongProcedure {
        override def value(v1: Char, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charObjectProcedure[T](procedure: (Char, T) => Unit): CharObjectProcedure[T] = {
      new CharObjectProcedure[T] {
        override def value(v1: Char, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def charProcedure(procedure: Char => Unit): CharProcedure = {
      new CharProcedure {
        override def value(v: Char): Unit = procedure.apply(v)
      }
    }
    implicit def charShortProcedure(procedure: (Char, Short) => Unit): CharShortProcedure = {
      new CharShortProcedure {
        override def value(v1: Char, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Double Procedure >>

    implicit def doubleBooleanProcedure(procedure: (Double, Boolean) => Unit): DoubleBooleanProcedure = {
      new DoubleBooleanProcedure {
        override def value(v1: Double, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleByteProcedure(procedure: (Double, Byte) => Unit): DoubleByteProcedure = {
      new DoubleByteProcedure {
        override def value(v1: Double, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleCharProcedure(procedure: (Double, Char) => Unit): DoubleCharProcedure = {
      new DoubleCharProcedure {
        override def value(v1: Double, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleDoubleProcedure(procedure: (Double, Double) => Unit): DoubleDoubleProcedure = {
      new DoubleDoubleProcedure {
        override def value(v1: Double, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleFloatProcedure(procedure: (Double, Float) => Unit): DoubleFloatProcedure = {
      new DoubleFloatProcedure {
        override def value(v1: Double, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleIntProcedure(procedure: (Double, Int) => Unit): DoubleIntProcedure = {
      new DoubleIntProcedure {
        override def value(v1: Double, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleLongProcedure(procedure: (Double, Long) => Unit): DoubleLongProcedure = {
      new DoubleLongProcedure {
        override def value(v1: Double, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleObjectProcedure[T](procedure: (Double, T) => Unit): DoubleObjectProcedure[T] = {
      new DoubleObjectProcedure[T] {
        override def value(v1: Double, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def doubleProcedure(procedure: Double => Unit): DoubleProcedure = {
      new DoubleProcedure {
        override def value(v: Double): Unit = procedure.apply(v)
      }
    }
    implicit def doubleShortProcedure(procedure: (Double, Short) => Unit): DoubleShortProcedure = {
      new DoubleShortProcedure {
        override def value(v1: Double, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion   \

    // region << Float Procedure >>

    implicit def floatBooleanProcedure(procedure: (Float, Boolean) => Unit): FloatBooleanProcedure = {
      new FloatBooleanProcedure {
        override def value(v1: Float, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatByteProcedure(procedure: (Float, Byte) => Unit): FloatByteProcedure = {
      new FloatByteProcedure {
        override def value(v1: Float, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatCharProcedure(procedure: (Float, Char) => Unit): FloatCharProcedure = {
      new FloatCharProcedure {
        override def value(v1: Float, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatDoubleProcedure(procedure: (Float, Double) => Unit): FloatDoubleProcedure = {
      new FloatDoubleProcedure {
        override def value(v1: Float, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatFloatProcedure(procedure: (Float, Float) => Unit): FloatFloatProcedure = {
      new FloatFloatProcedure {
        override def value(v1: Float, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatIntProcedure(procedure: (Float, Int) => Unit): FloatIntProcedure = {
      new FloatIntProcedure {
        override def value(v1: Float, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatLongProcedure(procedure: (Float, Long) => Unit): FloatLongProcedure = {
      new FloatLongProcedure {
        override def value(v1: Float, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatObjectProcedure[T](procedure: (Float, T) => Unit): FloatObjectProcedure[T] = {
      new FloatObjectProcedure[T] {
        override def value(v1: Float, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def floatProcedure(procedure: Float => Unit): FloatProcedure = {
      new FloatProcedure {
        override def value(v: Float): Unit = procedure.apply(v)
      }
    }
    implicit def floatShortProcedure(procedure: (Float, Short) => Unit): FloatShortProcedure = {
      new FloatShortProcedure {
        override def value(v1: Float, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Int Procedure >>

    implicit def intBooleanProcedure(procedure: (Int, Boolean) => Unit): IntBooleanProcedure = {
      new IntBooleanProcedure {
        override def value(v1: Int, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intByteProcedure(procedure: (Int, Byte) => Unit): IntByteProcedure = {
      new IntByteProcedure {
        override def value(v1: Int, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intCharProcedure(procedure: (Int, Char) => Unit): IntCharProcedure = {
      new IntCharProcedure {
        override def value(v1: Int, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intDoubleProcedure(procedure: (Int, Double) => Unit): IntDoubleProcedure = {
      new IntDoubleProcedure {
        override def value(v1: Int, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intFloatProcedure(procedure: (Int, Float) => Unit): IntFloatProcedure = {
      new IntFloatProcedure {
        override def value(v1: Int, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intIntProcedure(procedure: (Int, Int) => Unit): IntIntProcedure = {
      new IntIntProcedure {
        override def value(v1: Int, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intLongProcedure(procedure: (Int, Long) => Unit): IntLongProcedure = {
      new IntLongProcedure {
        override def value(v1: Int, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intObjectProcedure[T](procedure: (Int, T) => Unit): IntObjectProcedure[T] = {
      new IntObjectProcedure[T] {
        override def value(v1: Int, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def intProcedure(procedure: Int => Unit): IntProcedure = {
      new IntProcedure {
        override def value(v: Int): Unit = procedure.apply(v)
      }
    }
    implicit def intShortProcedure(procedure: (Int, Short) => Unit): IntShortProcedure = {
      new IntShortProcedure {
        override def value(v1: Int, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Long Procedure >>

    implicit def longBooleanProcedure(procedure: (Long, Boolean) => Unit): LongBooleanProcedure = {
      new LongBooleanProcedure {
        override def value(v1: Long, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longByteProcedure(procedure: (Long, Byte) => Unit): LongByteProcedure = {
      new LongByteProcedure {
        override def value(v1: Long, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longCharProcedure(procedure: (Long, Char) => Unit): LongCharProcedure = {
      new LongCharProcedure {
        override def value(v1: Long, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longDoubleProcedure(procedure: (Long, Double) => Unit): LongDoubleProcedure = {
      new LongDoubleProcedure {
        override def value(v1: Long, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longFloatProcedure(procedure: (Long, Float) => Unit): LongFloatProcedure = {
      new LongFloatProcedure {
        override def value(v1: Long, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longIntProcedure(procedure: (Long, Int) => Unit): LongIntProcedure = {
      new LongIntProcedure {
        override def value(v1: Long, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longLongProcedure(procedure: (Long, Long) => Unit): LongLongProcedure = {
      new LongLongProcedure {
        override def value(v1: Long, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longObjectProcedure[T](procedure: (Long, T) => Unit): LongObjectProcedure[T] = {
      new LongObjectProcedure[T] {
        override def value(v1: Long, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def longProcedure(procedure: Long => Unit): LongProcedure = {
      new LongProcedure {
        override def value(v: Long): Unit = procedure.apply(v)
      }
    }
    implicit def longShortProcedure(procedure: (Long, Short) => Unit): LongShortProcedure = {
      new LongShortProcedure {
        override def value(v1: Long, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Object Procedure >>

    implicit def objectBooleanProcedure[T](procedure: (T, Boolean) => Unit): ObjectBooleanProcedure[T] = {
      new ObjectBooleanProcedure[T] {
        override def value(v1: T, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectByteProcedure[T](procedure: (T, Byte) => Unit): ObjectByteProcedure[T] = {
      new ObjectByteProcedure[T] {
        override def value(v1: T, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectCharProcedure[T](procedure: (T, Char) => Unit): ObjectCharProcedure[T] = {
      new ObjectCharProcedure[T] {
        override def value(v1: T, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectDoubleProcedure[T](procedure: (T, Double) => Unit): ObjectDoubleProcedure[T] = {
      new ObjectDoubleProcedure[T] {
        override def value(v1: T, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectFloatProcedure[T](procedure: (T, Float) => Unit): ObjectFloatProcedure[T] = {
      new ObjectFloatProcedure[T] {
        override def value(v1: T, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectIntProcedure[T](procedure: (T, Int) => Unit): com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure[T] = {
      new com.gs.collections.api.block.procedure.primitive.ObjectIntProcedure[T] {
        override def value(v1: T, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectLongProcedure[T](procedure: (T, Long) => Unit): ObjectLongProcedure[T] = {
      new ObjectLongProcedure[T] {
        override def value(v1: T, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def objectShortProcedure[T](procedure: (T, Short) => Unit): ObjectShortProcedure[T] = {
      new ObjectShortProcedure[T] {
        override def value(v1: T, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // region << Short Procedure >>

    implicit def shortBooleanProcedure(procedure: (Short, Boolean) => Unit): ShortBooleanProcedure = {
      new ShortBooleanProcedure {
        override def value(v1: Short, v2: Boolean): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortByteProcedure(procedure: (Short, Byte) => Unit): ShortByteProcedure = {
      new ShortByteProcedure {
        override def value(v1: Short, v2: Byte): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortCharProcedure(procedure: (Short, Char) => Unit): ShortCharProcedure = {
      new ShortCharProcedure {
        override def value(v1: Short, v2: Char): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortDoubleProcedure(procedure: (Short, Double) => Unit): ShortDoubleProcedure = {
      new ShortDoubleProcedure {
        override def value(v1: Short, v2: Double): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortFloatProcedure(procedure: (Short, Float) => Unit): ShortFloatProcedure = {
      new ShortFloatProcedure {
        override def value(v1: Short, v2: Float): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortIntProcedure(procedure: (Short, Int) => Unit): ShortIntProcedure = {
      new ShortIntProcedure {
        override def value(v1: Short, v2: Int): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortLongProcedure(procedure: (Short, Long) => Unit): ShortLongProcedure = {
      new ShortLongProcedure {
        override def value(v1: Short, v2: Long): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortObjectProcedure[T](procedure: (Short, T) => Unit): ShortObjectProcedure[T] = {
      new ShortObjectProcedure[T] {
        override def value(v1: Short, v2: T): Unit = procedure.apply(v1, v2)
      }
    }
    implicit def shortProcedure(procedure: Short => Unit): ShortProcedure = {
      new ShortProcedure {
        override def value(v: Short): Unit = procedure.apply(v)
      }
    }
    implicit def shortShortProcedure(procedure: (Short, Short) => Unit): ShortShortProcedure = {
      new ShortShortProcedure {
        override def value(v1: Short, v2: Short): Unit = procedure.apply(v1, v2)
      }
    }

    // endregion

    // endregion

  }
}