hedgehog.predef

We have our own FP predef for 2 reasons.

  1. The obvious political reasons. I don't think there are any really good reasons to need more than one implementation of this library (if we do our job correctly).

Probably more importantly:

  1. Library dependencies do have a cost. Especially in the JVM world where we insist of relying on binary compatibility.

Type members

Classlikes

trait Applicative[F[_]] extends Functor[F]
Companion:
object
Companion:
class

Convenience syntax for Applicative usage.

Convenience syntax for Applicative usage.

Please forgive the use of overloading here, which avoids having to have an ApplicativeBuilder.

trait DecimalPlus[A]

Operations that are unfortunately missing from Fractional

Operations that are unfortunately missing from Fractional

Companion:
object
Companion:
class
class EitherOps[L, R](e: Either[L, R])
trait Functor[F[_]]
Companion:
object
object Functor
Companion:
class
abstract class Identity[A]

The simplest form of monad that we can use with hedgehog.

The simplest form of monad that we can use with hedgehog.

NOTE: We must use some form of call-by-need value for our M in GenT[M, ?] to avoid stack overflows.

Companion:
object
object Identity
Companion:
class
trait IntegralPlus[A]

Operations that are unfortunately missing from Integral

Operations that are unfortunately missing from Integral

Companion:
object
Companion:
class
sealed trait LazyList[A]

A very naive lazy-list. Unfortunately using Scala Stream results in the head being evaluated prematurely for shrinking.

A very naive lazy-list. Unfortunately using Scala Stream results in the head being evaluated prematurely for shrinking.

Companion:
object
object LazyList
Companion:
class
trait Monad[F[_]] extends Applicative[F]
Companion:
object
object Monad
Companion:
class
case class StateT[M[_], S, A](run: S => M[(S, A)])
Companion:
object
object StateT extends StateTImplicits2
Companion:
class
abstract class StateTImplicits1
abstract class StateTImplicits2 extends StateTImplicits1
trait StateTOpt[M[_]]

Types

type State[S, A] = StateT[Identity, S, A]

Value members

Concrete methods

@tailrec
def findMap[A, B](fa: LazyList[A])(f: A => Option[B]): Option[B]
def replicateM[M[_], A](n: Int, fa: M[A])(implicit F: Applicative[M]): M[List[A]]

Performs the action n times, returning the list of results.

Performs the action n times, returning the list of results.

def sequence[M[_], A](fa: List[M[A]])(implicit F: Applicative[M]): M[List[A]]

Strict sequencing in an applicative functor M that ignores the value in fa.

Strict sequencing in an applicative functor M that ignores the value in fa.

def some[A](a: A): Option[A]
def stateT[M[_]]: StateTOpt[M]
def traverse[M[_], A, B](fa: List[A])(f: A => M[B])(implicit F: Applicative[M]): M[List[B]]

Implicits

Implicits

implicit def eitherOps[L, R](e: Either[L, R]): EitherOps[L, R]