Streams for (Co)Free!
5 likes2,157 views
The document discusses the concepts of streams, coinduction, and cofree structures in functional programming, highlighting their applications such as data processing and user interfaces. It outlines the differences between inductive and coinductive processes, provides formulas and methods for cofree structures, and briefly presents laws for clean functional code. Additionally, it emphasizes the role of streams in programming languages and presents examples of cofree structures in use.
![Cofree
Huh?
// For Functor `F`
final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]])](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-16-320.jpg)
![Cofree:Take 1Cofree[F,A] isacoinductive process
thatgenerates A's using effect F.](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-17-320.jpg)
![Cofree:Take 2Cofree[F,A] isacurrentposition A ona
landscapethatrequires effect Fto
movetoanewposition.](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-18-320.jpg)
![Cofree
Comonad Methods
» Where am I? def extract(f: Cofree[F, A]): A
» Terraform! def extend(f: Cofree[F, A] => B):
Cofree[F, B]
» Plus Functor!](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-19-320.jpg)
![Cofree
Fibs
final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]])
// final case class Name[A](run: => A)
val fibs: Cofree[Name, Int] = {
def unfold(prev1: Int, prev2: Int): Cofree[Name, Int] =
Cofree(prev1 + prev2, Name(unfold(prev2, prev1 + prev2)))
unfold(0, 1)
}](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-20-320.jpg)
![Cofree
Append
def append[F[_]: ApplicativePlus, A](c1: Cofree[F, A], c2: Cofree[F, A]): Cofree[F, A] =
Cofree(c1.head, c1.tail.map(t => append(t, c2)) <+> c2.point[F])](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-21-320.jpg)
![Cofree
Collect/Disperse
def collect[F[_]: MonadPlus, A](c: Cofree[F, A]): F[Vector[A]] = {
val singleton = Vector[A](c.head).point[F]
(singleton |@| c.tail.flatMap(collect(_)))(_ ++ _) <+> singleton
}
def disperse[F[_]: ApplicativePlus, A](seq: Seq[A]): Option[Cofree[F, A]] =
seq.foldRight[Option[Cofree[F, A]]](None) {
case (a, None) => Some(Cofree(a, mempty[F, Cofree[F, A]]))
case (a, Some(tail)) => Some(Cofree(a, tail.point[F]))
}](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-22-320.jpg)
![Cofree
Zip
def zipWith[F[_]: Zip: Functor, A, B, C](
c1: Cofree[F, A], c2: Cofree[F, B])(
f: (A, B) => C): Cofree[F, C] =
Cofree(
f(c1.head, c2.head),
Zip[F].zipWith(c1.tail, c2.tail)(zipWith(_, _)(f)))](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-23-320.jpg)
![Cofree
Scan
def scan[F[_]: Functor, A, S](
c: Cofree[F, A])(s: S)(f: (S, A) => S): Cofree[F, S] = {
val s2 = f(s, c.head)
Cofree(s2, c.tail.map(scan(_)(s2)(f)))
}](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-24-320.jpg)
![Cofree
Filter
def zeros[F[_]: Functor, A: Monoid](c: Cofree[F, A])(p: A => Boolean): Cofree[F, A] =
if (p(c.head)) Cofree(c.head, c.tail.map(zeros(_)(p)))
else Cofree(mzero[A], c.tail.map(zeros(_)(p)))
def filter[F[_]: Monad, A](c: Cofree[F, A])(p: A => Boolean): F[Cofree[F, A]] =
if (p(c.head)) Cofree(c.head, c.tail.flatMap(filter(_)(p))).point[F]
else c.tail.flatMap(filter(_)(p))](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-25-320.jpg)
![Cofree
Pipes:Types
// final case class Kleisli[F[_], A, B](run: A => F[B])
type Pipe[F[_], A, B] = Cofree[Kleisli[F, A, ?], B]
type Source[F[_], A] = Pipe[F, Unit, A]
type Sink[F[_], A] = Pipe[F, A, Unit]](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-26-320.jpg)
![Cofree
Pipes: Utilities
def pipe[F[_]: Applicative, A, B, C](from: Pipe[F, A, B], to: Pipe[F, B, C]): Pipe[F, A, C] =
Cofree[Kleisli[F, A, ?], C](
to.head,
Kleisli(a => (from.tail.run(a) |@| to.tail.run(from.head))(pipe(_, _))))
// e.g. Unit
def runPipe[F[_]: Monad, A: Monoid](pipe: Pipe[F, A, A]): F[A] =
(pipe.head.point[F] |@| pipe.tail.run(mzero[A]).flatMap(runPipe(_)))(_ |+| _)](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-27-320.jpg)
![Cofree
IO, Byte Streams, Etc.
type IOPipe[A, B] = Pipe[Task, A, B]
...
type BytePipe = IOPipe[Array[Byte], Array[Byte]]](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-28-320.jpg)
![Cofree
Merging:Types
type Select[F[_], A] = Coproduct[F, F, A]
type Merge[F[_], A, B] = Pipe[Select[F, ?], A, B]](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-29-320.jpg)
![Cofree
Merging: Function
def merge[F[_]: Applicative, A, B](left: Source[F, A], right: Source[F, A])
(s: Select[Id, Merge[F, A, B]]): Source[F, B] = {
def embed[F[_]: Functor, A](s: Select[F, A]): F[Select[Id, A]] = s.run match {
case -/ (fa) => fa.map(a => Coproduct[Id, Id, A](a.left [A]))
case /-(fa) => fa.map(a => Coproduct[Id, Id, A](a.right[A]))
}
def step(y: Merge[F, A, B], fs: F[Source[F, B]]): Source[F, B] =
Cofree[Kleisli[F, Unit, ?], B](y.head, Kleisli(_ => fs))
s.run match {
case -/ (y) =>
step(y,
(left.tail.run(()) |@| embed(y.tail.run(left.head)))(
(left, y) => merge(left, right)(y)))
case /-(y) =>
step(y,
(right.tail.run(()) |@| embed(y.tail.run(right.head)))(
(right, y) => merge(left, right)(y)))
}
}](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-30-320.jpg)
![Cofree
Forking
def fork[F[_]: Applicative, A](left: Sink[F, A], right: Sink[F, A]): Sink[F, A] =
Cofree[Kleisli[F, A, ?], Unit]((),
Kleisli(a => (left.tail.run(a) |@| right.tail.run(a))(fork(_, _))))](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-31-320.jpg)
![Cofree
Machines
case class Instr[F[_], A](
goLeft: F[A],
goRight: F[A],
goUp: F[A],
goDown: F[A])
// Cofree[Instr[F, ?], A]
def productWith[F[_]: Functor, G[_]: Functor, A, B, C](
c1: Cofree[F, A], c2: Cofree[G, B])(
f: (A, B) => C): Cofree[Product[F, G, ?], C] =
Cofree[Product[F, G, ?], C](f(c1.head, c2.head),
Product((c1.tail.map(productWith(_, c2)(f)),
c2.tail.map(productWith(c1, _)(f)))))](https://image.slidesharecdn.com/presentation-161111214240/85/Streams-for-Co-Free-32-320.jpg)
Streams for (Co)Free!
- 1. Streams for (Co)Free!JohnA. De Goes — @jdegoes
- 2. Agenda » Induction/Coinduction » Universality of Streams » Cofree: A Principled Stream » Challenge
- 3. InductionTear downastructureto culminate in aterminalvalue.
- 4. Inductive Programs Examples » Parse a config file » Sort a list » Send an HTTP response » Compute the millionth digit of pi
- 6. CoinductionStartfroman initialvalueto build up an infinite structure.
- 7. Coinductive Processes Examples » Produce the next state of the UI given a user- input » Produce current state of config given update to config » Transform stream of requests to responses » Produce (all) the digits of pi
- 9. ByAnyOther Name Astream isamainstream example ofacoinductive process. » Data processing » Web servers » User-interfaces » Discrete "FRP" » So much more...
- 10. Streams ✓ Stateful ✓ Incremental computation ✓ Non-termination ✓ Consume & Emit
- 11. Streams Choices, Choices » Akka Streams » Java Streams » Scalaz-Streams » FS2 » Big Data: Spark, Flink, Pachyderm, Kafka, ad infinitum...
- 12. John's Laws ofClean FunctionalCode 1.Reasonability is directly proportional to totality & referential-transparency. 2.Composability is inversely proportional to number of data types. 3.Obfuscation is directly proportional to number of lawless interfaces. 4.Correctness is directly proportional to degree of polymorphism. 5.Shoddiness is directly proportional to encapsulation. 6.Volume is inversely proportional to orthogonality.
- 13. AkkaStream akka.stream AbruptTerminationException AbstractShape ActorAttributes ActorMaterializer ActorMaterializerSettings AmorphousShape Attributes BidiShape BindFailedException BufferOverflowException Client ClosedShape ConnectionException DelayOverflowStrategy EagerClose FanInShape FanInShape10 FanInShape11 FanInShape12 FanInShape13 FanInShape14 FanInShape15 FanInShape16 FanInShape17 FanInShape18 FanInShape19 FanInShape1N FanInShape2 FanInShape20 FanInShape21 FanInShape22 FanInShape3 FanInShape4 FanInShape5 FanInShape6 FanInShape7 FanInShape8 FanInShape9 FanOutShape FanOutShape10 FanOutShape11 FanOutShape12 FanOutShape13 FanOutShape14 FanOutShape15 FanOutShape16 FanOutShape17 FanOutShape18 FanOutShape19 FanOutShape2 FanOutShape20 FanOutShape21 FanOutShape22 FanOutShape3 FanOutShape4 FanOutShape5 FanOutShape6 FanOutShape7 FanOutShape8 FanOutShape9 FlowMonitor FlowMonitorState FlowShape Fusing Graph IgnoreBoth IgnoreCancel IgnoreComplete Inlet InPort IOResult KillSwitch KillSwitches MaterializationContext MaterializationException Materializer MaterializerLoggingProvider Outlet OutPort OverflowStrategy QueueOfferResult RateExceededException Server Shape SharedKillSwitch SinkShape SourceShape StreamLimitReachedException StreamSubscriptionTimeoutSettings StreamSubscriptionTimeoutTerminationMode StreamTcpException SubstreamCancelStrategy Supervision ThrottleMode TLSClientAuth TLSClosing TLSProtocol TLSRole UniformFanInShape UniformFanOutShape UniqueKillSwitch
- 14. WhatCan Save Us?!? John's Laws ofClean FunctionalCode 1.Reasonability is directly proportional to totality & referential-transparency. 2.Composability is inversely proportional to number of data types. 3.Obfuscation is directly proportional to number of lawless interfaces. 4.Correctness is directly proportional to degree of polymorphism. 5.Shoddiness is directly proportional to encapsulation. 6.Volume is inversely proportional to orthogonality.
- 15. CofreeALLTHE POWER OFFREE, NOWWITH STREAMING!!!
- 16. Cofree Huh? // For Functor `F` final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]])
- 17. Cofree:Take 1Cofree[F,A] isacoinductive process thatgenerates A's using effect F.
- 18. Cofree:Take 2Cofree[F,A] isacurrentposition A ona landscapethatrequires effect Fto movetoanewposition.
- 19. Cofree Comonad Methods » Where am I? def extract(f: Cofree[F, A]): A » Terraform! def extend(f: Cofree[F, A] => B): Cofree[F, B] » Plus Functor!
- 20. Cofree Fibs final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]]) // final case class Name[A](run: => A) val fibs: Cofree[Name, Int] = { def unfold(prev1: Int, prev2: Int): Cofree[Name, Int] = Cofree(prev1 + prev2, Name(unfold(prev2, prev1 + prev2))) unfold(0, 1) }
- 21. Cofree Append def append[F[_]: ApplicativePlus, A](c1: Cofree[F, A], c2: Cofree[F, A]): Cofree[F, A] = Cofree(c1.head, c1.tail.map(t => append(t, c2)) <+> c2.point[F])
- 22. Cofree Collect/Disperse def collect[F[_]: MonadPlus, A](c: Cofree[F, A]): F[Vector[A]] = { val singleton = Vector[A](c.head).point[F] (singleton |@| c.tail.flatMap(collect(_)))(_ ++ _) <+> singleton } def disperse[F[_]: ApplicativePlus, A](seq: Seq[A]): Option[Cofree[F, A]] = seq.foldRight[Option[Cofree[F, A]]](None) { case (a, None) => Some(Cofree(a, mempty[F, Cofree[F, A]])) case (a, Some(tail)) => Some(Cofree(a, tail.point[F])) }
- 23. Cofree Zip def zipWith[F[_]: Zip: Functor, A, B, C]( c1: Cofree[F, A], c2: Cofree[F, B])( f: (A, B) => C): Cofree[F, C] = Cofree( f(c1.head, c2.head), Zip[F].zipWith(c1.tail, c2.tail)(zipWith(_, _)(f)))
- 24. Cofree Scan def scan[F[_]: Functor, A, S]( c: Cofree[F, A])(s: S)(f: (S, A) => S): Cofree[F, S] = { val s2 = f(s, c.head) Cofree(s2, c.tail.map(scan(_)(s2)(f))) }
- 25. Cofree Filter def zeros[F[_]: Functor, A: Monoid](c: Cofree[F, A])(p: A => Boolean): Cofree[F, A] = if (p(c.head)) Cofree(c.head, c.tail.map(zeros(_)(p))) else Cofree(mzero[A], c.tail.map(zeros(_)(p))) def filter[F[_]: Monad, A](c: Cofree[F, A])(p: A => Boolean): F[Cofree[F, A]] = if (p(c.head)) Cofree(c.head, c.tail.flatMap(filter(_)(p))).point[F] else c.tail.flatMap(filter(_)(p))
- 26. Cofree Pipes:Types // final case class Kleisli[F[_], A, B](run: A => F[B]) type Pipe[F[_], A, B] = Cofree[Kleisli[F, A, ?], B] type Source[F[_], A] = Pipe[F, Unit, A] type Sink[F[_], A] = Pipe[F, A, Unit]
- 27. Cofree Pipes: Utilities def pipe[F[_]: Applicative, A, B, C](from: Pipe[F, A, B], to: Pipe[F, B, C]): Pipe[F, A, C] = Cofree[Kleisli[F, A, ?], C]( to.head, Kleisli(a => (from.tail.run(a) |@| to.tail.run(from.head))(pipe(_, _)))) // e.g. Unit def runPipe[F[_]: Monad, A: Monoid](pipe: Pipe[F, A, A]): F[A] = (pipe.head.point[F] |@| pipe.tail.run(mzero[A]).flatMap(runPipe(_)))(_ |+| _)
- 28. Cofree IO, Byte Streams, Etc. type IOPipe[A, B] = Pipe[Task, A, B] ... type BytePipe = IOPipe[Array[Byte], Array[Byte]]
- 29. Cofree Merging:Types type Select[F[_], A] = Coproduct[F, F, A] type Merge[F[_], A, B] = Pipe[Select[F, ?], A, B]
- 30. Cofree Merging: Function def merge[F[_]: Applicative, A, B](left: Source[F, A], right: Source[F, A]) (s: Select[Id, Merge[F, A, B]]): Source[F, B] = { def embed[F[_]: Functor, A](s: Select[F, A]): F[Select[Id, A]] = s.run match { case -/ (fa) => fa.map(a => Coproduct[Id, Id, A](a.left [A])) case /-(fa) => fa.map(a => Coproduct[Id, Id, A](a.right[A])) } def step(y: Merge[F, A, B], fs: F[Source[F, B]]): Source[F, B] = Cofree[Kleisli[F, Unit, ?], B](y.head, Kleisli(_ => fs)) s.run match { case -/ (y) => step(y, (left.tail.run(()) |@| embed(y.tail.run(left.head)))( (left, y) => merge(left, right)(y))) case /-(y) => step(y, (right.tail.run(()) |@| embed(y.tail.run(right.head)))( (right, y) => merge(left, right)(y))) } }
- 31. Cofree Forking def fork[F[_]: Applicative, A](left: Sink[F, A], right: Sink[F, A]): Sink[F, A] = Cofree[Kleisli[F, A, ?], Unit]((), Kleisli(a => (left.tail.run(a) |@| right.tail.run(a))(fork(_, _))))
- 32. Cofree Machines case class Instr[F[_], A]( goLeft: F[A], goRight: F[A], goUp: F[A], goDown: F[A]) // Cofree[Instr[F, ?], A] def productWith[F[_]: Functor, G[_]: Functor, A, B, C]( c1: Cofree[F, A], c2: Cofree[G, B])( f: (A, B) => C): Cofree[Product[F, G, ?], C] = Cofree[Product[F, G, ?], C](f(c1.head, c2.head), Product((c1.tail.map(productWith(_, c2)(f)), c2.tail.map(productWith(c1, _)(f)))))
- 34. ChallengeGo Do SomethingThat'sATinyBit Simpler...ABitMore Functional...