all

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val bigDecimalToInt: Prism[BigDecimal, Int]

val bigDecimalToLong: Prism[BigDecimal, Long]

val bigIntToBoolean: Prism[BigInt, Boolean]

val bigIntToByte: Prism[BigInt, Byte]

val bigIntToChar: Prism[BigInt, Char]

val bigIntToInt: Prism[BigInt, Int]

val bigIntToLong: Prism[BigInt, Long]

val byteToBoolean: Prism[Byte, Boolean]

val charToBoolean: Prism[Char, Boolean]

def clone(): AnyRef

def cofreeToStream[A]: Iso[Cofree[Option, A], OneAnd[Stream, A]]

Iso variant of pCofreeToStream

def cofreeToTree[A]: Iso[Cofree[Stream, A], Tree[A]]

Iso variant of pCofreeToTree

final def disjunctionToEither[E, A]: Iso[\/[E, A], Either[E, A]]

final def disjunctionToValidation[E, A]: Iso[\/[E, A], Validation[E, A]]

val doubleToFloat: Prism[Double, Float]

val doubleToInt: Prism[Double, Int]

final def eitherToDisjunction[E, A]: Iso[Either[E, A], \/[E, A]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def failure[E, A]: Prism[Validation[E, A], E]

def finalize(): Unit

final def flip[A, B, C]: Iso[(A) ⇒ (B) ⇒ C, (B) ⇒ (A) ⇒ C]

final def flipped[A, B, C]: ((A) ⇒ (B) ⇒ C) ⇒ (B) ⇒ (A) ⇒ C

final def getClass(): Class[_]

def hashCode(): Int

final def iListToList[A]: Iso[IList[A], List[A]]

val intToBoolean: Prism[Int, Boolean]

val intToByte: Prism[Int, Byte]

val intToChar: Prism[Int, Char]

final def isInstanceOf[T0]: Boolean

final def just[A]: Prism[Maybe[A], A]

final def left[A, B]: Prism[\/[A, B], A]

final def left3[A, B, C]: Prism[Either3[A, B, C], A]

final def leftMostLabel[A]: Lens[Tree[A], A]

def listToVector[A]: Iso[List[A], Vector[A]]

val longToBoolean: Prism[Long, Boolean]

val longToByte: Prism[Long, Byte]

val longToChar: Prism[Long, Char]

val longToInt: Prism[Long, Int]

def mapToSet[K]: Iso[Map[K, Unit], Set[K]]

final def maybeToOption[A]: Iso[Maybe[A], Option[A]]

final def middle3[A, B, C]: Prism[Either3[A, B, C], B]

final def ne(arg0: AnyRef): Boolean

final def nelToOneAnd[A]: Iso[NonEmptyList[A], OneAnd[List, A]]

final def none[A]: Prism[Option[A], Unit]

final def nothing[A]: Prism[Maybe[A], Unit]

final def notify(): Unit

final def notifyAll(): Unit

final def optNelToList[A]: Iso[Option[NonEmptyList[A]], List[A]]

final def optionToDisjunction[A]: Iso[Option[A], \/[Unit, A]]

def pCofreeToStream[A, B]: PIso[Cofree[Option, A], Cofree[Option, B], OneAnd[Stream, A], OneAnd[Stream, B]]

Polymorphic isomorphism between Cofree[Option, _] and OneAnd[Stream, _]

def pCofreeToTree[A, B]: PIso[Cofree[Stream, A], Cofree[Stream, B], Tree[A], Tree[B]]

Polymorphic isomorphism between Cofree[Stream, _] and Tree

final def pDisjunctionToEither[E1, E2, A1, A2]: PIso[\/[E1, A1], \/[E2, A2], Either[E1, A1], Either[E2, A2]]

final def pDisjunctionToValidation[E1, E2, A1, A2]: PIso[\/[E1, A1], \/[E2, A2], Validation[E1, A1], Validation[E2, A2]]

final def pEitherToDisjunction[E1, E2, A1, A2]: PIso[Either[E1, A1], Either[E2, A2], \/[E1, A1], \/[E2, A2]]

final def pFailure[E, A, F]: PPrism[Validation[E, A], Validation[F, A], E, F]

final def pIListToList[A, B]: PIso[IList[A], IList[B], List[A], List[B]]

final def pJust[A, B]: PPrism[Maybe[A], Maybe[B], A, B]

final def pLeft[A, B, C]: PPrism[\/[A, B], \/[C, B], A, C]

final def pLeft3[A, B, C, D]: PPrism[Either3[A, B, C], Either3[D, B, C], A, D]

def pListToVector[A, B]: PIso[List[A], List[B], Vector[A], Vector[B]]

final def pMaybeToOption[A, B]: PIso[Maybe[A], Maybe[B], Option[A], Option[B]]

final def pMiddle3[A, B, C, D]: PPrism[Either3[A, B, C], Either3[A, D, C], B, D]

final def pNelToOneAnd[A, B]: PIso[NonEmptyList[A], NonEmptyList[B], OneAnd[List, A], OneAnd[List, B]]

final def pOptNelToList[A, B]: PIso[Option[NonEmptyList[A]], Option[NonEmptyList[B]], List[A], List[B]]

final def pOptionToDisjunction[A, B]: PIso[Option[A], Option[B], \/[Unit, A], \/[Unit, B]]

final def pRight[A, B, C]: PPrism[\/[A, B], \/[A, C], B, C]

final def pRight3[A, B, C, D]: PPrism[Either3[A, B, C], Either3[A, B, D], C, D]

final def pSome[A, B]: PPrism[Option[A], Option[B], A, B]

final def pStdLeft[A, B, C]: PPrism[Either[A, B], Either[C, B], A, C]

final def pStdRight[A, B, C]: PPrism[Either[A, B], Either[A, C], B, C]

final def pSuccess[E, A, B]: PPrism[Validation[E, A], Validation[E, B], A, B]

final def pTrySuccess[A, B]: PPrism[Try[A], Try[B], A, B]

final def pValidationToDisjunction[E1, E2, A1, A2]: PIso[Validation[E1, A1], Validation[E2, A2], \/[E1, A1], \/[E2, A2]]

final def right[A, B]: Prism[\/[A, B], B]

final def right3[A, B, C]: Prism[Either3[A, B, C], C]

final def rightMostLabel[A]: Lens[Tree[A], A]

final def rootLabel[A]: Lens[Tree[A], A]

final def some[A]: Prism[Option[A], A]

final def stdLeft[A, B]: Prism[Either[A, B], A]

final def stdRight[A, B]: Prism[Either[A, B], B]

val stringToBoolean: Prism[String, Boolean]

val stringToByte: Prism[String, Byte]

val stringToInt: Prism[String, Int]

val stringToList: Iso[String, List[Char]]

val stringToLong: Prism[String, Long]

val stringToURI: Prism[String, URI]

val stringToUUID: Prism[String, UUID]

final def subForest[A]: Lens[Tree[A], Stream[Tree[A]]]

final def success[E, A]: Prism[Validation[E, A], A]

final def synchronized[T0](arg0: ⇒ T0): T0

def theseToDisjunction[A, B]: Prism[\&/[A, B], \/[A, B]]

def toString(): String

final def tryFailure[A]: Prism[Try[A], Throwable]

final def trySuccess[A]: Prism[Try[A], A]

def tuple1Iso[A]: Iso[(A), A]

final def validationToDisjunction[E, A]: Iso[Validation[E, A], \/[E, A]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def nelAndOneIso[A]: Iso[NonEmptyList[A], OneAnd[List, A]]

final def pNelAndOneIso[A, B]: PIso[NonEmptyList[A], NonEmptyList[B], OneAnd[List, A], OneAnd[List, B]]

def theseDisjunction[A, B]: Prism[\&/[A, B], \/[A, B]]