Brad bradparker

## 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 =

## default.nix
let
  overlay = self: super:
    {
      haskell = super.haskell // {
        packages = super.haskell.packages // {
          ghcjs = super.haskell.packages.ghcjs.extend (hself: hsuper: {
            # Doctest fails to build with a strange error.
            doctest = null;

            # These require doctest to run their tests.

## the-little-typer.pie
#lang pie

(claim one
  Nat)
(define one
  (add1 zero))

(claim vegetables
  (Pair Atom Atom))
(define vegetables

## Comonad.hs
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE DeriveFunctor #-}
{-# OPTIONS_GHC -Wall #-}

-- $ nix-shell -p "haskellPackages.ghcWithPackages (pkgs: [ pkgs.random ])"
-- $ runhaskell Comonad.hs

module Main where

## CommonmarkJSON.hs
{-# LANGUAGE OverloadedStrings #-}

module Main
  ( main
  ) where

import CMarkGFM
  ( ListAttributes
  , Node
  , NodeType

## Mtl.hs
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE RankNTypes #-}

module Main where

import Control.Monad
import Control.Monad.Trans.State (runState, runStateT)
import Control.Monad.Trans.Except (runExceptT, runExcept)
import Control.Monad.Error.Class
import Control.Monad.State.Class