haghard

type | [+A, +B] = Union.Type[A, B]
object Union {
  trait Tag extends Any
  type Base
  type Type[+A, +B] <: Base with Tag
  
  implicit def first[A]: A <:< Type[A, Nothing] = 
    implicitly[A <:< A].asInstanceOf[A <:< Type[A, Nothing]]
  implicit def second[B]: B <:< Type[Nothing, B] = 
    implicitly[B <:< B].asInstanceOf[B <:< Type[Nothing, B]]

haghard

object Example {
  import cats._, implicits._
  import cats.effect._
  import fs2._
  import scala.concurrent.ExecutionContext

  // start N streams concurrently, and stream their results in order
  // e.g. download a file from  a server in N parts concurrently, and stream it
  // this approach is good for showcasing usage of concurrent abstractions,
  // but a lower level implementation using Pull is likely to be much more performant

haghard

package com.acme

import com.typesafe.config.Config

trait Module {
  implicit def config: Config
}

haghard

import concurrent.{ExecutionContext, Future => SFuture, Promise}                 
import util.Try                                                                                                 
                                                                                                                
import _root_.scalaz.\/                                                                                         
import _root_.scalaz.concurrent.{Task => ZTask}                                                                 
                                                                                                                
                                                                                                                
object Task {                                                                                                   
                                                                                                                
  def fromScala[A]                    

haghard

Category theory jargon cheat sheet

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.

Functor

A functor is something that supports map.

haghard

import reflect.ClassTag

trait Semigroup[F]{
  def append(a1: F, a2: F): F

  def apply: Apply[({type λ[α]=F})#λ] = new SemigroupApply{}

  protected[this] trait SemigroupApply extends Apply[({type λ[α]=F})#λ]{
    override def map[A, B: ClassTag](fa)(f) = fa
    override def ap[A, B: ClassTag](fa)(f) = append(fa, f)

haghard

// This should work with Scala 2.10.4 & scalaz 7.1, core, effect and concurrent packages
import scalaz.{ concurrent, Free, Functor, Monad, syntax }
import concurrent.Task
import Free.{freeMonad => _, _}
import syntax.monad._

// Describe the set of actions - which are functors

sealed trait RedisF[+A] {
  def map[B](fn: A => B): RedisF[B]

haghard

package org.iainhull.akka


import scala.concurrent.duration._

import akka.actor._
import akka.event.Logging
import akka.pattern.ask
import akka.util.Timeout
import akka.persistence.{PersistentView, AtLeastOnceDelivery, PersistentActor}

haghard

import java.util.regex.Pattern
import play.core.Routes
import play.api.mvc._

object Router extends Routes {

  def routes = {
    // Static paths
    case Route("GET",    p"")              => controllers.Application.index
    case Route("GET",    p"/items")        => controllers.Items.list

haghard

As compiled by Kevin Wright a.k.a @thecoda

(executive producer of the movie, and I didn't even know it... clever huh?)

please, please, please - If you know of any slides/code/whatever not on here, then ping me on twitter or comment this Gist!

Monday June 16th