Standard Library Integration

// Available via import scalaz.std.list._ or import scalaz.Scalaz._

implicit def listMonad: Monad[List] with Traverse[List] with MonadPlus[List] with Alt[List] with BindRec[List] with Zip[List] with Unzip[List] with Align[List] with IsEmpty[List] with Cobind[List]

implicit def listEqual[A: Equal]: Equal[List[A]]
implicit def listOrder[A: Order]: Order[List[A]]  
implicit def listShow[A: Show]: Show[List[A]]
implicit def listMonoid[A]: Monoid[List[A]]

import scalaz._
import scalaz.std.list._
import scalaz.syntax.monad._

// Monadic operations
val result = List(1, 2) >>= (x => List(x, x * 2))
// Result: List(1, 2, 2, 4)

// Traverse with effects
import scalaz.std.option._
import scalaz.syntax.traverse._
val validated = List(1, 2, 3).traverse(x => if (x > 0) Some(x) else None)
// Result: Some(List(1, 2, 3))

// Available via import scalaz.std.vector._ or import scalaz.Scalaz._

implicit def vectorMonad: Monad[Vector] with Traverse[Vector] with MonadPlus[Vector] with Alt[Vector] with BindRec[Vector] with Zip[Vector] with Unzip[Vector] with Align[Vector] with IsEmpty[Vector] with Cobind[Vector]

implicit def vectorEqual[A: Equal]: Equal[Vector[A]]
implicit def vectorOrder[A: Order]: Order[Vector[A]]
implicit def vectorShow[A: Show]: Show[Vector[A]]
implicit def vectorMonoid[A]: Monoid[Vector[A]]

// Available via import scalaz.std.stream._ or import scalaz.Scalaz._

implicit def streamMonad: Monad[Stream] with Traverse[Stream] with MonadPlus[Stream] with Alt[Stream] with BindRec[Stream] with Zip[Stream] with Unzip[Stream] with Align[Stream] with IsEmpty[Stream] with Cobind[Stream]

implicit def streamEqual[A: Equal]: Equal[Stream[A]]
implicit def streamOrder[A: Order]: Order[Stream[A]]
implicit def streamShow[A: Show]: Show[Stream[A]]
implicit def streamMonoid[A]: Monoid[Stream[A]]

// Available via import scalaz.std.option._ or import scalaz.Scalaz._

implicit def optionMonad: Monad[Option] with Traverse[Option] with MonadPlus[Option] with Alt[Option] with BindRec[Option] with Zip[Option] with Unzip[Option] with Align[Option] with IsEmpty[Option] with Cobind[Option] with Optional[Option]

implicit def optionEqual[A: Equal]: Equal[Option[A]]
implicit def optionOrder[A: Order]: Order[Option[A]]
implicit def optionShow[A: Show]: Show[Option[A]]
implicit def optionMonoid[A: Semigroup]: Monoid[Option[A]]

import scalaz._
import scalaz.std.option._
import scalaz.syntax.applicative._

// Applicative operations
val result = (some(1) |@| some(2) |@| some(3))(_ + _ + _)
// Result: Some(6)

// MonadPlus operations  
import scalaz.syntax.monadPlus._
val filtered = some(5).filter(_ > 10)
// Result: None

// Available via import scalaz.std.map._ or import scalaz.Scalaz._

implicit def mapMonad[K]: Monad[Map[K, ?]] with Traverse[Map[K, ?]] with BindRec[Map[K, ?]]

implicit def mapEqual[K, V](implicit K: Equal[K], V: Equal[V]): Equal[Map[K, V]]
implicit def mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[Map[K, V]]
implicit def mapMonoid[K, V]: Monoid[Map[K, V]]

// Functor instance for second type parameter
implicit def mapFunctor[K]: Functor[Map[K, ?]]

// Available via import scalaz.std.set._ or import scalaz.Scalaz._

implicit def setMonoid[A]: Monoid[Set[A]]
implicit def setBand[A]: Band[Set[A]]
implicit def setEqual[A]: Equal[Set[A]]
implicit def setShow[A: Show]: Show[Set[A]]

// Foldable instance
implicit def setFoldable: Foldable[Set]

// Available via import scalaz.std.either._ or import scalaz.Scalaz._

implicit def eitherMonad[L]: Monad[Either[L, ?]] with Traverse[Either[L, ?]] with BindRec[Either[L, ?]]

implicit def eitherEqual[A: Equal, B: Equal]: Equal[Either[A, B]]
implicit def eitherShow[A: Show, B: Show]: Show[Either[A, B]]
implicit def eitherOrder[A: Order, B: Order]: Order[Either[A, B]]

// Bifunctor and Bitraverse instances
implicit def eitherBifunctor: Bifunctor[Either]
implicit def eitherBitraverse: Bitraverse[Either]

// Available via import scalaz.std.function._ or import scalaz.Scalaz._

// Monad instance for Reader (A => ?)
implicit def function1Monad[R]: Monad[R => ?] with BindRec[R => ?]

// Arrow instances
implicit def function1Arrow: Arrow[Function1] with Choice[Function1]

// Category instance
implicit def function1Category: Category[Function1]

// Contravariant functor for input type
implicit def function1Contravariant[R]: Contravariant[? => R]

// Various other instances
implicit def function1Equal[A, B](implicit B: Equal[B]): Equal[A => B]
implicit def function1Show[A, B](implicit B: Show[B]): Show[A => B]
implicit def function1Monoid[A, B](implicit B: Monoid[B]): Monoid[A => B]

import scalaz._
import scalaz.std.function._
import scalaz.syntax.monad._

// Reader monad
val computation = for {
  x <- ((_: Int) * 2)
  y <- ((_: Int) + 10)
} yield x + y

val result = computation(5)  // (5 * 2) + (5 + 10) = 25

// Available via import scalaz.std.tuple._ or import scalaz.Scalaz._

// Monad instance for second element
implicit def tuple2Monad[A: Monoid]: Monad[(A, ?)] with Comonad[(A, ?)]

// Bifunctor and Bitraverse
implicit def tuple2Bifunctor: Bifunctor[Tuple2]
implicit def tuple2Bitraverse: Bitraverse[Tuple2]

// Equal, Order, Show instances
implicit def tuple2Equal[A: Equal, B: Equal]: Equal[(A, B)]
implicit def tuple2Order[A: Order, B: Order]: Order[(A, B)]
implicit def tuple2Show[A: Show, B: Show]: Show[(A, B)]

// Monoid instance
implicit def tuple2Monoid[A: Monoid, B: Monoid]: Monoid[(A, B)]

// Available via import scalaz.std.anyVal._ or import scalaz.Scalaz._

// Int instances
implicit def intEqual: Equal[Int]
implicit def intOrder: Order[Int]
implicit def intShow: Show[Int]
implicit def intEnum: Enum[Int]
implicit def intAdditionMonoid: Monoid[Int @@ Tags.Addition]
implicit def intMultiplicationMonoid: Monoid[Int @@ Tags.Multiplication]

// Long instances  
implicit def longEqual: Equal[Long]
implicit def longOrder: Order[Long]
implicit def longShow: Show[Long]
implicit def longEnum: Enum[Long]

// Double instances
implicit def doubleEqual: Equal[Double]
implicit def doubleOrder: Order[Double]
implicit def doubleShow: Show[Double]

// Float instances
implicit def floatEqual: Equal[Float]
implicit def floatOrder: Order[Float]
implicit def floatShow: Show[Float]

// Short instances
implicit def shortEqual: Equal[Short]
implicit def shortOrder: Order[Short]
implicit def shortShow: Show[Short]

// Byte instances
implicit def byteEqual: Equal[Byte]
implicit def byteOrder: Order[Byte]
implicit def byteShow: Show[Byte]

// Char instances
implicit def charEqual: Equal[Char]
implicit def charOrder: Order[Char]
implicit def charShow: Show[Char]
implicit def charEnum: Enum[Char]

// Available via import scalaz.std.anyVal._ or import scalaz.Scalaz._

implicit def booleanEqual: Equal[Boolean]
implicit def booleanOrder: Order[Boolean]
implicit def booleanShow: Show[Boolean]
implicit def booleanEnum: Enum[Boolean]

// Boolean algebra instances
implicit def booleanConjunctionMonoid: Monoid[Boolean @@ Tags.Conjunction]
implicit def booleanDisjunctionMonoid: Monoid[Boolean @@ Tags.Disjunction]

// Available via import scalaz.std.anyVal._ or import scalaz.Scalaz._

implicit def unitEqual: Equal[Unit]
implicit def unitOrder: Order[Unit]
implicit def unitShow: Show[Unit]
implicit def unitMonoid: Monoid[Unit]

// Available via import scalaz.std.string._ or import scalaz.Scalaz._

implicit def stringEqual: Equal[String]
implicit def stringOrder: Order[String]
implicit def stringShow: Show[String]
implicit def stringMonoid: Monoid[String]

// String as a list of characters
implicit def stringFoldable: Foldable[String]

import scalaz._
import scalaz.std.string._
import scalaz.syntax.monoid._

val combined = "Hello" |+| " " |+| "World"
// Result: "Hello World"

// Available via import scalaz.std.java.util._ or import scalaz.Scalaz._

// ArrayList instances
implicit def arrayListMonad: Monad[ArrayList] with Traverse[ArrayList] with MonadPlus[ArrayList]
implicit def arrayListEqual[A: Equal]: Equal[ArrayList[A]]

// HashMap instances  
implicit def hashMapEqual[K: Equal, V: Equal]: Equal[HashMap[K, V]]
implicit def hashMapMonoid[K, V]: Monoid[HashMap[K, V]]

// HashSet instances
implicit def hashSetEqual[A: Equal]: Equal[HashSet[A]]
implicit def hashSetMonoid[A]: Monoid[HashSet[A]]

// Available via import scalaz.std.java.time._ (JVM only)

implicit def instantEqual: Equal[Instant]
implicit def instantOrder: Order[Instant]
implicit def instantShow: Show[Instant]

implicit def durationEqual: Equal[Duration]
implicit def durationOrder: Order[Duration]
implicit def durationShow: Show[Duration]
implicit def durationMonoid: Monoid[Duration]

implicit def localDateEqual: Equal[LocalDate]
implicit def localDateOrder: Order[LocalDate]
implicit def localDateShow: Show[LocalDate]

implicit def localTimeEqual: Equal[LocalTime]
implicit def localTimeOrder: Order[LocalTime]
implicit def localTimeShow: Show[LocalTime]

implicit def localDateTimeEqual: Equal[LocalDateTime]
implicit def localDateTimeOrder: Order[LocalDateTime]
implicit def localDateTimeShow: Show[LocalDateTime]

// Available via import scalaz.std.scalaUtil._ or import scalaz.Scalaz._

implicit def tryMonad: Monad[Try] with BindRec[Try] with MonadError[Try, Throwable] with Traverse[Try] with Cozip[Try]

implicit def tryEqual[A: Equal]: Equal[Try[A]]
implicit def tryShow[A: Show]: Show[Try[A]]

// Available via import scalaz.std.scalaFuture._ (JVM and some JS environments)
// Requires implicit ExecutionContext

implicit def futureMonad(implicit ec: ExecutionContext): Monad[Future] with BindRec[Future] with Nondeterminism[Future] with MonadError[Future, Throwable]

implicit def futureEqual[A: Equal](implicit ec: ExecutionContext, duration: Duration = Duration.Inf): Equal[Future[A]]
implicit def futureShow[A: Show](implicit ec: ExecutionContext, duration: Duration = Duration.Inf): Show[Future[A]]

// Import specific type instances
import scalaz.std.option._    // Option instances only
import scalaz.std.list._      // List instances only  
import scalaz.std.string._    // String instances only

// Import categories
import scalaz.std.anyVal._    // All primitive type instances
import scalaz.std.java.util._ // Java collection instances

// Import everything
import scalaz._
import Scalaz._  // Includes all std instances and syntax

// Or import all std instances
import scalaz.std.AllInstances._
// Or all std functions
import scalaz.std.AllFunctions._

import scalaz._
import Scalaz._

// All instances and syntax available
val result1 = List(1, 2, 3).map(_ * 2)                    // Functor
val result2 = (some(1) |@| some(2))(_ + _)                // Applicative  
val result3 = List(1, 2).flatMap(x => List(x, x * 2))     // Monad
val result4 = "Hello" |+| " " |+| "World"                 // Monoid
val result5 = 1 === 1                                     // Equal
val result6 = 5 > 3                                       // Order

// Type-safe equality and ordering
import scalaz.syntax.equal._
import scalaz.syntax.order._
val equal = 1 === 1      // Uses Equal[Int]
val greater = 5 ?|? 3    // Uses Order[Int], returns Ordering.GT