Category theory is general abolute nonsens

General nonsense (math.)
Abstract nonsense
From Wikipedia, the free encyclopedia
In mathematics, abstract nonsense, general abstract nonsense, and general nonsense are terms used facetiously by
some mathematicians to describe certain kinds of arguments and methods related to category theory. (Very) roughly
speaking, category theory is the study of the general form of mathematical theories, without regard to their content. As a
result, a proof that relies on category theoretic ideas often seems slightly out of context to those who are not used to such
abstraction, sometimes to the extent that it resembles a comicalnon sequitur. Such proofs are sometimes dubbed “abstract
nonsense” as a light-hearted way of alerting people to their abstract nature.

Category theory is absolute
general nonsense!
What is all the fuss with all those monoids
and semigroups I keep hearing about?

“Functional Programming is academic
phenomenon. Unless your product is purely
mathematical, it’s nothing but a nice idea that
has nothing to do with real world”

Why not FP?
● FP might be good nice academic exercise, but ..

Why not FP?
● .. has nothing to do with real world

Why not FP?
● The last three decades proved that OO-programming is
useful & necessary

Why not FP?
useful & necessary
● OO has some inconveniences, but it is a de facto standard

Why not FP?
useful & necessary
● OO has some inconveniences, but it is a de facto standard
● FP is complex, I don’t understand it, I doubt it will be
applicable to real world, ever!

Edsger Dijkstra
ˈɛtsxər ˈdɛɪkstra

Edsger Dijkstra
ˈɛtsxər ˈdɛɪkstra
https://en.wikipedia.org/wiki/Edsger_W._Dijkstra

https://xkcd.com/292/

This paper tries to convince us that the well-known goto statement
should be eliminated from our programming languages or, at least (since
I don’t think that it will ever be eliminated), that programmers should
not use it. (...)

not use it. (...) The author is a proponent of the socalled “structured
programming” style, in which, if I get it right, gotos are replaced by
indentation.

indentation. Structured programming is a nice academic exercise, which
works well for small examples, but I doubt that any real-world program
will ever be written in such a style.

will ever be written in such a style. More than 10 years of industrial
experience with Fortran have proved conclusively to everybody
concerned that, in the real world, the goto is useful and necessary:

concerned that, in the real world, the goto is useful and necessary: its
presence might cause some inconveniences in debugging, but it is a de
facto standard and we must live with it.

concerned that, in the real world, the goto is useful and necessary: its
presence might cause some inconveniences in debugging, but it is a de
facto standard and we must live with it. It will take more than the
academic elucubrations of a purist to remove it from our languages. (...)

“Semigroup, monoid, typeclass…
It sounds so abstract”

“Semigroup, monoid, typeclass…
It sounds so abstract”
“Yes, but so do all OO-patterns!”

“The Story of
a Blackout”
In 5 acts

Our goal:
● DRY principle
● Separation of concerns
● Epic decoupling
● Clean API
● Minimal Boilerplate

503 Service Temporarily Unavailable
nginx

The 5 Stages of Loss and Grief

1. Denial

1. Denial
2. Anger

1. Denial
2. Anger
3. Bargaining

1. Denial
2. Anger
3. Bargaining
4. Depression

1. Denial
2. Anger
3. Bargaining
4. Depression
5. Acceptance

Domain & Feature Requests
Domain:
● Users place Orders in the auction system
Order

Domain:
● Orders can be:
○ General - contain list of Products
○ Complex - combined from two or more
other Orders
○ Cancelled - used to be fully fledged
Orders, but now are cancelled
Order
General Complex Cancelled

Domain:
● Orders can be:
○ General - contain list of Products
○ Complex - combined from two or more
other Orders
○ Cancelled - used to be fully fledged
Orders, but now are cancelled
● Products can be:
○ Basic - id & price
○ Discounted - wrapped Product &
discount
○ OutOfStock - used to be in warehouse, but
now gone (sorry)
Order
General Complex Cancelled
Product
Basic Discounter
Out of
Stock

Feature Requests:
● Present current state of orders (JSON)
● Calculate final checkout
● Calculate average Order price
● “Simplify” Orders

sealed trait Order
case class GeneralOrder(products: List[Product]) extends Order
case object CancelledOrder extends Order
case class ComplexOrder(orders: List[Order]) extends Order
sealed trait Product
case class BasicProduct(id: Int, price: BigDecimal) extends Product
case class DiscountedProduct(product: Product,
discount: Double) extends Product
case object OutOfStock extends Product

test("should evaluate order") {
val o1 = GeneralOrder(BasicProduct(10, BigDecimal("10.2")) :: Nil)
val o2 = GeneralOrder(DiscountedProduct(
product = BasicProduct(11, BigDecimal("1")),
discount = 0.2) :: Nil)
val o3 = CancelledOrder
val order = ComplexOrder(o1 :: o2 :: o3 :: Nil)
order.evaluate should equal (BigDecimal("11.0"))
}

}
[error] OrderTest.scala evaluate is not a member of jw.ComplexOrder
[error] order.evaluate should equal (BigDecimal("11.0"))
[error] ^
[error] one error found

trait Evaluatable[T] { def evaluate: T }
sealed trait Order extends Evaluatable[BigDecimal]
case object CancelledOrder extends Order {
def evaluate: BigDecimal = BigDecimal("0.0")
}
case class ComplexOrder(orders: List[Order]) extends Order {
def evaluate: BigDecimal = orders.foldLeft(BigDecimal("0.0")) {
case (acc, o) => acc + o.evaluate
}
}
case class GeneralOrder(products: List[Product]) extends Order {
def evaluate: BigDecimal = products.foldLeft(BigDecimal("0.0")) {
case (acc, p) => acc + p.evaluate
}
}

trait Evaluatable[T] { def evaluate: T }
sealed trait Product extends Evaluatable[BigDecimal]
case class BasicProduct(id: Int, price: BigDecimal) extends Product {
def evaluate: BigDecimal = price
}
case class DiscountedProduct(product: Product, discount: Double) extends Product {
def evaluate: BigDecimal = product.evaluate * (1 - discount)
}
case object OutOfStock extends Product {
}

}
[info] OrderTest:
[info] - should evaluate order

test("should calculate average") {
val o1 = GeneralOrder(DiscountedProduct(product =
BasicProduct(11, BigDecimal("1")), discount = 0.2) :: Nil)
val o2 = GeneralOrder(BasicProduct(10, BigDecimal("4")) :: Nil)
Order.average(o1 :: o2 :: o3 :: Nil) should equal(BigDecimal("5.0"))
}

}
[error] OrderTest.scala average is not a member of jw.Order
[error] Order.average should equal (BigDecimal("5.0"))
[error] ^
[error] one error found

object Stat {
def mean(xs: Seq[BigDecimal]): BigDecimal =
xs.reduce(_ + _) / xs.size
}

object Order {
def average(orders: Seq[Order]): BigDecimal =
Stat.mean(orders.map(_.evaluate))
}
object Stat {
}

AWESOME!
I just need it to work for
Doubles and Ints as
well! Can you make it
more generic?

object Stat {
def mean(xs: Seq[Number]): Number =
}

trait Number[A] {
def value: A
def +(other: Number[A]): Number[A]
def /(other: Number[A]): Number[A]
def /(other: Int): Number[A]
}

trait Number[A] {
def value: A
}
case class BigDecimalNumber(value: BigDecimal) extends Number[BigDecimal] {
def +(other: Number[BigDecimal]) = BigDecimalNumber(value + other.value)
def /(other: Number[BigDecimal]) = BigDecimalNumber(value / other.value)
def /(other: Int) = BigDecimalNumber(value / other)
}

trait Number[A] {
def value: A
}
}
case class IntNumber(value: Int) extends Number[Int] {
def +(other: Number[Int]) = IntNumber(value + other.value)
def /(other: Number[Int]) = IntNumber(value / other.value)
def /(other: Int) = IntNumber(value / other)
}

trait Number[A] {
def value: A
}
}
case class IntNumber(value: Int) extends Number[Int] {
def +(other: Number[Int]) = IntNumber(value + other.value)
def /(other: Number[Int]) = IntNumber(value / other.value)
def /(other: Int) = IntNumber(value / other)
}
case class DoubleNumber(value: Double) extends Number[Double] {
def +(other: Number[Double]) = DoubleNumber(value + other.value)
def /(other: Number[Double]) = DoubleNumber(value / other.value)
def /(other: Int) = DoubleNumber(value / other)
}

object Stat {
}
object Order {
}

object Stat {
def mean[A](xs: Seq[Number[A]]): Number[A] =
}
object Order {
Stat.mean(orders.map(o => BigDecimalNumber(o.evaluate))).value
}

}
[info] OrderTest:
[info] - should calculate average

test("should serialize to json") {
val order = ComplexOrder(o1 :: o2 :: Nil)
val expectedJson = """{
"type: "complex"",
"orders: [{
"type: "general"",
"products: [{"type: "basic"", "id: 10", "price: 10.2"}]"
},
"cancelled order"]"
}"""
JsonSerializer.write(order) should equal(expectedJson)
}

"type: "complex"",
"orders: [{
"type: "general"",
},
"cancelled order"]"
}"""
}
[error] OrderTest.scala not found: value JsonSerializer
[error] JsonSerializer.write(order) should equal(expectedJson)
[error] ^

object JsonSerializer {
def write(order: Order): String = ...
}

I have few objects I also need to
serialize to JSON. Can you make
your code a bit more generic?
Thanks!!!

def write(sth: ???): String = ...
}

def write(serializable: JsonSerializable) = ...
}

def write(serializable: JsonSerializable) = ...
}
trait JsonSerializable {
def toJson: JsonValue
}

def write(serializable: JsonSerializable) =
JsonWriter.write(serializable.toJson)
}
}

sealed trait JsonValue
case class JsonObject(elem: Map[String, JsonValue]) extends JsonValue
case class JsonArray(elems: List[JsonValue]) extends JsonValue
case class JsonString(value: String) extends JsonValue
case class JsonNumber(value: BigDecimal) extends JsonValue

object JsonWriter {
def write(json: JsonValue): String =

object JsonWriter {
def write(json: JsonValue): String = json match {

object JsonWriter {
case JsonNumber(value) => value.toString
}
}

object JsonWriter {
case JsonString(value) => s""""$value""""
}
}

object JsonWriter {
case JsonArray(elems) => "[" + elems.map(write).mkString(", ") + "]"
}
}

object JsonWriter {
case JsonObject(elems) =>
val entries = for {
(key, value) <- elems
} yield s""""$key: ${write(value)}""""
"{" + entries.mkString(", ") + "}"
case JsonArray(elems) => "[" + elems.map(write).mkString(", ") + "]"
}
}

object JsonWriter {
def write(json: JsonValue): String = ...
}

object JsonWriter {
def write(json: JsonValue): String = ...
}
}
}

sealed trait Order extends Evaluatable[BigDecimal] with JsonSerializable {
def evaluate: BigDecimal
}

}
}
def toJson: JsonValue = JsonObject(Map(
"type" -> JsonString("general"),
"products" -> JsonArray(products.map(_.toJson))
))
}

}
case object CancelledOrder extends Order {
def toJson: JsonValue = JsonString("cancelled order")
}

}
}
override def toJson: JsonValue = JsonObject(Map(
"type" -> JsonString("complex"),
"orders" -> JsonArray(orders.map(_.toJson)))
)
}

sealed trait Product extends Evaluatable[BigDecimal] with JsonSerializable {
}
"type" -> JsonString("basic"),
"id" -> JsonNumber(BigDecimal(id)),
"price" -> JsonNumber(price)
))
}

}
"type" -> JsonString("discounted"),
"product" -> product.toJson,
"discount" -> JsonNumber(discount)
))
}

}
case object OutOfStock extends Product {
def toJson: JsonValue = JsonString("out of stock")
}

"type: "complex"",
"orders: [{
"type: "general"",
},
"cancelled order"]"
}"""
}
[info] OrderTest:
[info] - should serialize to json

Act.3: “Re-inventing the
Wheel”

object Order {
Stat.mean(orders.map(o => BigDecimalNumber(o.evaluate))).value
}

object Order {
}

object Stat {
def mean[A](xs: Seq[Number[A]]): Number[A] =
}
object Order {
}

object Stat {
def mean[A](xs: Seq[A]): A =
}
object Order {
}

object Stat {
def mean[A](xs: Seq[A])(implicit number: Number[A]): A =
number.divide(xs.reduce(number.plus),xs.size)
}
object Order {
}

trait Number[A] {
def plus(n1: A, n2: A): A
def divide(n1: A, n2: A): A
def divide(n1: A, n2: Int): A
}

trait Number[A] {
}
object Number {
implicit object BigDecimalNumber extends Number[BigDecimal] {
def plus(n1: BigDecimal, n2: BigDecimal): BigDecimal = n1 + n2
def divide(n1: BigDecimal, n2: BigDecimal): BigDecimal = n1 / n2
def divide(n1: BigDecimal, n2: Int): BigDecimal = n1 / n2
}

trait Number[A] {
}
object Number {
implicit object BigDecimalNumber extends Number[BigDecimal] {
def plus(n1: BigDecimal, n2: BigDecimal): BigDecimal = n1 + n2
def divide(n1: BigDecimal, n2: BigDecimal): BigDecimal = n1 / n2
def divide(n1: BigDecimal, n2: Int): BigDecimal = n1 / n2
}
implicit object IntNumber extends Number[Int] {
def plus(n1: Int, n2: Int): Int = n1 + n2
def divide(n1: Int, n2: Int): Int = n1 / n2
}
}

object Stat {
number.divide(xs.reduce(number.plus),xs.size)
}
object Order {
def average(orders: Seq[Order])(BigDecimalNumber): BigDecimal =
}

implicit class NumberOps[A](a: A)(implicit number: Number[A]) {
def +(other: A) = number.plus(a, other)
def /(other: A) = number.divide(a, other)
def /(other: Int) = number.divide(a, other)
}
}

object Stat {
xs.reduce(number.plus) / xs.size
}
object Order {
}

object Stat {
}
object Order {
}

[info] OrderTest:

sealed trait Order extends Evaluatable[BigDecimal] with JsonSerializable
}
"products" -> JsonArray(products.map(_.toJson))
))
}

}
}

trait Json[-A] {
def toJson(a: A): JsonValue
}
}

trait Json[-A] {
def toJson(a: A): JsonValue
}
def write[A](a: A)(implicit json: Json[A]) =
JsonWriter.write(json.toJson(a))
}

object OrderJson {
implicit object ProductToJson extends Json[Product] {
def toJson(product: Product): JsonValue = ...
}
implicit object OrderToJson extends Json[Order] {
def toJson(order: Order): JsonValue = ...
}
}

implicit object ProductToJson extends Json[Product] {
def toJson(product: Product): JsonValue = product match {
case BasicProduct(id, price) =>
JsonObject(Map(
"type" -> JsonString("basic"),
"id" -> JsonNumber(BigDecimal(id)),
"price" -> JsonNumber(price)
))
case DiscountedProduct(product, discount) =>
JsonObject(Map(
"type" -> JsonString("discounted"),
"product" -> toJson(product),
"discount" -> JsonNumber(discount)
))
case OutOfStock() =>
JsonString("out of stock")
}
}

implicit object OrderToJson extends Json[Order] {
def toJson(order: Order): JsonValue = order match {
case GeneralOrder(products) =>
JsonObject(Map(
"products" -> JsonArray(products.map(ProductToJson.toJson))
))
case ComplexOrder(orders) =>
JsonObject(Map(
"type" -> JsonString("complex"),
"orders" -> JsonArray(orders.map(toJson))
))
case CancelledOrder() =>
JsonString("cancelled order")
}
}

"type: "complex"",
"orders: [{
"type: "general"",
},
"cancelled order"]"
}"""
}
[error] OrderTest.scala could not find implicit value for parameter json: json.Json[jw.
ComplexOrder]
[error] JsonSerializer.write(order) should equal(expectedJson)

"type: "complex"",
"orders: [{
"type: "general"",
},
"cancelled order"]"
}"""
import OrderJson._
}
[info] OrderTest:

sealed trait Product extends Evaluatable[BigDecimal]
}
}
case class OutOfStock() extends Product {
}

sealed trait Order extends Evaluatable[BigDecimal]
}
}
case class CancelledOrder() extends Order {
}
}

trait Evaluate[-A, T] { def evaluate(a: A): T }
object Order {
implicit object ProductEvaluate extends Evaluate[Product, BigDecimal] {
def evaluate(product: Product): BigDecimal = product match {
case BasicProduct(id, price) => price
case DiscountedProduct(discounted, discount) => evaluate(discounted) * (1 - discount)
case OutOfStock() => BigDecimal("0.0")
}}
implicit object OrderEvaluate extends Evaluate[Order, BigDecimal] {
def evaluate(order: Order): BigDecimal = order match {
case GeneralOrder(products) => products.foldLeft(BigDecimal("0.0")) {
case (acc, p) => acc + ProductEvaluate.evaluate(p)
}
case ComplexOrder(orders) => orders.foldLeft(BigDecimal("0.0")) {
case (acc, o) => acc + evaluate(o)
}
case CancelledOrder() => BigDecimal("0.0")
}}}

trait Evaluate[-A, T] { def evaluate(a: A): T }
object Evaluate {
implicit class EvaluateOps[-A, T](a: A)(implicit ev: Evaluate[A, T]) {
def evaluate = ev.evaluate(a)
}
}
import Evaluate._

def simplify(orders: Seq[Order]): Order =
orders.foldLeft(CancelledOrder()) { ?? }

orders.foldLeft(CancelledOrder()) {
case (acc, o) => acc + o
}

}
trait Addable[A] {
def add(a1: A, a2: A): A
}

}
trait Addable[A] {
}
implicit object OrderAddable extends Addable[Order] {
def add(o1: Order, o2: Order): Order = (o1, o2) match {
case (CancelledOrder(), o2) => o2
case (o1, CancelledOrder()) => o1
case (GeneralOrder(ps1), GeneralOrder(ps2)) => GeneralOrder(ps1 ++ ps2)
case (ComplexOrder(os1), ComplexOrder(os2)) => ComplexOrder(os1 ++ os2)
case (o1, ComplexOrder(orders)) => ComplexOrder(o1 :: orders)
case (ComplexOrder(orders), o2) => ComplexOrder(o2 :: orders)
}
}

import Addable._
}
trait Addable[A] {
}

import Addable._
}
trait Addable[A] {
}
object Addable {
implicit class AddableOps[A](a: A) {
def |+|(other: A)(implicit addable: Addable[A]) = addable.add(a, other)
}
}

import Addable._
case (acc, o) => acc |+| o
}
trait Addable[A] {
}
object Addable {
implicit class AddableOps[A](a: A) {
def |+|(other: A)(implicit addable: Addable[A]) = addable.add(a, other)
}
}

case (acc, o) => acc |+| o
}

def simplify(orders: Seq[Order]): Order = fold(orders)

trait AddableWithZero[A] {
def zero: A
}

def zero: A
}
object AddableWithZero {
def fold[A](values: Seq[A])(implicit addableWithZ: AddableWithZero[A]): A = {
values.fold(addableWithZ.zero){
case (acc, v) => addableWithZ.add(acc, v)
}
}
}

def zero: A
}
implicit object OrderAddableWithZero extends AddableWithZero[Order] {
def zero = CancelledOrder()
def add(o1: Order, o2: Order): Order = OrderAddable.add(o1,o2)
}

Definitions
● Type classes
○ Ad-hoc polymorphism

Definitions
● Type classes
● Abstract Data Type (ADT)

Definitions
● Type classes
● Addable → Semigroup

Definitions
● Type classes
● AddableWithZero → Monoid

Definitions
● Type classes
● AddableWithZero → Monoid
● Type classes come with laws!

Where to go next
1. Functor
2. Applicative
3. Monad!
All are just type classes with some laws. That’s it!

Before we go, a bit of history...

Links & Resources
● https://github.com/rabbitonweb/scala_typeclasses
● https://inoio.de/blog/2014/07/19/type-class-101-semigroup/
● http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-
part-12-type-classes.html
● https://www.youtube.com/watch?v=sVMES4RZF-8
● http://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf
● https://www.destroyallsoftware.com/misc/reject.pdf
● http://southpark.cc.com/avatar
● http://www.tandemic.com/wp-content/uploads/Definition.png

And that’s all folks!
Paweł Szulc

Paweł Szulc
twitter: @rabbitonweb

Paweł Szulc
blog: http://rabbitonweb.com

Paweł Szulc
github: https://github.com/rabbitonweb

Paweł Szulc
github: https://github.com/rabbitonweb
Questions?

object Stat {
import Number._
}

object Stat {
import Number._
}
object Stat {
import Number._
def mean[A : Number](xs: Seq[A]): A =
}

}

}
def write[A : Json](a: A) =
JsonWriter.write(implicitly[Json[A]].toJson(a))
}

Category theory is general abolute nonsens

More Related Content

Similar to Category theory is general abolute nonsens (20)

More from Pawel Szulc (20)

Recently uploaded (20)

Category theory is general abolute nonsens