bradparker

{-# 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))

bradparker

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

bradparker

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.

bradparker

#!/usr/bin/env bash

main () {
  local filename="the-little-typer.rkt"

  tmux \
    new-window   "nix-shell --run 'vim $filename'"\; \
    split-window "nix-shell --run 'entr -c racket $filename <<< $filename'"\; \
    select-layout even-horizontal\; \
    split-window -v "nix-shell --run 'racket -i'"

bradparker

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE DeriveFunctor #-}
{-# OPTIONS_GHC -Wall #-}

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

module Main where

bradparker

{-# LANGUAGE OverloadedStrings #-}

module Main
  ( main
  ) where

import CMarkGFM
  ( ListAttributes
  , Node
  , NodeType

bradparker

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

bradparker

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}

module Main where

import Control.Monad (replicateM)
import qualified Data.ByteString.Char8 as BS
import Data.ByteString.Char8 (ByteString)
import Data.Foldable (foldl')
import Data.Functor.Contravariant (contramap)

bradparker

{-# LANGUAGE Arrows #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE FlexibleContexts #-}
{-# OPTIONS_GHC -Wall #-}

module Main where

import Data.Bool (bool)
import Data.Text (Text)
import Control.Arrow (returnA)

bradparker

data Balance =
  Balance !Int
          !Int
  deriving (Eq, Show)

instance Semigroup Balance where
  Balance a b <> Balance c d
    | b <= c = Balance (a + c - b) d
    | otherwise = Balance a (d + b - c)