bradparker

module Main where

import Data.Time
import Data.Time.Clock
import Data.Time.Format
import Data.Time.Calendar
import Data.Maybe
import System.Environment
import Text.ParserCombinators.ReadP
import Data.Char

bradparker

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RebindableSyntax #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -Wall #-}

module Scott where

import qualified Prelude as Builtin
import qualified Data.Char as Builtin
import GHC.Num (Num(fromInteger, (-), (+)))

bradparker

module Main
  ( main
  ) where

import Control.Arrow ((&&&))
import Control.Monad.Trans.State (StateT(StateT), evalStateT)
import Data.List (uncons, unfoldr)
import Data.Maybe (fromMaybe, listToMaybe)
import System.Environment (getArgs)

bradparker

{-# LANGUAGE DeriveFoldable #-}

module Main where

import Data.Map (Map)
import qualified Data.Map as Map
import Data.Foldable

data Object a
  = Value a

bradparker

{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE RankNTypes #-}

module Main where

import Control.Applicative (Applicative(..))
import Data.Bool (Bool(False, True), not)
import Data.Char (toUpper)
import Data.Function (($), (&), (.), const, flip)

bradparker

dist

bradparker

module Main where

import Data.Functor (void)
import Control.Applicative ((<|>), empty, many, some, optional)
import Control.Monad (msum, replicateM)
import Control.Monad.State (StateT(runStateT))
import Control.Monad.State.Class (get, put)
import Data.Char (isHexDigit, chr, isDigit, isSpace)
import Data.Map (Map)
import Data.Maybe (listToMaybe, fromMaybe)

bradparker

module Main where

import Data.Bool (bool)
import Control.Monad ((<=<))
import Control.Monad.State (State, evalState, get, put)
import Data.Char (isSpace)
import Data.Foldable (traverse_)
import Data.Functor.Compose (Compose(Compose, getCompose))
import Data.Functor.Const (Const(Const, getConst))
import Data.Functor.Product (Product(Pair))

bradparker

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE TypeOperators #-}

module Data.Text.Sized
  ( Text

bradparker

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Data.Constrained
  ( Constrained(unconstrained)
  , constrain
  ) where

import Data.Bool ((&&), otherwise)