-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Essential features
--   
--   Essential features
@package ACME
@version 0.0.0.0

module Acme.Unit
class Unit t
unit :: Unit t => t
instance Unit u => Unit (t -> u)
instance Unit t => Unit (Identity t)
instance (Unit t, Unit u, Unit v, Unit w, Unit x) => Unit (t, u, v, w, x)
instance (Unit t, Unit u, Unit v, Unit w) => Unit (t, u, v, w)
instance (Unit t, Unit u, Unit v) => Unit (t, u, v)
instance (Unit t, Unit u) => Unit (t, u)
instance Unit ()

module Acme.Trivial
data Trivial t
Trivial :: Trivial t
instance Eq (Trivial t)
instance Ord (Trivial t)
instance Show (Trivial t)
instance Read (Trivial t)
instance Monad Trivial
instance Functor Trivial

module Acme.Smash

-- | smash "THE ONE" <a>NEO</a> == "THE ONEO"
smash :: Eq a => [a] -> [a] -> [a]

module Acme.Pirates
forPlunder :: IOMode
forSafeKeeping :: IOMode
digUpChest :: FilePath -> IOMode -> IO Handle
buryChest :: Handle -> IO ()
loadDoubloon :: Handle -> IO Char
loadCashBox :: Handle -> IO String
stowDoubloon :: Handle -> Char -> IO ()
stowCashBox :: Handle -> String -> IO ()
readTreasureMap :: Handle -> IO Integer
xMarksTheSpot :: Handle -> SeekMode -> Integer -> IO ()
loadTheTreasure :: Handle -> IO String
abandonShip :: ExitCode -> IO a
whatSayYe :: IO String
collectDoubloon :: IO Char
pollySquawks :: Char -> IO ()
pollySays :: [Char] -> IO ()
captainsLog :: String -> IO ()
theBlackSpot :: Exception e => e -> IO a
mutiny :: Exception e => IO a -> (e -> IO a) -> IO a
shiverMeTimbers :: a -> a
yar :: a -> a
meMateys :: a -> a

module Acme.Perhaps
data Perhaps t
Definitely :: t -> Perhaps t
Probably :: t -> Perhaps t
ProbablyNot :: Perhaps t
Nope :: Perhaps t
instance Eq t => Eq (Perhaps t)
instance Ord t => Ord (Perhaps t)
instance Show t => Show (Perhaps t)
instance Read t => Read (Perhaps t)
instance Monad Perhaps


-- | An interface to continuations using Peirce's law
--   
--   This module is bogus, as the following proof demonstrates:
--   
--   peirce (f -&gt; f 1 == f 2) == 1
--   
--   peirce (f -&gt; f 2 == f 1) == 2
--   
--   f 1 == f 2
--   
--   Therefore, 1 == 2.
module Acme.Peirce

-- | Ex falso
falseVoid :: Void -> a

-- | Peirce's law
peirce :: ((a -> a1) -> a) -> a

-- | Law of excluded middle
lem :: (a -> b) -> ((a -> Void) -> b) -> b

-- | Double negation law
doubleNeg :: ((b -> Void) -> Void) -> b
instance Typeable ContinueException
instance Show ContinueException
instance Exception ContinueException


-- | A monad to handle economic transactions between computations
module Acme.Money
data Money u t

-- | Lift an IO computation into the Money monad
lift' :: IO t -> Money u t

-- | Charge n simoleons from the purchasing computation
charge :: Float -> Money u ()

-- | Purchase the ith computation from the list
purchase :: Int -> Money u u

-- | Run several computations, where the computations may purchase the use
--   of one another
runMoneys :: [(IORef Float, Money a a)] -> [IO a]
instance Monad (Money u)


-- | Various ciphers.
module Acme.Cipher
data Cipher key
encode :: Cipher t -> t -> String -> String
decode :: Cipher t -> t -> String -> String

-- | The Playfair cipher
playfair :: Cipher [Char]

-- | The letter substitution cipher
substitution :: Cipher [(Char, Char)]
addLetters :: Char -> Char -> Char
subtractLetters :: Char -> Char -> Char

-- | The Viginere cipher (acts like one-time pad if the key is as long as
--   the plaintext)
viginere :: Cipher [Char]

-- | The Caesar cipher
caesar :: Cipher Char
newtype Plugboard
Plugboard :: [(Char, Char)] -> Plugboard
newtype Reflector
Reflector :: [(Char, Char)] -> Reflector
newtype RotorMapping
RotorMapping :: [(Char, Char)] -> RotorMapping
enigma :: RandomGen g => g -> Cipher (Plugboard, Reflector, (RotorMapping, RotorMapping, RotorMapping))