/core/src/main/scala/scalaz/WriterT.scala

http://github.com/scalaz/scalaz · Scala · 480 lines · 373 code · 102 blank · 5 comment · 0 complexity · 46166bc25e9a0d0fb490dd1d97557f2b MD5 · raw file

  1. package scalaz
  2. import Id._
  3. final case class WriterT[W, F[_], A](run: F[(W, A)]) { self =>
  4. import WriterT._
  5. def off: UnwriterT[F, W, A] =
  6. UnwriterT(run)
  7. /** alias for `off` */
  8. def unary_- : UnwriterT[F, W, A] =
  9. UnwriterT(run)
  10. def mapValue[X, B](f: ((W, A)) => (X, B))(implicit F: Functor[F]): WriterT[X, F, B] =
  11. writerT(F.map(run)(f))
  12. def mapWritten[X](f: W => X)(implicit F: Functor[F]): WriterT[X, F, A] =
  13. mapValue(wa => (f(wa._1), wa._2))
  14. def mapT[W2, G[_], B](f: F[(W, A)] => G[(W2, B)]): WriterT[W2, G, B] =
  15. WriterT(f(run))
  16. def written(implicit F: Functor[F]): F[W] =
  17. F.map(run)(_._1)
  18. def value(implicit F: Functor[F]): F[A] =
  19. F.map(run)(_._2)
  20. def swap(implicit F: Functor[F]): WriterT[A, F, W] =
  21. mapValue(wa => (wa._2, wa._1))
  22. def :++>(w: => W)(implicit F: Functor[F], W: Semigroup[W]): WriterT[W, F, A] =
  23. mapWritten(W.append(_, w))
  24. def :++>>(f: A => W)(implicit F: Functor[F], W: Semigroup[W]): WriterT[W, F, A] =
  25. mapValue(wa => (W.append(wa._1, f(wa._2)), wa._2))
  26. def <++:(w: W)(implicit F: Functor[F], W: Semigroup[W]): WriterT[W, F, A] =
  27. mapWritten(W.append(w, _))
  28. def <<++:(f: A => W)(implicit F: Functor[F], s: Semigroup[W]): WriterT[W, F, A] =
  29. mapValue(wa => (s.append(f(wa._2), wa._1), wa._2))
  30. def reset(implicit Z: Monoid[W], F: Functor[F]): WriterT[W, F, A] =
  31. mapWritten(_ => Z.zero)
  32. def map[B](f: A => B)(implicit F: Functor[F]): WriterT[W, F, B] =
  33. writerT(F.map(run)(wa => (wa._1, f(wa._2))))
  34. def mapF[B](f: A => F[B])(implicit F: Bind[F]): WriterT[W, F, B] = writerT {
  35. F.bind(run)(wa => F.map(f(wa._2))(a => (wa._1, a)))
  36. }
  37. def ap[B](f: => WriterT[W, F, A => B])(implicit F: Apply[F], W: Semigroup[W]): WriterT[W, F, B] = writerT {
  38. F.apply2(f.run, run) {
  39. case ((w1, fab), (w2, a)) => (W.append(w1, w2), fab(a))
  40. }
  41. }
  42. def flatMap[B](f: A => WriterT[W, F, B])(implicit F: Bind[F], s: Semigroup[W]): WriterT[W, F, B] =
  43. flatMapF(f.andThen(_.run))
  44. def flatMapF[B](f: A => F[(W, B)])(implicit F: Bind[F], s: Semigroup[W]): WriterT[W, F, B] =
  45. writerT(F.bind(run){wa =>
  46. val z = f(wa._2)
  47. F.map(z)(wb => (s.append(wa._1, wb._1), wb._2))
  48. })
  49. def traverse[G[_], B](f: A => G[B])(implicit G: Applicative[G], F: Traverse[F]): G[WriterT[W, F, B]] = {
  50. G.map(F.traverse(run){
  51. case (w, a) => G.map(f(a))(b => (w, b))
  52. })(WriterT(_))
  53. }
  54. def foldRight[B](z: => B)(f: (A, => B) => B)(implicit F: Foldable[F]): B =
  55. F.foldr(run, z) { a => b =>
  56. f(a._2, b)
  57. }
  58. def bimap[C, D](f: W => C, g: A => D)(implicit F: Functor[F]): WriterT[C, F, D] =
  59. writerT[F, C, D](F.map(run)({
  60. case (a, b) => (f(a), g(b))
  61. }))
  62. def leftMap[C](f: W => C)(implicit F: Functor[F]): WriterT[C, F, A] =
  63. bimap(f, identity)
  64. def bitraverse[G[_], C, D](f: W => G[C], g: A => G[D])(implicit G: Applicative[G], F: Traverse[F]): G[WriterT[C, F, D]] =
  65. G.map(F.traverse[G, (W, A), (C, D)](run) {
  66. case (a, b) => G.tuple2(f(a), g(b))
  67. })(writerT(_))
  68. def rwst[R, S](implicit F: Functor[F]): ReaderWriterStateT[R, W, S, F, A] = ReaderWriterStateT(
  69. (r, s) => F.map(self.run) {
  70. case (w, a) => (w, a, s)
  71. }
  72. )
  73. def wpoint[G[_]](implicit F: Functor[F], P: Applicative[G]): WriterT[G[W], F, A] =
  74. writerT(F.map(self.run) {
  75. case (w, a) => (P.point(w), a)
  76. })
  77. def colocal[X](f: W => X)(implicit F: Functor[F]): WriterT[X, F, A] = mapWritten(f)
  78. }
  79. object WriterT extends WriterTInstances with WriterTFunctions
  80. sealed abstract class WriterTInstances16 {
  81. implicit def writerTDivisible[F[_], W, A](implicit F0: Divisible[F]): Divisible[WriterT[W, F, *]] =
  82. new WriterTDivisible[F, W] {
  83. implicit def F: Divisible[F] = F0
  84. }
  85. }
  86. sealed abstract class WriterTInstances15 extends WriterTInstances16 {
  87. implicit def writerTMonoid[W, F[_], A](implicit M: Monoid[F[(W,A)]]): Monoid[WriterT[W, F, A]] =
  88. new Monoid[WriterT[W, F, A]] {
  89. def zero = WriterT(M.zero)
  90. def append(a: WriterT[W, F, A], b: => WriterT[W, F, A]) = WriterT(M.append(a.run, b.run))
  91. }
  92. implicit def writerTPlus[W, F[_]](implicit F0: Plus[F]): Plus[WriterT[W, F, *]] =
  93. new WriterTPlus[F, W] {
  94. def F = F0
  95. }
  96. implicit def writerTDecidable[F[_], W, A](implicit F0: Decidable[F]): Decidable[WriterT[W, F, *]] =
  97. new WriterTDecidable[F, W] {
  98. implicit def F: Decidable[F] = F0
  99. }
  100. }
  101. sealed abstract class WriterTInstances14 extends WriterTInstances15 {
  102. implicit def writerFunctor[W]: Functor[Writer[W, *]] =
  103. new WriterTFunctor[Id, W] {
  104. implicit def F = idInstance
  105. }
  106. implicit def writerTPlusEmpty[W, F[_]](implicit F0: PlusEmpty[F]): PlusEmpty[WriterT[W, F, *]] =
  107. new WriterTPlusEmpty[F, W] {
  108. def F = F0
  109. }
  110. }
  111. sealed abstract class WriterTInstances13 extends WriterTInstances14 {
  112. implicit def writerTFunctor[W, F[_]](implicit F0: Functor[F]): Functor[WriterT[W, F, *]] =
  113. new WriterTFunctor[F, W] {
  114. implicit def F = F0
  115. }
  116. }
  117. sealed abstract class WriterTInstances12 extends WriterTInstances13 {
  118. implicit def writerBind[W](implicit W0: Semigroup[W]): Bind[Writer[W, *]] =
  119. new WriterTBind[Id, W] {
  120. implicit def F = idInstance
  121. implicit def W = W0
  122. }
  123. }
  124. sealed abstract class WriterTInstances11 extends WriterTInstances12 {
  125. implicit def writerTBindRec[W, F[_]](implicit W0: Semigroup[W], F0: BindRec[F], F1: Applicative[F]): BindRec[WriterT[W, F, *]] =
  126. new WriterTBindRec[F, W] {
  127. implicit def F = F0
  128. implicit def A = F1
  129. implicit def W = W0
  130. }
  131. }
  132. sealed abstract class WriterTInstances10 extends WriterTInstances11 {
  133. implicit def writerTApply[W, F[_]](implicit W0: Semigroup[W], F0: Apply[F]): Apply[WriterT[W, F, *]] =
  134. new WriterTApply[F, W] {
  135. implicit def F = F0
  136. implicit def W = W0
  137. }
  138. }
  139. sealed abstract class WriterTInstances9 extends WriterTInstances10 {
  140. implicit def writerTBind[W, F[_]](implicit W0: Semigroup[W], F0: Bind[F]): Bind[WriterT[W, F, *]] =
  141. new WriterTBind[F, W] {
  142. implicit def F = F0
  143. implicit def W = W0
  144. }
  145. }
  146. sealed abstract class WriterTInstances8 extends WriterTInstances9 {
  147. implicit def writerTApplicative[W, F[_]](implicit W0: Monoid[W], F0: Applicative[F]): Applicative[WriterT[W, F, *]] =
  148. new WriterTApplicative[F, W] {
  149. implicit def F = F0
  150. implicit def W = W0
  151. }
  152. }
  153. sealed abstract class WriterTInstances7 extends WriterTInstances8 {
  154. implicit def writerBindRec[W](implicit W0: Semigroup[W]): BindRec[Writer[W, *]] =
  155. new WriterTBindRec[Id, W] {
  156. implicit def F = idInstance
  157. implicit def A = idInstance
  158. implicit def W = W0
  159. }
  160. }
  161. sealed abstract class WriterTInstances6 extends WriterTInstances7 {
  162. implicit def writerMonad[W](implicit W0: Monoid[W]): Monad[Writer[W, *]] =
  163. new WriterTMonad[Id, W] {
  164. implicit def F = idInstance
  165. implicit def W = W0
  166. }
  167. }
  168. sealed abstract class WriterTInstance5 extends WriterTInstances6 {
  169. implicit def writerTMonad[W, F[_]](implicit W0: Monoid[W], F0: Monad[F]): Monad[WriterT[W, F, *]] =
  170. new WriterTMonad[F, W] {
  171. implicit def F = F0
  172. implicit def W = W0
  173. }
  174. }
  175. sealed abstract class WriterTInstances4 extends WriterTInstance5 {
  176. implicit def writerFoldable[W]: Foldable[Writer[W, *]] =
  177. new WriterTFoldable[Id, W] {
  178. implicit def F = idInstance
  179. }
  180. implicit def writerTEqual[F[_], W, A](implicit E: Equal[F[(W, A)]]): Equal[WriterT[W, F, A]] = E.contramap((_: WriterT[W, F, A]).run)
  181. implicit def writerTMonadError[F[_], E, W](implicit F0: MonadError[F, E], W0: Monoid[W]): MonadError[WriterT[W, F, *], E] =
  182. new WriterTMonadError[F, E, W] {
  183. override def F = F0
  184. override def W = W0
  185. }
  186. }
  187. sealed abstract class WriterTInstances3 extends WriterTInstances4 {
  188. implicit def writerTBifunctor[F[_]](implicit F0: Functor[F]): Bifunctor[WriterT[*, F, *]] =
  189. new WriterTBifunctor[F] {
  190. implicit def F = F0
  191. }
  192. implicit def writerTFoldable[W, F[_]](implicit F0: Foldable[F]): Foldable[WriterT[W, F, *]] =
  193. new WriterTFoldable[F, W] {
  194. implicit def F = F0
  195. }
  196. implicit def writerEqual[W, A](implicit E: Equal[(W, A)]): Equal[Writer[W, A]] = E.contramap((_: Writer[W, A]).run)
  197. implicit def writerTMonadPlus[W, F[_]](implicit W0: Monoid[W], F0: MonadPlus[F]): MonadPlus[WriterT[W, F, *]] =
  198. new WriterTMonadPlus[F, W] {
  199. def F = F0
  200. def W = W0
  201. }
  202. }
  203. sealed abstract class WriterTInstances2 extends WriterTInstances3 {
  204. implicit def writerComonad[W]: Comonad[Writer[W, *]] =
  205. new WriterComonad[W] {
  206. implicit def F = implicitly
  207. }
  208. }
  209. sealed abstract class WriterTInstances1 extends WriterTInstances2 {
  210. implicit val writerBitraverse: Bitraverse[Writer] =
  211. new WriterTBitraverse[Id] {
  212. implicit def F = idInstance
  213. }
  214. implicit def writerTTraverse[W, F[_]](implicit F0: Traverse[F]): Traverse[WriterT[W, F, *]] =
  215. new WriterTTraverse[F, W] {
  216. implicit def F = F0
  217. }
  218. }
  219. sealed abstract class WriterTInstances0 extends WriterTInstances1 {
  220. implicit def writerTBitraverse[F[_]](implicit F0: Traverse[F]): Bitraverse[WriterT[*, F, *]] =
  221. new WriterTBitraverse[F] {
  222. implicit def F = F0
  223. }
  224. implicit def writerTraverse[W]: Traverse[Writer[W, *]] =
  225. new WriterTTraverse[Id, W] {
  226. implicit def F = idInstance
  227. }
  228. }
  229. sealed abstract class WriterTInstances extends WriterTInstances0 {
  230. implicit def writerTMonadListen[W, F[_]](implicit F0: Monad[F], W0: Monoid[W]): MonadListen[WriterT[W, F, *], W] =
  231. new WriterTMonadListen[F, W] {
  232. implicit def F = F0
  233. implicit def W = W0
  234. }
  235. implicit def writerTHoist[W](implicit W0: Monoid[W]): Hoist[λ[(α[_], β) => WriterT[W, α, β]]] =
  236. new WriterTHoist[W] {
  237. implicit def W = W0
  238. }
  239. implicit def writerTShow[F[_], W, A](implicit F0: Show[F[(W, A)]]): Show[WriterT[W, F, A]] =
  240. Contravariant[Show].contramap(F0)(_.run)
  241. }
  242. trait WriterTFunctions {
  243. def writerT[F[_], W, A](v: F[(W, A)]): WriterT[W, F, A] = WriterT(v)
  244. def writerTU[FAB, AB, A0, B0](fab: FAB)(implicit
  245. u1: Unapply[Functor, FAB]{type A = AB},
  246. @deprecated("scala/bug#5075", "") u2: Unapply2[Bifunctor, AB]{type A = A0; type B = B0},
  247. l: AB === (A0, B0)
  248. ): WriterT[A0, u1.M, B0] = WriterT(l.subst[u1.M](u1(fab)))
  249. def writer[W, A](v: (W, A)): Writer[W, A] =
  250. writerT[Id, W, A](v)
  251. def tell[W](w: W): Writer[W, Unit] = writer((w, ()))
  252. def put[F[_], W, A](value: F[A])(w: W)(implicit F: Functor[F]): WriterT[W, F, A] =
  253. WriterT(F.map(value)(a => (w, a)))
  254. /** Puts the written value that is produced by applying the given function into a writer transformer and associates with `value` */
  255. def putWith[F[_], W, A](value: F[A])(w: A => W)(implicit F: Functor[F]): WriterT[W, F, A] =
  256. WriterT(F.map(value)(a => (w(a), a)))
  257. }
  258. //
  259. // Type class implementation traits
  260. //
  261. import WriterT.writerT
  262. private trait WriterTDivisible[F[_], W] extends Divisible[WriterT[W, F, *]] {
  263. implicit def F: Divisible[F]
  264. override def conquer[Z]: WriterT[W, F, Z] = WriterT(F.conquer)
  265. override def divide2[A1, A2, Z](a1: => WriterT[W, F, A1], a2: => WriterT[W, F, A2])(f: Z => (A1, A2)): WriterT[W, F, Z] =
  266. WriterT(
  267. F.divide2[(W, A1), (W, A2), (W, Z)](a1.run, a2.run) ( (z: (W, Z)) =>
  268. (z._1, f(z._2)) match {
  269. case (w, (l, r)) => ((w, l), (w, r))
  270. }
  271. )
  272. )
  273. }
  274. private trait WriterTDecidable[F[_], W] extends Decidable[WriterT[W, F, *]] with WriterTDivisible[F, W] {
  275. implicit def F: Decidable[F]
  276. override def choose2[Z, A1, A2](a1: => WriterT[W, F, A1], a2: => WriterT[W, F, A2])(f: Z => A1 \/ A2): WriterT[W, F, Z] =
  277. WriterT(
  278. F.choose2[(W, Z), (W, A1), (W, A2)](a1.run, a2.run)( (z: (W, Z)) =>
  279. f(z._2).fold(l => -\/((z._1, l)), r => \/-((z._1, r)))
  280. )
  281. )
  282. }
  283. private trait WriterTPlus[F[_], W] extends Plus[WriterT[W, F, *]] {
  284. def F: Plus[F]
  285. override final def plus[A](a: WriterT[W, F, A], b: => WriterT[W, F, A]) =
  286. WriterT(F.plus(a.run, b.run))
  287. }
  288. private trait WriterTPlusEmpty[F[_], W] extends PlusEmpty[WriterT[W, F, *]] with WriterTPlus[F, W] {
  289. def F: PlusEmpty[F]
  290. override final def empty[A] = WriterT(F.empty)
  291. }
  292. private trait WriterTFunctor[F[_], W] extends Functor[WriterT[W, F, *]] {
  293. implicit def F: Functor[F]
  294. override def map[A, B](fa: WriterT[W, F, A])(f: A => B) = fa map f
  295. }
  296. private trait WriterTApply[F[_], W] extends Apply[WriterT[W, F, *]] with WriterTFunctor[F, W] {
  297. implicit def F: Apply[F]
  298. implicit def W: Semigroup[W]
  299. override def ap[A, B](fa: => WriterT[W, F, A])(f: => WriterT[W, F, A => B]) = fa ap f
  300. }
  301. private trait WriterTApplicative[F[_], W] extends Applicative[WriterT[W, F, *]] with WriterTApply[F, W] {
  302. implicit def F: Applicative[F]
  303. implicit def W: Monoid[W]
  304. def point[A](a: => A) = writerT(F.point((W.zero, a)))
  305. }
  306. private trait WriterTBind[F[_], W] extends Bind[WriterT[W, F, *]] with WriterTApply[F, W] {
  307. implicit def F: Bind[F]
  308. override final def bind[A, B](fa: WriterT[W, F, A])(f: A => WriterT[W, F, B]) = fa flatMap f
  309. }
  310. private trait WriterTBindRec[F[_], W] extends BindRec[WriterT[W, F, *]] with WriterTBind[F, W] {
  311. implicit def F: BindRec[F]
  312. implicit def A: Applicative[F]
  313. def tailrecM[A, B](a: A)(f: A => WriterT[W, F, A \/ B]): WriterT[W, F, B] = {
  314. def go(t: (W, A)): F[(W, A) \/ (W, B)] =
  315. F.map(f(t._2).run) {
  316. case (w0, e) =>
  317. val w1 = W.append(t._1, w0)
  318. e.bimap((w1, _), (w1, _))
  319. }
  320. WriterT(F.bind(f(a).run) {
  321. case (w, -\/(a0)) => F.tailrecM((w, a0))(go)
  322. case (w, \/-(b)) => A.point((w, b))
  323. })
  324. }
  325. }
  326. private trait WriterTMonad[F[_], W] extends Monad[WriterT[W, F, *]] with WriterTApplicative[F, W] with WriterTBind[F, W] {
  327. implicit def F: Monad[F]
  328. }
  329. private trait WriterTMonadPlus[F[_], W] extends MonadPlus[WriterT[W, F, *]] with WriterTMonad[F, W] with WriterTPlusEmpty[F, W] {
  330. def F: MonadPlus[F]
  331. }
  332. private trait WriterTMonadError[F[_], E, W] extends MonadError[WriterT[W, F, *], E] with WriterTMonad[F, W] {
  333. implicit def F: MonadError[F, E]
  334. override def handleError[A](fa: WriterT[W, F, A])(f: E => WriterT[W, F, A]) =
  335. WriterT[W, F, A](F.handleError(fa.run)(f(_).run))
  336. override def raiseError[A](e: E) =
  337. WriterT[W, F, A](F.raiseError[(W, A)](e))
  338. }
  339. private trait WriterTFoldable[F[_], W] extends Foldable.FromFoldr[WriterT[W, F, *]] {
  340. implicit def F: Foldable[F]
  341. override def foldRight[A, B](fa: WriterT[W, F, A], z: => B)(f: (A, => B) => B) = fa.foldRight(z)(f)
  342. }
  343. private trait WriterTTraverse[F[_], W] extends Traverse[WriterT[W, F, *]] with WriterTFoldable[F, W] {
  344. implicit def F: Traverse[F]
  345. def traverseImpl[G[_]: Applicative, A, B](fa: WriterT[W, F, A])(f: A => G[B]) = fa traverse f
  346. }
  347. private trait WriterTBifunctor[F[_]] extends Bifunctor[WriterT[*, F, *]] {
  348. implicit def F: Functor[F]
  349. override def bimap[A, B, C, D](fab: WriterT[A, F, B])(f: A => C, g: B => D) =
  350. fab.bimap(f, g)
  351. }
  352. private trait WriterTBitraverse[F[_]] extends Bitraverse[WriterT[*, F, *]] with WriterTBifunctor[F] {
  353. implicit def F: Traverse[F]
  354. def bitraverseImpl[G[_]: Applicative, A, B, C, D](fab: WriterT[A, F, B])(f: A => G[C], g: B => G[D]) =
  355. fab.bitraverse(f, g)
  356. }
  357. private trait WriterComonad[W] extends Comonad[Writer[W, *]] with WriterTFunctor[Id, W] {
  358. def copoint[A](p: Writer[W, A]): A = p.value
  359. override def cojoin[A](fa: Writer[W, A]): Writer[W, Writer[W, A]] =
  360. Writer(fa.written, fa)
  361. override def cobind[A, B](fa: Writer[W, A])(f: (Writer[W, A]) => B): Writer[W, B] =
  362. Writer(fa.written, f(fa))
  363. }
  364. private trait WriterTHoist[W] extends Hoist[λ[(α[_], β) => WriterT[W, α, β]]] {
  365. def liftM[M[_], B](mb: M[B])(implicit M: Monad[M]): WriterT[W, M, B] =
  366. WriterT(M.map(mb)((W.zero, _)))
  367. implicit def W: Monoid[W]
  368. implicit def apply[M[_]: Monad]: Monad[WriterT[W, M, *]] = WriterT.writerTMonad
  369. def hoist[M[_]: Monad, N[_]](f: M ~> N) =
  370. λ[WriterT[W, M, *] ~> WriterT[W, N, *]](_ mapT f.apply)
  371. }
  372. private trait WriterTMonadListen[F[_], W] extends MonadListen[WriterT[W, F, *], W] with WriterTMonad[F, W] {
  373. implicit def F: Monad[F]
  374. implicit def W: Monoid[W]
  375. def writer[A](w: W, v: A): WriterT[W, F, A] = WriterT.writerT(F.point((w, v)))
  376. def listen[A](fa: WriterT[W, F, A]): WriterT[W, F, (A, W)] =
  377. WriterT(F.map(fa.run){ case (w, a) => (w, (a, w)) })
  378. }