Skip to content

Instantly share code, notes, and snippets.

@tonymorris

tonymorris/nopointed.patch

Created December 28, 2012 02:43
Show Gist options
  • Save tonymorris/4394028 to your computer and use it in GitHub Desktop.
Save tonymorris/4394028 to your computer and use it in GitHub Desktop.
Download ZIP
Patch scalaz-seven removing Pointed, Copointed, ArrId
Raw
nopointed.patch
diff --git a/README.md b/README.md
index 0782789..0cb6f6a 100644
--- a/README.md
+++ b/README.md
@@ -172,7 +172,7 @@ in Scala flows from left-to-right, can require fewer type annotations.
every possible extension method. This should also help compiler performance,
by reducing the implicit search space.
* Syntax is layered in the same way as type classes. Importing the syntax for, say, `Applicative`
- will also provide the syntax for `Pointed` and `Functor`.
+ will also provide the syntax for `Apply` and `Functor`.
Syntax can be imported in two ways. Firstly, the syntax specialized for a particular instance
of a type class can be imported directly from the instance itself.
diff --git a/core/src/main/scala/scalaz/Applicative.scala b/core/src/main/scala/scalaz/Applicative.scala
index 0e34762..e3235fa 100644
--- a/core/src/main/scala/scalaz/Applicative.scala
+++ b/core/src/main/scala/scalaz/Applicative.scala
@@ -17,8 +17,12 @@ package scalaz
* @see [[scalaz.Applicative.ApplicativeLaw]]
*/
////
-trait Applicative[F[_]] extends Apply[F] with Pointed[F] { self =>
+trait Applicative[F[_]] extends Apply[F] { self =>
////
+ def point[A](a: => A): F[A]
+
+ // alias for point
+ def pure[A](a: => A): F[A] = point(a)
// derived functions
override def map[A, B](fa: F[A])(f: A => B): F[B] =
@@ -81,11 +85,6 @@ object Applicative {
////
- def applicative[F[_]](p: Pointed[F], a: Apply[F]): Applicative[F] = new Applicative[F] {
- def point[A](a: => A): F[A] = p.point(a)
- def ap[A,B](fa: => F[A])(f: => F[A => B]): F[B] = a.ap(fa)(f)
- }
-
implicit def monoidApplicative[M:Monoid]: Applicative[({type λ[α] = M})#λ] = Monoid[M].applicative
////
diff --git a/core/src/main/scala/scalaz/ArrId.scala b/core/src/main/scala/scalaz/ArrId.scala
deleted file mode 100644
index f10165c..0000000
--- a/core/src/main/scala/scalaz/ArrId.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-package scalaz
-
-////
-/**
- *
- */
-////
-trait ArrId[=>:[_, _]] { self =>
- ////
- def id[A]: A =>: A
-
- ////
- val arrIdSyntax = new scalaz.syntax.ArrIdSyntax[=>:] { def F = ArrId.this }
-}
-
-object ArrId {
- @inline def apply[F[_, _]](implicit F: ArrId[F]): ArrId[F] = F
-
- ////
-
- ////
-}
-
diff --git a/core/src/main/scala/scalaz/BijectionT.scala b/core/src/main/scala/scalaz/BijectionT.scala
index 9d4d0dc..af9ef8f 100644
--- a/core/src/main/scala/scalaz/BijectionT.scala
+++ b/core/src/main/scala/scalaz/BijectionT.scala
@@ -76,10 +76,10 @@ trait BijectionTFunctions {
type Bijection[A, B] =
BijectionT[Id, Id, A, B]
- def liftBijection[F[+_], G[+_], A, B](t: A => B, f: B => A)(implicit PF: Pointed[F], PG: Pointed[G]): BijectionT[F, G, A, B] =
+ def liftBijection[F[+_], G[+_], A, B](t: A => B, f: B => A)(implicit PF: Applicative[F], PG: Applicative[G]): BijectionT[F, G, A, B] =
bijection(a => PF.point(t(a)), a => PG.point(f(a)))
- def bijectionId[F[+_], G[+_], A](implicit PF: Pointed[F], PG: Pointed[G]): BijectionT[F, G, A, A] =
+ def bijectionId[F[+_], G[+_], A](implicit PF: Applicative[F], PG: Applicative[G]): BijectionT[F, G, A, A] =
liftBijection(x => x, x => x)
def curryB[A, B, C]: Bijection[(A, B) => C, A => B => C] =
diff --git a/core/src/main/scala/scalaz/Bitraverse.scala b/core/src/main/scala/scalaz/Bitraverse.scala
index 9e2eca7..d2954d1 100644
--- a/core/src/main/scala/scalaz/Bitraverse.scala
+++ b/core/src/main/scala/scalaz/Bitraverse.scala
@@ -36,12 +36,12 @@ trait Bitraverse[F[_, _]] extends Bifunctor[F] with Bifoldable[F] { self =>
def leftTraverse[X]: Traverse[({type λ[α] = F[α, X]})#λ] = new Traverse[({type λ[α] = F[α, X]})#λ] {
def traverseImpl[G[_]:Applicative,A,B](fa: F[A, X])(f: A => G[B]): G[F[B, X]] =
- bitraverseImpl(fa)(f, x => Pointed[G] point x)
+ bitraverseImpl(fa)(f, x => Applicative[G] point x)
}
def rightTraverse[X]: Traverse[({type λ[α] = F[X, α]})#λ] = new Traverse[({type λ[α] = F[X, α]})#λ] {
def traverseImpl[G[_]:Applicative,A,B](fa: F[X, A])(f: A => G[B]): G[F[X, B]] =
- bitraverseImpl(fa)(x => Pointed[G] point x, f)
+ bitraverseImpl(fa)(x => Applicative[G] point x, f)
}
class Bitraversal[G[_]](implicit G: Applicative[G]) {
@@ -68,14 +68,24 @@ trait Bitraverse[F[_, _]] extends Bifunctor[F] with Bifoldable[F] { self =>
def traverseSTrampoline[S, G[_] : Applicative, A, B, C, D](fa: F[A, B])(f: A => State[S, G[C]])(g: B => State[S, G[D]]): State[S, G[F[C, D]]] = {
import Free._
implicit val A = StateT.stateTMonadState[S, Trampoline].compose(Applicative[G])
- bitraverse[({type λ[α]=StateT[Trampoline, S, G[α]]})#λ, A, B, C, D](fa)(f(_: A).lift[Trampoline])(g(_: B).lift[Trampoline]).unliftId[Trampoline, G[F[C, D]], S, S]
+
+ new State[S, G[F[C, D]]] {
+ def apply(initial: S) = {
+ val st = bitraverse[({type λ[α]=StateT[Trampoline, S, G[α]]})#λ, A, B, C, D](fa)(f(_: A).lift[Trampoline])(g(_: B).lift[Trampoline])
+ st(initial).run
+ }
+ }
}
/** Bitraverse `fa` with a `Kleisli[G, S, C]` and `Kleisli[G, S, D]`, internally using a `Trampoline` to avoid stack overflow. */
def bitraverseKTrampoline[S, G[+_] : Applicative, A, B, C, D](fa: F[A, B])(f: A => Kleisli[G, S, C])(g: B => Kleisli[G, S, D]): Kleisli[G, S, F[C, D]] = {
import Free._
implicit val A = Kleisli.kleisliMonadReader[Trampoline, S].compose(Applicative[G])
- Kleisli(bitraverse[({type λ[α]=Kleisli[Trampoline, S, G[α]]})#λ, A, B, C, D](fa)(z => Kleisli[Id, S, G[C]](i => f(z)(i)).lift[Trampoline])(z => Kleisli[Id, S, G[D]](i => g(z)(i)).lift[Trampoline]).unliftId[Trampoline, S, G[F[C, D]]] run _)
+
+ Kleisli[G, S, F[C, D]](s => {
+ val kl = bitraverse[({type λ[α]=Kleisli[Trampoline, S, G[α]]})#λ, A, B, C, D](fa)(z => Kleisli[Id, S, G[C]](i => f(z)(i)).lift[Trampoline])(z => Kleisli[Id, S, G[D]](i => g(z)(i)).lift[Trampoline])
+ kl.run(s).run
+ })
}
def bifoldLShape[A,B,C](fa: F[A,B], z: C)(f: (C,A) => C)(g: (C,B) => C): (C, F[Unit, Unit]) =
diff --git a/core/src/main/scala/scalaz/Category.scala b/core/src/main/scala/scalaz/Category.scala
index e7bc05d..c8a9394 100644
--- a/core/src/main/scala/scalaz/Category.scala
+++ b/core/src/main/scala/scalaz/Category.scala
@@ -5,7 +5,9 @@ package scalaz
*
*/
////
-trait Category[=>:[_, _]] extends ArrId[=>:] with Compose[=>:] { self =>
+trait Category[=>:[_, _]] extends Compose[=>:] { self =>
+ def id[A]: A =>: A
+
////
// TODO GeneralizedCategory, GeneralizedFunctor, et al, from Scalaz6 ?
diff --git a/core/src/main/scala/scalaz/Codensity.scala b/core/src/main/scala/scalaz/Codensity.scala
index 5f98353..3639233 100644
--- a/core/src/main/scala/scalaz/Codensity.scala
+++ b/core/src/main/scala/scalaz/Codensity.scala
@@ -2,7 +2,7 @@ package scalaz
trait Codensity[F[+_], +A] { self =>
def apply[B](f: A => F[B]): F[B]
- def improve(implicit F: Pointed[F]): F[A] =
+ def improve(implicit F: Applicative[F]): F[A] =
apply(a => F.point(a))
def flatMap[B](k: A => Codensity[F, B]): Codensity[F, B] = {
new Codensity[F, B] {
diff --git a/core/src/main/scala/scalaz/Cokleisli.scala b/core/src/main/scala/scalaz/Cokleisli.scala
index fa18bce..09406d0 100644
--- a/core/src/main/scala/scalaz/Cokleisli.scala
+++ b/core/src/main/scala/scalaz/Cokleisli.scala
@@ -37,13 +37,7 @@ object Cokleisli extends CokleisliFunctions with CokleisliInstances {
}
}
-trait CokleisliInstances1 {
- implicit def cokleisliArrId[F[_]](implicit F0: Copointed[F]) = new CokleisliArrId[F] {
- override implicit def F = F0
- }
-}
-
-trait CokleisliInstances0 extends CokleisliInstances1 {
+trait CokleisliInstances0 {
implicit def cokleisliCompose[F[_]](implicit F0: Cojoin[F] with Functor[F]) = new CokleisliCompose[F] {
override implicit def F = F0
}
@@ -64,9 +58,6 @@ trait CokleisliFunctions {
// def redaer[A, B](r: A => B): Redaer[A, B] =
// Cokleisli[A, Identity, B](a => r(a.value))
-//
-// def ksa[F[_] : Copointed, A]: Cokleisli[A, F, A] =
-// Cokleisli(a => Copointed[F].copoint(a))
}
private[scalaz] trait CokleisliMonad[F[_], R] extends Monad[({type λ[α] = Cokleisli[F, R, α]})#λ] {
@@ -75,13 +66,6 @@ private[scalaz] trait CokleisliMonad[F[_], R] extends Monad[({type λ[α] = Cokl
def bind[A, B](fa: Cokleisli[F, R, A])(f: (A) => Cokleisli[F, R, B]) = fa flatMap f
}
-
-private[scalaz] trait CokleisliArrId[F[_]] extends ArrId[({type λ[α, β] = Cokleisli[F, α, β]})#λ] {
- implicit def F: Copointed[F]
-
- override def id[A] = Cokleisli(F.copoint)
-}
-
private[scalaz] trait CokleisliCompose[F[_]] extends Compose[({type λ[α, β] = Cokleisli[F, α, β]})#λ] {
implicit def F: Cojoin[F] with Functor[F]
@@ -91,12 +75,12 @@ private[scalaz] trait CokleisliCompose[F[_]] extends Compose[({type λ[α, β] =
private[scalaz] trait CokleisliArrow[F[_]]
extends Arrow[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
- with CokleisliArrId[F]
with CokleisliCompose[F] {
implicit def F: Comonad[F]
def arr[A, B](f: (A) => B) = Cokleisli(a => f(F.copoint(a)))
+ def id[A] = Cokleisli(F.copoint)
def first[A, B, C](f: Cokleisli[F, A, B]) =
Cokleisli[F, (A, C), (B, C)](w => (f.run(F.map(w)(ac => ac._1)), F.copoint(w)._2))
diff --git a/core/src/main/scala/scalaz/Comonad.scala b/core/src/main/scala/scalaz/Comonad.scala
index 56ee062..51dcc1a 100644
--- a/core/src/main/scala/scalaz/Comonad.scala
+++ b/core/src/main/scala/scalaz/Comonad.scala
@@ -5,10 +5,15 @@ package scalaz
*
*/
////
-trait Comonad[F[_]] extends Copointed[F] with Cojoin[F] with Cobind[F] { self =>
+trait Comonad[F[_]] extends Cojoin[F] with Cobind[F] { self =>
+ /** Also known as `extract` / `copure` */
+ def copoint[A](p: F[A]): A
////
// derived functions
+
+ /** alias for `copoint` */
+ def copure[A](p: F[A]): A = copoint(p)
trait ComonadLaws {
def cobindLeftIdentity[A](fa: F[A])(implicit F: Equal[F[A]]): Boolean =
F.equal(cobind(fa)(copoint), fa)
diff --git a/core/src/main/scala/scalaz/Composition.scala b/core/src/main/scala/scalaz/Composition.scala
index f108657..0bfcc15 100644
--- a/core/src/main/scala/scalaz/Composition.scala
+++ b/core/src/main/scala/scalaz/Composition.scala
@@ -8,14 +8,6 @@ private[scalaz] trait CompositionFunctor[F[_], G[_]] extends Functor[({type λ[
override def map[A, B](fga: F[G[A]])(f: (A) => B): F[G[B]] = F(fga)(ga => G(ga)(f))
}
-private[scalaz] trait CompositionPointed[F[_], G[_]] extends Pointed[({type λ[α] = F[G[α]]})#λ] with CompositionFunctor[F, G] {
- implicit def F: Pointed[F]
-
- implicit def G: Pointed[G]
-
- def point[A](a: => A): F[G[A]] = F.point(G.point(a))
-}
-
private[scalaz] trait CompositionApply[F[_], G[_]] extends Apply[({type λ[α] = F[G[α]]})#λ] with CompositionFunctor[F, G] {
implicit def F: Apply[F]
@@ -25,16 +17,15 @@ private[scalaz] trait CompositionApply[F[_], G[_]] extends Apply[({type λ[α] =
F.apply2(f, fa)((ff, ga) => G.ap(ga)(ff))
}
-private[scalaz] trait CompositionApplicative[F[_], G[_]] extends Applicative[({type λ[α] = F[G[α]]})#λ] with CompositionPointed[F, G] with CompositionFunctor[F, G] {
+private[scalaz] trait CompositionApplicative[F[_], G[_]] extends Applicative[({type λ[α] = F[G[α]]})#λ] with CompositionApply[F, G] {
implicit def F: Applicative[F]
implicit def G: Applicative[G]
- def ap[A, B](fa: => F[G[A]])(f: => F[G[A => B]]): F[G[B]] =
- F.apply2(f, fa)((ff, ga) => G.ap(ga)(ff))
+ def point[A](a: => A): F[G[A]] = F.point(G.point(a))
}
-private[scalaz] trait CompositionApplicativePlus[F[_], G[_]] extends ApplicativePlus[({type λ[α] = F[G[α]]})#λ] with CompositionPointed[F, G] with CompositionFunctor[F, G] with CompositionApplicative[F, G] {
+private[scalaz] trait CompositionApplicativePlus[F[_], G[_]] extends ApplicativePlus[({type λ[α] = F[G[α]]})#λ] with CompositionApplicative[F, G] {
implicit def F: ApplicativePlus[F]
implicit def G: ApplicativePlus[G]
diff --git a/core/src/main/scala/scalaz/Copointed.scala b/core/src/main/scala/scalaz/Copointed.scala
deleted file mode 100644
index d2fc6ee..0000000
--- a/core/src/main/scala/scalaz/Copointed.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-package scalaz
-
-////
-/**
- *
- */
-////
-trait Copointed[F[_]] extends Functor[F] { self =>
- ////
- /** Also known as `extract` / `copure` */
- def copoint[A](p: F[A]): A
-
- // derived functions
-
- /** alias for `copoint` */
- def copure[A](p: F[A]): A = copoint(p)
-
- ////
- val copointedSyntax = new scalaz.syntax.CopointedSyntax[F] { def F = Copointed.this }
-}
-
-object Copointed {
- @inline def apply[F[_]](implicit F: Copointed[F]): Copointed[F] = F
-
- ////
-
- ////
-}
-
diff --git a/core/src/main/scala/scalaz/Coproduct.scala b/core/src/main/scala/scalaz/Coproduct.scala
index 10bd238..89e08f4 100644
--- a/core/src/main/scala/scalaz/Coproduct.scala
+++ b/core/src/main/scala/scalaz/Coproduct.scala
@@ -22,7 +22,7 @@ sealed trait Coproduct[F[+_], G[+_], A] {
, x => G.extend(x)(a => rightc(a)))
)
- def copoint(implicit F: Copointed[F], G: Copointed[G]): A =
+ def copoint(implicit F: Comonad[F], G: Comonad[G]): A =
run.fold(F.copoint(_), G.copoint(_))
def contramap[B](f: B => A)(implicit F: Contravariant[F], G: Contravariant[G]): Coproduct[F, G, B] =
diff --git a/core/src/main/scala/scalaz/EitherT.scala b/core/src/main/scala/scalaz/EitherT.scala
index e3b335e..c72e430 100644
--- a/core/src/main/scala/scalaz/EitherT.scala
+++ b/core/src/main/scala/scalaz/EitherT.scala
@@ -202,25 +202,19 @@ object EitherT extends EitherTFunctions with EitherTInstances {
apply(F.map(e)(_ fold (\/.left, \/.right)))
/** Evaluate the given value, which might throw an exception. */
- def fromTryCatch[F[+_], A](a: => F[A])(implicit F: Pointed[F]): EitherT[F, Throwable, A] = try {
+ def fromTryCatch[F[+_], A](a: => F[A])(implicit F: Applicative[F]): EitherT[F, Throwable, A] = try {
right(a)
} catch {
case e => left(F.point(e))
}
}
-trait EitherTInstances4 {
+trait EitherTInstances3 {
implicit def eitherTFunctor[F[+_], L](implicit F0: Functor[F]) = new EitherTFunctor[F, L] {
implicit def F = F0
}
}
-trait EitherTInstances3 extends EitherTInstances4 {
- implicit def eitherTPointed[F[+_], L](implicit F0: Pointed[F]) = new EitherTPointed[F, L] {
- implicit def F = F0
- }
-}
-
trait EitherTInstances2 extends EitherTInstances3 {
implicit def eitherTApply[F[+_], L](implicit F0: Apply[F]) = new EitherTApply[F, L] {
implicit def F = F0
@@ -281,20 +275,16 @@ private[scalaz] trait EitherTFunctor[F[+_], E] extends Functor[({type λ[α]=Eit
override def map[A, B](fa: EitherT[F, E, A])(f: (A) => B): EitherT[F, E, B] = fa map f
}
-private[scalaz] trait EitherTPointed[F[+_], E] extends Pointed[({type λ[α]=EitherT[F, E, α]})#λ] with EitherTFunctor[F, E] {
- implicit def F: Pointed[F]
-
- def point[A](a: => A): EitherT[F, E, A] = EitherT(F.point(\/-(a)))
-}
-
private[scalaz] trait EitherTApply[F[+_], E] extends Apply[({type λ[α]=EitherT[F, E, α]})#λ] with EitherTFunctor[F, E] {
implicit def F: Apply[F]
override def ap[A, B](fa: => EitherT[F, E, A])(f: => EitherT[F, E, (A) => B]): EitherT[F, E, B] = fa ap f
}
-private[scalaz] trait EitherTApplicative[F[+_], E] extends Applicative[({type λ[α]=EitherT[F, E, α]})#λ] with EitherTApply[F, E] with EitherTPointed[F, E] {
+private[scalaz] trait EitherTApplicative[F[+_], E] extends Applicative[({type λ[α]=EitherT[F, E, α]})#λ] with EitherTApply[F, E] {
implicit def F: Applicative[F]
+ def point[A](a: => A): EitherT[F, E, A] = EitherT(F.point(\/-(a)))
+
}
private[scalaz] trait EitherTMonad[F[+_], E] extends Monad[({type λ[α]=EitherT[F, E, α]})#λ] with EitherTApplicative[F, E] {
diff --git a/core/src/main/scala/scalaz/Free.scala b/core/src/main/scala/scalaz/Free.scala
index 972013c..2e1c711 100644
--- a/core/src/main/scala/scalaz/Free.scala
+++ b/core/src/main/scala/scalaz/Free.scala
@@ -169,13 +169,9 @@ sealed abstract class Free[S[+_], +A](implicit S: Functor[S]) {
object Trampoline extends TrampolineInstances
trait TrampolineInstances {
- implicit val trampolineMonad: Monad[Trampoline] with Copointed[Trampoline] = new Monad[Trampoline] with Copointed[Trampoline] {
+ implicit val trampolineMonad: Monad[Trampoline] = new Monad[Trampoline] {
override def point[A](a: => A) = return_[Function0, A](a)
def bind[A, B](ta: Trampoline[A])(f: A => Trampoline[B]) = ta flatMap f
- def copoint[A](p: Free.Trampoline[A]): A = {
- import std.function.function0Instance
- p.run
- }
}
}
@@ -217,10 +213,10 @@ trait FreeFunctions {
def reset[A](r: Trampoline[A]): Trampoline[A] = { val a = r.run; return_(a) }
/** Suspend the given computation in a single step. */
- def return_[S[+_], A](value: => A)(implicit S: Pointed[S]): Free[S, A] =
+ def return_[S[+_], A](value: => A)(implicit S: Applicative[S]): Free[S, A] =
Suspend[S, A](S.point(Return[S, A](value)))
- def suspend[S[+_], A](value: => Free[S, A])(implicit S: Pointed[S]): Free[S, A] =
+ def suspend[S[+_], A](value: => Free[S, A])(implicit S: Applicative[S]): Free[S, A] =
Suspend[S, A](S.point(value))
/** A trampoline step that doesn't do anything. */
diff --git a/core/src/main/scala/scalaz/IdT.scala b/core/src/main/scala/scalaz/IdT.scala
index 163836e..f10746e 100644
--- a/core/src/main/scala/scalaz/IdT.scala
+++ b/core/src/main/scala/scalaz/IdT.scala
@@ -34,14 +34,14 @@ trait IdTInstances2 {
}
trait IdTInstances1 extends IdTInstances2 {
- implicit def idTPointed[F[_]](implicit F0: Pointed[F]): Pointed[({type λ[α] = IdT[F, α]})#λ] = new IdTPointed[F] {
- implicit def F: Pointed[F] = F0
+ implicit def idTApply[F[_]](implicit F0: Apply[F]): Apply[({type λ[α] = IdT[F, α]})#λ] = new IdTApply[F] {
+ implicit def F: Apply[F] = F0
}
}
trait IdTInstances0 extends IdTInstances1 {
- implicit def idTApply[F[_]](implicit F0: Apply[F]): Apply[({type λ[α] = IdT[F, α]})#λ] = new IdTApply[F] {
- implicit def F: Apply[F] = F0
+ implicit def idTApplicative[F[_]](implicit F0: Applicative[F]): Applicative[({type λ[α] = IdT[F, α]})#λ] = new IdTApplicative[F] {
+ implicit def F: Applicative[F] = F0
}
implicit def idTFoldable[F[_]](implicit F0: Foldable[F]): Foldable[({type λ[α] = IdT[F, α]})#λ] = new IdTFoldable[F] {
@@ -76,19 +76,19 @@ private[scalaz] trait IdTFunctor[F[_]] extends Functor[({type λ[α] = IdT[F, α
override def map[A, B](fa: IdT[F, A])(f: A => B) = fa map f
}
-private[scalaz] trait IdTPointed[F[_]] extends Pointed[({type λ[α] = IdT[F, α]})#λ] with IdTFunctor[F] {
- implicit def F: Pointed[F]
+private[scalaz] trait IdTApply[F[_]] extends Apply[({type λ[α] = IdT[F, α]})#λ] with IdTFunctor[F] {
+ implicit def F: Apply[F]
- def point[A](a: => A) = new IdT[F, A](F.point(a))
+ override def ap[A, B](fa: => IdT[F, A])(f: => IdT[F, A => B]): IdT[F, B] = fa ap f
}
-private[scalaz] trait IdTApply[F[_]] extends Apply[({type λ[α] = IdT[F, α]})#λ] with IdTFunctor[F] {
- implicit def F: Apply[F]
+private[scalaz] trait IdTApplicative[F[_]] extends Applicative[({type λ[α] = IdT[F, α]})#λ] with IdTApply[F] {
+ implicit def F: Applicative[F]
- def ap[A, B](fa: => IdT[F, A])(f: => IdT[F, A => B]): IdT[F, B] = fa ap f
+ def point[A](a: => A) = new IdT[F, A](F.point(a))
}
-private[scalaz] trait IdTMonad[F[_]] extends Monad[({type λ[α] = IdT[F, α]})#λ] with IdTPointed[F] {
+private[scalaz] trait IdTMonad[F[_]] extends Monad[({type λ[α] = IdT[F, α]})#λ] with IdTApplicative[F] {
implicit def F: Monad[F]
def bind[A, B](fa: IdT[F, A])(f: A => IdT[F, B]) = fa flatMap f
diff --git a/core/src/main/scala/scalaz/Isomorphism.scala b/core/src/main/scala/scalaz/Isomorphism.scala
index 9a607ef..1d503e7 100644
--- a/core/src/main/scala/scalaz/Isomorphism.scala
+++ b/core/src/main/scala/scalaz/Isomorphism.scala
@@ -186,12 +186,6 @@ trait IsomorphismFunctor[F[_], G[_]] extends Functor[F] {
override def map[A, B](fa: F[A])(f: A => B): F[B] = iso.from(G.map(iso.to(fa))(f))
}
-trait IsomorphismPointed[F[_], G[_]] extends Pointed[F] with IsomorphismFunctor[F, G] {
- implicit def G: Pointed[G]
-
- def point[A](a: => A): F[A] = iso.from(G.point(a))
-}
-
trait IsomorphismContravariant[F[_], G[_]] extends Contravariant[F] {
implicit def G: Contravariant[G]
@@ -200,23 +194,17 @@ trait IsomorphismContravariant[F[_], G[_]] extends Contravariant[F] {
def contramap[A, B](r: F[A])(f: B => A): F[B] = iso.from(G.contramap(iso.to(r))(f))
}
-trait IsomorphismCopointed[F[_], G[_]] extends Copointed[F] {
- implicit def G: Copointed[G]
-
- def iso: F <~> G
-
- def copoint[A](p: F[A]): A = G.copoint(iso.to(p))
-}
-
trait IsomorphismApply[F[_], G[_]] extends Apply[F] with IsomorphismFunctor[F, G] {
implicit def G: Apply[G]
override def ap[A, B](fa: => F[A])(f: => F[(A) => B]): F[B] = iso.from(G.ap(iso.to(fa))(iso.to(f)))
}
-trait IsomorphismApplicative[F[_], G[_]] extends Applicative[F] with IsomorphismApply[F, G] with IsomorphismPointed[F, G] {
+trait IsomorphismApplicative[F[_], G[_]] extends Applicative[F] with IsomorphismApply[F, G] {
implicit def G: Applicative[G]
+ def point[A](a: => A): F[A] = iso.from(G.point(a))
+
override def ap[A, B](fa: => F[A])(f: => F[(A) => B]): F[B] = iso.from(G.ap(iso.to(fa))(iso.to(f)))
}
@@ -230,7 +218,7 @@ trait IsomorphismMonad[F[_], G[_]] extends Monad[F] with IsomorphismApplicative[
implicit def G: Monad[G]
}
-trait IsomorphismCojoin[F[_], G[_]] extends Cojoin[F] {
+trait IsomorphismCojoin[F[_], G[_]] extends Cojoin[F] with IsomorphismFunctor[F, G] {
implicit def G: Cojoin[G] with Functor[G]
def iso: F <~> G
@@ -238,8 +226,10 @@ trait IsomorphismCojoin[F[_], G[_]] extends Cojoin[F] {
def cojoin[A](a: F[A]): F[F[A]] = iso.from(G.map(G.cojoin(iso.to(a)))(iso.from.apply))
}
-trait IsomorphismComonad[F[_], G[_]] extends Comonad[F] with IsomorphismCojoin[F, G] with IsomorphismCopointed[F, G] {
- implicit def G: Comonad[G] with Functor[G] with Copointed[G]
+trait IsomorphismComonad[F[_], G[_]] extends Comonad[F] with IsomorphismCojoin[F, G] {
+ implicit def G: Comonad[G] with Functor[G]
+ def copoint[A](p: F[A]): A = G.copoint(iso.to(p))
+
}
trait IsomorphismPlus[F[_], G[_]] extends Plus[F] {
diff --git a/core/src/main/scala/scalaz/Kleisli.scala b/core/src/main/scala/scalaz/Kleisli.scala
index 57d6922..302e2b2 100644
--- a/core/src/main/scala/scalaz/Kleisli.scala
+++ b/core/src/main/scala/scalaz/Kleisli.scala
@@ -46,16 +46,16 @@ sealed trait Kleisli[M[+_], -A, +B] { self =>
def flatMap[C, AA <: A](f: B => Kleisli[M, AA, C])(implicit M: Bind[M]): Kleisli[M, AA, C] =
kleisli((r: AA) => M.bind[B, C](run(r))(((b: B) => f(b).run(r))))
- def lift[L[+_]: Pointed]: Kleisli[({type λ[+α]=L[M[α]]})#λ, A, B] = new Kleisli[({type λ[+α]=L[M[α]]})#λ, A, B] {
- def run(a: A) = Pointed[L].point(self(a))
+ def lift[L[+_]: Applicative]: Kleisli[({type λ[+α]=L[M[α]]})#λ, A, B] = new Kleisli[({type λ[+α]=L[M[α]]})#λ, A, B] {
+ def run(a: A) = Applicative[L].point(self(a))
}
import Liskov._
- def unlift[N[+_], FF[+_], AA <: A, BB >: B](implicit M: Copointed[N], ev: this.type <~< Kleisli[({type λ[+α] = N[FF[α]]})#λ, AA, BB]): Kleisli[FF, AA, BB] = new Kleisli[FF, AA, BB] {
- def run(a: AA) = Copointed[N].copoint(ev(self) run a)
+ def unlift[N[+_], FF[+_], AA <: A, BB >: B](implicit M: Comonad[N], ev: this.type <~< Kleisli[({type λ[+α] = N[FF[α]]})#λ, AA, BB]): Kleisli[FF, AA, BB] = new Kleisli[FF, AA, BB] {
+ def run(a: AA) = Comonad[N].copoint(ev(self) run a)
}
- def unliftId[N[+_], AA <: A, BB >: B](implicit M: Copointed[N], ev: this.type <~< Kleisli[({type λ[+α] = N[α]})#λ, AA, BB]): Reader[AA, BB] =
+ def unliftId[N[+_], AA <: A, BB >: B](implicit M: Comonad[N], ev: this.type <~< Kleisli[({type λ[+α] = N[α]})#λ, AA, BB]): Reader[AA, BB] =
unlift[N, Id, AA, BB]
def rwst[W, S](implicit M: Functor[M], W: Monoid[W]): ReaderWriterStateT[M, A, W, S, B] = ReaderWriterStateT(
@@ -74,16 +74,13 @@ sealed trait Kleisli[M[+_], -A, +B] { self =>
//
// Prioritized Implicits for type class instances
//
-trait KleisliInstances9 {
+trait KleisliInstances8 {
implicit def kleisliFunctor[F[+_], R](implicit F0: Functor[F]): Functor[({type λ[α] = Kleisli[F, R, α]})#λ] = new KleisliFunctor[F, R] {
implicit def F: Functor[F] = F0
}
}
-trait KleisliInstances8 extends KleisliInstances9 {
- implicit def kleisliPointed[F[+_], R](implicit F0: Pointed[F]): Pointed[({type λ[α] = Kleisli[F, R, α]})#λ] = new KleisliPointed[F, R] {
- implicit def F: Pointed[F] = F0
- }
+trait KleisliInstances7 extends KleisliInstances8 {
implicit def kleisliApply[F[+_], R](implicit F0: Apply[F]): Apply[({type λ[α] = Kleisli[F, R, α]})#λ] = new KleisliApply[F, R] {
implicit def F: Apply[F] = F0
@@ -94,7 +91,7 @@ trait KleisliInstances8 extends KleisliInstances9 {
}
}
-trait KleisliInstances7 extends KleisliInstances8 {
+trait KleisliInstances6 extends KleisliInstances7 {
implicit def kleisliApplicative[F[+_], R](implicit F0: Applicative[F]): Applicative[({type λ[α] = Kleisli[F, R, α]})#λ] = new KleisliApplicative[F, R] {
implicit def F: Applicative[F] = F0
}
@@ -103,39 +100,32 @@ trait KleisliInstances7 extends KleisliInstances8 {
}
}
-trait KleisliInstances6 extends KleisliInstances7 {
+trait KleisliInstances5 extends KleisliInstances6 {
implicit def kleisliApplicativePlus[F[+_], R](implicit F0: ApplicativePlus[F]): ApplicativePlus[({type λ[α] = Kleisli[F, R, α]})#λ] = new ApplicativePlus[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliApplicative[F, R] with KleisliPlusEmpty[F, R] {
implicit def F: ApplicativePlus[F] = F0
}
- implicit def kleisliArrId[F[+_]](implicit F0: Pointed[F]) = new KleisliArrIdArr[F] {
- implicit def F: Pointed[F] = F0
- }
implicit def kleisliSemigroup[F[+_], A, B](implicit FB0: Semigroup[F[B]]) = new KleisliSemigroup[F, A, B] {
implicit def FB = FB0
}
}
-trait KleisliInstances5 extends KleisliInstances6 {
+trait KleisliInstances4 extends KleisliInstances5 {
implicit def kleisliMonadPlus[F[+_], A](implicit F0: MonadPlus[F]) = new KleisliMonadPlus[F, A] {
implicit def F = F0
}
}
-trait KleisliInstances4 extends KleisliInstances5 {
+trait KleisliInstances3 extends KleisliInstances4 {
implicit def kleisliMonadReader[F[+_], R](implicit F0: Monad[F]) = new KleisliMonadReader[F, R] {
implicit def F: Monad[F] = F0
}
}
-trait KleisliInstances3 extends KleisliInstances4 {
+trait KleisliInstances2 extends KleisliInstances3 {
implicit def kleisliIdFunctor[R]: Functor[({type λ[α] = Kleisli[Id, R, α]})#λ] = kleisliFunctor[Id, R]
}
-trait KleisliInstances2 extends KleisliInstances3 {
- implicit def kleisliIdPointed[R]: Pointed[({type λ[α] = Kleisli[Id, R, α]})#λ] = kleisliPointed[Id, R]
-}
-
trait KleisliInstances1 extends KleisliInstances2 {
implicit def kleisliIdApplicative[R]: Applicative[({type λ[α] = Kleisli[Id, R, α]})#λ] = kleisliApplicative[Id, R]
@@ -195,12 +185,6 @@ private[scalaz] trait KleisliFunctor[F[+_], R] extends Functor[({type λ[α] = K
override def map[A, B](fa: Kleisli[F, R, A])(f: A => B): Kleisli[F, R, B] = fa map f
}
-private[scalaz] trait KleisliPointed[F[+_], R] extends Pointed[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliFunctor[F, R] {
- implicit def F: Pointed[F]
-
- def point[A](a: => A): Kleisli[F, R, A] = kleisli((r: R) => F.point(a))
-}
-
private[scalaz] trait KleisliApply[F[+_], R] extends Apply[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliFunctor[F, R] {
implicit def F: Apply[F]
override def ap[A, B](fa: => Kleisli[F, R, A])(f: => Kleisli[F, R, (A) => B]): Kleisli[F, R, B] = Kleisli[F, R, B](r => F.ap(fa(r))(f(r)))
@@ -213,8 +197,9 @@ private[scalaz] trait KleisliDistributive[F[+_], R] extends Distributive[({type
Kleisli(r => F.distribute(a)(f(_) run r))
}
-private[scalaz] trait KleisliApplicative[F[+_], R] extends Applicative[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliApply[F, R] with KleisliPointed[F, R]{
+private[scalaz] trait KleisliApplicative[F[+_], R] extends Applicative[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliApply[F, R] {
implicit def F: Applicative[F]
+ def point[A](a: => A): Kleisli[F, R, A] = kleisli((r: R) => F.point(a))
}
private[scalaz] trait KleisliMonad[F[+_], R] extends Monad[({type λ[α] = Kleisli[F, R, α]})#λ] with KleisliApplicative[F, R] {
@@ -248,17 +233,8 @@ private[scalaz] trait KleisliMonadPlus[F[+_], R] extends MonadPlus[({type λ[α]
// (* *) -> *
//
-private[scalaz] trait KleisliArrIdArr[F[+_]] extends ArrId[({type λ[α, β] = Kleisli[F, α, β]})#λ] {
- implicit def F: Pointed[F]
-
- def id[A]: Kleisli[F, A, A] = kleisli(a => F.point(a))
-
- def arr[A, B](f: (A) => B): Kleisli[F, A, B] = kleisli(a => F.point(f(a)))
-}
-
private[scalaz] trait KleisliArrow[F[+_]]
extends Arrow[({type λ[α, β] = Kleisli[F, α, β]})#λ]
- with KleisliArrIdArr[F]
with Split[({type λ[α, β] = Kleisli[F, α, β]})#λ]
with Choice[({type λ[α, β] = Kleisli[F, α, β]})#λ] {
@@ -266,6 +242,10 @@ private[scalaz] trait KleisliArrow[F[+_]]
def compose[A, B, C](bc: Kleisli[F, B, C], ab: Kleisli[F, A, B]): Kleisli[F, A, C] = ab >=> bc
+ def id[A]: Kleisli[F, A, A] = kleisli(a => F.point(a))
+
+ def arr[A, B](f: (A) => B): Kleisli[F, A, B] = kleisli(a => F.point(f(a)))
+
def first[A, B, C](f: Kleisli[F, A, B]): Kleisli[F, (A, C), (B, C)] = kleisli[F, (A, C), (B, C)] {
case (a, c) => F.map(f.run(a))((b: B) => (b, c))
}
diff --git a/core/src/main/scala/scalaz/LazyEitherT.scala b/core/src/main/scala/scalaz/LazyEitherT.scala
index 2f3c98c..a9b7dac 100644
--- a/core/src/main/scala/scalaz/LazyEitherT.scala
+++ b/core/src/main/scala/scalaz/LazyEitherT.scala
@@ -75,7 +75,7 @@ sealed trait LazyEitherT[F[+_], +A, +B] {
F.foldr[LazyEither[A, B], Z](run, z)(a => b => LazyEither.lazyEitherInstance[A].foldRight[B, Z](a, b)(f))
}
- def ap[AA >: A, C](f: => LazyEitherT[F, AA, B => C])(implicit F: Applicative[F]): LazyEitherT[F, AA, C] = {
+ def ap[AA >: A, C](f: => LazyEitherT[F, AA, B => C])(implicit F: Apply[F]): LazyEitherT[F, AA, C] = {
// TODO check laziness
LazyEitherT[F, AA, C](F.apply2(f.run, run)((ff: LazyEither[AA, B => C], aa: LazyEither[A, B]) => LazyEither.lazyEitherInstance[AA].ap(aa)(ff)))
}
@@ -147,11 +147,11 @@ trait LazyEitherTInstances3 {
}
trait LazyEitherTInstances2 extends LazyEitherTInstances3 {
- implicit def lazyEitherTPointed[F[+_], L](implicit F0: Pointed[F]) = new LazyEitherTPointed[F, L] {
+ implicit def lazyEitherTApply[F[+_], L](implicit F0: Apply[F]) = new LazyEitherTApply[F, L] {
implicit def F = F0
}
- implicit def lazyEitherTLeftProjectionPointed[F[+_], L](implicit F0: Pointed[F]) = new IsomorphismPointed[({type λ[α] = LazyEitherT.LeftProjectionT[F, L, α]})#λ, ({type λ[α] = LazyEitherT[F, L, α]})#λ] {
- implicit def G = lazyEitherTPointed[F, L]
+ implicit def lazyEitherTLeftProjectionApply[F[+_], L](implicit F0: Apply[F]) = new IsomorphismApply[({type λ[α] = LazyEitherT.LeftProjectionT[F, L, α]})#λ, ({type λ[α] = LazyEitherT[F, L, α]})#λ] {
+ implicit def G = lazyEitherTApply[F, L]
def iso = LazyEitherT.lazyEitherTLeftProjectionEIso2[F, L]
}
}
@@ -218,10 +218,10 @@ trait LazyEitherTFunctions {
import LazyEither._
- def lazyLeftT[F[+_], A, B](a: => A)(implicit p: Pointed[F]): LazyEitherT[F, A, B] =
+ def lazyLeftT[F[+_], A, B](a: => A)(implicit p: Applicative[F]): LazyEitherT[F, A, B] =
lazyEitherT(p.point(lazyLeft(a)))
- def lazyRightT[F[+_], A, B](b: => B)(implicit p: Pointed[F]): LazyEitherT[F, A, B] =
+ def lazyRightT[F[+_], A, B](b: => B)(implicit p: Applicative[F]): LazyEitherT[F, A, B] =
lazyEitherT(p.point(lazyRight(b)))
import Isomorphism.{IsoFunctorTemplate, IsoBifunctorTemplate}
@@ -246,16 +246,18 @@ private[scalaz] trait LazyEitherTFunctor[F[+_], E] extends Functor[({type λ[α]
override def map[A, B](fa: LazyEitherT[F, E, A])(f: (A) => B): LazyEitherT[F, E, B] = fa map (a => f(a))
}
-private[scalaz] trait LazyEitherTPointed[F[+_], E] extends Pointed[({type λ[α]=LazyEitherT[F, E, α]})#λ] with LazyEitherTFunctor[F, E] {
- implicit def F: Pointed[F]
+private[scalaz] trait LazyEitherTApply[F[+_], E] extends Apply[({type λ[α]=LazyEitherT[F, E, α]})#λ] with LazyEitherTFunctor[F, E] {
+ implicit def F: Apply[F]
+
+ override def ap[A, B](fa: => LazyEitherT[F, E, A])(f: => LazyEitherT[F, E, (A) => B]): LazyEitherT[F, E, B] = fa ap f
- def point[A](a: => A): LazyEitherT[F, E, A] = LazyEitherT.lazyRightT(a)
}
-private[scalaz] trait LazyEitherTApplicative[F[+_], E] extends Applicative[({type λ[α]=LazyEitherT[F, E, α]})#λ] with LazyEitherTPointed[F, E] {
+private[scalaz] trait LazyEitherTApplicative[F[+_], E] extends Applicative[({type λ[α]=LazyEitherT[F, E, α]})#λ] with LazyEitherTApply[F, E] {
implicit def F: Applicative[F]
- override def ap[A, B](fa: => LazyEitherT[F, E, A])(f: => LazyEitherT[F, E, (A) => B]): LazyEitherT[F, E, B] = fa ap f
+ def point[A](a: => A): LazyEitherT[F, E, A] = LazyEitherT.lazyRightT(a)
+
}
private[scalaz] trait LazyEitherTMonad[F[+_], E] extends Monad[({type λ[α]=LazyEitherT[F, E, α]})#λ] with LazyEitherTApplicative[F, E] {
diff --git a/core/src/main/scala/scalaz/LazyOptionT.scala b/core/src/main/scala/scalaz/LazyOptionT.scala
index 3b74e3f..3ab72db 100644
--- a/core/src/main/scala/scalaz/LazyOptionT.scala
+++ b/core/src/main/scala/scalaz/LazyOptionT.scala
@@ -77,14 +77,14 @@ trait LazyOptionTInstances2 {
}
trait LazyOptionTInstances1 extends LazyOptionTInstances2 {
- implicit def lazyOptionTPointed[F[+_]](implicit F0: Pointed[F]): Pointed[({type λ[α] = LazyOptionT[F, α]})#λ] = new LazyOptionTPointed[F] {
- implicit def F: Pointed[F] = F0
+ implicit def lazyOptionTApply[F[+_]](implicit F0: Apply[F]): Apply[({type λ[α] = LazyOptionT[F, α]})#λ] = new LazyOptionTApply[F] {
+ implicit def F: Apply[F] = F0
}
}
trait LazyOptionTInstances0 extends LazyOptionTInstances1 {
- implicit def lazyOptionTApply[F[+_]](implicit F0: Apply[F]): Apply[({type λ[α] = LazyOptionT[F, α]})#λ] = new LazyOptionTApply[F] {
- implicit def F: Apply[F] = F0
+ implicit def lazyOptionTApplicative[F[+_]](implicit F0: Applicative[F]): Applicative[({type λ[α] = LazyOptionT[F, α]})#λ] = new LazyOptionTApplicative[F] {
+ implicit def F: Applicative[F] = F0
}
implicit def lazyOptionEqual[F[+_], A](implicit FA: Equal[F[LazyOption[A]]]): Equal[LazyOptionT[F, A]] = Equal.equalBy((_: LazyOptionT[F, A]).run)
}
@@ -105,10 +105,10 @@ trait LazyOptionTFunctions {
import LazyOption._
- def lazySomeT[F[+_], A](a: => A)(implicit F: Pointed[F]): LazyOptionT[F, A] =
+ def lazySomeT[F[+_], A](a: => A)(implicit F: Applicative[F]): LazyOptionT[F, A] =
lazyOptionT(F.point(lazySome(a)))
- def lazyNoneT[F[+_], A](implicit F: Pointed[F]): LazyOptionT[F, A] =
+ def lazyNoneT[F[+_], A](implicit F: Applicative[F]): LazyOptionT[F, A] =
lazyOptionT(F.point(lazyNone[A]))
}
@@ -123,20 +123,19 @@ private[scalaz] trait LazyOptionTFunctor[F[+_]] extends Functor[({type λ[α] =
override def map[A, B](fa: LazyOptionT[F, A])(f: A => B): LazyOptionT[F, B] = fa map (a => f(a))
}
-private[scalaz] trait LazyOptionTPointed[F[+_]] extends Pointed[({type λ[α] = LazyOptionT[F, α]})#λ] with LazyOptionTFunctor[F] {
- implicit def F: Pointed[F]
-
- def point[A](a: => A): LazyOptionT[F, A] = LazyOptionT[F, A](F.point(LazyOption.lazySome(a)))
-}
-
private[scalaz] trait LazyOptionTApply[F[+_]] extends Apply[({type λ[α] = LazyOptionT[F, α]})#λ] with LazyOptionTFunctor[F] {
implicit def F: Apply[F]
- def ap[A, B](fa: => LazyOptionT[F, A])(f: => LazyOptionT[F, A => B]): LazyOptionT[F, B] =
+ override def ap[A, B](fa: => LazyOptionT[F, A])(f: => LazyOptionT[F, A => B]): LazyOptionT[F, B] =
LazyOptionT(F.apply2(f.run, fa.run)({ case (ff, aa) => LazyOption.lazyOptionInstance.ap(aa)(ff) }))
}
-private[scalaz] trait LazyOptionTMonad[F[+_]] extends Monad[({type λ[α] = LazyOptionT[F, α]})#λ] with LazyOptionTPointed[F] {
+private[scalaz] trait LazyOptionTApplicative[F[+_]] extends Applicative[({type λ[α] = LazyOptionT[F, α]})#λ] with LazyOptionTApply[F] {
+ implicit def F: Applicative[F]
+ def point[A](a: => A): LazyOptionT[F, A] = LazyOptionT[F, A](F.point(LazyOption.lazySome(a)))
+}
+
+private[scalaz] trait LazyOptionTMonad[F[+_]] extends Monad[({type λ[α] = LazyOptionT[F, α]})#λ] with LazyOptionTApplicative[F] {
implicit def F: Monad[F]
def bind[A, B](fa: LazyOptionT[F, A])(f: A => LazyOptionT[F, B]): LazyOptionT[F, B] = fa flatMap (a => f(a))
diff --git a/core/src/main/scala/scalaz/Lens.scala b/core/src/main/scala/scalaz/Lens.scala
index e327a2d..df5f6e3 100644
--- a/core/src/main/scala/scalaz/Lens.scala
+++ b/core/src/main/scala/scalaz/Lens.scala
@@ -372,9 +372,6 @@ trait LensFunctions extends LensFamilyFunctions {
}
trait LensInstances0 { this: LensInstances =>
- implicit def lensArrId: ArrId[({type λ[α, β] = Lens[α, β]})#λ] = new LensArrId {
- }
-
import scala.collection.SeqLike
implicit def seqLikeLensFamily[S1, S2, A, Repr <: SeqLike[A, Repr]](lens: LensFamily[S1, S2, Repr, Repr]) =
@@ -640,19 +637,14 @@ trait LensInstances extends LensInstances0 {
LensFamilyUnzip[S1, S2].unzip7(lens.xmapbB(tuple7B))
}
-private[scalaz] trait LensArrId
- extends ArrId[Lens]{
-
- def id[A] = LensFamily.lensId
-}
-
private[scalaz] trait LensCategory
extends Choice[Lens]
- with Split[Lens]
- with LensArrId {
+ with Split[Lens] {
def compose[A, B, C](bc: Lens[B, C], ab: Lens[A, B]): Lens[A, C] = ab >=> bc
+ def id[A] = LensFamily.lensId
+
def choice[A, B, C](f: => Lens[A, C], g: => Lens[B, C]): Lens[A \/ B, C] =
LensFamily.lens {
case -\/(a) =>
diff --git a/core/src/main/scala/scalaz/ListT.scala b/core/src/main/scala/scalaz/ListT.scala
index 9920b9d..2361ec0 100644
--- a/core/src/main/scala/scalaz/ListT.scala
+++ b/core/src/main/scala/scalaz/ListT.scala
@@ -5,7 +5,7 @@ package scalaz
*/
sealed case class ListT[M[+_], +A](underlying: M[List[A]]){
- def uncons(implicit M: Pointed[M]): M[Option[(A, ListT[M, A])]] = {
+ def uncons(implicit M: Applicative[M]): M[Option[(A, ListT[M, A])]] = {
M.map(underlying){list =>
list match {
case Nil => None
@@ -22,7 +22,7 @@ sealed case class ListT[M[+_], +A](underlying: M[List[A]]){
def headOption(implicit M: Functor[M]) : M[Option[A]] = M.map(underlying)(_.headOption)
- def tailM(implicit M: Pointed[M]) : M[ListT[M, A]] = M.map(uncons)(_.get._2)
+ def tailM(implicit M: Applicative[M]) : M[ListT[M, A]] = M.map(uncons)(_.get._2)
def filter(p: A => Boolean)(implicit M: Functor[M]): ListT[M, A] = new ListT(M.map(underlying)(_.filter(p)))
@@ -76,9 +76,6 @@ trait ListTInstances2 {
}
trait ListTInstances1 extends ListTInstances2 {
- implicit def listTPointedPlus[F[+_]](implicit F0: Monad[F]): Pointed[({type λ[α] = ListT[F, α]})#λ] with Plus[({type λ[α] = ListT[F, α]})#λ] = new ListTPointedPlusEmpty[F] {
- implicit def F: Monad[F] = F0
- }
implicit def listTMonoid[F[+_], A](implicit F0: Monad[F]): Monoid[ListT[F, A]] = new ListTMonoid[F, A] {
implicit def F: Monad[F] = F0
@@ -96,7 +93,7 @@ trait ListTInstances extends ListTInstances1 {
}
object ListT extends ListTInstances {
- def empty[M[+_], A](implicit M: Pointed[M]): ListT[M, A] = new ListT[M, A](M.point(Nil))
+ def empty[M[+_], A](implicit M: Applicative[M]): ListT[M, A] = new ListT[M, A](M.point(Nil))
def fromList[M[+_], A](mas: M[List[A]]): ListT[M, A] = new ListT(mas)
}
@@ -121,9 +118,11 @@ private[scalaz] trait ListTMonoid[F[+_], A] extends Monoid[ListT[F, A]] with Lis
def zero: ListT[F, A] = ListT.empty[F, A]
}
-private[scalaz] trait ListTPointedPlusEmpty[F[+_]] extends Pointed[({type λ[α] = ListT[F, α]})#λ] with PlusEmpty[({type λ[α] = ListT[F, α]})#λ] with ListTFunctor[F] {
+private[scalaz] trait ListTMonadPlus[F[+_]] extends MonadPlus[({type λ[α] = ListT[F, α]})#λ] with ListTFunctor[F] {
implicit def F: Monad[F]
+ def bind[A, B](fa: ListT[F, A])(f: A => ListT[F, B]): ListT[F, B] = fa flatMap f
+
def point[A](a: => A): ListT[F, A] = a :: ListT.empty[F, A]
def empty[A]: ListT[F, A] = ListT.empty[F, A]
@@ -131,12 +130,6 @@ private[scalaz] trait ListTPointedPlusEmpty[F[+_]] extends Pointed[({type λ[α]
def plus[A](a: ListT[F, A], b: => ListT[F, A]): ListT[F, A] = a ++ b
}
-private[scalaz] trait ListTMonadPlus[F[+_]] extends MonadPlus[({type λ[α] = ListT[F, α]})#λ] with ListTPointedPlusEmpty[F] {
- implicit def F: Monad[F]
-
- def bind[A, B](fa: ListT[F, A])(f: A => ListT[F, B]): ListT[F, B] = fa flatMap f
-}
-
private[scalaz] trait ListTHoist extends Hoist[ListT] {
import ListT._
diff --git a/core/src/main/scala/scalaz/OptionT.scala b/core/src/main/scala/scalaz/OptionT.scala
index 5f73002..20e6676 100644
--- a/core/src/main/scala/scalaz/OptionT.scala
+++ b/core/src/main/scala/scalaz/OptionT.scala
@@ -77,9 +77,6 @@ trait OptionTInstances2 {
}
trait OptionTInstances1 extends OptionTInstances2 {
- implicit def optionTPointed[F[+_]](implicit F0: Pointed[F]): Pointed[({type λ[α] = OptionT[F, α]})#λ] = new OptionTPointed[F] {
- implicit def F: Pointed[F] = F0
- }
implicit def optionTApply[F[+_]](implicit F0: Apply[F]): Apply[({type λ[α] = OptionT[F, α]})#λ] = new OptionTApply[F] {
implicit def F: Apply[F] = F0
}
@@ -89,6 +86,9 @@ trait OptionTInstances0 extends OptionTInstances1 {
implicit def optionTFoldable[F[+_]](implicit F0: Foldable[F]): Foldable[({type λ[α] = OptionT[F, α]})#λ] = new OptionTFoldable[F] {
implicit def F: Foldable[F] = F0
}
+ implicit def optionTApplicative[F[+_]](implicit F0: Applicative[F]): Applicative[({type λ[α] = OptionT[F, α]})#λ] = new OptionTApplicative[F] {
+ implicit def F: Applicative[F] = F0
+ }
}
trait OptionTInstances extends OptionTInstances0 {
@@ -123,22 +123,23 @@ private[scalaz] trait OptionTFunctor[F[+_]] extends Functor[({type λ[α] = Opti
override def map[A, B](fa: OptionT[F, A])(f: A => B): OptionT[F, B] = fa map f
}
-private[scalaz] trait OptionTPointed[F[+_]] extends Pointed[({type λ[α] = OptionT[F, α]})#λ] with OptionTFunctor[F] {
- implicit def F: Pointed[F]
+private[scalaz] trait OptionTApply[F[+_]] extends Apply[({type λ[α] = OptionT[F, α]})#λ] with OptionTFunctor[F] {
+ implicit def F: Apply[F]
- def point[A](a: => A): OptionT[F, A] = OptionT[F, A](F.point(some(a)))
+ override def ap[A, B](fa: => OptionT[F, A])(f: => OptionT[F, A => B]): OptionT[F, B] = fa ap f
}
-private[scalaz] trait OptionTApply[F[+_]] extends Apply[({type λ[α] = OptionT[F, α]})#λ] with OptionTFunctor[F] {
- implicit def F: Apply[F]
+private[scalaz] trait OptionTApplicative[F[+_]] extends Applicative[({type λ[α] = OptionT[F, α]})#λ] with OptionTApply[F] {
+ implicit def F: Applicative[F]
- def ap[A, B](fa: => OptionT[F, A])(f: => OptionT[F, A => B]): OptionT[F, B] = fa ap f
+ def point[A](a: => A): OptionT[F, A] = OptionT[F, A](F.point(some(a)))
}
-private[scalaz] trait OptionTMonad[F[+_]] extends Monad[({type λ[α] = OptionT[F, α]})#λ] with OptionTPointed[F] {
+private[scalaz] trait OptionTMonad[F[+_]] extends Monad[({type λ[α] = OptionT[F, α]})#λ] with OptionTApplicative[F] {
implicit def F: Monad[F]
def bind[A, B](fa: OptionT[F, A])(f: A => OptionT[F, B]): OptionT[F, B] = fa flatMap f
+
}
private[scalaz] trait OptionTFoldable[F[+_]] extends Foldable.FromFoldr[({type λ[α] = OptionT[F, α]})#λ] {
diff --git a/core/src/main/scala/scalaz/PLens.scala b/core/src/main/scala/scalaz/PLens.scala
index 57e2e14..7435ff2 100644
--- a/core/src/main/scala/scalaz/PLens.scala
+++ b/core/src/main/scala/scalaz/PLens.scala
@@ -568,13 +568,7 @@ trait PLensFunctions extends PLensFamilyFunctions with PLensInstances {
}
}
-trait PLensInstances0 {
- implicit def plensArrI: PLensArrId = new PLensArrId {
- }
-
-}
-
-trait PLensInstances extends PLensInstances0 {
+trait PLensInstances {
import PLensFamily._
@@ -635,16 +629,12 @@ trait PLensInstances extends PLensInstances0 {
}
-private[scalaz] trait PLensArrId extends ArrId[PLens] {
- def id[A]: PLens[A, A] = PLensFamily.plensId
-}
-
private[scalaz] trait PLensCategory
extends Choice[PLens]
- with Split[PLens]
- with PLensArrId {
+ with Split[PLens] {
def compose[A, B, C](bc: PLens[B, C], ab: PLens[A, B]): PLens[A, C] = ab >=> bc
+ def id[A]: PLens[A, A] = PLensFamily.plensId
def choice[A, B, C](f: => PLens[A, C], g: => PLens[B, C]): PLens[A \/ B, C] =
PLensFamily.plens[A \/ B, C] {
diff --git a/core/src/main/scala/scalaz/Pointed.scala b/core/src/main/scala/scalaz/Pointed.scala
deleted file mode 100644
index afdd952..0000000
--- a/core/src/main/scala/scalaz/Pointed.scala
+++ /dev/null
@@ -1,43 +0,0 @@
-package scalaz
-
-////
-/**
- *
- */
-////
-trait Pointed[F[_]] extends Functor[F] { self =>
- ////
-
- def point[A](a: => A): F[A]
-
- // derived functions
-
- /** alias for `point` */
- def pure[A](a: => A): F[A] = point(a)
-
- /**The composition of Pointeds `F` and `G`, `[x]F[G[x]]`, is a Pointed */
- def compose[G[_]](implicit G0: Pointed[G]): Pointed[({type λ[α] = F[G[α]]})#λ] = new CompositionPointed[F, G] {
- implicit def F = self
-
- implicit def G = G0
- }
-
- /**The product of Pointeds `F` and `G`, `[x](F[x], G[x]])`, is a Pointed */
- def product[G[_]](implicit G0: Pointed[G]): Pointed[({type λ[α] = (F[α], G[α])})#λ] = new ProductPointed[F, G] {
- implicit def F = self
-
- implicit def G = G0
- }
-
- ////
- val pointedSyntax = new scalaz.syntax.PointedSyntax[F] { def F = Pointed.this }
-}
-
-object Pointed {
- @inline def apply[F[_]](implicit F: Pointed[F]): Pointed[F] = F
-
- ////
-
- ////
-}
-
diff --git a/core/src/main/scala/scalaz/Product.scala b/core/src/main/scala/scalaz/Product.scala
index b8bbf8a..128da3f 100644
--- a/core/src/main/scala/scalaz/Product.scala
+++ b/core/src/main/scala/scalaz/Product.scala
@@ -9,14 +9,6 @@ private[scalaz] trait ProductFunctor[F[_], G[_]] extends Functor[({type λ[α] =
override def map[A, B](fa: (F[A], G[A]))(f: (A) => B): (F[B], G[B]) = (F.map(fa._1)(f), G.map(fa._2)(f))
}
-private[scalaz] trait ProductPointed[F[_], G[_]] extends Pointed[({type λ[α] = (F[α], G[α])})#λ] with ProductFunctor[F, G] {
- implicit def F: Pointed[F]
-
- implicit def G: Pointed[G]
-
- def point[A](a: => A): (F[A], G[A]) = (F.point(a), G.point(a))
-}
-
private[scalaz] trait ProductApply[F[_], G[_]] extends Apply[({type λ[α] = (F[α], G[α])})#λ] with ProductFunctor[F, G] {
implicit def F: Apply[F]
@@ -26,15 +18,15 @@ private[scalaz] trait ProductApply[F[_], G[_]] extends Apply[({type λ[α] = (F[
(F.ap(fa._1)(f._1), G.ap(fa._2)(f._2))
}
-private[scalaz] trait ProductApplicative[F[_], G[_]] extends Applicative[({type λ[α] = (F[α], G[α])})#λ] with ProductPointed[F, G] {
+private[scalaz] trait ProductApplicative[F[_], G[_]] extends Applicative[({type λ[α] = (F[α], G[α])})#λ] with ProductApply[F, G] {
implicit def F: Applicative[F]
implicit def G: Applicative[G]
- def ap[A, B](fa: => (F[A], G[A]))(f: => (F[(A) => B], G[(A) => B])): (F[B], G[B]) = (F.ap(fa._1)(f._1), G.ap(fa._2)(f._2))
+ def point[A](a: => A): (F[A], G[A]) = (F.point(a), G.point(a))
}
-private[scalaz] trait ProductApplicativePlus[F[_], G[_]] extends ApplicativePlus[({type λ[α] = (F[α], G[α])})#λ] with ProductPointed[F, G] with ProductFunctor[F, G] with ProductApplicative[F, G] {
+private[scalaz] trait ProductApplicativePlus[F[_], G[_]] extends ApplicativePlus[({type λ[α] = (F[α], G[α])})#λ] with ProductApplicative[F, G] {
implicit def F: ApplicativePlus[F]
implicit def G: ApplicativePlus[G]
diff --git a/core/src/main/scala/scalaz/ReaderWriterStateT.scala b/core/src/main/scala/scalaz/ReaderWriterStateT.scala
index 34f7b69..2fc653e 100644
--- a/core/src/main/scala/scalaz/ReaderWriterStateT.scala
+++ b/core/src/main/scala/scalaz/ReaderWriterStateT.scala
@@ -38,21 +38,13 @@ trait ReaderWriterStateTFunctions {
}
-trait ReaderWriterStateTInstances1 {
+trait ReaderWriterStateTInstances0 {
implicit def rwstFunctor[F[+_], R, W, S](implicit F0: Functor[F]): Functor[({type λ[+α] = ReaderWriterStateT[F, R, W, S, α]})#λ] =
new ReaderWriterStateTFunctor[F, R, W, S] {
implicit def F = F0
}
}
-trait ReaderWriterStateTInstances0 extends ReaderWriterStateTInstances1 {
- implicit def rwstPointed[F[+_], R, W, S](implicit W0: Monoid[W], F0: Pointed[F]): Pointed[({type λ[+α] = ReaderWriterStateT[F, R, W, S, α]})#λ] =
- new ReaderWriterStateTPointed[F, R, W, S] {
- implicit def F = F0
- implicit def W = W0
- }
-}
-
trait ReaderWriterStateTInstances extends ReaderWriterStateTInstances0 {
implicit def rwstMonad[F[+_], R, W, S](implicit W0: Monoid[W], F0: Monad[F]):
MonadReader[({type λ[-r, +α]=ReaderWriterStateT[F, r, W, S, α]})#λ, R] with MonadState[({type f[s, +a] = ReaderWriterStateT[F, R, W, s, a]})#f, S] =
@@ -73,19 +65,16 @@ private[scalaz] trait ReaderWriterStateTFunctor[F[+_], R, W, S] extends Functor[
override def map[A, B](fa: ReaderWriterStateT[F, R, W, S, A])(f: A => B) = fa map f
}
-private[scalaz] trait ReaderWriterStateTPointed[F[+_], R, W, S] extends Pointed[({type λ[α]=ReaderWriterStateT[F, R, W, S, α]})#λ] with ReaderWriterStateTFunctor[F, R, W, S] {
- implicit def F: Pointed[F]
- implicit def W: Monoid[W]
- def point[A](a: => A) = ReaderWriterStateT((r, s) => F.point((W.zero, a, s)))
-}
-
private[scalaz] trait ReaderWriterStateTMonadReader[F[+_], R, W, S]
extends MonadReader[({type λ[r, α]=ReaderWriterStateT[F, r, W, S, α]})#λ, R]
with MonadState[({type f[s, a] = ReaderWriterStateT[F, R, W, s, a]})#f, S]
- with ReaderWriterStateTPointed[F, R, W, S] {
+ with ReaderWriterStateTFunctor[F, R, W, S] {
implicit def F: Monad[F]
+ implicit def W: Monoid[W]
def bind[A, B](fa: ReaderWriterStateT[F, R, W, S, A])(f: A => ReaderWriterStateT[F, R, W, S, B]) = fa flatMap f
+ def point[A](a: => A) =
+ ReaderWriterStateT((r, s) => F.point((W.zero, a, s)))
def ask: ReaderWriterStateT[F, R, W, S, R] =
ReaderWriterStateT((r, s) => F.point((W.zero, r, s)))
def local[A](f: (R) => R)(fa: ReaderWriterStateT[F, R, W, S, A]): ReaderWriterStateT[F, R, W, S, A] =
diff --git a/core/src/main/scala/scalaz/Semigroup.scala b/core/src/main/scala/scalaz/Semigroup.scala
index ca7bcae..21ea72c 100644
--- a/core/src/main/scala/scalaz/Semigroup.scala
+++ b/core/src/main/scala/scalaz/Semigroup.scala
@@ -79,10 +79,10 @@ object Semigroup {
def append(f1: A, f2: => A): A = o.max(f1, f2)
}
- def repeat[F[_], A](a: A)(implicit F: Pointed[F], m: Semigroup[F[A]]): F[A] =
+ def repeat[F[_], A](a: A)(implicit F: Applicative[F], m: Semigroup[F[A]]): F[A] =
m.append(F.point(a), repeat[F, A](a))
- def iterate[F[_], A](a: A)(f: A => A)(implicit F: Pointed[F], m: Semigroup[F[A]]): F[A] =
+ def iterate[F[_], A](a: A)(f: A => A)(implicit F: Applicative[F], m: Semigroup[F[A]]): F[A] =
m.append(F.point(a), iterate[F, A](f(a))(f))
////
diff --git a/core/src/main/scala/scalaz/StateT.scala b/core/src/main/scala/scalaz/StateT.scala
index de69ffd..0b0baa3 100644
--- a/core/src/main/scala/scalaz/StateT.scala
+++ b/core/src/main/scala/scalaz/StateT.scala
@@ -63,16 +63,16 @@ trait IndexedStateT[F[+_], -S1, +S2, +A] { self =>
case (s1, a) => f(a)(s1)
})
- def lift[M[+_]: Pointed]: IndexedStateT[({type λ[+α]=M[F[α]]})#λ, S1, S2, A] = new IndexedStateT[({type λ[+α]=M[F[α]]})#λ, S1, S2, A] {
- def apply(initial: S1): M[F[(S2, A)]] = Pointed[M].point(self(initial))
+ def lift[M[+_]: Applicative]: IndexedStateT[({type λ[+α]=M[F[α]]})#λ, S1, S2, A] = new IndexedStateT[({type λ[+α]=M[F[α]]})#λ, S1, S2, A] {
+ def apply(initial: S1): M[F[(S2, A)]] = Applicative[M].point(self(initial))
}
import Liskov._
- def unlift[M[+_], FF[+_], AA >: A, S1m <: S1, S2m >: S2](implicit M: Copointed[M], ev: this.type <~< IndexedStateT[({type λ[+α] = M[FF[α]]})#λ, S1m, S2m, AA]): IndexedStateT[FF, S1m, S2m, AA] = new IndexedStateT[FF, S1m, S2m, AA] {
- def apply(initial: S1m): FF[(S2m, AA)] = Copointed[M].copoint(ev(self)(initial))
+ def unlift[M[+_], FF[+_], AA >: A, S1m <: S1, S2m >: S2](implicit M: Comonad[M], ev: this.type <~< IndexedStateT[({type λ[+α] = M[FF[α]]})#λ, S1m, S2m, AA]): IndexedStateT[FF, S1m, S2m, AA] = new IndexedStateT[FF, S1m, S2m, AA] {
+ def apply(initial: S1m): FF[(S2m, AA)] = Comonad[M].copoint(ev(self)(initial))
}
- def unliftId[M[+_], AA >: A, S1m <: S1, S2m >: S2](implicit M: Copointed[M], ev: this.type <~< IndexedStateT[M, S1m, S2m, AA]): IndexedState[S1m, S2m, AA] = unlift[M, Id, AA, S1m, S2m]
+ def unliftId[M[+_], AA >: A, S1m <: S1, S2m >: S2](implicit M: Comonad[M], ev: this.type <~< IndexedStateT[M, S1m, S2m, AA]): IndexedState[S1m, S2m, AA] = unlift[M, Id, AA, S1m, S2m]
def rwst[W, R, S >: S2 <: S1](implicit F: Functor[F], W: Monoid[W]): ReaderWriterStateT[F, R, W, S, A] = ReaderWriterStateT(
(r, s) => F.map(self(s)) {
@@ -113,13 +113,7 @@ trait IndexedStateTInstances extends IndexedStateTInstances0 {
}
}
-trait StateTInstances2 extends IndexedStateTInstances {
- implicit def stateTPointed[S, F[+_]](implicit F0: Pointed[F]): Pointed[({type f[+a] = StateT[F, S, a]})#f] = new StateTPointed[S, F] {
- implicit def F: Pointed[F] = F0
- }
-}
-
-trait StateTInstances1 extends StateTInstances2 {
+trait StateTInstances1 extends IndexedStateTInstances {
implicit def stateTMonadState[S, F[+_]](implicit F0: Monad[F]): MonadState[({type f[s, +a] = StateT[F, s, a]})#f, S] = new StateTMonadState[S, F] {
implicit def F: Monad[F] = F0
}
@@ -135,15 +129,15 @@ trait StateTInstances extends StateTInstances0 {
}
trait IndexedStateTFunctions {
- def constantIndexedStateT[F[+_], S1, S2, A](a: A)(s: => S2)(implicit F: Pointed[F]): IndexedStateT[F, S1, S2, A] =
+ def constantIndexedStateT[F[+_], S1, S2, A](a: A)(s: => S2)(implicit F: Applicative[F]): IndexedStateT[F, S1, S2, A] =
IndexedStateT((_: S1) => F.point((s, a)))
}
trait StateTFunctions extends IndexedStateTFunctions {
- def constantStateT[F[+_], S, A](a: A)(s: => S)(implicit F: Pointed[F]): StateT[F, S, A] =
+ def constantStateT[F[+_], S, A](a: A)(s: => S)(implicit F: Applicative[F]): StateT[F, S, A] =
StateT((_: S) => F.point((s, a)))
- def stateT[F[+_], S, A](a: A)(implicit F: Pointed[F]): StateT[F, S, A] =
+ def stateT[F[+_], S, A](a: A)(implicit F: Applicative[F]): StateT[F, S, A] =
StateT(s => F.point((s, a)))
}
@@ -173,19 +167,15 @@ private[scalaz] trait IndexedStateTFunctorRight[S1, S2, F[+_]] extends Functor[(
override def map[A, B](fa: IndexedStateT[F, S1, S2, A])(f: A => B): IndexedStateT[F, S1, S2, B] = fa.map(f)
}
-private[scalaz] trait StateTPointed[S, F[+_]] extends Pointed[({type f[+a] = StateT[F, S, a]})#f] with IndexedStateTFunctorRight[S, S, F] {
- implicit def F: Pointed[F]
+private[scalaz] trait StateTMonadState[S, F[+_]] extends MonadState[({type f[s, +a] = StateT[F, s, a]})#f, S] {
+ implicit def F: Monad[F]
+
+ def bind[A, B](fa: StateT[F, S, A])(f: A => StateT[F, S, B]): StateT[F, S, B] = fa.flatMap(f)
def point[A](a: => A): StateT[F, S, A] = {
lazy val aa = a
StateT(s => F.point(s, aa))
}
-}
-
-private[scalaz] trait StateTMonadState[S, F[+_]] extends MonadState[({type f[s, +a] = StateT[F, s, a]})#f, S] with StateTPointed[S, F] {
- implicit def F: Monad[F]
-
- def bind[A, B](fa: StateT[F, S, A])(f: A => StateT[F, S, B]): StateT[F, S, B] = fa.flatMap(f)
def init: StateT[F, S, S] = StateT(s => F.point((s, s)))
diff --git a/core/src/main/scala/scalaz/StoreT.scala b/core/src/main/scala/scalaz/StoreT.scala
index ed8ad1c..19ca00a 100644
--- a/core/src/main/scala/scalaz/StoreT.scala
+++ b/core/src/main/scala/scalaz/StoreT.scala
@@ -38,10 +38,10 @@ sealed trait IndexedStoreT[F[+_], +I, -A, +B] {
def pos: I =
run._2
- def peek(a: A)(implicit F: Copointed[F]): B =
+ def peek(a: A)(implicit F: Comonad[F]): B =
F.copoint(set)(a)
- def peeks(f: I => A)(implicit F: Copointed[F]): B =
+ def peeks(f: I => A)(implicit F: Comonad[F]): B =
F.copoint(set)(f(pos))
def seek[J](j: J): IndexedStoreT[F, J, A, B] =
@@ -50,10 +50,10 @@ sealed trait IndexedStoreT[F[+_], +I, -A, +B] {
def seeks[J](f: I => J): IndexedStoreT[F, J, A, B] =
indexedStoreT((set, f(pos)))
- def experiment[G[+_]](f: I => G[A])(implicit F: Copointed[F], G: Functor[G]): G[B] =
+ def experiment[G[+_]](f: I => G[A])(implicit F: Comonad[F], G: Functor[G]): G[B] =
G.map(f(pos))(F.copoint(set))
- def copoint(implicit F: Copointed[F], ev: I <:< A): B =
+ def copoint(implicit F: Comonad[F], ev: I <:< A): B =
F.copoint(run._1)(run._2)
def map[C](f: B => C)(implicit ftr: Functor[F]): IndexedStoreT[F, I, A, C] =
@@ -117,12 +117,7 @@ trait IndexedStoreTInstances extends IndexedStoreTInstances0 {
implicit def F: Functor[F] = F0
}
}
-trait StoreTInstances3 extends IndexedStoreTInstances {
- implicit def storeTCopointed[F[+_], A](implicit F0: Copointed[F]) = new StoreTCopointed[F, A] {
- implicit def F: Copointed[F] = F0
- }
-}
-trait StoreTInstances2 extends StoreTInstances3 {
+trait StoreTInstances2 extends IndexedStoreTInstances {
implicit def storeTCobind[F[+_], A](implicit F0: Cobind[F]) = new StoreTCobind[F, A] {
implicit def F: Cobind[F] = F0
}
@@ -160,19 +155,16 @@ private[scalaz] trait IndexedStoreTBifunctor[F[+_], A0] extends Bifunctor[({type
override def bimap[A, B, C, D](fab: IndexedStoreT[F, A, A0, B])(f: A => C, g: B => D): IndexedStoreT[F, C, A0, D] = (fab bimap f)(g)
}
-private[scalaz] trait StoreTCopointed[F[+_], A0] extends Copointed[({type λ[+α]=StoreT[F, A0, α]})#λ] with IndexedStoreTFunctorRight[F, A0, A0] {
- implicit def F: Copointed[F]
- def copoint[A](p: StoreT[F, A0, A]) = p.copoint
-}
-
private[scalaz] trait StoreTCobind[F[+_], A0] extends Cobind[({type λ[+α]=StoreT[F, A0, α]})#λ] with IndexedStoreTFunctorRight[F, A0, A0] {
implicit def F: Cobind[F]
def cobind[A, B](fa: StoreT[F, A0, A])(f: (StoreT[F, A0, A]) => B) = fa cobind f
}
-private[scalaz] trait StoreTComonad[F[+_], A0] extends Comonad[({type λ[+α]=StoreT[F, A0, α]})#λ] with StoreTCobind[F, A0] with StoreTCopointed[F, A0]{
+private[scalaz] trait StoreTComonad[F[+_], A0] extends Comonad[({type λ[+α]=StoreT[F, A0, α]})#λ] with StoreTCobind[F, A0] {
implicit def F: Comonad[F]
def cojoin[A](a: StoreT[F, A0, A]) = a.duplicate
+ def copoint[A](p: StoreT[F, A0, A]) = p.copoint
+
}
private[scalaz] trait StoreTComonadStore[F[+_], S] extends ComonadStore[({type λ[σ, +α]=StoreT[F, σ, α]})#λ, S] with StoreTComonad[F, S] {
diff --git a/core/src/main/scala/scalaz/StreamT.scala b/core/src/main/scala/scalaz/StreamT.scala
index 39d5dc1..9a5c0eb 100644
--- a/core/src/main/scala/scalaz/StreamT.scala
+++ b/core/src/main/scala/scalaz/StreamT.scala
@@ -16,7 +16,7 @@ sealed class StreamT[M[+_], +A](val step: M[StreamT.Step[A, StreamT[M, A]]]) {
, done = M.point(None)
))
- def ::[AA >: A](a: => AA)(implicit M: Pointed[M]): StreamT[M, AA] = StreamT[M, AA](M.point(Yield(a, this)))
+ def ::[AA >: A](a: => AA)(implicit M: Applicative[M]): StreamT[M, AA] = StreamT[M, AA](M.point(Yield(a, this)))
def isEmpty(implicit M: Monad[M]): M[Boolean] = M.map(uncons)(!_.isDefined)
@@ -148,12 +148,9 @@ trait StreamTInstances2 {
}
trait StreamTInstances1 extends StreamTInstances2 {
- implicit def StreamTPointedPlus[F[+_]](implicit F0: Pointed[F]): Pointed[({type λ[α] = StreamT[F, α]})#λ] with Plus[({type λ[α] = StreamT[F, α]})#λ] = new StreamTPointed[F] {
- implicit def F: Pointed[F] = F0
- }
- implicit def StreamTMonoid[F[+_], A](implicit F0: Pointed[F]): Monoid[StreamT[F, A]] = new StreamTMonoid[F, A] {
- implicit def F: Pointed[F] = F0
+ implicit def StreamTMonoid[F[+_], A](implicit F0: Applicative[F]): Monoid[StreamT[F, A]] = new StreamTMonoid[F, A] {
+ implicit def F: Applicative[F] = F0
}
}
@@ -175,9 +172,9 @@ trait StreamTInstances extends StreamTInstances0 {
object StreamT extends StreamTInstances {
def apply[M[+_], A](step: M[Step[A, StreamT[M, A]]]): StreamT[M, A] = new StreamT[M, A](step)
- def empty[M[+_], A](implicit M: Pointed[M]): StreamT[M, A] = new StreamT[M, A](M point Done)
+ def empty[M[+_], A](implicit M: Applicative[M]): StreamT[M, A] = new StreamT[M, A](M point Done)
- def fromStream[M[+_], A](mas: M[Stream[A]])(implicit M: Pointed[M]): StreamT[M, A] = {
+ def fromStream[M[+_], A](mas: M[Stream[A]])(implicit M: Applicative[M]): StreamT[M, A] = {
def loop(as: Stream[A]): Step[A, StreamT[M, A]] = as match {
case head #:: tail => Yield(head, apply(M.point(loop(tail))))
case _ => Done
@@ -252,29 +249,25 @@ private[scalaz] trait StreamTSemigroup[F[+_], A] extends Semigroup[StreamT[F, A]
}
private[scalaz] trait StreamTMonoid[F[+_], A] extends Monoid[StreamT[F, A]] with StreamTSemigroup[F, A] {
- implicit def F: Pointed[F]
+ implicit def F: Applicative[F]
def zero: StreamT[F, A] = StreamT.empty[F, A]
}
-private[scalaz] trait StreamTPointed[F[+_]] extends Pointed[({type λ[α] = StreamT[F, α]})#λ] with Plus[({type λ[α] = StreamT[F, α]})#λ] with StreamTFunctor[F] {
- implicit def F: Pointed[F]
+private[scalaz] trait StreamTMonad[F[+_]] extends Monad[({type λ[α] = StreamT[F, α]})#λ] with StreamTFunctor[F] {
+ implicit def F: Monad[F]
def point[A](a: => A): StreamT[F, A] = a :: StreamT.empty[F, A]
- def empty[A]: StreamT[F, A] = StreamT.empty
-
- def plus[A](a: StreamT[F, A], b: => StreamT[F, A]): StreamT[F, A] = a ++ b
-}
-
-private[scalaz] trait StreamTMonad[F[+_]] extends Monad[({type λ[α] = StreamT[F, α]})#λ] with StreamTPointed[F] {
- implicit def F: Monad[F]
-
def bind[A, B](fa: StreamT[F, A])(f: A => StreamT[F, B]): StreamT[F, B] = fa flatMap f
}
private[scalaz] trait StreamTMonadPlus[F[+_]] extends MonadPlus[({type λ[α] = StreamT[F, α]})#λ] with StreamTMonad[F] {
implicit def F: Monad[F]
+
+ def empty[A]: StreamT[F, A] = StreamT.empty
+
+ def plus[A](a: StreamT[F, A], b: => StreamT[F, A]): StreamT[F, A] = a ++ b
}
private[scalaz] trait StreamTHoist extends Hoist[StreamT] {
diff --git a/core/src/main/scala/scalaz/Traverse.scala b/core/src/main/scala/scalaz/Traverse.scala
index d0a1b86..3bb75cc 100644
--- a/core/src/main/scala/scalaz/Traverse.scala
+++ b/core/src/main/scala/scalaz/Traverse.scala
@@ -52,14 +52,20 @@ trait Traverse[F[_]] extends Functor[F] with Foldable[F] { self =>
def traverseSTrampoline[S, G[+_] : Applicative, A, B](fa: F[A])(f: A => State[S, G[B]]): State[S, G[F[B]]] = {
import Free._
implicit val A = StateT.stateTMonadState[S, Trampoline].compose(Applicative[G])
- traverse[({type λ[α]=StateT[Trampoline, S, G[α]]})#λ, A, B](fa)(f(_: A).lift[Trampoline]).unliftId[Trampoline, G[F[B]], S, S]
+ State[S, G[F[B]]](s => {
+ val st = traverse[({type λ[α]=StateT[Trampoline, S, G[α]]})#λ, A, B](fa)(f(_: A).lift[Trampoline])
+ st.run(s).run
+ })
}
/** Traverse `fa` with a `Kleisli[G, S, B]`, internally using a `Trampoline` to avoid stack overflow. */
def traverseKTrampoline[S, G[+_] : Applicative, A, B](fa: F[A])(f: A => Kleisli[G, S, B]): Kleisli[G, S, F[B]] = {
import Free._
implicit val A = Kleisli.kleisliMonadReader[Trampoline, S].compose(Applicative[G])
- Kleisli(traverse[({type λ[α]=Kleisli[Trampoline, S, G[α]]})#λ, A, B](fa)(z => Kleisli[Id, S, G[B]](i => f(z)(i)).lift[Trampoline]).unliftId[Trampoline, S, G[F[B]]] run _)
+ Kleisli[G, S, F[B]](s => {
+ val kl = traverse[({type λ[α]=Kleisli[Trampoline, S, G[α]]})#λ, A, B](fa)(z => Kleisli[Id, S, G[B]](i => f(z)(i)).lift[Trampoline]).run(s)
+ kl.run
+ })
}
// derived functions
@@ -137,7 +143,7 @@ trait Traverse[F[_]] extends Functor[F] with Foldable[F] { self =>
/**
* @param nat A natural transformation from `M` to `N` for which these properties hold:
- * `(a: A) => nat(Pointed[M].pure[A](a)) === Pointed[M].point[A](a)`
+ * `(a: A) => nat(Applicative[M].pure[A](a)) === Applicative[M].point[A](a)`
* `(f: M[A => B], ma: M[A]) => nat(Applicative[M].ap(ma)(f)) === Applicative[N].ap(nat(ma))(nat(f))`
*/
def naturality[N[_], M[_], A](nat: (M ~> N))
diff --git a/core/src/main/scala/scalaz/UnwriterT.scala b/core/src/main/scala/scalaz/UnwriterT.scala
index fe213d9..a63651f 100644
--- a/core/src/main/scala/scalaz/UnwriterT.scala
+++ b/core/src/main/scala/scalaz/UnwriterT.scala
@@ -75,7 +75,7 @@ sealed trait UnwriterT[F[+_], +U, +A] { self =>
case (a, b) => G.apply2(f(a), g(b))((_, _))
})(unwriterT(_))
- def wpoint[G[+_]](implicit F: Functor[F], P: Pointed[G]): UnwriterT[F, G[U], A] =
+ def wpoint[G[+_]](implicit F: Functor[F], P: Applicative[G]): UnwriterT[F, G[U], A] =
unwriterT(F.map(self.run) {
case (u, a) => (P.point(u), a)
})
@@ -105,9 +105,6 @@ trait UnwriterTInstances0 extends UnwriterTInstances1 {
implicit def unwriterTBind[F[+_], W](implicit F0: Bind[F]) = new UnwriterTBind[F, W] {
implicit def F = F0
}
- implicit def unwriterTCopointed[F[+_], W](implicit F0: Copointed[F]) = new UnwriterTCopointed[F, W] {
- implicit def F = F0
- }
implicit def unwriterTFoldable[F[+_], W](implicit F0: Foldable[F]) = new UnwriterTFoldable[F, W] {
implicit def F = F0
}
@@ -215,17 +212,13 @@ private[scalaz] trait UnwriterTBitraverse[F[+_]] extends Bitraverse[({type λ[+
fab.bitraverse(f, g)
}
-private[scalaz] trait UnwriterTCopointed[F[+_], W] extends Copointed[({type λ[+α] = UnwriterT[F, W, α]})#λ] with UnwriterTFunctor[F, W] {
- implicit def F: Copointed[F]
-
- def copoint[A](p: UnwriterT[F, W, A]): A = F.copoint(p.value)
-}
-
-private[scalaz] trait UnwriterComonad[W] extends Comonad[({type λ[+α] = Unwriter[W, α]})#λ] with UnwriterTCopointed[Id, W] {
+private[scalaz] trait UnwriterComonad[W] extends Comonad[({type λ[+α] = Unwriter[W, α]})#λ] with UnwriterTFunctor[Id, W] {
override def cojoin[A](fa: Unwriter[W, A]): Unwriter[W, Unwriter[W, A]] =
Unwriter(fa.unwritten, fa)
override def cobind[A, B](fa: Unwriter[W, A])(f: (Unwriter[W, A]) => B): Unwriter[W, B] =
Unwriter(fa.unwritten, f(fa))
+ def copoint[A](p: Unwriter[W, A]): A = p.value
+
}
diff --git a/core/src/main/scala/scalaz/Validation.scala b/core/src/main/scala/scalaz/Validation.scala
index 8888d2c..347b032 100644
--- a/core/src/main/scala/scalaz/Validation.scala
+++ b/core/src/main/scala/scalaz/Validation.scala
@@ -381,9 +381,7 @@ trait ValidationInstances1 extends ValidationInstances2 {
}
trait ValidationInstances2 extends ValidationInstances3 {
- implicit def ValidationInstances1[L]: Pointed[({type l[a] = Validation[L, a]})#l] with Traverse[({type l[a] = Validation[L, a]})#l] with Cozip[({type l[a] = Validation[L, a]})#l] with Plus[({type l[a] = Validation[L, a]})#l] = new Pointed[({type l[a] = Validation[L, a]})#l] with Traverse[({type l[a] = Validation[L, a]})#l] with Cozip[({type l[a] = Validation[L, a]})#l] with Plus[({type l[a] = Validation[L, a]})#l] {
- def point[A](a: => A) =
- Success(a)
+ implicit def ValidationInstances1[L]: Traverse[({type l[a] = Validation[L, a]})#l] with Cozip[({type l[a] = Validation[L, a]})#l] with Plus[({type l[a] = Validation[L, a]})#l] = new Traverse[({type l[a] = Validation[L, a]})#l] with Cozip[({type l[a] = Validation[L, a]})#l] with Plus[({type l[a] = Validation[L, a]})#l] {
override def map[A, B](fa: Validation[L, A])(f: A => B) =
fa map f
diff --git a/core/src/main/scala/scalaz/WriterT.scala b/core/src/main/scala/scalaz/WriterT.scala
index 6e13b15..a3b08df 100644
--- a/core/src/main/scala/scalaz/WriterT.scala
+++ b/core/src/main/scala/scalaz/WriterT.scala
@@ -89,7 +89,7 @@ sealed trait WriterT[F[+_], +W, +A] { self =>
}
)
- def wpoint[G[+_]](implicit F: Functor[F], P: Pointed[G]): WriterT[F, G[W], A] =
+ def wpoint[G[+_]](implicit F: Functor[F], P: Applicative[G]): WriterT[F, G[W], A] =
writerT(F.map(self.run) {
case (w, a) => (P.point(w), a)
})
@@ -100,27 +100,14 @@ object WriterT extends WriterTFunctions with WriterTInstances {
writerT(v)
}
-trait WriterTInstances14 {
+trait WriterTInstances12 {
implicit def writerFunctor[W]: WriterTFunctor[Id, W] = new WriterTFunctor[Id, W] {
implicit def F = idInstance
}
}
-trait WriterTInstances13 extends WriterTInstances14 {
- implicit def writerTFunctor[F[+_], W](implicit F0: Functor[F]) = new WriterTFunctor[F, W] {
- implicit def F = F0
- }
-}
-
-trait WriterTInstances12 extends WriterTInstances13 {
- implicit def writerPointed[W](implicit W0: Monoid[W]): Pointed[({type λ[+α]=Writer[W, α]})#λ] = new WriterTPointed[Id, W] {
- implicit def F = idInstance
- implicit def W = W0
- }
-}
trait WriterTInstances11 extends WriterTInstances12 {
- implicit def writerTPointed[F[+_], W](implicit W0: Monoid[W], F0: Pointed[F]): Pointed[({type λ[+α]=WriterT[F, W, α]})#λ] = new WriterTPointed[F, W] {
+ implicit def writerTFunctor[F[+_], W](implicit F0: Functor[F]) = new WriterTFunctor[F, W] {
implicit def F = F0
- implicit def W = W0
}
}
@@ -170,9 +157,6 @@ trait WriterTInstances4 extends WriterTInstance5 {
implicit def writerBifunctor = new WriterTBifunctor[Id] {
implicit def F = idInstance
}
- implicit def writerCopointed[W] = new WriterTCopointed[Id, W] {
- implicit def F = idInstance
- }
implicit def writerFoldable[W] = new WriterTFoldable[Id, W] {
implicit def F = idInstance
}
@@ -183,9 +167,6 @@ trait WriterTInstances3 extends WriterTInstances4 {
implicit def writerTBifunctor[F[+_]](implicit F0: Functor[F]) = new WriterTBifunctor[F] {
implicit def F = F0
}
- implicit def writerTCopointed[F[+_], W](implicit F0: Copointed[F]) = new WriterTCopointed[F, W] {
- implicit def F = F0
- }
implicit def writerTFoldable[F[+_], W](implicit F0: Foldable[F]) = new WriterTFoldable[F, W] {
implicit def F = F0
}
@@ -267,13 +248,6 @@ private[scalaz] trait WriterTFunctor[F[+_], W] extends Functor[({type λ[+α]=Wr
override def map[A, B](fa: WriterT[F, W, A])(f: (A) => B) = fa map f
}
-private[scalaz] trait WriterTPointed[F[+_], W] extends Pointed[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTFunctor[F, W] {
- implicit def F: Pointed[F]
- implicit def W: Monoid[W]
-
- def point[A](a: => A) = writerT(F.point((W.zero, a)))
-}
-
private[scalaz] trait WriterTApply[F[+_], W] extends Apply[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTFunctor[F, W] {
implicit def F: Apply[F]
implicit def W: Semigroup[W]
@@ -281,9 +255,10 @@ private[scalaz] trait WriterTApply[F[+_], W] extends Apply[({type λ[+α]=Writer
override def ap[A, B](fa: => WriterT[F, W, A])(f: => WriterT[F, W, (A) => B]) = fa ap f
}
-private[scalaz] trait WriterTApplicative[F[+_], W] extends Applicative[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTApply[F, W] with WriterTPointed[F, W] {
+private[scalaz] trait WriterTApplicative[F[+_], W] extends Applicative[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTApply[F, W] {
implicit def F: Applicative[F]
implicit def W: Monoid[W]
+ def point[A](a: => A) = writerT(F.point((W.zero, a)))
}
private[scalaz] trait WriterTEach[F[+_], W] extends Each[({type λ[+α]=WriterT[F, W, α]})#λ] {
@@ -297,7 +272,7 @@ private[scalaz] trait WriterTIndex[W] extends Index[({type λ[+α]=WriterT[Id, W
def index[A](fa: WriterT[Id, W, A], i: Int) = if(i == 0) Some(fa.value) else None
}
-private[scalaz] trait WriterTMonad[F[+_], W] extends Monad[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTApplicative[F, W] with WriterTPointed[F, W] {
+private[scalaz] trait WriterTMonad[F[+_], W] extends Monad[({type λ[+α]=WriterT[F, W, α]})#λ] with WriterTApplicative[F, W] {
implicit def F: Monad[F]
def bind[A, B](fa: WriterT[F, W, A])(f: (A) => WriterT[F, W, B]) = fa flatMap f
@@ -329,13 +304,8 @@ private[scalaz] trait WriterTBitraverse[F[+_]] extends Bitraverse[({type λ[+α,
fab.bitraverse(f, g)
}
-private[scalaz] trait WriterTCopointed[F[+_], W] extends Copointed[({type λ[+α] = WriterT[F, W, α]})#λ] with WriterTFunctor[F, W] {
- implicit def F: Copointed[F]
-
- def copoint[A](p: WriterT[F, W, A]): A = F.copoint(p.value)
-}
-
-private[scalaz] trait WriterComonad[W] extends Comonad[({type λ[+α] = Writer[W, α]})#λ] with WriterTCopointed[Id, W] {
+private[scalaz] trait WriterComonad[W] extends Comonad[({type λ[+α] = Writer[W, α]})#λ] with WriterTFunctor[Id, W] {
+ def copoint[A](p: Writer[W, A]): A = p.value
override def cojoin[A](fa: Writer[W, A]): Writer[W, Writer[W, A]] =
Writer(fa.written, fa)
diff --git a/core/src/main/scala/scalaz/package.scala b/core/src/main/scala/scalaz/package.scala
index 8fb87e1..5d5d9d1 100644
--- a/core/src/main/scala/scalaz/package.scala
+++ b/core/src/main/scala/scalaz/package.scala
@@ -27,16 +27,14 @@
* - [[scalaz.Each]]
* - [[scalaz.Index]]
* - [[scalaz.Functor]]
- * - [[scalaz.Pointed]] extends [[scalaz.Functor]]
* - [[scalaz.Contravariant]]
- * - [[scalaz.Copointed]] extends [[scalaz.Functor]]
* - [[scalaz.Apply]] extends [[scalaz.Functor]]
- * - [[scalaz.Applicative]] extends [[scalaz.Apply]] with [[scalaz.Pointed]]
+ * - [[scalaz.Applicative]] extends [[scalaz.Apply]]
* - [[scalaz.Bind]] extends [[scalaz.Apply]]
* - [[scalaz.Monad]] extends [[scalaz.Applicative]] with [[scalaz.Bind]]
* - [[scalaz.Cojoin]]
* - [[scalaz.Cobind]]
- * - [[scalaz.Comonad]] extends [[scalaz.Copointed]] with [[scalaz.Cojoin]] with [[scalaz.Cobind]]
+ * - [[scalaz.Comonad]] extends [[scalaz.Functor]] with [[scalaz.Cojoin]] with [[scalaz.Cobind]]
* - [[scalaz.PlusEmpty]] extends [[scalaz.Plus]]
* - [[scalaz.ApplicativePlus]] extends [[scalaz.Applicative]] with [[scalaz.PlusEmpty]]
* - [[scalaz.MonadPlus]] extends [[scalaz.Monad]] with [[scalaz.ApplicativePlus]]
diff --git a/core/src/main/scala/scalaz/std/AnyVal.scala b/core/src/main/scala/scalaz/std/AnyVal.scala
index 36a3472..e19d981 100644
--- a/core/src/main/scala/scalaz/std/AnyVal.scala
+++ b/core/src/main/scala/scalaz/std/AnyVal.scala
@@ -577,22 +577,22 @@ trait BooleanFunctions {
* Returns the value `a` lifted into the context `M` if `cond` is `true`, otherwise, the empty value
* for `M`.
*/
- final def pointOrEmpty[M[_], A](cond: Boolean)(a: => A)(implicit M: Pointed[M], M0: PlusEmpty[M]): M[A] =
+ final def pointOrEmpty[M[_], A](cond: Boolean)(a: => A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A] =
if (cond) M.point(a) else M0.empty
/**
* Returns the value `a` lifted into the context `M` if `cond` is `false`, otherwise, the empty value
* for `M`.
*/
- final def emptyOrPure[M[_], A](cond: Boolean)(a: => A)(implicit M: Pointed[M], M0: PlusEmpty[M]): M[A] =
+ final def emptyOrPure[M[_], A](cond: Boolean)(a: => A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A] =
if (!cond) M.point(a) else M0.empty
- final def pointOrEmptyNT[M[_]](cond: Boolean)(implicit M: Pointed[M], M0: PlusEmpty[M]): (Id ~> M) =
+ final def pointOrEmptyNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): (Id ~> M) =
new (Id ~> M) {
def apply[A](a: A): M[A] = pointOrEmpty[M, A](cond)(a)
}
- final def emptyOrPureNT[M[_]](cond: Boolean)(implicit M: Pointed[M], M0: PlusEmpty[M]): (Id ~> M) =
+ final def emptyOrPureNT[M[_]](cond: Boolean)(implicit M: Applicative[M], M0: PlusEmpty[M]): (Id ~> M) =
new (Id ~> M) {
def apply[A](a: A): M[A] = emptyOrPure[M, A](cond)(a)
}
diff --git a/core/src/main/scala/scalaz/std/Function.scala b/core/src/main/scala/scalaz/std/Function.scala
index fb9e6d3..22d7307 100644
--- a/core/src/main/scala/scalaz/std/Function.scala
+++ b/core/src/main/scala/scalaz/std/Function.scala
@@ -17,11 +17,17 @@ trait FunctionInstances0 extends FunctionInstances1 {
}
trait FunctionInstances extends FunctionInstances0 {
- implicit def function0Instance[T] = new Traverse[Function0] with Monad[Function0] with Copointed[Function0] with Distributive[Function0] {
+ implicit def function0Instance[T] = new Traverse[Function0] with Monad[Function0] with Comonad[Function0] with Distributive[Function0] {
def point[A](a: => A) = () => a
def copoint[A](p: () => A) = p()
+ def cobind[A, B](fa: Function0[A])(f: Function0[A] => B) =
+ () => f(fa)
+
+ def cojoin[A](a: Function0[A]): Function0[Function0[A]] =
+ () => a
+
def bind[A, B](fa: () => A)(f: (A) => () => B) = () => f(fa())()
override def map[A,B](fa: () => A)(f: A => B) = () => f(fa())
diff --git a/core/src/main/scala/scalaz/std/Option.scala b/core/src/main/scala/scalaz/std/Option.scala
index e9eeb5f..0862efd 100644
--- a/core/src/main/scala/scalaz/std/Option.scala
+++ b/core/src/main/scala/scalaz/std/Option.scala
@@ -181,17 +181,17 @@ trait OptionFunctions {
* Returns the item contained in the Option wrapped in type M if the Option is defined,
* otherwise, the empty value for type M.
*/
- final def orEmpty[A, M[_] : Pointed : PlusEmpty](oa: Option[A]): M[A] = oa match {
- case Some(a) => Pointed[M].point(a)
+ final def orEmpty[A, M[_] : Applicative : PlusEmpty](oa: Option[A]): M[A] = oa match {
+ case Some(a) => Applicative[M].point(a)
case None => PlusEmpty[M].empty
}
/**
* Returns the given value if None, otherwise lifts the Some value and passes it to the given function.
*/
- final def foldLift[F[_], A, B](oa: Option[A])(b: => B, k: F[A] => B)(implicit p: Pointed[F]): B = oa match {
+ final def foldLift[F[_], A, B](oa: Option[A])(b: => B, k: F[A] => B)(implicit p: Applicative[F]): B = oa match {
case None => b
- case Some(a) => k(Pointed[F].point(a))
+ case Some(a) => k(Applicative[F].point(a))
}
/**
diff --git a/core/src/main/scala/scalaz/std/java/util/concurrent/Callable.scala b/core/src/main/scala/scalaz/std/java/util/concurrent/Callable.scala
index 4ac928e..609e5e2 100644
--- a/core/src/main/scala/scalaz/std/java/util/concurrent/Callable.scala
+++ b/core/src/main/scala/scalaz/std/java/util/concurrent/Callable.scala
@@ -9,11 +9,16 @@ trait CallableInstances {
def order(f1: Callable[A], f2: Callable[A]) = Order[A].order(f1.call, f2.call)
}
- implicit def callablePointed: Pointed[Callable] = new Pointed[Callable] {
+ implicit def callableFunctor: Functor[Callable] = new Functor[Callable] {
def map[A, B](fa: Callable[A])(f: (A) => B) = new Callable[B] {
def call() = f(fa.call)
}
+ }
+ implicit def callableMonad: Monad[Callable] = new Monad[Callable] {
+ def bind[A, B](fa: Callable[A])(f: (A) => Callable[B]) = new Callable[B] {
+ def call() = f(fa.call).call
+ }
def point[A](a: => A) = new Callable[A] {
def call() = a
}
diff --git a/core/src/main/scala/scalaz/syntax/ApplicativeSyntax.scala b/core/src/main/scala/scalaz/syntax/ApplicativeSyntax.scala
index 375f9b5..e59eed0 100644
--- a/core/src/main/scala/scalaz/syntax/ApplicativeSyntax.scala
+++ b/core/src/main/scala/scalaz/syntax/ApplicativeSyntax.scala
@@ -7,7 +7,6 @@ trait ApplicativeOps[F[_],A] extends Ops[F[A]] {
////
final def unlessM(cond: Boolean): F[Unit] = scalaz.std.boolean.unlessM(cond)(self)
final def whenM(cond: Boolean): F[Unit] = scalaz.std.boolean.whenM(cond)(self)
-
////
}
@@ -17,20 +16,45 @@ trait ToApplicativeOps0 {
}
-trait ToApplicativeOps extends ToApplicativeOps0 with ToApplyOps with ToPointedOps {
+trait ToApplicativeOps extends ToApplicativeOps0 with ToApplyOps {
implicit def ToApplicativeOps[F[_],A](v: F[A])(implicit F0: Applicative[F]) =
new ApplicativeOps[F,A] { def self = v; implicit def F: Applicative[F] = F0 }
////
-
- ////
+ implicit def ApplicativeIdV[A](v: => A) = new ApplicativeIdV[A] {
+ lazy val self = v
+ }
+
+ trait ApplicativeIdV[A] extends Ops[A] {
+ def point[F[_] : Applicative]: F[A] = Applicative[F].point(self)
+ def pure[F[_] : Applicative]: F[A] = Applicative[F].point(self)
+ def η[F[_] : Applicative]: F[A] = Applicative[F].point(self)
+ } ////
}
-trait ApplicativeSyntax[F[_]] extends ApplySyntax[F] with PointedSyntax[F] {
+trait ApplicativeSyntax[F[_]] extends ApplySyntax[F] {
implicit def ToApplicativeOps[A](v: F[A]): ApplicativeOps[F, A] = new ApplicativeOps[F,A] { def self = v; implicit def F: Applicative[F] = ApplicativeSyntax.this.F }
def F: Applicative[F]
////
+ def point[A](a: => A)(implicit F: Applicative[F]): F[A] = F.point(a)
+
+ /** Alias for `point` */
+ def pure[A](a: => A)(implicit F: Applicative[F]): F[A] = F.point(a)
+ def η[A](a: => A)(implicit F: Applicative[F]): F[A] = F.point(a)
+
+ implicit def ApplicativeIdV[A](v: => A) = new ApplicativeIdV[A] {
+ lazy val self = v
+ }
+
+ trait ApplicativeIdV[A] extends Ops[A] {
+ def point(implicit F: Applicative[F]): F[A] = Applicative[F].point(self)
+
+ /** Alias for `point` */
+ def pure(implicit F: Applicative[F]): F[A] = Applicative[F].point(self)
+
+ def η(implicit F: Applicative[F]): F[A] = Applicative[F].point(self)
+ }
////
}
diff --git a/core/src/main/scala/scalaz/syntax/ArrIdSyntax.scala b/core/src/main/scala/scalaz/syntax/ArrIdSyntax.scala
deleted file mode 100644
index 4ce955e..0000000
--- a/core/src/main/scala/scalaz/syntax/ArrIdSyntax.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-package scalaz
-package syntax
-
-/** Wraps a value `self` and provides methods related to `ArrId` */
-trait ArrIdOps[F[_, _],A, B] extends Ops[F[A, B]] {
- implicit def F: ArrId[F]
- ////
-
- ////
-}
-
-trait ToArrIdOps0 {
- implicit def ToArrIdOpsUnapply[FA](v: FA)(implicit F0: Unapply2[ArrId, FA]) =
- new ArrIdOps[F0.M,F0.A,F0.B] { def self = F0(v); implicit def F: ArrId[F0.M] = F0.TC }
-
-}
-
-trait ToArrIdOps extends ToArrIdOps0 {
-
- implicit def ToArrIdOps[F[_, _],A, B](v: F[A, B])(implicit F0: ArrId[F]) =
- new ArrIdOps[F,A, B] { def self = v; implicit def F: ArrId[F] = F0 }
-
-
- ////
-
- ////
-}
-
-trait ArrIdSyntax[F[_, _]] {
- implicit def ToArrIdOps[A, B](v: F[A, B]): ArrIdOps[F, A, B] = new ArrIdOps[F, A, B] { def self = v; implicit def F: ArrId[F] = ArrIdSyntax.this.F }
-
- def F: ArrId[F]
- ////
-
- ////
-}
diff --git a/core/src/main/scala/scalaz/syntax/CategorySyntax.scala b/core/src/main/scala/scalaz/syntax/CategorySyntax.scala
index e6e5e64..57bfd70 100644
--- a/core/src/main/scala/scalaz/syntax/CategorySyntax.scala
+++ b/core/src/main/scala/scalaz/syntax/CategorySyntax.scala
@@ -15,7 +15,7 @@ trait ToCategoryOps0 {
}
-trait ToCategoryOps extends ToCategoryOps0 with ToArrIdOps with ToComposeOps {
+trait ToCategoryOps extends ToCategoryOps0 with ToComposeOps {
implicit def ToCategoryOps[F[_, _],A, B](v: F[A, B])(implicit F0: Category[F]) =
new CategoryOps[F,A, B] { def self = v; implicit def F: Category[F] = F0 }
@@ -28,7 +28,7 @@ trait ToCategoryOps extends ToCategoryOps0 with ToArrIdOps with ToComposeOps {
////
}
-trait CategorySyntax[F[_, _]] extends ArrIdSyntax[F] with ComposeSyntax[F] {
+trait CategorySyntax[F[_, _]] extends ComposeSyntax[F] {
implicit def ToCategoryOps[A, B](v: F[A, B]): CategoryOps[F, A, B] = new CategoryOps[F, A, B] { def self = v; implicit def F: Category[F] = CategorySyntax.this.F }
def F: Category[F]
diff --git a/core/src/main/scala/scalaz/syntax/ComonadSyntax.scala b/core/src/main/scala/scalaz/syntax/ComonadSyntax.scala
index 352bd3a..b47e351 100644
--- a/core/src/main/scala/scalaz/syntax/ComonadSyntax.scala
+++ b/core/src/main/scala/scalaz/syntax/ComonadSyntax.scala
@@ -5,6 +5,7 @@ package syntax
trait ComonadOps[F[_],A] extends Ops[F[A]] {
implicit def F: Comonad[F]
////
+ def copoint: A = F.copoint(self)
////
}
@@ -15,7 +16,7 @@ trait ToComonadOps0 {
}
-trait ToComonadOps extends ToComonadOps0 with ToCopointedOps with ToCojoinOps with ToCobindOps {
+trait ToComonadOps extends ToComonadOps0 with ToCojoinOps with ToCobindOps {
implicit def ToComonadOps[F[_],A](v: F[A])(implicit F0: Comonad[F]) =
new ComonadOps[F,A] { def self = v; implicit def F: Comonad[F] = F0 }
@@ -24,7 +25,7 @@ trait ToComonadOps extends ToComonadOps0 with ToCopointedOps with ToCojoinOps wi
////
}
-trait ComonadSyntax[F[_]] extends CopointedSyntax[F] with CojoinSyntax[F] with CobindSyntax[F] {
+trait ComonadSyntax[F[_]] extends CojoinSyntax[F] with CobindSyntax[F] {
implicit def ToComonadOps[A](v: F[A]): ComonadOps[F, A] = new ComonadOps[F,A] { def self = v; implicit def F: Comonad[F] = ComonadSyntax.this.F }
def F: Comonad[F]
diff --git a/core/src/main/scala/scalaz/syntax/CopointedSyntax.scala b/core/src/main/scala/scalaz/syntax/CopointedSyntax.scala
deleted file mode 100644
index bd38094..0000000
--- a/core/src/main/scala/scalaz/syntax/CopointedSyntax.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-package scalaz
-package syntax
-
-/** Wraps a value `self` and provides methods related to `Copointed` */
-trait CopointedOps[F[_],A] extends Ops[F[A]] {
- implicit def F: Copointed[F]
- ////
- def copoint: A = F.copoint(self)
-
- ////
-}
-
-trait ToCopointedOps0 {
- implicit def ToCopointedOpsUnapply[FA](v: FA)(implicit F0: Unapply[Copointed, FA]) =
- new CopointedOps[F0.M,F0.A] { def self = F0(v); implicit def F: Copointed[F0.M] = F0.TC }
-
-}
-
-trait ToCopointedOps extends ToCopointedOps0 with ToFunctorOps {
- implicit def ToCopointedOps[F[_],A](v: F[A])(implicit F0: Copointed[F]) =
- new CopointedOps[F,A] { def self = v; implicit def F: Copointed[F] = F0 }
-
- ////
-
- ////
-}
-
-trait CopointedSyntax[F[_]] extends FunctorSyntax[F] {
- implicit def ToCopointedOps[A](v: F[A]): CopointedOps[F, A] = new CopointedOps[F,A] { def self = v; implicit def F: Copointed[F] = CopointedSyntax.this.F }
-
- def F: Copointed[F]
- ////
-
- ////
-}
diff --git a/core/src/main/scala/scalaz/syntax/FunctorSyntax.scala b/core/src/main/scala/scalaz/syntax/FunctorSyntax.scala
index c5e08f4..aa46662 100644
--- a/core/src/main/scala/scalaz/syntax/FunctorSyntax.scala
+++ b/core/src/main/scala/scalaz/syntax/FunctorSyntax.scala
@@ -16,7 +16,7 @@ trait FunctorOps[F[_],A] extends Ops[F[A]] {
final def strengthR[B](b: B): F[(A, B)] = F.strengthR(self, b)
final def fpair: F[(A, A)] = F.fpair(self)
final def void: F[Unit] = F.void(self)
- final def fpoint[G[_]: Pointed]: F[G[A]] = F.map(self)(a => Pointed[G].point(a))
+ final def fpoint[G[_]: Applicative]: F[G[A]] = F.map(self)(a => Applicative[G].point(a))
final def >|[B](b: => B): F[B] = F.map(self)(_ => b)
final def as[B](b: => B): F[B] = F.map(self)(_ => b)
////
diff --git a/core/src/main/scala/scalaz/syntax/IdOps.scala b/core/src/main/scala/scalaz/syntax/IdOps.scala
index 4120a07..60a2884 100644
--- a/core/src/main/scala/scalaz/syntax/IdOps.scala
+++ b/core/src/main/scala/scalaz/syntax/IdOps.scala
@@ -1,7 +1,7 @@
package scalaz.syntax
import annotation.tailrec
-import scalaz.{Pointed, Monoid, NonEmptyList, Kleisli, Reader, \/}
+import scalaz.{Applicative, Monoid, NonEmptyList, Kleisli, Reader, \/}
import scalaz.Id._
@@ -65,11 +65,11 @@ trait IdOps[A] extends Ops[A] {
/**
* If the provided partial function is defined for `self` run this,
- * otherwise lift `self` into `F` with the provided [[scalaz.Pointed]].
+ * otherwise lift `self` into `F` with the provided [[scalaz.Applicative]].
*/
- def visit[F[_] : Pointed](p: PartialFunction[A, F[A]]): F[A] =
+ def visit[F[_] : Applicative](p: PartialFunction[A, F[A]]): F[A] =
if (p isDefinedAt self) p(self)
- else Pointed[F].point(self)
+ else Applicative[F].point(self)
}
trait ToIdOps {
diff --git a/core/src/main/scala/scalaz/syntax/PointedSyntax.scala b/core/src/main/scala/scalaz/syntax/PointedSyntax.scala
deleted file mode 100644
index 3537f61..0000000
--- a/core/src/main/scala/scalaz/syntax/PointedSyntax.scala
+++ /dev/null
@@ -1,58 +0,0 @@
-package scalaz
-package syntax
-
-/** Wraps a value `self` and provides methods related to `Pointed` */
-trait PointedOps[F[_],A] extends Ops[F[A]] {
- implicit def F: Pointed[F]
- ////
- ////
-}
-
-trait ToPointedOps0 {
- implicit def ToPointedOpsUnapply[FA](v: FA)(implicit F0: Unapply[Pointed, FA]) =
- new PointedOps[F0.M,F0.A] { def self = F0(v); implicit def F: Pointed[F0.M] = F0.TC }
-
-}
-
-trait ToPointedOps extends ToPointedOps0 with ToFunctorOps {
- implicit def ToPointedOps[F[_],A](v: F[A])(implicit F0: Pointed[F]) =
- new PointedOps[F,A] { def self = v; implicit def F: Pointed[F] = F0 }
-
- ////
- implicit def PointedIdV[A](v: => A) = new PointedIdV[A] {
- lazy val self = v
- }
-
- trait PointedIdV[A] extends Ops[A] {
- def point[F[_] : Pointed]: F[A] = Pointed[F].point(self)
- def pure[F[_] : Pointed]: F[A] = Pointed[F].point(self)
- def η[F[_] : Pointed]: F[A] = Pointed[F].point(self)
- }
- ////
-}
-
-trait PointedSyntax[F[_]] extends FunctorSyntax[F] {
- implicit def ToPointedOps[A](v: F[A]): PointedOps[F, A] = new PointedOps[F,A] { def self = v; implicit def F: Pointed[F] = PointedSyntax.this.F }
-
- def F: Pointed[F]
- ////
- def point[A](a: => A)(implicit F: Pointed[F]): F[A] = F.point(a)
-
- /** Alias for `point` */
- def pure[A](a: => A)(implicit F: Pointed[F]): F[A] = F.point(a)
- def η[A](a: => A)(implicit F: Pointed[F]): F[A] = F.point(a)
-
- implicit def PointedIdV[A](v: => A) = new PointedIdV[A] {
- lazy val self = v
- }
-
- trait PointedIdV[A] extends Ops[A] {
- def point(implicit F: Pointed[F]): F[A] = Pointed[F].point(self)
-
- /** Alias for `point` */
- def pure(implicit F: Pointed[F]): F[A] = Pointed[F].point(self)
-
- def η(implicit F: Pointed[F]): F[A] = Pointed[F].point(self)
- }
- ////
-}
diff --git a/core/src/main/scala/scalaz/syntax/Syntax.scala b/core/src/main/scala/scalaz/syntax/Syntax.scala
index b4ca717..f390cf4 100644
--- a/core/src/main/scala/scalaz/syntax/Syntax.scala
+++ b/core/src/main/scala/scalaz/syntax/Syntax.scala
@@ -35,12 +35,8 @@ trait Syntaxes {
object functor extends ToFunctorOps
- object pointed extends ToPointedOps
-
object contravariant extends ToContravariantOps
- object copointed extends ToCopointedOps
-
object apply extends ToApplyOps
object applicative extends ToApplicativeOps
@@ -81,8 +77,6 @@ trait Syntaxes {
object category extends ToCategoryOps
- object arrId extends ToArrIdOps
-
object arrow extends ToArrowOps
object choice extends ToChoiceOps
@@ -125,9 +119,9 @@ trait ToDataOps extends ToIdOps with ToTreeOps with ToWriterOps with ToValidatio
trait ToTypeClassOps
extends ToSemigroupOps with ToMonoidOps with ToGroupOps with ToEqualOps with ToLengthOps with ToShowOps
with ToOrderOps with ToEnumOps with ToMetricSpaceOps with ToPlusEmptyOps with ToEachOps with ToIndexOps
- with ToFunctorOps with ToPointedOps with ToContravariantOps with ToCopointedOps with ToApplyOps
+ with ToFunctorOps with ToContravariantOps with ToApplyOps
with ToApplicativeOps with ToBindOps with ToMonadOps with ToCojoinOps with ToComonadOps
with ToBifoldableOps with ToCozipOps
with ToPlusOps with ToApplicativePlusOps with ToMonadPlusOps with ToTraverseOps with ToBifunctorOps
- with ToBitraverseOps with ToArrIdOps with ToComposeOps with ToCategoryOps
+ with ToBitraverseOps with ToComposeOps with ToCategoryOps
with ToArrowOps with ToFoldableOps with ToChoiceOps with ToSplitOps with ToZipOps with ToUnzipOps with ToMonadWriterOps with ToListenableMonadWriterOps
diff --git a/core/src/main/scala/scalaz/syntax/ToStateOps.scala b/core/src/main/scala/scalaz/syntax/ToStateOps.scala
index 003a96b..1ecf8e9 100644
--- a/core/src/main/scala/scalaz/syntax/ToStateOps.scala
+++ b/core/src/main/scala/scalaz/syntax/ToStateOps.scala
@@ -3,7 +3,7 @@ package syntax
trait StateV[A] extends Ops[A] {
def state[S]: State[S, A] = State.state[S, A](self)
- def stateT[F[+_]:Pointed, S]: StateT[F, S, A] = StateT.stateT[F, S, A](self)
+ def stateT[F[+_]:Applicative, S]: StateT[F, S, A] = StateT.stateT[F, S, A](self)
}
trait ToStateOps {
diff --git a/core/src/main/scala/scalaz/syntax/std/BooleanOps.scala b/core/src/main/scala/scalaz/syntax/std/BooleanOps.scala
index db9cae3..58a2824 100644
--- a/core/src/main/scala/scalaz/syntax/std/BooleanOps.scala
+++ b/core/src/main/scala/scalaz/syntax/std/BooleanOps.scala
@@ -250,15 +250,15 @@ trait BooleanOps extends Ops[Boolean] {
final def !?[A](a: => A)(implicit z: Monoid[A]): A = b.zeroOrValue(self)(a)
trait GuardPrevent[M[_]] {
- def apply[A](a: => A)(implicit M: Pointed[M], M0: PlusEmpty[M]): M[A]
+ def apply[A](a: => A)(implicit M: Applicative[M], M0: PlusEmpty[M]): M[A]
}
final def guard[M[_]] = new GuardPrevent[M] {
- def apply[A](a: => A)(implicit M: Pointed[M], M0: PlusEmpty[M]) = b.pointOrEmpty[M, A](self)(a)
+ def apply[A](a: => A)(implicit M: Applicative[M], M0: PlusEmpty[M]) = b.pointOrEmpty[M, A](self)(a)
}
final def prevent[M[_]] = new GuardPrevent[M] {
- def apply[A](a: => A)(implicit M: Pointed[M], M0: PlusEmpty[M]) = b.emptyOrPure[M, A](self)(a)
+ def apply[A](a: => A)(implicit M: Applicative[M], M0: PlusEmpty[M]) = b.emptyOrPure[M, A](self)(a)
}
}
diff --git a/core/src/main/scala/scalaz/syntax/std/Function1Ops.scala b/core/src/main/scala/scalaz/syntax/std/Function1Ops.scala
index ccd2d8f..cd3de1f 100644
--- a/core/src/main/scala/scalaz/syntax/std/Function1Ops.scala
+++ b/core/src/main/scala/scalaz/syntax/std/Function1Ops.scala
@@ -11,7 +11,7 @@ trait Function1Ops[T, R] extends Ops[T => R] {
def arrow[A[_, _]](implicit a: Arrow[A]): A[T, R] =
a.arr(self)
- def kleisli[Z[+_]](implicit z: Pointed[Z]): Kleisli[Z, T, R] =
+ def kleisli[Z[+_]](implicit z: Applicative[Z]): Kleisli[Z, T, R] =
Kleisli.kleisli((t: T) => z.point(self(t)))
def unary_!(implicit m: Memo[T, R]): (T) => R = m(self)
diff --git a/core/src/main/scala/scalaz/syntax/std/OptionOps.scala b/core/src/main/scala/scalaz/syntax/std/OptionOps.scala
index 74fcf3e..18c6e19 100644
--- a/core/src/main/scala/scalaz/syntax/std/OptionOps.scala
+++ b/core/src/main/scala/scalaz/syntax/std/OptionOps.scala
@@ -92,9 +92,9 @@ trait OptionOps[A] extends Ops[Option[A]] {
final def last: Option[A] @@ Last = Tag(self)
- final def orEmpty[M[_] : Pointed : PlusEmpty]: M[A] = o.orEmpty[A, M](self)
+ final def orEmpty[M[_] : Applicative : PlusEmpty]: M[A] = o.orEmpty[A, M](self)
- final def foldLift[F[_] : Pointed, B](b: => B, k: F[A] => B): B = o.foldLift(self)(b, k)
+ final def foldLift[F[_] : Applicative, B](b: => B, k: F[A] => B): B = o.foldLift(self)(b, k)
final def foldLiftOpt[B](b: => B, k: Option[A] => B): B = o.foldLiftOpt[A, B](self)(b, k)
}
diff --git a/core/src/main/scala/scalaz/undo/History.scala b/core/src/main/scala/scalaz/undo/History.scala
index bd1cf68..5f27966 100644
--- a/core/src/main/scala/scalaz/undo/History.scala
+++ b/core/src/main/scala/scalaz/undo/History.scala
@@ -4,10 +4,9 @@ package undo
case class History[S](current: S, undos: List[S] = Nil, redos: List[S] = Nil)
trait HistoryInstances {
- implicit def history: Pointed[History] = new Pointed[History] {
+ implicit def history: Functor[History] = new Functor[History] {
def map[A, B](fa: History[A])(f: (A) => B): History[B] = History(f(fa.current), fa.undos.map(f), fa.redos.map(f))
- def point[A](a: => A): History[A] = History(a)
}
implicit def historyShow[S](implicit SL: Show[List[S]], S: Show[S]) = new Show[History[S]] {
diff --git a/core/src/main/scala/scalaz/undo/UndoT.scala b/core/src/main/scala/scalaz/undo/UndoT.scala
index f728b90..c159cbe 100644
--- a/core/src/main/scala/scalaz/undo/UndoT.scala
+++ b/core/src/main/scala/scalaz/undo/UndoT.scala
@@ -36,16 +36,14 @@ final case class UndoT[F[+_], S, +A](hstate: StateT[F, History[S], A]) {
//
trait UndoTInstances1 {
- // Prefer Pointed over Functor
implicit def undoTFunctor[S, F[+_]](implicit F0: Functor[F]): Functor[({type G[+x] = UndoT[F, S, x]})#G] = new UndoTFunctor[S, F] {
implicit def F: Functor[F] = F0
}
}
trait UndoTInstances0 extends UndoTInstances1 {
- // Prefer Monad over Pointed
- implicit def undoTPointed[S, F[+_]](implicit F0: Pointed[F]): Pointed[({type G[+x] = UndoT[F, S, x]})#G] = new UndoTPointed[S, F] {
- implicit def F: Pointed[F] = F0
+ implicit def undoTMonad[S, F[+_]](implicit F0: Monad[F]): Monad[({type G[+x] = UndoT[F, S, x]})#G] = new UndoTMonad[S, F] {
+ implicit def F: Monad[F] = F0
}
}
@@ -118,24 +116,26 @@ private[scalaz] trait UndoTFunctor[S, F[+_]]
override def map[A, B](fa: UndoT[F, S, A])(f: A => B) = fa.map(f)
}
-private[scalaz] trait UndoTPointed[S, F[+_]]
- extends Pointed[({type G[x] = UndoT[F, S, x]})#G]
+private[scalaz] trait UndoTMonad[S, F[+_]]
+ extends Monad[({type G[x] = UndoT[F, S, x]})#G]
with UndoTFunctor[S, F] {
- implicit def F: Pointed[F]
+ implicit def F: Monad[F]
def point[A](a: => A) = UndoT[F, S, A](StateT(s => F.point(s, a)))
+
+ def bind[A, B](fa: UndoT[F, S, A])(f: A => UndoT[F, S, B]) = fa.flatMap(f)
}
private[scalaz] trait UndoTMonadState[S, F[+_]]
extends MonadState[({type HS[X, Y] = UndoT[F, X, Y]})#HS, S]
- with UndoTPointed[S, F] {
+ with UndoTMonad[S, F] {
implicit def F: Monad[F]
implicit def HMS: HStateTMonadState[F, S]
- def bind[A, B](fa: UndoT[F, S, A])(f: A => UndoT[F, S, B]) = fa.flatMap(f)
+ override def bind[A, B](fa: UndoT[F, S, A])(f: A => UndoT[F, S, B]) = fa.flatMap(f)
def init = UndoT[F, S, S](HMS.gets(s => s.current))
diff --git a/example/src/main/scala/scalaz/example/MixedBag.scala b/example/src/main/scala/scalaz/example/MixedBag.scala
index 3589486..f6e5c6b 100644
--- a/example/src/main/scala/scalaz/example/MixedBag.scala
+++ b/example/src/main/scala/scalaz/example/MixedBag.scala
@@ -69,7 +69,7 @@ object MixedBag extends App {
val f = kleisli((i: Int) => some(i))
f map (i => i * 2) map (x => println(x)) run 3
- val K = Kleisli.kleisliArrId[Option] // or, Arr[({type λ[α, β]=Kleisli[Option, α, β]})#λ]
+ val K = Arrow[({type λ[α, β]=Kleisli[Option, α, β]})#λ]
f >>> K.arr(i => i * 2) >>> K.arr(x => println(x)) run 3
}
diff --git a/example/src/main/scala/scalaz/example/StateTUsage.scala b/example/src/main/scala/scalaz/example/StateTUsage.scala
index 39e01a5..b1393d8 100644
--- a/example/src/main/scala/scalaz/example/StateTUsage.scala
+++ b/example/src/main/scala/scalaz/example/StateTUsage.scala
@@ -9,11 +9,6 @@ object StateTUsage extends App {
Functor[({type l[a] = StateT[M, Int, a]})#l]
}
- def p[M[+_]: Pointed] {
- Functor[({type l[a] = StateT[M, Int, a]})#l]
- Pointed[({type l[a] = StateT[M, Int, a]})#l]
- }
-
def m[M[+_]: Monad] {
Applicative[({type l[a] = StateT[M, Int, a]})#l]
Monad[({type l[a] = StateT[M, Int, a]})#l]
diff --git a/example/src/main/scala/scalaz/example/SyntaxUsage.scala b/example/src/main/scala/scalaz/example/SyntaxUsage.scala
index fb60b06..a220006 100644
--- a/example/src/main/scala/scalaz/example/SyntaxUsage.scala
+++ b/example/src/main/scala/scalaz/example/SyntaxUsage.scala
@@ -64,17 +64,6 @@ object SyntaxUsage extends App {
o2.tuple(o2)
}
-
- // Monad extends from Pointed, so we can use (std.Option.option: Monad[Option]) where Pointed[F] is called for.
- def useParentTypeClass {
- import scalaz._
-
- def needPointed[F[_] : Pointed] = ()
-
- import std.option._
- needPointed[Option]
- }
-
def stdSyntax() {
import scalaz.std.anyVal._
import scalaz.std.stream.streamSyntax._
diff --git a/example/src/main/scala/scalaz/example/TrampolineUsage.scala b/example/src/main/scala/scalaz/example/TrampolineUsage.scala
index 81ad05d..f22ea6e 100644
--- a/example/src/main/scala/scalaz/example/TrampolineUsage.scala
+++ b/example/src/main/scala/scalaz/example/TrampolineUsage.scala
@@ -4,7 +4,7 @@ object TrampolineUsage extends App {
import scalaz._, Scalaz._, Free._
- def quickSort[F[+ _] : Pointed, T: Order](xs: List[T]): Free[F, List[T]] = {
+ def quickSort[F[+ _] : Applicative, T: Order](xs: List[T]): Free[F, List[T]] = {
xs match {
case Nil =>
return_ {
@@ -21,8 +21,8 @@ object TrampolineUsage extends App {
}
}
- def runQuickSort[F[+ _] : Pointed : Copointed, T: Order](xs: List[T]): List[T] =
- quickSort[F, T](xs).go(f => Copointed[F].copoint(f))
+ def runQuickSort[F[+ _] : Applicative : Comonad, T: Order](xs: List[T]): List[T] =
+ quickSort[F, T](xs).go(f => Comonad[F].copoint(f))
val xs = List.fill(32)(util.Random.nextInt())
@@ -55,7 +55,7 @@ object TrampolineUsage extends App {
/**Run using `F1` as a binding for lists longer than `threshold`, and `F2` otherwise. */
- def quickSort2[F[+ _] : Pointed, F2[+ _] : Pointed, T: Order](xs: List[T], nat: F2 ~> F, threshold: Int): Free[F, List[T]] = {
+ def quickSort2[F[+ _] : Applicative, F2[+ _] : Applicative, T: Order](xs: List[T], nat: F2 ~> F, threshold: Int): Free[F, List[T]] = {
def qs(as: List[T]): Free[F, List[T]] =
if (as.lengthCompare(threshold) < 0) {
val free: Free[F2, List[T]] = quickSort2[F2, F2, T](as, NaturalTransformation.refl[F2], threshold)
@@ -78,8 +78,8 @@ object TrampolineUsage extends App {
}
}
- def runQuickSort2[F[+ _] : Pointed : Copointed, F2[+ _] : Pointed, T: Order](xs: List[T], nat: F2 ~> F, threshold: Int): List[T] =
- quickSort2[F, F2, T](xs, nat, threshold).go(f => Copointed[F].copoint(f))
+ def runQuickSort2[F[+ _] : Applicative : Comonad, F2[+ _] : Applicative, T: Order](xs: List[T], nat: F2 ~> F, threshold: Int): List[T] =
+ quickSort2[F, F2, T](xs, nat, threshold).go(f => Comonad[F].copoint(f))
{
diff --git a/iteratee/src/main/scala/scalaz/iteratee/EnumerateeT.scala b/iteratee/src/main/scala/scalaz/iteratee/EnumerateeT.scala
index a7caf77..e5ddf98 100644
--- a/iteratee/src/main/scala/scalaz/iteratee/EnumerateeT.scala
+++ b/iteratee/src/main/scala/scalaz/iteratee/EnumerateeT.scala
@@ -132,12 +132,12 @@ trait EnumerateeTFunctions {
}
}
- def group[E, F[_], G[_]](n: Int)(implicit F: Pointed[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G] =
+ def group[E, F[_], G[_]](n: Int)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G] =
new EnumerateeT[E, F[E], G] {
def apply[A] = take[E, F](n).up[G].sequenceI.apply[A]
}
- def splitOn[E, F[_], G[_]](p: E => Boolean)(implicit F: Pointed[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G] =
+ def splitOn[E, F[_], G[_]](p: E => Boolean)(implicit F: Applicative[F], FE: Monoid[F[E]], G: Monad[G]): EnumerateeT[E, F[E], G] =
new EnumerateeT[E, F[E], G] {
def apply[A] = {
(takeWhile[E, F](p).up[G] flatMap (xs => drop[E, G](1).map(_ => xs))).sequenceI.apply[A]
@@ -166,7 +166,7 @@ trait EnumerateeTFunctions {
}
- def doneOr[O, I, F[_] : Pointed, A](f: (Input[I] => IterateeT[I, F, A]) => IterateeT[O, F, StepT[I, F, A]]): StepT[I, F, A] => IterateeT[O, F, StepT[I, F, A]] = {
+ def doneOr[O, I, F[_] : Applicative, A](f: (Input[I] => IterateeT[I, F, A]) => IterateeT[O, F, StepT[I, F, A]]): StepT[I, F, A] => IterateeT[O, F, StepT[I, F, A]] = {
(s: StepT[I, F, A]) => s.mapContOr(k => f(k), done(s, emptyInput))
}
}
diff --git a/iteratee/src/main/scala/scalaz/iteratee/EnumeratorT.scala b/iteratee/src/main/scala/scalaz/iteratee/EnumeratorT.scala
index 12be261..339e6b9 100644
--- a/iteratee/src/main/scala/scalaz/iteratee/EnumeratorT.scala
+++ b/iteratee/src/main/scala/scalaz/iteratee/EnumeratorT.scala
@@ -48,7 +48,7 @@ trait EnumeratorT[E, F[_]] { self =>
def zipWithIndex(implicit M: Monad[F]): EnumeratorT[(E, Long), F] =
EnumerateeT.zipWithIndex[E, F] run self
- def drainTo[M[_]](implicit M: Monad[F], P: PlusEmpty[M], Z: Pointed[M]): F[M[E]] =
+ def drainTo[M[_]](implicit M: Monad[F], P: PlusEmpty[M], Z: Applicative[M]): F[M[E]] =
(IterateeT.consume[E, F, M] &= self).run
def reduced[B](b: B)(f: (B, E) => B)(implicit M: Monad[F]): EnumeratorT[B, F] =
@@ -96,7 +96,7 @@ trait EnumeratorTInstances extends EnumeratorTInstances0 {
trait EnumeratorTFunctions {
def enumerate[E](as: Stream[E]): Enumerator[E] = enumStream[E, Id](as)
- def empty[E, F[_]: Pointed]: EnumeratorT[E, F] =
+ def empty[E, F[_]: Applicative]: EnumeratorT[E, F] =
new EnumeratorT[E, F] {
def apply[A] = _.pointI
}
@@ -104,7 +104,7 @@ trait EnumeratorTFunctions {
/**
* An EnumeratorT that is at EOF
*/
- def enumEofT[E, F[_] : Pointed]: EnumeratorT[E, F] =
+ def enumEofT[E, F[_] : Applicative]: EnumeratorT[E, F] =
new EnumeratorT[E, F] {
def apply[A] = _.mapCont(_(eofInput))
}
@@ -117,7 +117,7 @@ trait EnumeratorTFunctions {
def apply[A] = s => iterateeT(Monad[F].bind(f) { _ => s.pointI.value })
}
- def enumOne[E, F[_]: Pointed](e: E): EnumeratorT[E, F] =
+ def enumOne[E, F[_]: Applicative](e: E): EnumeratorT[E, F] =
new EnumeratorT[E, F] {
def apply[A] = _.mapCont(_(elInput(e)))
}
@@ -238,10 +238,7 @@ private[scalaz] trait EnumeratorTFunctor[F[_]] extends Functor[({type λ[α]=Enu
abstract override def map[A, B](fa: EnumeratorT[A, F])(f: A => B): EnumeratorT[B, F] = fa.map(f)
}
-private[scalaz] trait EnumeratorTPointed[F[_]] extends Pointed[({type λ[α]=EnumeratorT[α, F]})#λ] with EnumeratorTFunctor[F] {
- def point[E](e: => E) = EnumeratorT.enumOne[E, F](e)
-}
-
-private [scalaz] trait EnumeratorTMonad[F[_]] extends Monad[({type λ[α]=EnumeratorT[α, F]})#λ] with EnumeratorTPointed[F] {
+private [scalaz] trait EnumeratorTMonad[F[_]] extends Monad[({type λ[α]=EnumeratorT[α, F]})#λ] with EnumeratorTFunctor[F] {
def bind[A, B](fa: EnumeratorT[A, F])(f: A => EnumeratorT[B, F]) = fa.flatMap(f)
+ def point[E](e: => E) = EnumeratorT.enumOne[E, F](e)
}
diff --git a/iteratee/src/main/scala/scalaz/iteratee/Iteratee.scala b/iteratee/src/main/scala/scalaz/iteratee/Iteratee.scala
index 525575d..6609bb5 100644
--- a/iteratee/src/main/scala/scalaz/iteratee/Iteratee.scala
+++ b/iteratee/src/main/scala/scalaz/iteratee/Iteratee.scala
@@ -11,7 +11,7 @@ trait IterateeFunctions {
/**
* Repeats the given iteratee by appending with the given monoid.
*/
- def repeatBuild[E, A, F[_]](iter: Iteratee[E, A])(implicit mon: Monoid[F[A]], F: Pointed[F]): Iteratee[E, F[A]] = {
+ def repeatBuild[E, A, F[_]](iter: Iteratee[E, A])(implicit mon: Monoid[F[A]], F: Applicative[F]): Iteratee[E, F[A]] = {
import Iteratee._
def step(acc: F[A])(s: Input[E]): Iteratee[E, F[A]] =
s(el = e => iter.foldT[Iteratee[E, F[A]]](
@@ -31,7 +31,7 @@ trait IterateeFunctions {
/**
* Iteratee that collects all inputs with the given monoid.
*/
- def collect[A, F[_]](implicit mon: Monoid[F[A]], pt: Pointed[F]): Iteratee[A, F[A]] = {
+ def collect[A, F[_]](implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]] = {
fold[A, Id, F[A]](mon.zero)((acc, e) => mon.append(acc, pt.point(e)))
}
@@ -47,7 +47,7 @@ trait IterateeFunctions {
/**
* Iteratee that collects the first n inputs.
*/
- def take[A, F[_]](n: Int)(implicit mon: Monoid[F[A]], pt: Pointed[F]): Iteratee[A, F[A]] = {
+ def take[A, F[_]](n: Int)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]] = {
def loop(acc: F[A], n: Int)(s: Input[A]): Iteratee[A, F[A]] =
s(el = e =>
if (n <= 0) done[A, Id, F[A]](acc, s)
@@ -61,7 +61,7 @@ trait IterateeFunctions {
/**
* Iteratee that collects inputs with the given monoid until the input element fails a test.
*/
- def takeWhile[A, F[_]](p: A => Boolean)(implicit mon: Monoid[F[A]], pt: Pointed[F]): Iteratee[A, F[A]] = {
+ def takeWhile[A, F[_]](p: A => Boolean)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]] = {
def loop(acc: F[A])(s: Input[A]): Iteratee[A, F[A]] =
s(el = e =>
if (p(e)) cont(loop(mon.append(acc, pt.point(e))))
@@ -75,13 +75,13 @@ trait IterateeFunctions {
/**
* Iteratee that collects inputs with the given monoid until the input element passes a test.
*/
- def takeUntil[A, F[_]](p: A => Boolean)(implicit mon: Monoid[F[A]], pt: Pointed[F]): Iteratee[A, F[A]] =
+ def takeUntil[A, F[_]](p: A => Boolean)(implicit mon: Monoid[F[A]], pt: Applicative[F]): Iteratee[A, F[A]] =
takeWhile(!p(_))
/**
* Produces chunked output split by the given predicate.
*/
- def groupBy[A, F[_]](pred: (A, A) => Boolean)(implicit mon: Monoid[F[A]], pr: Pointed[F]): Iteratee[A, F[A]] = {
+ def groupBy[A, F[_]](pred: (A, A) => Boolean)(implicit mon: Monoid[F[A]], pr: Applicative[F]): Iteratee[A, F[A]] = {
Iteratee.peek[A, Id] flatMap {
case None => done(Monoid[F[A]].zero, Input.Empty[A])
case Some(h) => takeWhile(pred(_, h))
diff --git a/iteratee/src/main/scala/scalaz/iteratee/IterateeT.scala b/iteratee/src/main/scala/scalaz/iteratee/IterateeT.scala
index abf9d09..b753dd6 100644
--- a/iteratee/src/main/scala/scalaz/iteratee/IterateeT.scala
+++ b/iteratee/src/main/scala/scalaz/iteratee/IterateeT.scala
@@ -112,9 +112,9 @@ sealed trait IterateeT[E, F[_], A] {
loop(this)
}
- def up[G[_]](implicit G: Pointed[G], F: Functor[F], FC: Copointed[F]): IterateeT[E, G, A] = {
+ def up[G[_]](implicit G: Applicative[G], F: Comonad[F]): IterateeT[E, G, A] = {
mapI(new (F ~> G) {
- def apply[A](a: F[A]) = G.point(FC.copoint(a))
+ def apply[A](a: F[A]) = G.point(F.copoint(a))
})
}
@@ -215,10 +215,10 @@ trait IterateeTFunctions {
val value = s
}
- def cont[E, F[_] : Pointed, A](c: Input[E] => IterateeT[E, F, A]): IterateeT[E, F, A] =
+ def cont[E, F[_] : Applicative, A](c: Input[E] => IterateeT[E, F, A]): IterateeT[E, F, A] =
StepT.scont(c).pointI
- def done[E, F[_] : Pointed, A](d: => A, r: => Input[E]): IterateeT[E, F, A] =
+ def done[E, F[_] : Applicative, A](d: => A, r: => Input[E]): IterateeT[E, F, A] =
StepT.sdone(d, r).pointI
/**
@@ -230,24 +230,24 @@ trait IterateeTFunctions {
}
/**
- * An iteratee that consumes all of the input into something that is PlusEmpty and Pointed.
+ * An iteratee that consumes all of the input into something that is PlusEmpty and Applicative.
*/
- def consume[E, F[_]: Monad, A[_]: PlusEmpty : Pointed]: IterateeT[E, F, A[E]] = {
+ def consume[E, F[_]: Monad, A[_]: PlusEmpty : Applicative]: IterateeT[E, F, A[E]] = {
import scalaz.syntax.plus._
def step(e: Input[E]): IterateeT[E, F, A[E]] =
e.fold(empty = cont(step)
- , el = e => cont(step).map(a => Pointed[A].point(e) <+> a)
+ , el = e => cont(step).map(a => Applicative[A].point(e) <+> a)
, eof = done(PlusEmpty[A].empty, eofInput[E])
)
cont(step)
}
- def collectT[E, F[_], A[_]](implicit M: Monad[F], mae: Monoid[A[E]], pointed: Pointed[A]): IterateeT[E, F, A[E]] = {
+ def collectT[E, F[_], A[_]](implicit M: Monad[F], mae: Monoid[A[E]], pointed: Applicative[A]): IterateeT[E, F, A[E]] = {
import scalaz.syntax.semigroup._
def step(e: Input[E]): IterateeT[E, F, A[E]] =
e.fold(empty = cont(step)
- , el = e => cont(step).map(a => Pointed[A].point(e) |+| a)
+ , el = e => cont(step).map(a => Applicative[A].point(e) |+| a)
, eof = done(Monoid[A[E]].zero, eofInput[E])
)
@@ -255,7 +255,7 @@ trait IterateeTFunctions {
}
/**An iteratee that consumes the head of the input **/
- def head[E, F[_] : Pointed]: IterateeT[E, F, Option[E]] = {
+ def head[E, F[_] : Applicative]: IterateeT[E, F, Option[E]] = {
def step(s: Input[E]): IterateeT[E, F, Option[E]] =
s(empty = cont(step)
, el = e => done(Some(e), emptyInput[E])
@@ -272,7 +272,7 @@ trait IterateeTFunctions {
}
/**An iteratee that returns the first element of the input **/
- def peek[E, F[_] : Pointed]: IterateeT[E, F, Option[E]] = {
+ def peek[E, F[_] : Applicative]: IterateeT[E, F, Option[E]] = {
def step(s: Input[E]): IterateeT[E, F, Option[E]]
= s(el = e => done(Some(e), s),
empty = cont(step),
@@ -288,7 +288,7 @@ trait IterateeTFunctions {
}
/**An iteratee that skips the first n elements of the input **/
- def drop[E, F[_] : Pointed](n: Int): IterateeT[E, F, Unit] = {
+ def drop[E, F[_] : Applicative](n: Int): IterateeT[E, F, Unit] = {
def step(s: Input[E]): IterateeT[E, F, Unit] =
s(el = _ => drop(n - 1),
empty = cont(step),
@@ -300,7 +300,7 @@ trait IterateeTFunctions {
/**
* An iteratee that skips elements while the predicate evaluates to true.
*/
- def dropWhile[E, F[_] : Pointed](p: E => Boolean): IterateeT[E, F, Unit] = {
+ def dropWhile[E, F[_] : Applicative](p: E => Boolean): IterateeT[E, F, Unit] = {
def step(s: Input[E]): IterateeT[E, F, Unit] =
s(el = e => if (p(e)) dropWhile(p) else done((), s),
empty = cont(step),
@@ -311,9 +311,9 @@ trait IterateeTFunctions {
/**
* An iteratee that skips elements until the predicate evaluates to true.
*/
- def dropUntil[E, F[_] : Pointed](p: E => Boolean): IterateeT[E, F, Unit] = dropWhile(!p(_))
+ def dropUntil[E, F[_] : Applicative](p: E => Boolean): IterateeT[E, F, Unit] = dropWhile(!p(_))
- def fold[E, F[_] : Pointed, A](init: A)(f: (A, E) => A): IterateeT[E, F, A] = {
+ def fold[E, F[_] : Applicative, A](init: A)(f: (A, E) => A): IterateeT[E, F, A] = {
def step(acc: A): Input[E] => IterateeT[E, F, A] = s =>
s(el = e => cont(step(f(acc, e))),
empty = cont(step(acc)),
@@ -332,15 +332,15 @@ trait IterateeTFunctions {
/**
* An iteratee that counts and consumes the elements of the input
*/
- def length[E, F[_] : Pointed]: IterateeT[E, F, Int] = fold(0)((a, _) => a + 1)
+ def length[E, F[_] : Applicative]: IterateeT[E, F, Int] = fold(0)((a, _) => a + 1)
/**
* An iteratee that checks if the input is EOF.
*/
- def isEof[E, F[_] : Pointed]: IterateeT[E, F, Boolean] = cont(in => done(in.isEof, in))
+ def isEof[E, F[_] : Applicative]: IterateeT[E, F, Boolean] = cont(in => done(in.isEof, in))
def sum[E: Monoid, F[_]: Monad]: IterateeT[E, F, E] =
- foldM[E, F, E](Monoid[E].zero)((a, e) => Pointed[F].point(Monoid[E].append(a, e)))
+ foldM[E, F, E](Monoid[E].zero)((a, e) => Applicative[F].point(Monoid[E].append(a, e)))
}
//
diff --git a/iteratee/src/main/scala/scalaz/iteratee/StepT.scala b/iteratee/src/main/scala/scalaz/iteratee/StepT.scala
index 048d00f..6e613dc 100644
--- a/iteratee/src/main/scala/scalaz/iteratee/StepT.scala
+++ b/iteratee/src/main/scala/scalaz/iteratee/StepT.scala
@@ -40,7 +40,7 @@ sealed trait StepT[E, F[_], A] {
, (_, _) => z
)
- def mapCont(k: (Input[E] => IterateeT[E, F, A]) => IterateeT[E, F, A])(implicit F: Pointed[F]): IterateeT[E, F, A] =
+ def mapCont(k: (Input[E] => IterateeT[E, F, A]) => IterateeT[E, F, A])(implicit F: Applicative[F]): IterateeT[E, F, A] =
mapContOr[IterateeT[E, F, A]](k, pointI)
def doneValue: LazyOption[A] =
@@ -76,7 +76,7 @@ sealed trait StepT[E, F[_], A] {
def >-[Z](cont: => Z, done: => Z): Z =
fold(_ => cont, (_, _) => done)
- def pointI(implicit P: Pointed[F]): IterateeT[E, F, A] =
+ def pointI(implicit P: Applicative[F]): IterateeT[E, F, A] =
iterateeT(P.point(this))
}
diff --git a/iterv/src/main/scala/scalaz/Iteratee.scala b/iterv/src/main/scala/scalaz/Iteratee.scala
index ba13cd1..98b7f3f 100644
--- a/iterv/src/main/scala/scalaz/Iteratee.scala
+++ b/iterv/src/main/scala/scalaz/Iteratee.scala
@@ -230,7 +230,7 @@ object IterV {
/**
* Takes while the given predicate holds, appending with the given monoid.
*/
- def takeWhile[A, F[_]](pred: A => Boolean)(implicit mon: Monoid[F[A]], pr: Pointed[F]): IterV[A, F[A]] = {
+ def takeWhile[A, F[_]](pred: A => Boolean)(implicit mon: Monoid[F[A]], pr: Applicative[F]): IterV[A, F[A]] = {
def peekStepDoneOr(z: F[A]) = peekDoneOr(z, step(z, _: A))
def step(acc: F[A], a: A): IterV[A, F[A]] = {
@@ -245,7 +245,7 @@ object IterV {
/**
* Produces chunked output split by the given predicate.
*/
- def groupBy[A, F[_]](pred: (A, A) => Boolean)(implicit mon: Monoid[F[A]], pr: Pointed[F]): IterV[A, F[A]] = {
+ def groupBy[A, F[_]](pred: (A, A) => Boolean)(implicit mon: Monoid[F[A]], pr: Applicative[F]): IterV[A, F[A]] = {
IterV.peek flatMap {
case None => Done(mzero[F[A]], Empty[A])
case Some(h) => takeWhile(pred(_, h))
@@ -255,7 +255,7 @@ object IterV {
/**
* Repeats the given iteratee by appending with the given monoid.
*/
- def repeat[E, A, F[_]](iter: IterV[E,A])(implicit mon: Monoid[F[A]], pr: Pointed[F]): IterV[E, F[A]] = {
+ def repeat[E, A, F[_]](iter: IterV[E,A])(implicit mon: Monoid[F[A]], pr: Applicative[F]): IterV[E, F[A]] = {
def step(acc: F[A])(s: Input[E]): IterV[E, F[A]] =
s(el = e => iter.fold(
(a, _) => Cont(step(acc |+| pr.point(a))),
diff --git a/project/GenTypeClass.scala b/project/GenTypeClass.scala
index c95a081..291eb2c 100644
--- a/project/GenTypeClass.scala
+++ b/project/GenTypeClass.scala
@@ -29,9 +29,8 @@ object TypeClass {
lazy val each = TypeClass("Each", *->*)
lazy val index = TypeClass("Index", *->*)
lazy val functor = TypeClass("Functor", *->*)
- lazy val pointed = TypeClass("Pointed", *->*, extendsList = Seq(functor))
lazy val apply: TypeClass = TypeClass("Apply", *->*, extendsList = Seq(functor))
- lazy val applicative = TypeClass("Applicative", *->*, extendsList = Seq(apply, pointed))
+ lazy val applicative = TypeClass("Applicative", *->*, extendsList = Seq(apply))
lazy val zip = TypeClass("Zip", *->*)
lazy val unzip = TypeClass("Unzip", *->*)
lazy val bind = TypeClass("Bind", *->*, extendsList = Seq(apply))
@@ -40,10 +39,9 @@ object TypeClass {
lazy val traverse = TypeClass("Traverse", *->*, extendsList = Seq(functor, foldable))
lazy val contravariant = TypeClass("Contravariant", *->*)
- lazy val copointed = TypeClass("Copointed", *->*, extendsList = Seq(functor))
lazy val cojoin = TypeClass("Cojoin", *->*, extendsList = Seq(functor))
lazy val cobind = TypeClass("Cobind", *->*, extendsList = Seq(functor))
- lazy val comonad = TypeClass("Comonad", *->*, extendsList = Seq(copointed, cojoin, cobind))
+ lazy val comonad = TypeClass("Comonad", *->*, extendsList = Seq(functor, cojoin, cobind))
lazy val cozip = TypeClass("Cozip", *->*)
lazy val codiagonal = TypeClass("Codiagonal", *^*->*)
@@ -86,9 +84,7 @@ object TypeClass {
each,
index,
functor,
- pointed,
contravariant,
- copointed,
apply,
applicative,
zip,
diff --git a/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazArbitrary.scala b/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazArbitrary.scala
index 46a3e28..7eb60a9 100644
--- a/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazArbitrary.scala
+++ b/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazArbitrary.scala
@@ -156,7 +156,7 @@ object ScalazArbitrary {
import java.util.concurrent.Callable
- implicit def CallableArbitrary[A](implicit a: Arbitrary[A]): Arbitrary[Callable[A]] = Functor[Arbitrary].map(arb[A])((x: A) => Pointed[Callable].point(x))
+ implicit def CallableArbitrary[A](implicit a: Arbitrary[A]): Arbitrary[Callable[A]] = Functor[Arbitrary].map(arb[A])((x: A) => Applicative[Callable].point(x))
import scalaz.concurrent.Promise
import scalaz.concurrent.Promise._
@@ -233,9 +233,9 @@ object ScalazArbitrary {
implicit def indexedStoreTArb[F[+_], I, A, B](implicit A: Arbitrary[(F[A => B], I)]): Arbitrary[IndexedStoreT[F, I, A, B]] = Functor[Arbitrary].map(A)(IndexedStoreT[F, I, A, B](_))
- implicit def listTArb[F[+_], A](implicit FA: Arbitrary[F[List[A]]], F: Pointed[F]): Arbitrary[ListT[F, A]] = Functor[Arbitrary].map(FA)(ListT.fromList(_))
+ implicit def listTArb[F[+_], A](implicit FA: Arbitrary[F[List[A]]], F: Applicative[F]): Arbitrary[ListT[F, A]] = Functor[Arbitrary].map(FA)(ListT.fromList(_))
- implicit def streamTArb[F[+_], A](implicit FA: Arbitrary[F[Stream[A]]], F: Pointed[F]): Arbitrary[StreamT[F, A]] = Functor[Arbitrary].map(FA)(StreamT.fromStream(_))
+ implicit def streamTArb[F[+_], A](implicit FA: Arbitrary[F[Stream[A]]], F: Applicative[F]): Arbitrary[StreamT[F, A]] = Functor[Arbitrary].map(FA)(StreamT.fromStream(_))
// workaround bug in Scalacheck 1.8-SNAPSHOT.
private def arbDouble: Arbitrary[Double] = Arbitrary { Gen.oneOf(posNum[Double], negNum[Double])}
diff --git a/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazProperties.scala b/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazProperties.scala
index c31978b..0c63d61 100644
--- a/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazProperties.scala
+++ b/scalacheck-binding/src/main/scala/scalaz/scalacheck/ScalazProperties.scala
@@ -164,14 +164,6 @@ object ScalazProperties {
}
}
-
- object copointed {
- def laws[M[_]](implicit a: Copointed[M], am: Arbitrary[M[Int]],
- af: Arbitrary[Int => Int], e: Equal[M[Int]]) = new Properties("copointed") {
- include(functor.laws[M])
- }
- }
-
object comonad {
def cobindLeftIdentity[F[_], A](implicit F: Comonad[F], F0: Equal[F[A]], fa: Arbitrary[F[A]]) =
forAll(F.comonadLaw.cobindLeftIdentity[A] _)
@@ -185,7 +177,7 @@ object ScalazProperties {
def laws[F[_]](implicit a: Comonad[F], am: Arbitrary[F[Int]],
af: Arbitrary[F[Int] => Int], e: Equal[F[Int]]) = new Properties("comonad") {
- include(copointed.laws[F])
+ include(functor.laws[F])
property("cobind left identity") = cobindLeftIdentity[F, Int]
property("cobind right identity") = cobindRightIdentity[F, Int, Int]
property("cobind associative") = cobindAssociative[F, Int, Int, Int, Int]
diff --git a/tests/src/test/scala/scalaz/CoKleisliTest.scala b/tests/src/test/scala/scalaz/CoKleisliTest.scala
index a676d2e..2062f3e 100644
--- a/tests/src/test/scala/scalaz/CoKleisliTest.scala
+++ b/tests/src/test/scala/scalaz/CoKleisliTest.scala
@@ -15,12 +15,10 @@ class CokleisliTest extends Spec {
object instances {
def monad[F[_], W] = Monad[({type λ[α] = Cokleisli[F, W, α]})#λ]
- def arrId[F[_] : Copointed, W] = ArrId[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
def compose[F[_], W](implicit F: Cojoin[F] with Functor[F]) = Compose[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
def arrow[F[_] : Comonad, W] = Arrow[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
// checking absence of ambiguity
- def arrId[F[_] : Comonad, W] = ArrId[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
def compose[F[_], W](implicit F: Comonad[F]) = Compose[({type λ[α, β] = Cokleisli[F, α, β]})#λ]
}
diff --git a/tests/src/test/scala/scalaz/EitherTTest.scala b/tests/src/test/scala/scalaz/EitherTTest.scala
index 76a751e..70e8e6f 100644
--- a/tests/src/test/scala/scalaz/EitherTTest.scala
+++ b/tests/src/test/scala/scalaz/EitherTTest.scala
@@ -17,7 +17,6 @@ class EitherTTest extends Spec {
object instances {
def functor[F[+_] : Functor, A] = Functor[({type λ[α] = EitherT[F, A, α]})#λ]
- def pointed[F[+_] : Pointed, A] = Pointed[({type λ[α] = EitherT[F, A, α]})#λ]
def apply[F[+_] : Apply, A] = Apply[({type λ[α] = EitherT[F, A, α]})#λ]
def applicative[F[+_] : Applicative, A] = Applicative[({type λ[α] = EitherT[F, A, α]})#λ]
def monad[F[+_] : Monad, A] = Monad[({type λ[α] = EitherT[F, A, α]})#λ]
@@ -26,7 +25,6 @@ class EitherTTest extends Spec {
// checking absence of ambiguity
def functor[F[+_] : Monad, A] = Functor[({type λ[α] = EitherT[F, A, α]})#λ]
- def pointed[F[+_] : Monad, A] = Pointed[({type λ[α] = EitherT[F, A, α]})#λ]
def apply[F[+_] : Monad, A] = Apply[({type λ[α] = EitherT[F, A, α]})#λ]
def foldable[F[+_] : Traverse, A] = Foldable[({type λ[α] = EitherT[F, A, α]})#λ]
}
diff --git a/tests/src/test/scala/scalaz/KleisliTest.scala b/tests/src/test/scala/scalaz/KleisliTest.scala
index ceb936e..bfad30c 100644
--- a/tests/src/test/scala/scalaz/KleisliTest.scala
+++ b/tests/src/test/scala/scalaz/KleisliTest.scala
@@ -40,20 +40,17 @@ class KleisliTest extends Spec {
def monoid[F[+_], A, B](implicit FB: Monoid[F[B]]) = Monoid[Kleisli[F, A, B]]
def functor[F[+_] : Functor, A] = Functor[({type f[a] = Kleisli[F, A, a]})#f]
def apply[F[+_] : Apply, A] = Apply[({type f[a] = Kleisli[F, A, a]})#f]
- def pointed[F[+_] : Pointed, A] = Pointed[({type f[a] = Kleisli[F, A, a]})#f]
def plus[F[+_] : Plus, A] = Plus[({type f[a] = Kleisli[F, A, a]})#f]
def empty[F[+_] : PlusEmpty, A] = PlusEmpty[({type f[a] = Kleisli[F, A, a]})#f]
def monadReader[F[+_] : Monad, A] = MonadReader[({type f[s, a] = Kleisli[F, s, a]})#f, A]
- def arrId[F[+_]: Pointed, A] = ArrId[({type λ[α, β]=Kleisli[F, α, β]})#λ]
- def category[F[+_]: Monad, A] = ArrId[({type λ[α, β]=Kleisli[F, α, β]})#λ]
+ def category[F[+_]: Monad, A] = Category[({type λ[α, β]=Kleisli[F, α, β]})#λ]
def arrow[F[+_]: Monad, A] = Arrow[({type λ[α, β]=Kleisli[F, α, β]})#λ]
// checking absence of ambiguity
def semigroup[F[+_], A, B](implicit FB: Monoid[F[B]]) = Semigroup[Kleisli[F, A, B]]
def functor[F[+_] : Monad, A] = Functor[({type f[a] = Kleisli[F, A, a]})#f]
def apply[F[+_] : Monad, A] = Apply[({type f[a] = Kleisli[F, A, a]})#f]
- def pointed[F[+_] : Monad, A] = Pointed[({type f[a] = Kleisli[F, A, a]})#f]
def plus[F[+_] : PlusEmpty, A] = Plus[({type f[a] = Kleisli[F, A, a]})#f]
def empty[F[+_] : MonadPlus, A] = PlusEmpty[({type f[a] = Kleisli[F, A, a]})#f]
@@ -61,10 +58,8 @@ class KleisliTest extends Spec {
// F = Id
def readerFunctor[A] = Functor[({type λ[α] = Reader[A, α]})#λ]
def readerApply[A] = Apply[({type λ[α] = Reader[A, α]})#λ]
- def readerPointed[A] = Pointed[({type λ[α] = Reader[A, α]})#λ]
def readerMonadReader[A] = MonadReader[({type f[s, a] = Reader[s, a]})#f, A]
- def readerArrId = ArrId[Reader]
- def readerCategory = ArrId[Reader]
+ def readerCategory = Ca1tegory[Reader]
def readerArrow = Arrow[Reader]
// Sigh, more tests needed, see http://stackoverflow.com/questions/11913128/scalaz-7-why-using-type-alias-results-in-ambigous-typeclass-resolution-for-rea
@@ -72,7 +67,6 @@ class KleisliTest extends Spec {
type ReaderX[A] = Reader[X, A]
def readerXFunctor = Functor[ReaderX]
def readerXApply = Apply[ReaderX]
- def readerXPointed = Pointed[ReaderX]
}
}
}
diff --git a/tests/src/test/scala/scalaz/LazyOptionTTest.scala b/tests/src/test/scala/scalaz/LazyOptionTTest.scala
index cc83365..bf6df01 100644
--- a/tests/src/test/scala/scalaz/LazyOptionTTest.scala
+++ b/tests/src/test/scala/scalaz/LazyOptionTTest.scala
@@ -13,13 +13,11 @@ class LazyOptionTTest extends Spec {
object instances {
def functor[F[+_] : Functor] = Functor[({type λ[α] = LazyOptionT[F, α]})#λ]
- def pointed[F[+_] : Pointed] = Pointed[({type λ[α] = LazyOptionT[F, α]})#λ]
def apply[F[+_] : Apply] = Apply[({type λ[α] = LazyOptionT[F, α]})#λ]
def monad[F[+_] : Monad] = Monad[({type λ[α] = LazyOptionT[F, α]})#λ]
// checking absence of ambiguity
def functor[F[+_] : Monad] = Functor[({type λ[α] = LazyOptionT[F, α]})#λ]
- def pointed[F[+_] : Monad] = Pointed[({type λ[α] = LazyOptionT[F, α]})#λ]
def apply[F[+_] : Monad] = Apply[({type λ[α] = LazyOptionT[F, α]})#λ]
}
}
diff --git a/tests/src/test/scala/scalaz/OptionTTest.scala b/tests/src/test/scala/scalaz/OptionTTest.scala
index f8b1ef6..0ccad34 100644
--- a/tests/src/test/scala/scalaz/OptionTTest.scala
+++ b/tests/src/test/scala/scalaz/OptionTTest.scala
@@ -15,7 +15,6 @@ class OptionTTest extends Spec {
object instances {
def functor[F[+_] : Functor] = Functor[({type λ[α] = OptionT[F, α]})#λ]
- def pointed[F[+_] : Pointed] = Pointed[({type λ[α] = OptionT[F, α]})#λ]
def apply[F[+_] : Apply] = Apply[({type λ[α] = OptionT[F, α]})#λ]
def monad[F[+_] : Monad] = Monad[({type λ[α] = OptionT[F, α]})#λ]
def foldable[F[+_] : Foldable] = Foldable[({type λ[α] = OptionT[F, α]})#λ]
@@ -23,7 +22,6 @@ class OptionTTest extends Spec {
// checking absence of ambiguity
def functor[F[+_] : Monad] = Functor[({type λ[α] = OptionT[F, α]})#λ]
- def pointed[F[+_] : Monad] = Pointed[({type λ[α] = OptionT[F, α]})#λ]
def apply[F[+_] : Monad] = Apply[({type λ[α] = OptionT[F, α]})#λ]
def foldable[F[+_] : Traverse] = Foldable[({type λ[α] = OptionT[F, α]})#λ]
}
diff --git a/tests/src/test/scala/scalaz/PLensTest.scala b/tests/src/test/scala/scalaz/PLensTest.scala
index 7447187..0941b90 100644
--- a/tests/src/test/scala/scalaz/PLensTest.scala
+++ b/tests/src/test/scala/scalaz/PLensTest.scala
@@ -14,7 +14,6 @@ class PLensTest extends Spec {
}
object instances {
- def arrId = ArrId[PLens]
def category = Category[PLens]
def choice = Choice[PLens]
def split = Split[PLens]
diff --git a/tests/src/test/scala/scalaz/StateTTest.scala b/tests/src/test/scala/scalaz/StateTTest.scala
index a51b940..c92967b 100644
--- a/tests/src/test/scala/scalaz/StateTTest.scala
+++ b/tests/src/test/scala/scalaz/StateTTest.scala
@@ -20,16 +20,13 @@ class StateTTest extends Spec {
object instances {
def functor[S, F[+_] : Functor] = Functor[({type λ[+α] = StateT[F, S, α]})#λ]
- def pointed[S, F[+_] : Pointed] = Pointed[({type λ[+α] = StateT[F, S, α]})#λ]
def monadState[S, F[+_] : Monad] = MonadState[({type λ[α, +β]=StateT[F, α, β]})#λ, S]
// F = Id
def functor[S] = Functor[({type λ[α] = State[S, α]})#λ]
- def pointed[S] = Pointed[({type λ[α] = State[S, α]})#λ]
def monadState[S] = MonadState[({type λ[α, β]=State[α, β]})#λ, S]
// checking absence of ambiguity
def functor[S, F[+_] : Monad] = Functor[({type λ[+α] = StateT[F, S, α]})#λ]
- def pointed[S, F[+_] : Monad] = Pointed[({type λ[+α] = StateT[F, S, α]})#λ]
}
}
diff --git a/tests/src/test/scala/scalaz/StoreTTest.scala b/tests/src/test/scala/scalaz/StoreTTest.scala
index 20e14cd..be2e42d 100644
--- a/tests/src/test/scala/scalaz/StoreTTest.scala
+++ b/tests/src/test/scala/scalaz/StoreTTest.scala
@@ -17,13 +17,11 @@ class StoreTTest extends Spec {
object instances {
type A = Int
def functor[F[+_] : Functor] = Functor[({type λ[+α] = StoreT[F, A, α]})#λ]
- def copointed[F[+_] : Copointed] = Copointed[({type λ[+α] = StoreT[F, A, α]})#λ]
def cobind[F[+_] : Cobind] = Cobind[({type λ[+α] = StoreT[F, A, α]})#λ]
def comonad[F[+_] : Comonad] = Comonad[({type λ[+α] = StoreT[F, A, α]})#λ]
// checking absence of ambiguity
def functor[F[+_] : Comonad] = Functor[({type λ[+α] = StoreT[F, A, α]})#λ]
- def copointed[F[+_] : Comonad] = Copointed[({type λ[+α] = StoreT[F, A, α]})#λ]
def cobind[F[+_] : Comonad] = Cobind[({type λ[+α] = StoreT[F, A, α]})#λ]
}
diff --git a/tests/src/test/scala/scalaz/StreamTTest.scala b/tests/src/test/scala/scalaz/StreamTTest.scala
index d702d0d..147e998 100644
--- a/tests/src/test/scala/scalaz/StreamTTest.scala
+++ b/tests/src/test/scala/scalaz/StreamTTest.scala
@@ -45,7 +45,7 @@ class StreamTTest extends Spec {
object instances {
def semigroup[F[+_]: Functor, A] = Semigroup[StreamT[F, A]]
- def monoid[F[+_]: Pointed, A] = Monoid[StreamT[F, A]]
+ def monoid[F[+_]: Applicative, A] = Monoid[StreamT[F, A]]
def functor[F[+_]: Functor, A] = Functor[({type λ[α]=StreamT[F, α]})#λ]
def monad[F[+_]: Monad, A] = Monad[({type λ[α]=StreamT[F, α]})#λ]
}
diff --git a/tests/src/test/scala/scalaz/ValidationTest.scala b/tests/src/test/scala/scalaz/ValidationTest.scala
index 35bbc27..07c7ec4 100644
--- a/tests/src/test/scala/scalaz/ValidationTest.scala
+++ b/tests/src/test/scala/scalaz/ValidationTest.scala
@@ -20,7 +20,7 @@ class ValidationTest extends Spec {
"fpoint and point" in {
- import syntax.pointed._
+ import syntax.applicative._
import std.AllInstances._
import Validation._
@@ -70,7 +70,6 @@ class ValidationTest extends Spec {
def show[E: Show, A: Show] = Show[Validation[E, A]]
def equal[E: Equal, A: Equal] = Equal[Validation[E, A]]
def order[E: Order, A: Order] = Order[Validation[E, A]]
- def pointed[E] = Pointed[({type λ[α]=Validation[E, α]})#λ]
def semigroup[E: Semigroup, A: Semigroup] = Semigroup[Validation[E, A]]
def applicative[E: Semigroup] = Applicative[({type λ[α]=Validation[E, α]})#λ]
def traverse[E: Semigroup] = Traverse[({type λ[α]=Validation[E, α]})#λ]
@@ -79,6 +78,5 @@ class ValidationTest extends Spec {
// checking absence of ambiguity
def equal[E: Order, A: Order] = Equal[Validation[E, A]]
- def pointed[E: Semigroup] = Pointed[({type λ[α] = Validation[E, α]})#λ]
}
}
diff --git a/tests/src/test/scala/scalaz/WriterTTest.scala b/tests/src/test/scala/scalaz/WriterTTest.scala
index 2b3fb10..8592800 100644
--- a/tests/src/test/scala/scalaz/WriterTTest.scala
+++ b/tests/src/test/scala/scalaz/WriterTTest.scala
@@ -17,7 +17,7 @@ class WriterTTest extends Spec {
checkAll(monad.laws[WriterTOptInt])
checkAll(traverse.laws[WriterTOptInt])
checkAll(bifunctor.laws[WriterTOpt])
- checkAll(copointed.laws[({type λ[+α]=WriterT[NonEmptyList, Int, α]})#λ])
+ checkAll(functor.laws[({type λ[+α]=WriterT[NonEmptyList, Int, α]})#λ])
checkAll(bitraverse.laws[WriterTOpt])
implicit def writerArb[F[+_], W, A](implicit W: Arbitrary[W], A: Arbitrary[A]): Arbitrary[Writer[W, A]] =
@@ -27,27 +27,22 @@ class WriterTTest extends Spec {
object instances {
def functor[F[+_]: Functor, W] = Functor[({type λ[+α]=WriterT[F, W, α]})#λ]
- def pointed[F[+_]: Pointed, W: Monoid] = Pointed[({type λ[+α]=WriterT[F, W, α]})#λ]
def apply[F[+_]: Monad, W: Semigroup] = Apply[({type λ[+α]=WriterT[F, W, α]})#λ]
def monad[F[+_]: Monad, W: Monoid] = Monad[({type λ[+α]=WriterT[F, W, α]})#λ]
def foldable[F[+_]: Foldable, W] = Foldable[({type λ[+α]=WriterT[F, W, α]})#λ]
def traverse[F[+_]: Traverse, W] = Traverse[({type λ[+α]=WriterT[F, W, α]})#λ]
- def copointed[F[+_]: Copointed, W] = Copointed[({type λ[+α]=WriterT[F, W, α]})#λ]
def functor[F[+_]: Monad, W: Monoid] = Functor[({type λ[+α]=WriterT[F, W, α]})#λ]
- def pointed[F[+_]: Monad, W: Monoid] = Pointed[({type λ[+α]=WriterT[F, W, α]})#λ]
def apply[F[+_]: Monad, W: Monoid] = Apply[({type λ[+α]=WriterT[F, W, α]})#λ]
def functor[F[+_]: Traverse, W: Monoid] = Functor[({type λ[+α]=WriterT[F, W, α]})#λ]
def foldable[F[+_]: Traverse, W] = Foldable[({type λ[+α]=WriterT[F, W, α]})#λ]
object writer {
def functor[W] = Functor[({type λ[+α]=Writer[W, α]})#λ]
- def pointed[W: Monoid] = Pointed[({type λ[+α]=Writer[W, α]})#λ]
def apply[W: Semigroup] = Apply[({type λ[+α]=Writer[W, α]})#λ]
def monad[W: Monoid] = Monad[({type λ[+α]=Writer[W, α]})#λ]
def foldable[W] = Foldable[({type λ[+α]=Writer[W, α]})#λ](WriterT.writerTFoldable[Id, W])
def traverse[W] = Traverse[({type λ[+α]=Writer[W, α]})#λ]
- def copointed[W] = Copointed[({type λ[+α]=Writer[W, α]})#λ]
def comonad[W] = Comonad[({type λ[+α]=Writer[W, α]})#λ]
}
}
diff --git a/tests/src/test/scala/scalaz/iteratee/EnumeratorTTest.scala b/tests/src/test/scala/scalaz/iteratee/EnumeratorTTest.scala
index 557e9bc..ed1ddfb 100644
--- a/tests/src/test/scala/scalaz/iteratee/EnumeratorTTest.scala
+++ b/tests/src/test/scala/scalaz/iteratee/EnumeratorTTest.scala
@@ -108,7 +108,6 @@ class EnumeratorTTest extends Spec {
object instances {
//def functor[F[_] : Functor] = Functor[({type λ[α] = EnumeratorT[α, F]})#λ]
- //def pointed[F[_] : Pointed] = Pointed[({type λ[α] = EnumeratorT[α, F]})#λ]
def monad[F[_] : Monad] = Monad[({type λ[α] = EnumeratorT[α, F]})#λ]
def semigroup[E, F[_]: Bind] = Semigroup[EnumeratorT[E, F]]
def monoid[E, F[_]: Monad] = Monoid[EnumeratorT[E, F]]
diff --git a/typelevel/src/main/scala/scalaz/typelevel/Func.scala b/typelevel/src/main/scala/scalaz/typelevel/Func.scala
index d99c8a8..678c1c7 100644
--- a/typelevel/src/main/scala/scalaz/typelevel/Func.scala
+++ b/typelevel/src/main/scala/scalaz/typelevel/Func.scala
@@ -77,10 +77,6 @@ trait FuncInstances3 {
}
trait FuncInstances2 extends FuncInstances3 {
- implicit def FuncPointed[F[_], TC[F[_]] <: Pointed[F], R](implicit TC0: KTypeClass[TC], F0: TC[F]): Pointed[({type λ[α] = Func[F, TC, R, α]})#λ] = new FuncPointed[F, TC, R] {
- implicit def TC: KTypeClass[TC] = TC0
- implicit def F: TC[F] = F0
- }
implicit def FuncApply[F[_], TC[F[_]] <: Apply[F], R](implicit TC0: KTypeClass[TC], F0: TC[F]): Apply[({type λ[α] = Func[F, TC, R, α]})#λ] = new FuncApply[F, TC, R] {
implicit def TC: KTypeClass[TC] = TC0
implicit def F: TC[F] = F0
@@ -109,12 +105,6 @@ trait FuncFunctions {
def F = F0.TC
def runA(a: A) = F0(f(a))
}
- def pointedfunc[M[_], A, B](f: A => M[B])(implicit F0: Pointed[M]): Func[M, Pointed, A, B] = func[M, Pointed, A, B](f)
- def pointedfuncU[A, R](f: A => R)(implicit F0: Unapply[Pointed, R]): Func[F0.M, Pointed, A, F0.A] = new Func[F0.M, Pointed, A, F0.A] {
- def TC = KTypeClass[Pointed]
- def F = F0.TC
- def runA(a: A) = F0(f(a))
- }
def applyfunc[M[_], A, B](f: A => M[B])(implicit F0: Apply[M]): Func[M, Apply, A, B] = func[M, Apply, A, B](f)
def applyfuncU[A, R](f: A => R)(implicit F0: Unapply[Apply, R]): Func[F0.M, Apply, A, F0.A] = new Func[F0.M, Apply, A, F0.A] {
def TC = KTypeClass[Apply]
@@ -147,15 +137,6 @@ object FunctorFuncU {
def apply[A, R](f: A => R)(implicit F0: Unapply[Functor, R]): Func[F0.M, Functor, A, F0.A] = Func.functorfuncU(f)
}
-object PointedFunc {
- def apply[M[_], A, B](f: A => M[B])(implicit F0: Pointed[M]): Func[M, Pointed, A, B] = Func.pointedfunc(f)
- def HNil[A, B] = Func.hnilfunc[Pointed, A, B]
-}
-
-object PointedFuncU {
- def apply[A, R](f: A => R)(implicit F0: Unapply[Pointed, R]): Func[F0.M, Pointed, A, F0.A] = Func.pointedfuncU(f)
-}
-
object ApplyFunc {
def apply[M[_], A, B](f: A => M[B])(implicit F0: Apply[M]): Func[M, Apply, A, B] = Func.applyfunc(f)
def HNil[A, B] = Func.hnilfunc[Apply, A, B]
@@ -184,19 +165,15 @@ private[scalaz] trait FuncFunctor[F[_], TC[F[_]] <: Functor[F], R] extends Funct
override def map[A, B](fa: Func[F, TC, R, A])(f: A => B): Func[F, TC, R, B] = fa mapA f
}
-private[scalaz] trait FuncPointed[F[_], TC[F[_]] <: Pointed[F], R] extends Pointed[({type λ[α] = Func[F, TC, R, α]})#λ] with FuncFunctor[F, TC, R] {
- implicit def TC: KTypeClass[TC]
- implicit def F: TC[F]
- def point[A](a: => A): Func[F, TC, R, A] = func((r: R) => F.point(a))
-}
-
private[scalaz] trait FuncApply[F[_], TC[F[_]] <: Apply[F], R] extends Apply[({type λ[α] = Func[F, TC, R, α]})#λ] with FuncFunctor[F, TC, R] {
implicit def TC: KTypeClass[TC]
implicit def F: TC[F]
def ap[A, B](fa: => Func[F, TC, R, A])(f: => Func[F, TC, R, (A) => B]): Func[F, TC, R, B] = func(r => F.ap(fa.runA(r))(f.runA(r)))
}
-private[scalaz] trait FuncApplicative[F[_], TC[F[_]] <: Applicative[F], R] extends Applicative[({type λ[α] = Func[F, TC, R, α]})#λ] with FuncApply[F, TC, R] with FuncPointed[F, TC, R] {
+private[scalaz] trait FuncApplicative[F[_], TC[F[_]] <: Applicative[F], R] extends Applicative[({type λ[α] = Func[F, TC, R, α]})#λ] with FuncApply[F, TC, R] {
implicit def TC: KTypeClass[TC]
implicit def F: TC[F]
+ def point[A](a: => A): Func[F, TC, R, A] = func((r: R) => F.point(a))
+
}
diff --git a/typelevel/src/main/scala/scalaz/typelevel/GenericList.scala b/typelevel/src/main/scala/scalaz/typelevel/GenericList.scala
index 6c8b583..d33ca5f 100644
--- a/typelevel/src/main/scala/scalaz/typelevel/GenericList.scala
+++ b/typelevel/src/main/scala/scalaz/typelevel/GenericList.scala
@@ -114,7 +114,7 @@ sealed trait GenericList[+M[_]] {
* Version of `apply` which takes the bare function and wraps it into `N`.
*/
final def applyP[N[X] >: M[X] : Applicative, R](f: Function[R]): N[R] =
- apply[N, R](Pointed[N].point(f))
+ apply[N, R](Applicative[N].point(f))
/**
* Upcasts the type constructor in this list. This operation is safe.
diff --git a/typelevel/src/main/scala/scalaz/typelevel/HStream.scala b/typelevel/src/main/scala/scalaz/typelevel/HStream.scala
index 3527d2a..1305bb3 100644
--- a/typelevel/src/main/scala/scalaz/typelevel/HStream.scala
+++ b/typelevel/src/main/scala/scalaz/typelevel/HStream.scala
@@ -96,8 +96,8 @@ trait HStream[T[_ <: Nat]] extends AbstractHStream { self =>
type Point[P[_]] = HStream[({ type λ[α <: Nat] = P[T[α]] })#λ]
- def point[P[_] : Pointed]: Point[P] = new Point[P] {
- def apply[N <: Nat](n: N) = Pointed[P].point(self(n))
+ def point[P[_] : Applicative]: Point[P] = new Point[P] {
+ def apply[N <: Nat](n: N) = Applicative[P].point(self(n))
}
}
diff --git a/typelevel/src/main/scala/scalaz/typelevel/KTypeClass.scala b/typelevel/src/main/scala/scalaz/typelevel/KTypeClass.scala
index 77f286d..56b968f 100644
--- a/typelevel/src/main/scala/scalaz/typelevel/KTypeClass.scala
+++ b/typelevel/src/main/scala/scalaz/typelevel/KTypeClass.scala
@@ -128,16 +128,6 @@ object KTypeClass {
}
- private[scalaz] trait ProductPointed[F[_], T <: TCList]
- extends ProductFunctor[F, T]
- with Pointed[TCCons[F, T]#Product]
- with Product[Pointed, F, T] {
-
- def point[A](a: => A) =
- FHead.point(a) :: FTail.point(a)
-
- }
-
private[scalaz] trait ProductApply[F[_], T <: TCList]
extends ProductFunctor[F, T]
with Apply[TCCons[F, T]#Product]
@@ -149,10 +139,14 @@ object KTypeClass {
}
private[scalaz] trait ProductApplicative[F[_], T <: TCList]
- extends ProductPointed[F, T]
- with ProductApply[F, T]
+ extends ProductApply[F, T]
with Applicative[TCCons[F, T]#Product]
- with Product[Applicative, F, T]
+ with Product[Applicative, F, T] {
+
+ def point[A](a: => A) =
+ FHead.point(a) :: FTail.point(a)
+
+ }
private[scalaz] trait ProductPlus[F[_], T <: TCList]
extends Plus[TCCons[F, T]#Product]
@@ -235,16 +229,6 @@ object KTypeClass {
}
- private[scalaz] trait ComposedPointed[F[_], T <: TCList]
- extends ComposedFunctor[F, T]
- with Pointed[TCCons[F, T]#Composed]
- with Composed[Pointed, F, T] {
-
- def point[A](a: => A) =
- FOuter.point(FInner.point(a))
-
- }
-
private[scalaz] trait ComposedApply[F[_], T <: TCList]
extends ComposedFunctor[F, T]
with Apply[TCCons[F, T]#Composed]
@@ -256,10 +240,14 @@ object KTypeClass {
}
private[scalaz] trait ComposedApplicative[F[_], T <: TCList]
- extends ComposedPointed[F, T]
- with ComposedApply[F, T]
+ extends ComposedApply[F, T]
with Applicative[TCCons[F, T]#Composed]
- with Composed[Applicative, F, T]
+ with Composed[Applicative, F, T] {
+
+ def point[A](a: => A) =
+ FOuter.point(FInner.point(a))
+
+ }
private[scalaz] trait ComposedFoldable[F[_], T <: TCList]
extends Foldable[TCCons[F, T]#Composed]
@@ -350,13 +338,6 @@ object KTypeClass {
new ComposedFunctor[F, T] { def FOuter = FO; def FInner = FI }
}
- implicit def PointedI: KTypeClass[Pointed] = new KTypeClass[Pointed] with Empty {
- def product[F[_], T <: TCList](FH: Pointed[F], FT: Pointed[T#Product]) =
- new ProductPointed[F, T] { def FHead = FH; def FTail = FT }
- def compose[F[_], T <: TCList](FO: Pointed[F], FI: Pointed[T#Composed]) =
- new ComposedPointed[F, T] { def FOuter = FO; def FInner = FI }
- }
-
implicit def ApplyI: KTypeClass[Apply] = new KTypeClass[Apply] with Empty {
def product[F[_], T <: TCList](FH: Apply[F], FT: Apply[T#Product]) =
new ProductApply[F, T] { def FHead = FH; def FTail = FT }
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment