Brad bradparker

## Ind.hs
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wall #-}

## Refined.ts
interface Refinement<A> {
  tag: string;
  value: A;
}

interface Refined<A, R> {
  value: A;
  refinement: R;
}

## Bits.hs
import Control.Monad.State
import Data.Traversable
import Data.Tuple

toByteBits :: Integral n => n -> [n]
toByteBits =
  evalState (for [1..8] (\_ -> state (\s -> swap (divMod s 2))))

main = do
  print $ toByteBits 1

## Byte.hs
{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE RankNTypes #-}

module Byte where

import Data.Bool (bool)
import Data.Functor.Const (Const(Const, getConst))
import Data.Bits ((.&.), (.|.), xor)
import Prelude hiding (sum)

## concurrency.ts
interface Person {
  name: string;
  age: number;
}

const people: Person[] = [{ name: "Bob", age: 100 }, { name: "Jane", age: 50 }];

const findPeople = (candidate: string): Promise<Person[]> => {
  return new Promise(resolve => {
    const timeout = Math.floor(Math.random() * 100);

## App.ts
import * as Either from "./Either";

type Action<I, E, A> = (input: I) => Promise<Either.Either<E, A>>;

export class App<I, E, A> {
  public run: Action<I, E, A>;

  public constructor(action: Action<I, E, A>) {
    this.run = action;
  }

## prepare-commit-message
#!/usr/bin/env bash

branchname=$(git branch | grep ^* | sed 's/\* //g')
regex="([A-Z]*-[0-9]*)"

if [[ $branchname =~ $regex ]]
then
  ticket_id="${BASH_REMATCH[1]}"
  message=`cat $1`

## Traversals.hs
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE FlexibleInstances #-}

module Traversals where

import Control.Applicative (Applicative(..))
import Data.Bool (Bool(True))

## LensesAndFunctionalReferences.hs
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TupleSections #-}

module LensesAndFunctionalReferences where

import Data.Char (chr, ord, toUpper)
import Data.Functor.Const (Const(Const, getConst))
import Data.Functor.Contravariant (Contravariant(contramap))
import Data.Functor.Identity (Identity(Identity, runIdentity))

## NewtypeLists.hs
{-# LANGUAGE TupleSections #-}

newtype NonEmpty a = NonEmpty { getNonEmpty :: (a, List a) }
newtype List a = List { getList :: Maybe (NonEmpty a) }

nil :: List a
nil = List Nothing

cons :: a -> List a -> List a
cons a =