A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)
I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.
A functor is something that supports map.
| I did a small project in C# recently, and I basically assumed | |
| that coming from Scala I could enjoy all the benefits of a | |
| (more) mainstream language and a polished, integrated | |
| ecosystem. | |
| Boy was I wrong. | |
| My experience starts with installing Microsoft's latest Visual | |
| Studio 2013 Express Desktop IDE which went really smooth. |
| case class GenericCache[A[_,_], B, C](instance: A[B,C], getf: B=>C, putf: (B,C)=>Unit) { | |
| def retrieve(b: B) = getf(b) | |
| def insert(b: B, c: C) = putf(b,c) | |
| } | |
| //Notice how neither cache implementations have to even be aware of the existnace of the typeclass. much more flexible than inheritance | |
| class FastCache[A,B] { | |
| private var m = Map[A,B]() //excuse mutability for illustration purposes | |
| def add(a: A, b: B): Unit = { | |
| m = m + (a->b) |
| // Polyfill for Object.create | |
| function create(proto) { | |
| function Ctor() {} | |
| Ctor.prototype = proto; | |
| return new Ctor(); | |
| } | |
| // Always returns an instance of constructor | |
| function getInstance(self, constructor) { | |
| return self instanceof constructor ? self : create(constructor.prototype); |
| -- THE SEARCH CONTINUES | |
| data GenericThing = SpecificThing Char | |
| | DifferentSpecificThing Double | |
| | AnotherSpecificThing String | |
| | YetAnotherDifferentSpecificThing Integer | |
| foo :: [GenericThing] -> GenericThing | |
| foo [] = return $ AnotherSpecificThing "" | |
| foo [SpecificThing one] = -- do something |
| (use '[clojure.core.logic]) | |
| (require '[clojure.core.logic.fd :as fd]) | |
| (defn simple [] | |
| (run* [x y] | |
| (fd/in x y (fd/interval 0 9)) | |
| (fd/eq | |
| (= (+ x y) 9) | |
| (= (+ (* 4 x) (* 2 y)) 24)))) |
| case class T() // your data type that you want to "implicitly" thread through | |
| case class TReader[+A](run: T => A) { | |
| def map[B](f: A => B): TReader[B] = | |
| sys.error("VFJlYWRlcihmIGNvbXBvc2UgcnVuKQ==") | |
| def flatMap[B](f: A => TReader[B]): TReader[B] = | |
| sys.error("VFJlYWRlcih0ID0+IGYocnVuKHQpKSBydW4gdCk=") | |
| def &&&[B](x: TReader[B]): TReader[(A, B)] = |
| Moved to https://github.com/tonymorris/type-class |
