Packages

package 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:

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

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. predef
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. trait Applicative[F[_]] extends Functor[F]
  2. trait ApplicativeSyntax extends AnyRef

    Convenience syntax for Applicative usage.

    Convenience syntax for Applicative usage.

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

  3. trait DecimalPlus[A] extends AnyRef

    Operations that are unfortunately missing from Fractional

  4. class EitherOps[L, R] extends AnyRef
  5. trait Functor[F[_]] extends AnyRef
  6. abstract class Identity[A] extends AnyRef

    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.

  7. trait IntegralPlus[A] extends AnyRef

    Operations that are unfortunately missing from Integral

  8. sealed trait LazyList[A] extends AnyRef

    A _very_ naive lazy-list.

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

  9. trait Monad[F[_]] extends Applicative[F]
  10. type State[S, A] = StateT[Identity, S, A]
  11. case class StateT[M[_], S, A](run: (S) => M[(S, A)]) extends Product with Serializable
  12. abstract class StateTImplicits1 extends AnyRef
  13. abstract class StateTImplicits2 extends StateTImplicits1
  14. trait StateTOpt[M[_]] extends AnyRef

Value Members

  1. def State: StateTOpt[Identity]
  2. implicit def eitherOps[L, R](e: Either[L, R]): EitherOps[L, R]
  3. def findMap[A, B](fa: LazyList[A])(f: (A) => Option[B]): Option[B]
    Annotations
    @tailrec()
  4. 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.

  5. 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.

  6. def some[A](a: A): Option[A]
  7. def stateT[M[_]]: StateTOpt[M]
  8. def traverse[M[_], A, B](fa: List[A])(f: (A) => M[B])(implicit F: Applicative[M]): M[List[B]]
  9. object Applicative
  10. object DecimalPlus
  11. object Functor
  12. object Identity
  13. object IntegralPlus
  14. object LazyList
  15. object Monad
  16. object StateT extends StateTImplicits2 with Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped