Xu Bin goseign

Shared State in pure Functional Programming

Newcomers to Functional Programming are often very confused about the proper way to share state without breaking purity and end up having a mix of pure and impure code that defeats the purpose of having pure FP code in the first place.

Reason why I decided to write up a beginner friendly guide :)

Use Case

We have a program that runs three computations at the same time and updates the internal state to keep track of the

Cats-Effect 3 Guide to Migration Guides

Cats-Effect 3 Migration Links

Scala Fix: https://github.com/typelevel/cats-effect/blob/d9285906a0b8f3c1b902549cae2781ebc4b90ee7/scalafix/README.md
Migration Guide proposal (https://github.com/typelevel/cats-effect/pull/1687/files)
Migration Guide hosted version since it's still in PR ( https://cats-effect-mig.netlify.app/cats-effect/docs/migration-guide)

Typelevel Library Versions latest on CE3

Tpolecat Ecosystem version table (https://gist.github.com/tpolecat/05d38226f0856d8fc02f0c560a76c69a)
Http4s version table (https://http4s.org/versions/)

Fibers

Fibers are an abstraction over sequential computation, similar to threads but at a higher level. There are two ways to think about this model: by example, and abstractly from first principles. We'll start with the example.

(credit here is very much due to Fabio Labella, who's incredible Scala World talk describes these ideas far better than I can)

Callback Sequentialization

Consider the following three functions

	import spray.json.{DefaultJsonProtocol, JsBoolean, JsObject, JsString, JsValue, RootJsonFormat}

	case class Document(field1: String, field2: String, field3: String, field4: String, field5: String, field6: String,
	field7: String, field8: String, field9: String, field10: String, field11: String, field12: String,
	field13: String, field14: String, field15: String, field16: String, field17: String, field18: String,
	field19: String, field20: String, field21: String, field22: String, field23: String, field24: String,
	approved: Boolean)

	object DocumentProtocol extends DefaultJsonProtocol {

	type Callback<A> = (a: A) => void;

	/**
	* Delays stuff for ensuring fairness.
	*/
	export function yieldRunLoop(): Promise<void> {
	const fn: (cb: (() => void)) => void = typeof setImmediate !== 'undefined'
	? setImmediate
	: cb => setTimeout(cb, 0)
	return new Promise(fn)

	import zio._
	import zio.console._
	import zio.duration.Duration
	import scala.util.Random
	import java.util.concurrent.TimeUnit

	object Main extends App {

	override def run(args: List[String]): ZIO[Main.Environment, Nothing, Int] = program.fold(_ => 1, _ => 0)

	package com.softwaremill.monadvalidation.lib

	import cats.Monad
	import cats.data.EitherT

	import scala.language.higherKinds

	trait ValidationResultLib[M[_]] {

	type ValidationResult[F, S] = EitherT[M, F, S]

	import akka.actor.{ActorSystem, Scheduler}
	import com.astoncap.util.concurrent.Async._

	import scala.concurrent.{ExecutionContext, Future, Promise}
	import scala.concurrent.duration.{Duration, FiniteDuration}
	import scala.util.Try

	trait Scheduling {

	implicit val scheduling: Scheduling = this

	package eventsourcing

	import java.time.Instant

	import cats._
	import cats.data.Coproduct
	import cats.free.{Free, Inject}
	import cats.implicits._
	import doobie.imports._
	import fs2.Stream

	final case class User private[domain] (userId: UserId, createdAt: Instant, name: String, email: Email) {

	def applyEvent(userEvent: UserEvent): Try[User] = userEvent match {
	case _: UserCreated => Failure(new IllegalStateException("User already created. Event cannot be applied."))
	case event: NameUpdated => Success(copy(name = event.newName))
	case event: EmailUpdated => Success(copy(email = event.newEmail))
	}

	def process(userCommand: UserCommand): Try[List[UserEvent]] = userCommand match {
	case _: CreateUser => Failure(new IllegalStateException("User already created. Command cannot be processed."))