noelwelsh

The Reader Monad

The reader monad is one solution to "dependency injection". This document shows how we might discover the reader monad when we attempt to solve this problem.

Dependency Injection

Our working definition of the dependency injection problem will be this: we have a method or function that takes certain parameters that we don't want to specify every time we call it. For example, we might have a function that gets a user given an ID and also requires a database connection.

def getUser(db: DbConnection, id: Id): User =

jdegoes

package fpmax

import scala.util.Try
import scala.io.StdIn.readLine

object App0 {
  def main: Unit = {
    println("What is your name?")

    val name = readLine()

paraseba

/*
 This is a demonstration of foldLeft and foldRight in scala using
 by-name parameters to process infinite streams and to short-circuit
 computations that can finish early.
 */

import scala.annotation.tailrec

/*
 foldLeft can be written in tail recursive form. The recursive call is not

a7madgamal

FINALLY no need for tricks!

bonus tip: for more darkness > https://darkreader.org/

monaddle

package testfree
import testfree.Console._
import testfree.Authorization.{ Authorize}
import scalaz.{Inject, _}
import Scalaz._
import scala.io.StdIn
import scalaz.Inject._

// Example of using two separate ADTs with separate interpreters and composing the interpeters.
// See talk by Runar Bjarnason https://www.youtube.com/watch?v=M258zVn4m2M, or "onion architecture" description

djspiewak

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

1. CPU-bound
2. Blocking IO
3. Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

ploeh

module ApiModel where

import Data.Time (ZonedTime(..), parseTimeM, defaultTimeLocale, iso8601DateFormat)

data ReservationRendition = ReservationRendition
  { rDate :: String
  , rName :: String
  , rEmail :: String
  , rQuantity :: Int }
  deriving (Eq, Show, Read)

davegurnell

object TypeclasseDemo {

  // The parts of the type class pattern are:
  //
  //   1. the "type class" itself -- a trait with a single type parameter;
  //
  //   2. type class "instances" for each type we care about,
  //      each marked with the `implicit` keyword;
  //
  //   3. an "interface" to the type class -- one or more methods

gigiigig

import shapeless._

import scalaz._
import Scalaz._

object console extends App {

  trait Foo[A] {
    type B
    def value: B

MoOx

// go on you labels pages
// eg https://github.com/cssnext/cssnext/labels
// paste this script in your console
// copy the output and now you can import it using https://github.com/popomore/github-labels !

var labels = [];
[].slice.call(document.querySelectorAll(".label-link"))
.forEach(function(element) {
  labels.push({
    name: element.textContent.trim(),