FranklinChen

Keybase proof

I hereby claim:

• I am franklinchen on github.
• I am franklinchen (https://keybase.io/franklinchen) on keybase.
• I have a public key ASDhVqCYgr6xkfxsfiM5OWYrkqFtO0Rc6P6wKgk8Mh8Xhwo

To claim this, I am signing this object:

FranklinChen

Homebrew build logs for shibboleth-sp on macOS 10.12
Build date: 2016-09-28 16:50:24

FranklinChen

use std::sync::{Arc, Mutex};
use std::thread;

struct Toaster {
    count: u32
}

impl Toaster {
    fn new() -> Toaster {
        Toaster { count: 0 }

FranklinChen

use std::thread::{spawn, sleep_ms};
use std::sync::mpsc::channel;

fn main() {
    // Names of attendees.
    let names = vec![format!("A"), format!("B"), format!("C"), format!("D"), format!("E")];

    // Create a channel to communicate between attendees and the toaster.
    let (toaster_tx, toaster_rx) = channel();

FranklinChen

-- | http://stackoverflow.com/questions/14259229/streaming-recursive-descent-of-a-directory-in-haskell/14261710#14261710
--
-- Updated to latest Pipes 4.

module Main where

import Pipes
import qualified Pipes.Prelude as P
import Control.Monad (forM_)
import System.Directory (doesDirectoryExist, getDirectoryContents)

FranklinChen

{-# LANGUAGE RankNTypes, DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances, TypeSynonymInstances #-}
module Main where
import Criterion.Main (defaultMain, bench, bgroup, nf)

--------------------------------------------------------------------------------
-- Fixed points of a functor

newtype Mu f = Mu { muF :: f (Mu f) }

FranklinChen

-- | Something for work, prototyped first in Haskell before turning
-- into Scala

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE LambdaCase #-}

import Test.Hspec
import Control.Monad.State

FranklinChen

{-# LANGUAGE OverloadedStrings #-}

import Data.String

data Value = VInt Int
  | VString String

-- In order to hide the unitype details from the user.
instance Show Value where
  show (VInt i) = show i

FranklinChen

import Control.Category ((>>>))

data Option = Option { name :: String }

-- Point-free style. Is this readable?
-- 
-- An Option matches a String if: we get the name of the Option and then prepend "--" to it, test whether that is equal
-- to the given String.
matches :: Option -> String -> Bool
matches = name >>> ("--" ++) >>> (==)

FranklinChen

-- Response to https://twitter.com/mfeathers/status/495979138365149184
-- Based on http://git.zx2c4.com/spark/tree/spark.c

import System.IO (hPutStrLn, stderr)
import System.Environment (getArgs)
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C

main :: IO ()
main = do