noelwelsh

import scalaz.{Functor, Monad}
import scalaz.std.option._
import scalaz.syntax.monad._
import scalaz.syntax.functor._

object SyntaxExamples {
  // This works fine
  Monad[Option].lift((x: Int) => x + 1)
  
  //  could not find implicit value for parameter F: scalaz.Functor[F]

noelwelsh

// Type class
trait Burp[A] {
  def burp(in: A): String
}

object Burp {
  def apply[A](implicit burp: Burp[A]): Burp[A] = burp
}

case class Foo(name: String)

noelwelsh

  val jettyWebPath = "src" / "main" / "webapp" / "WEB-INF" / "jetty-web.xml"

  lazy val installProductionRunMode = task {
    FileUtilities.copyFile("project" / "jetty-web.xml",
                           jettyWebPath,
                           log)
    log.info("Copied jetty-web.xml into place")
    None
  } describedAs("Install a jetty-web.xml that sets the run mode to production")

noelwelsh

sealed trait Observer[A] {
  def observe(in :A): Unit =
    this match {
      case Map(f, o) =>
        // This is completely unsound. b should be of type B, which we don't
        // have available at this point. The compiler allows us to insert
        // anything here, causing a runtime crash.
        val b = ()
        o.observe(b)
      case Sink(f) =>

noelwelsh

package myna
package app

import bigtop.util.Uuid
import myna.model.external.User
import myna.util.Base64
import play.api.libs.ws._
import play.api.libs.json._
import play.api.libs.concurrent.Promise
import play.api.mvc.Request

noelwelsh

package nl.mdj

import cats.arrow.NaturalTransformation
import cats.functor.Invariant
import cats._
import cats.syntax.all._

import scala.language.higherKinds

sealed abstract class FreeInvariant[F[_], A] extends Product with Serializable {

noelwelsh

package underscoreio
package enum

import shapeless._
import shapeless.labelled._
import shapeless.syntax.singleton._

// The intention of this code is to extract the names of the types at the leaves of an algebraic data type.
// E.g. for Color at the bottom of this file,
//

noelwelsh

import scalaz.stream._
import scalaz.concurrent.Task
import scalaz.stream.async

object ChatBot {
  val queue = async.boundedQueue[String](10)

  val reader =
    new Thread {
      override def run(): Unit = {

noelwelsh

// Push vs pull evaluation
// Interpreters
// Reification
// Generalised algebraic data types
import java.util.concurrent.ArrayBlockingQueue
import scalaz.Applicative
import scalaz.syntax.applicative._ // for |@|

final case class Sink[A,B](source: EventStream[A], initialValue: B, f: (B, A) => B) {
  def run: B = {

noelwelsh

Much software claims to scale horizontally
But don't take to these claims too wantonly
Too often things fail
To properly scale
And marketers talk irresponsibily