bmjames

#!/usr/bin/env sh

browser=chromium-browser

package=${1-base}

ghc-pkg describe $package | \
    grep haddock-html | \
    awk '{ print $2 "/index.html" }' | \
    xargs $browser &> /dev/null 

bmjames

{-# LANGUAGE OverloadedStrings #-}

module Main where

import Control.Concurrent (forkIO, ThreadId)
import Data.ByteString.Lazy (ByteString)
import Data.Text.Lazy (pack)
import Data.Text.Lazy.Encoding (encodeUtf8)
import Network.HTTP.Types (status200)
import Network.HTTP.Types.Header (hContentType)

bmjames

module Main where

import Data.Aeson hiding (Result)
import Data.Aeson.Encode.Pretty (encodePretty)
import Data.Attoparsec.ByteString
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS
import Data.ByteString.Lazy (toStrict)
import System.Console.ANSI

bmjames

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Main where

import Data.Functor
import Control.Monad
import Control.Monad.State
import Control.Monad.Writer

bmjames

-- http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC-Base.html#map

map :: (a -> b) -> [a] -> [b]
map _ []     = []
map f (x:xs) = f x : map f xs

bmjames

data Dog = Dog { name  :: Text
               , age   :: Int
               , likes :: Text
               } deriving Show

instance ToJSON Dog where
  toJSON = asObject [ name  `as` "name"
                    , age   `as` "age"
                    , likes `as` "likes"
                    ]

bmjames

object Chap5 extends App {
  import Stream._

  def ones: Stream[Int] = cons(1, ones)
  def lin: Stream[Int] = cons(1, lin.map(_ + 1))
 
  println(ones.flatMap(_ => empty[Int])) // Stack overflow!
}

sealed trait Stream[A] {

bmjames

import scalaz.Scalaz._

/** The problem: given the following database query results, associate each parentId to
  * a List of filenames.
  */
case class Row(parentId: Int, file: String)
val queryResult = Stream(Row(123, "foo.jpg"), Row(123, "bar.jpg"), Row(234, "foo.png"))

/** Using foldLeft is verbose because we have to specify:
  *   - how to create an empty Map to begin with

bmjames

object PragmaticParens {
  import scalaz._, Scalaz._, typelevel._

  private def f(c: Char): StateT[Option, Nat, Unit] =
    StateT(nat => (c match {
      case '(' => Some(nat.succ)
      case ')' => nat.pred
      case _   => Some(nat)
    }) map (_ -> ()))

bmjames

import scalaz._, syntax.monad._

final def filterMN[A, M[_]:Monad, N[_]:Monad](as: List[A])(p: A => N[M[Boolean]]): N[M[List[A]]] =
  as match {
    case Nil => Monad[N].point(Monad[M].point(Nil))
    case h :: t =>
      for {
        mb <- p(h)
        mg <- filterMN(t)(p)
      } yield {