ImperativeHaskell 1.1.1.0 → 2.0.0.0

raw patch · 20 files changed

+366/−226 lines, 20 filesbinary-added

Files

• Control/Monad/Imperative.hs +1/−1
• Control/Monad/Imperative/FunctionFactory.hs +0/−0
• Control/Monad/Imperative/Internals.hs +159/−127
• Control/Monad/Imperative/Operators.hs +61/−59
• ImperativeHaskell.cabal +34/−8
• Main.hs +55/−31
• dist/build/Control/Monad/Imperative.hi binary
• dist/build/Control/Monad/Imperative.o binary
• dist/build/Control/Monad/Imperative/FunctionFactory.hi binary
• dist/build/Control/Monad/Imperative/FunctionFactory.o binary
• dist/build/Control/Monad/Imperative/Internals.hi binary
• dist/build/Control/Monad/Imperative/Internals.o binary
• dist/build/Control/Monad/Imperative/Operators.hi binary
• dist/build/Control/Monad/Imperative/Operators.o binary
• dist/build/HSImperativeHaskell-2.0.0.0.o binary
• dist/build/autogen/Paths_ImperativeHaskell.hs +29/−0
• dist/build/autogen/cabal_macros.h +23/−0
• dist/build/libHSImperativeHaskell-2.0.0.0.a binary
• dist/package.conf.inplace +2/−0
• dist/setup-config +2/−0

@@ -9,6 +9,6 @@ -----------------------------------------------------------------------------
 module Control.Monad.Imperative (module X) where
 
-import Control.Monad.Imperative.Internals as X hiding (val, V(C))
+import Control.Monad.Imperative.Internals as X hiding (C)
 import Control.Monad.Imperative.Operators as X hiding (liftOp2)
 import Control.Monad.Imperative.FunctionFactory as X

@@ -1,9 +1,12 @@ {-# LANGUAGE
  GADTs,
- EmptyDataDecls,
  GeneralizedNewtypeDeriving,
  MultiParamTypeClasses,
- FlexibleInstances
+ FlexibleInstances,
+ FlexibleContexts,
+ UndecidableInstances,
+ TypeFamilies,
+ FunctionalDependencies
  #-}
 
 -----------------------------------------------------------------------------
@@ -13,9 +16,9 @@ -- Stability   :  experimental
 -- Portability :  GADTs, EmptyDataDecls, GeneralizedNewtypeDeriving, 
 --                MultiParamTypeClasses, FlexibleInstances
+-- 
 -- A module which defines the monad for ImperativeHaskell,  
 -- and some control operator to interact with 'MIO'
--- 
 -----------------------------------------------------------------------------
 module Control.Monad.Imperative.Internals
        ( modifyOp
@@ -24,197 +27,226 @@        , while'
        , break'
        , continue'
-       , return'
-       , returnV
-       , returnF
+       , defer'
        , function 
        , new
        , auto
        , runImperative
+       , io
        , V(Lit, C)       
-       , ValTp
        , MIO()
-       , Comp
-       , Val
-       , Var
+       , TyInLoop
+       , TyInFunc
+       , TyVar
+       , TyVal
+       , TyComp
        , (=:)
        , (&)
-       , val
+       , HasValue(..)
+       , CState(return')
        ) where
 
+import Data.Functor
 import Control.Monad.Cont
-import Control.Monad.Reader
+import Control.Monad.State
 import Data.IORef
 import Data.String (IsString(..))
 
-newtype MIO r a = MIO { getMIO :: ReaderT (Control r) (ContT r IO) a }
-                deriving (Monad, MonadCont, MonadIO)
+data TyInLoop
+data TyInFunc
 
-data Var
-data Val
-data Comp
+data TyVar
+data TyVal
+data TyComp i v
+                 
+type RCont r = ContT r IO
+type MIO_I i r a = StateT (Control i r) (RCont r) a
+type RetCont r = r -> RCont r ()
 
-class ValTp b where
-instance ValTp Var where
-instance ValTp Val where
-instance ValTp Comp where
+newtype MIO i r a = MIO { getMIO :: MIO_I i r a }
+                  deriving (Monad, MonadCont, MonadIO)
+  
+data V b r a where
+  R :: IORef a -> V TyVar r a
+  Lit :: a -> V TyVal r a
+  C :: MIO i r (V b r a) -> V (TyComp i b) r a
+  
+data Control i r where  
+  InFunction :: RetCont r -> Control TyInFunc r
+  InLoop :: MIO TyInLoop r () -> MIO TyInLoop r () -> RetCont r -> Control i r
 
-data Control r = InFunction (r -> ContT r IO ()) 
-               | InLoop { controlBreak :: MIO r () 
-                        , controlContinue :: MIO r () 
-                        , controlReturn :: r -> MIO r ()
-                        }
+getReturn :: Control i r -> RetCont r
+getReturn (InFunction ret) = ret
+getReturn (InLoop _ _ ret) = ret
 
--- | @'returnF' value@ acts like the imperative return, where
--- if called, it will exit the current function and place the 
--- returned value into the current continuation.  Note, this
--- doesn't work inside of loops.  Inside of loops, we need
--- 'returnV'
-returnF :: ValTp a => V a b b -> MIO b b
-returnF v = MIO $ do
-  v' <- getMIO $ val v
-  a <- ask
-  case a of
-    InLoop _ _ ret -> getMIO $ ret v'
-    InFunction ret -> lift $ ret v'
-  return v'
-  
--- | @'returnV' value@ acts like the imperative return, where
--- if called, it will exit the current function and place the 
--- returned value into the current continuation.  Note, this
--- doesn't work as a last function call.
-returnV :: ValTp a => V a b b -> MIO b ()
-returnV a = returnF a >> return ()
+-- | Although the functional dependency @b -> i@ is declared, 
+-- it does not do anything useful. 
+class HasValue r b i | b -> r i where
+  val :: b a -> MIO i r a
+instance HasValue r (V TyVar r) i where
+  val (R r) = MIO $ liftIO $ readIORef r
+instance HasValue r (V TyVal r) i where
+  val (Lit v) = return v
+instance HasValue r (V b r) a => HasValue r (V (TyComp a b) r) a where
+  val (C m) = val =<< m
+instance HasValue r (MIO i r) i where
+  val m = m
 
-class Returnable b r where
-  -- | @'return''@ can act as returnF or returnV depending on use
-  -- if it does not work, it is likely that type inference
-  -- could not figure out a sensible alternative.
-  return' :: ValTp a => V a b b -> MIO b r
+instance HasValue r IO i where
+  val m = liftIO m  
 
-instance Returnable b () where
-  return' a = returnV a 
+class CState i where 
+  type RetTy i a
+  getState :: MIO i r (Control i r)
+  
+  -- | @'return'' value@ acts like an imperative return. It passes
+  -- the given value to the return continuation.
+  return' :: HasValue r (V a r) i => V a r r -> MIO i r (RetTy i r)
+  toLoop :: MIO i r a -> MIO TyInLoop r a  
+  
+instance CState TyInFunc where 
+  type RetTy TyInFunc a = a
+  getState = MIO get
+  return' v = MIO $ do
+    v' <- getMIO $ val v
+    InFunction ret <- get
+    lift $ ret v'
+    return v'
 
-instance Returnable b b where
-  return' a = returnF a
+  toLoop (MIO m) = MIO $
+    wrapState m statefulRetCont $ \(InLoop _ _ retLoop) -> InFunction retLoop
 
+instance CState TyInLoop where 
+  type RetTy TyInLoop a = ()
+  getState = MIO get
+  return' v = MIO $ do
+    v' <- getMIO $ val v
+    InLoop _ _ ret <- get
+    lift $ ret v'
+    return ()
 
-runImperative :: MIO a a -> IO a
-runImperative foo = do
-  a <- runContT (callCC $ \ret -> runReaderT (getMIO foo) $ InFunction ret) return
-  return a
+  toLoop m = m  
 
--- | @'function' foo@ takes an ImperativeMonad action and removes it from it's  
--- specific function context, specifically making it applicable 
--- in the body of other functions.
-function :: MIO a a -> MIO b a
-function = MIO . liftIO . runImperative
+statefulRetCont :: Control t r -> Control i r -> Control t r
+statefulRetCont (InLoop a b _) = InLoop a b . getReturn
+statefulRetCont (InFunction _) = InFunction . getReturn
 
--- | @'break''@ exists the current loop.
--- if called outside of a loop, rather than throwing a compilation error,
--- it will simply return a runtime error.
-break' :: MIO a ()
-break' = MIO ask >>= controlBreak
+-- | @'for''(init, check, incr)@ acts like its imperative @for@ counterpart
+for' :: (CState i, HasValue r (V b r) i, HasValue r valt TyInLoop) => (MIO i r irr1, V b r Bool, MIO i r irr2) -> valt () -> MIO i r ()
+for' (init, check, incr) body = init >> for_r
+    where for_r = do
+            do_comp <- val check
+            when do_comp $ callCC $ \break_foo -> do
+                           callCC $ \continue_foo -> MIO $
+                             wrapState (getMIO $ val body) statefulRetCont $ \inbod -> 
+                                InLoop (toLoop $ break_foo ()) (toLoop $ continue_foo ()) (getReturn inbod)
+                           incr
+                           for_r
 
+-- | @'break''@ exists the current loop.  
+break' :: MIO TyInLoop r ()
+break' = do
+  InLoop b _ _ <- getState
+  b
+
 -- | 'continue'' continues the current loop, passing over
 -- any control flow that is defined.
--- if called outside of a loop, rather than throwing a compilation error,
--- it will simply return a runtime error.
-continue' :: MIO a ()
-continue' = MIO ask >>= controlContinue
+continue' :: MIO TyInLoop r ()
+continue' = do
+  InLoop _ c _ <- getState
+  c
 
+runWithRet :: MIO TyInFunc r a-> RetCont r -> RCont r a
+runWithRet m r = fmap fst $ runStateT (getMIO m) $ InFunction r
 
+-- | 'defer'' executes the given action (or value) before the 
+-- function returns.
+defer' :: HasValue r valt TyInFunc  => valt a -> MIO i r ()
+defer' m = MIO $ do
+  c <- get
+  put $ case c of 
+    InLoop a b r -> InLoop a b $ \i -> runWithRet (val m) r >> r i
+    InFunction r -> InFunction $ \i -> runWithRet (val m) r >> r i
+    
+-- | @'runImperative'@ takes an MIO action as returned by a function, 
+-- and lifts it into IO.
+runImperative :: MIO TyInFunc a a -> IO a
+runImperative foo = 
+  runContT (callCC $ \ret -> fst <$> runStateT (getMIO foo) (InFunction ret)) return 
 
-data V b r a where
-  R :: IORef a -> V Var r a
-  Lit :: a -> V Val r a
-  C :: ValTp b => MIO r (V b r a) -> V Comp r a
-instance Eq a => Eq (V Val r a) where
+
+-- | @'function' foo@ takes an ImperativeMonad action and removes it from it's  
+-- specific function context, specifically making it applicable 
+-- in the body of other functions.
+function ::  MIO TyInFunc a a -> MIO i b a
+function = MIO . liftIO . runImperative
+
+instance Eq a => Eq (V TyVal r a) where
   (Lit a) == (Lit a') = a == a'
-instance Show a => Show (V Val r a) where
+instance Show a => Show (V TyVal r a) where
   show (Lit a) = show a
-instance Num a => Num (V Val r a) where
+instance Num a => Num (V TyVal r a) where
   (Lit a) + (Lit b) = Lit $ a + b
   (Lit a) * (Lit b) = Lit $ a * b
   abs (Lit a) = Lit $ abs a
   signum (Lit a) = Lit $ signum a
   fromInteger = Lit . fromInteger
-  
-instance IsString s => IsString (V Val r s) where
+instance IsString s => IsString (V TyVal r s) where
   fromString = Lit . fromString
 
-
-val :: ValTp b => V b r a -> MIO r a
-val v = case v of
-  R r -> MIO $ liftIO $ readIORef r
-  Lit v -> return v
-  C m -> val =<< m
-
 -- | @('&')a@ gets a reference/pointer to the variable specified
-(&) :: V Var r a -> V Var s a
+(&) :: V TyVar r a -> V TyVar s a
 (&) (R a) = R a
 
+
 -- | 'auto' should just be used where the 
 -- type can be automatically infered and we don't need an initial value
 -- Use caution, as it is simply an alternate name for 'undefined'
 auto = undefined
 
 -- | 'new' constructs a new reference to the specified pure value
-new :: a -> MIO r (V Var r a)
+new :: (HasValue r (V TyVar r) i) => a -> MIO i r (V TyVar r a)
 new a = do
   r <- MIO $ liftIO $ newIORef a
   return $ R r
 
-
 infixr 0 =:
 
--- | The 'Assignable' class is used to specify a value which can be 
--- computed imperatively.
-
-class Assignable valt where 
-  -- | @variable '=:' value@ executes @value@ and writes it  
-  -- to the location pointed to by @variable@
-  (=:) :: V Var r a -> valt r a -> MIO r () 
-
-instance ValTp b => Assignable (V b) where  
-  (=:) (R ar) br = MIO $ do
-    b <- getMIO $ val br
-    liftIO $ writeIORef ar b
-
-instance Assignable MIO where  
-  (=:) (R ar) br = do
-    b <- br
-    liftIO $ writeIORef ar b
-
-
--- | @'for''(init, check, incr)@ acts like its imperative @for@ counterpart
-for' :: ValTp b => (MIO r irr1, V b r Bool, MIO r irr2) -> MIO r () -> MIO r ()
-for' (init, check, incr) body = init >> for_r
-  where for_r = do
-          do_comp <- val check
-          when do_comp $ callCC $ \break_foo -> do
-                         callCC $ \continue_foo -> MIO $ do
-                           flip withReaderT (getMIO body) $ \inbod ->
-                             InLoop (break_foo ()) (continue_foo ()) (controlReturn inbod)
-                         incr
-                         for_r
+-- | @variable '=:' value@ executes @value@ and writes it  
+-- to the location pointed to by @variable@
+(=:) :: (HasValue r valt i, HasValue r (V TyVar r) i) => V TyVar r a -> valt a -> MIO i r () 
+(R ar) =: br = MIO $ do
+  b <- getMIO $ val br
+  liftIO $ writeIORef ar b
 
 -- | @'while''(check)@ acts like its imperative @while@ counterpart.
-while' :: ValTp b => V b r Bool -> MIO r () -> MIO r ()
+while' :: (HasValue r (V b r) i, HasValue r (V b r) TyInLoop, HasValue r valt TyInLoop, CState i) => V b r Bool -> valt () -> MIO i r ()
 while' check = for'(return (), check, return () )
 
 -- | @'if''(check) act@ only performs @act@ if @check@ evaluates to true
 -- it is specifically a value in its argument.
-if' :: ValTp b => V b r Bool -> MIO r () -> MIO r ()
+if' :: (HasValue r (V b r) i, HasValue r valt i) => V b r Bool -> valt () -> MIO i r ()
 if' b m = do
   v <- val b
-  when v m
+  when v (val m)
 
 -- | @'modifyOp'@ makes a modification assignment operator 
 -- out of a binary haskell function.
 -- The suggested use is to replicate functionality of assignments
 -- like @-=@ or @%=@ from C style languages.
-modifyOp :: ValTp k => (a->b->a) -> V Var r a -> V k r b -> MIO r ()
+modifyOp :: (HasValue r (V TyVar r) i, HasValue r (V k r) i) => (a->b->a) -> V TyVar r a -> V k r b -> MIO i r ()
 modifyOp op (R ar) br = MIO $ do
   b <- getMIO $ val br
-  liftIO $ modifyIORef ar (\v -> op v b)+  liftIO $ modifyIORef ar (\v -> op v b)
+
+wrapState :: Monad m => StateT s m a -> (s' -> s -> s') -> (s' -> s) -> StateT s' m a
+wrapState st fOut fIn = do
+  sp <- get
+  (a, s) <- lift $ runStateT st $ fIn sp
+  put $ fOut sp s
+  return a
+
+-- | @'io' action@ takes a haskell 'IO' @action@ and makes it useable from within
+-- the MIO monad.
+io :: IO a -> MIO TyInFunc r a
+io = liftIO

@@ -1,61 +1,63 @@ {-# LANGUAGE
- NoMonomorphismRestriction
- #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Imperative.Operators
--- Maintainer  :  Matthew Mirman <mmirman@andrew.cmu.edu>
--- Stability   :  experimental
--- Portability :  NoMonomorphismRestriction
--- Some predefined operators for the imperative monad.
--- 
------------------------------------------------------------------------------
-module Control.Monad.Imperative.Operators where
-
-import Control.Monad.Imperative.Internals
-
-(+=:), (*=:), (-=:) :: (ValTp k, Num b) => V Var r b -> V k r b -> MIO r ()
-(+=:) a b = modifyOp (+) a b
-(*=:) a b = modifyOp (*) a b
-(-=:) a b = modifyOp (-) a b
-
-(%=:) :: (ValTp k, Integral b) => V Var r b -> V k r b -> MIO r ()
-(%=:) a b = modifyOp mod a b
-
-(<.), (>.), (>=.), (<=.) :: (ValTp b1, ValTp b2, Ord b) => V b1 r b -> V b2 r b -> V Comp r Bool
-(<.) a b = liftOp2 (<) a b
-(>.) a b = liftOp2 (>) a b
-(>=.) a b = liftOp2 (>=) a b
-(<=.) a b = liftOp2 (<=) a b
-
-(==.) :: (ValTp b1, ValTp b2, Eq b) => V b1 r b -> V b2 r b -> V Comp r Bool
-(==.) a b = liftOp2 (==) a b
-
-(+.), (-.), (*.) :: (ValTp b1, ValTp b2, Num c) => V b1 r c -> V b2 r c -> V Comp r c
-(+.) a b = liftOp2 (+) a b
-(-.) a b = liftOp2 (-) a b
-(*.) a b = liftOp2 (*) a b
-
-(%.) :: (ValTp b1, ValTp b2, Integral c) => V b1 r c -> V b2 r c -> V Comp r c
-(%.) a b = liftOp2 mod a b
-
-(/.) :: (ValTp b1, ValTp b2, Fractional c) => V b1 r c -> V b2 r c -> V Comp r c
-(/.) a b = liftOp2 (/) a b 
-
-(&&.), (||.) :: (ValTp b1, ValTp b2) => V b1 r Bool -> V b2 r Bool -> V Comp r Bool
-(&&.) a b = liftOp2 (&&) a b
-(||.) a b = liftOp2 (||) a b
-
-(~.) :: ValTp b1 => V b1 r Bool -> V Comp r Bool
-(~.) a = C $ do 
-  a' <- val a
-  return $ Lit $ not a'
-
--- | @'liftOp2' f@ turns a pure function into one which
--- gets executes its arguments and returns their value as a 
--- function.  It is defined using 'liftOp'.
-liftOp2 :: (ValTp b1, ValTp b2) => (a -> b -> c) -> V b1 r a -> V b2 r b -> V Comp r c
-liftOp2 f v1 v2 = C $ do
-  v1' <- val v1
-  v2' <- val v2
+ NoMonomorphismRestriction,+ TypeFamilies,+ FlexibleContexts+ #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Monad.Imperative.Operators+-- Maintainer  :  Matthew Mirman <mmirman@andrew.cmu.edu>+-- Stability   :  experimental+-- Portability :  NoMonomorphismRestriction+-- Some predefined operators for the imperative monad.+-- +-----------------------------------------------------------------------------+module Control.Monad.Imperative.Operators where++import Control.Monad.Imperative.Internals++(+=:), (*=:), (-=:) :: (HasValue r  (V k r) i, Num b) => V TyVar r b -> V k r b -> MIO i r ()+(+=:) a b = modifyOp (+) a b+(*=:) a b = modifyOp (*) a b+(-=:) a b = modifyOp (-) a b++(%=:) :: (HasValue r  (V k r) i, Integral b) => V TyVar r b -> V k r b -> MIO i r ()+(%=:) a b = modifyOp mod a b++(<.), (>.), (>=.), (<=.) :: (Ord c, HasValue r  (V b1 r) i, HasValue r  (V b2 r) i) => V b1 r c -> V b2 r c -> V (TyComp i TyVal) r Bool+(<.) a b = liftOp2 (<) a b+(>.) a b = liftOp2 (>) a b+(>=.) a b = liftOp2 (>=) a b+(<=.) a b = liftOp2 (<=) a b++(==.) :: (Eq c, HasValue r  (V b1 r) i, HasValue r  (V b2 r) i) => V b1 r c -> V b2 r c -> V (TyComp i TyVal) r Bool+(==.) a b = liftOp2 (==) a b++(+.), (-.), (*.) :: (Num c, HasValue r  (V b1 r) i, HasValue r  (V b2 r) i) => V b1 r c -> V b2 r c -> V (TyComp i TyVal) r c+(+.) a b = liftOp2 (+) a b+(-.) a b = liftOp2 (-) a b+(*.) a b = liftOp2 (*) a b++(%.) :: (Integral c, HasValue r  (V b1 r) i, HasValue r  (V b2 r) i) => V b1 r c -> V b2 r c -> V (TyComp i TyVal) r c+(%.) a b = liftOp2 mod a b++(/.) :: (HasValue r  (V b1 r) i, HasValue r  (V b2 r) i, Fractional c) => V b1 r c -> V b2 r c -> V (TyComp i TyVal) r c+(/.) a b = liftOp2 (/) a b ++(&&.), (||.) :: (HasValue r  (V b1 r) i , HasValue r  (V b2 r) i) => V b1 r Bool -> V b2 r Bool -> V (TyComp i TyVal) r Bool+(&&.) a b = liftOp2 (&&) a b+(||.) a b = liftOp2 (||) a b++(~.) :: (HasValue r  (V b r) i) => V b r Bool -> V (TyComp i TyVal) r Bool+(~.) a = C $ do +  a' <- val a+  return $ Lit $ not a'++-- | @'liftOp2' f@ turns a pure function into one which+-- gets executes its arguments and returns their value as a+-- function.  It is defined using 'liftOp'.+liftOp2 :: (HasValue r  (V b1 r) i, HasValue r  (V b2 r) i) => (a -> b -> c) -> V b1 r a -> V b2 r b -> V (TyComp i TyVal) r c+liftOp2 f v1 v2 = C $ do+  v1' <- val v1+  v2' <- val v2   return $ Lit $ f v1' v2'

@@ -1,10 +1,28 @@ Name:                ImperativeHaskell-Version:             1.1.1.0-Description:         A monad that uses GADTs and continuations-                     to replicate what it is like to program-                     in an imperative language like C or Java-                     with "return", "for", "break", "continue", -                     and mutable references.+Version:             2.0.0.0+Description:+  A monad that uses GADTs and continuations to replicate what it is like to program+  in an imperative language like C, Java or Go with "return", "for", "break", "continue", +  and mutable references.+  .+  In Version 2:+  .+  * Single return function: @return'@+  .+  * A Go language style @defer'@ primitive.+  .+  * Proper compiler errors when @break'@ and @continue'@ are used incorrectly+  . +  * /Note/: Version 2 has a very different internal structure from version 1, +    and thus there will likely be type signature conflicts.+  .+  For more information see:+  . +  * Examples on github <http://github.com/mmirman/ImperativeHaskell/blob/master/Main.hs>+  .+  * The relevant blog post <http://kormacode.blogspot.com/2011/11/c-style-haskell_10.html>+  + Synopsis:	     A library for writing Imperative style haskell.  Homepage:            https://github.com/mmirman/ImperativeHaskell@@ -37,5 +55,13 @@                       Control.Monad.Imperative.Operators,                       Control.Monad.Imperative.FunctionFactory   -  Extensions: GADTs, EmptyDataDecls, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleInstances, TemplateHaskell -    +  Extensions: GADTs, +              EmptyDataDecls, +              GeneralizedNewtypeDeriving, +              MultiParamTypeClasses, +              FlexibleInstances, +              FlexibleContexts,+              TemplateHaskell,+              UndecidableInstances,+              TypeFamilies,+              FunctionalDependencies

@@ -1,9 +1,7 @@ {-# LANGUAGE
- GADTs,
+ RankNTypes,
  TemplateHaskell,
- ScopedTypeVariables, 
- OverloadedStrings,
- RankNTypes
+ NoMonomorphismRestriction
  #-}
 
 -----------------------------------------------------------------------------
@@ -14,41 +12,55 @@ -- Portability :  portable
 -- Description :  An example module for Control.Monad.Imperative
 -- 
--- Copyright (C) 2012  Matthew Mirman
--- 
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
--- 
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
--- 
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>
-
+-- Some exampes of use.
+-----------------------------------------------------------------------------
 module Main where
 
 import Control.Monad.Imperative
-
-swap(r1, r2) = function $ do
+  
+swap(r1,r2) = function $ do
 {
     z <- new auto;
     z =: r1;
     r1 =: r2;
     r2 =: z;
+    return' r1;
 };
 
 imperativeId(r1) = function $ do
 {
-    return' r1;
+  return' r1;
 };
 
-type NumLit = forall r a . Num a => V Val r a
+type NumLit = forall r a . Num a => V TyVal r a
 
-factorial = function $ do
+deferer() = function $ do
+{ 
+  a <- new 0;
+  b <- new 2;
+  
+  defer' a;
+  
+  defer' $ do {
+    io $ putStrLn "hi1";
+    io $ putStrLn "hi2";
+  };
+  
+  defer' $ do {
+    imperativeId(a);
+    io $ putStrLn "hi3";
+    return' b; 
+  };
+  
+  return' a;
+}
+
+print' v = do 
+  v' <- val v
+  io $ print v'
+
+factorial :: (Show r, Num r, Ord r) => () -> MIO i b r
+factorial() = function $ do
 {
     a <- new 0;
     n <- new 1;
@@ -57,23 +69,35 @@     
     for' ( a =: Lit 1 , a <. Lit 11 , a +=: Lit 1 ) $ do
     {
+      
+        b <- new 0;
+        b =: a;
+        
+        defer' $ do {
+           print' b;
+        };
+        
         n *=: a;
-        if' ( a <. Lit 7)
+        if' ( a <. Lit 5)
             continue';
         
-        if' ( a >. Lit 5) 
+        if' ( a >. Lit 2) 
             break';
-
+        
         return' a;
-    };
+        
+    }; 
     
     a =: imperativeId(a);
     
     swap( (&)n , (&)a);
     
-    return' n;
+    return' a;
 };
 
 main = do
-  t <- runImperative factorial
-  putStrLn $ "Some Factorial: "++show (t :: Int)
+  t <- runImperative $ deferer()
+  putStrLn $ "Defer: " ++ show t
+  
+  j <- runImperative $ factorial()
+  putStrLn $ "Factorial: " ++ show j

binary file changed (absent → 3396 bytes)

binary file changed (absent → 408 bytes)

binary file changed (absent → 1821 bytes)

binary file changed (absent → 31608 bytes)

binary file changed (absent → 40450 bytes)

binary file changed (absent → 71864 bytes)

binary file changed (absent → 16736 bytes)

binary file changed (absent → 16596 bytes)

binary file changed (absent → 99548 bytes)

@@ -0,0 +1,29 @@+module Paths_ImperativeHaskell (+    version,+    getBinDir, getLibDir, getDataDir, getLibexecDir,+    getDataFileName+  ) where++import Data.Version (Version(..))+import System.Environment (getEnv)++version :: Version+version = Version {versionBranch = [2,0,0,0], versionTags = []}++bindir, libdir, datadir, libexecdir :: FilePath++bindir     = "/Users/matt/.cabal/bin"+libdir     = "/Users/matt/.cabal/lib/ImperativeHaskell-2.0.0.0/ghc-7.4.1"+datadir    = "/Users/matt/.cabal/share/ImperativeHaskell-2.0.0.0"+libexecdir = "/Users/matt/.cabal/libexec"++getBinDir, getLibDir, getDataDir, getLibexecDir :: IO FilePath+getBinDir = catch (getEnv "ImperativeHaskell_bindir") (\_ -> return bindir)+getLibDir = catch (getEnv "ImperativeHaskell_libdir") (\_ -> return libdir)+getDataDir = catch (getEnv "ImperativeHaskell_datadir") (\_ -> return datadir)+getLibexecDir = catch (getEnv "ImperativeHaskell_libexecdir") (\_ -> return libexecdir)++getDataFileName :: FilePath -> IO FilePath+getDataFileName name = do+  dir <- getDataDir+  return (dir ++ "/" ++ name)

@@ -0,0 +1,23 @@+/* DO NOT EDIT: This file is automatically generated by Cabal */++/* package base-4.5.0.0 */+#define VERSION_base "4.5.0.0"+#define MIN_VERSION_base(major1,major2,minor) (\+  (major1) <  4 || \+  (major1) == 4 && (major2) <  5 || \+  (major1) == 4 && (major2) == 5 && (minor) <= 0)++/* package mtl-2.1.1 */+#define VERSION_mtl "2.1.1"+#define MIN_VERSION_mtl(major1,major2,minor) (\+  (major1) <  2 || \+  (major1) == 2 && (major2) <  1 || \+  (major1) == 2 && (major2) == 1 && (minor) <= 1)++/* package template-haskell-2.7.0.0 */+#define VERSION_template_haskell "2.7.0.0"+#define MIN_VERSION_template_haskell(major1,major2,minor) (\+  (major1) <  2 || \+  (major1) == 2 && (major2) <  7 || \+  (major1) == 2 && (major2) == 7 && (minor) <= 0)+

binary file changed (absent → 145688 bytes)

@@ -0,0 +1,2 @@+[InstalledPackageInfo {installedPackageId = InstalledPackageId "ImperativeHaskell-2.0.0.0-inplace", sourcePackageId = PackageIdentifier {pkgName = PackageName "ImperativeHaskell", pkgVersion = Version {versionBranch = [2,0,0,0], versionTags = []}}, license = GPL (Just (Version {versionBranch = [3], versionTags = []})), copyright = "", maintainer = "Matthew Mirman <mmirman@andrew.cmu.edu>", author = "Matthew Mirman", stability = "", homepage = "https://github.com/mmirman/ImperativeHaskell", pkgUrl = "", synopsis = "", description = "A monad that uses GADTs and continuations to replicate what it is like to program\nin an imperative language like C, Java or Go with \"return\", \"for\", \"break\", \"continue\",\nand mutable references.\n\nIn Version 2:\n\n* Single return function: @return'@\n\n* A Go language style @defer'@ primitive.\n\n* Proper compiler errors when @break'@ and @continue'@ are used incorrectly\n\n* /Note/: Version 2 has a very different internal structure from version 1,\nand thus there will likely be type signature conflicts.\n\nFor more information see:\n\n* Examples on github <http://github.com/mmirman/ImperativeHaskell/blob/master/Main.hs>\n\n* The relevant blog post <http://kormacode.blogspot.com/2011/11/c-style-haskell_10.html>", category = "Control, Embedded, Development, Language", exposed = True, exposedModules = ["Control.Monad.Imperative","Control.Monad.Imperative.Internals","Control.Monad.Imperative.Operators","Control.Monad.Imperative.FunctionFactory"], hiddenModules = [], trusted = False, importDirs = ["/Users/matt/projects/ImperativeHaskell/dist/build"], libraryDirs = ["/Users/matt/projects/ImperativeHaskell/dist/build"], hsLibraries = ["HSImperativeHaskell-2.0.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "mtl-2.1.1-ae9b44386a2528180e60dcf2412689c0",InstalledPackageId "template-haskell-2.7.0.0-e0ac8598212fa76f924e85dd1be6a701"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/matt/projects/ImperativeHaskell/dist/doc/html/ImperativeHaskell/ImperativeHaskell.haddock"], haddockHTMLs = ["/Users/matt/projects/ImperativeHaskell/dist/doc/html/ImperativeHaskell"]}+]

@@ -0,0 +1,2 @@+Saved package config for ImperativeHaskell-2.0.0.0 written by Cabal-1.10.1.0 using ghc-7.0+LocalBuildInfo {configFlags = ConfigFlags {configPrograms = [], configProgramPaths = [], configProgramArgs = [], configHcFlavor = Flag GHC, configHcPath = NoFlag, configHcPkg = NoFlag, configVanillaLib = Flag True, configProfLib = Flag False, configSharedLib = Flag False, configProfExe = Flag False, configConfigureArgs = [], configOptimization = Flag NormalOptimisation, configProgPrefix = Flag "", configProgSuffix = Flag "", configInstallDirs = InstallDirs {prefix = Flag "/Users/matt/.cabal", bindir = NoFlag, libdir = NoFlag, libsubdir = NoFlag, dynlibdir = NoFlag, libexecdir = NoFlag, progdir = NoFlag, includedir = NoFlag, datadir = NoFlag, datasubdir = NoFlag, docdir = NoFlag, mandir = NoFlag, htmldir = NoFlag, haddockdir = NoFlag}, configScratchDir = NoFlag, configExtraLibDirs = [], configExtraIncludeDirs = [], configDistPref = Flag "dist", configVerbosity = Flag Normal, configUserInstall = Flag True, configPackageDB = NoFlag, configGHCiLib = Flag True, configSplitObjs = Flag False, configStripExes = Flag True, configConstraints = [Dependency (PackageName "base") (ThisVersion (Version {versionBranch = [4,5,0,0], versionTags = []})),Dependency (PackageName "mtl") (ThisVersion (Version {versionBranch = [2,1,1], versionTags = []})),Dependency (PackageName "template-haskell") (ThisVersion (Version {versionBranch = [2,7,0,0], versionTags = []}))], configConfigurationsFlags = [], configTests = Flag False}, extraConfigArgs = [], installDirTemplates = InstallDirs {prefix = "/Users/matt/.cabal", bindir = "$prefix/bin", libdir = "$prefix/lib", libsubdir = "$pkgid/$compiler", dynlibdir = "$libdir", libexecdir = "$prefix/libexec", progdir = "$libdir/hugs/programs", includedir = "$libdir/$libsubdir/include", datadir = "$prefix/share", datasubdir = "$pkgid", docdir = "$datadir/doc/$pkgid", mandir = "$datadir/man", htmldir = "$docdir/html", haddockdir = "$htmldir"}, compiler = Compiler {compilerId = CompilerId GHC (Version {versionBranch = [7,4,1], versionTags = []}), compilerLanguages = [(Haskell98,"-XHaskell98"),(Haskell2010,"-XHaskell2010")], compilerExtensions = [(UnknownExtension "Haskell98","-XHaskell98"),(UnknownExtension "Haskell2010","-XHaskell2010"),(UnknownExtension "Unsafe","-XUnsafe"),(UnknownExtension "Trustworthy","-XTrustworthy"),(UnknownExtension "Safe","-XSafe"),(CPP,"-XCPP"),(UnknownExtension "NoCPP","-XNoCPP"),(PostfixOperators,"-XPostfixOperators"),(UnknownExtension "NoPostfixOperators","-XNoPostfixOperators"),(TupleSections,"-XTupleSections"),(UnknownExtension "NoTupleSections","-XNoTupleSections"),(PatternGuards,"-XPatternGuards"),(UnknownExtension "NoPatternGuards","-XNoPatternGuards"),(UnicodeSyntax,"-XUnicodeSyntax"),(UnknownExtension "NoUnicodeSyntax","-XNoUnicodeSyntax"),(MagicHash,"-XMagicHash"),(UnknownExtension "NoMagicHash","-XNoMagicHash"),(PolymorphicComponents,"-XPolymorphicComponents"),(UnknownExtension "NoPolymorphicComponents","-XNoPolymorphicComponents"),(ExistentialQuantification,"-XExistentialQuantification"),(UnknownExtension "NoExistentialQuantification","-XNoExistentialQuantification"),(KindSignatures,"-XKindSignatures"),(UnknownExtension "NoKindSignatures","-XNoKindSignatures"),(EmptyDataDecls,"-XEmptyDataDecls"),(UnknownExtension "NoEmptyDataDecls","-XNoEmptyDataDecls"),(ParallelListComp,"-XParallelListComp"),(UnknownExtension "NoParallelListComp","-XNoParallelListComp"),(TransformListComp,"-XTransformListComp"),(UnknownExtension "NoTransformListComp","-XNoTransformListComp"),(UnknownExtension "MonadComprehensions","-XMonadComprehensions"),(UnknownExtension "NoMonadComprehensions","-XNoMonadComprehensions"),(ForeignFunctionInterface,"-XForeignFunctionInterface"),(UnknownExtension "NoForeignFunctionInterface","-XNoForeignFunctionInterface"),(UnliftedFFITypes,"-XUnliftedFFITypes"),(UnknownExtension "NoUnliftedFFITypes","-XNoUnliftedFFITypes"),(UnknownExtension "InterruptibleFFI","-XInterruptibleFFI"),(UnknownExtension "NoInterruptibleFFI","-XNoInterruptibleFFI"),(UnknownExtension "CApiFFI","-XCApiFFI"),(UnknownExtension "NoCApiFFI","-XNoCApiFFI"),(GHCForeignImportPrim,"-XGHCForeignImportPrim"),(UnknownExtension "NoGHCForeignImportPrim","-XNoGHCForeignImportPrim"),(LiberalTypeSynonyms,"-XLiberalTypeSynonyms"),(UnknownExtension "NoLiberalTypeSynonyms","-XNoLiberalTypeSynonyms"),(Rank2Types,"-XRank2Types"),(UnknownExtension "NoRank2Types","-XNoRank2Types"),(RankNTypes,"-XRankNTypes"),(UnknownExtension "NoRankNTypes","-XNoRankNTypes"),(ImpredicativeTypes,"-XImpredicativeTypes"),(UnknownExtension "NoImpredicativeTypes","-XNoImpredicativeTypes"),(TypeOperators,"-XTypeOperators"),(UnknownExtension "NoTypeOperators","-XNoTypeOperators"),(RecursiveDo,"-XRecursiveDo"),(UnknownExtension "NoRecursiveDo","-XNoRecursiveDo"),(DoRec,"-XDoRec"),(UnknownExtension "NoDoRec","-XNoDoRec"),(Arrows,"-XArrows"),(UnknownExtension "NoArrows","-XNoArrows"),(UnknownExtension "ParallelArrays","-XParallelArrays"),(UnknownExtension "NoParallelArrays","-XNoParallelArrays"),(TemplateHaskell,"-XTemplateHaskell"),(UnknownExtension "NoTemplateHaskell","-XNoTemplateHaskell"),(QuasiQuotes,"-XQuasiQuotes"),(UnknownExtension "NoQuasiQuotes","-XNoQuasiQuotes"),(NoImplicitPrelude,"-XNoImplicitPrelude"),(NoImplicitPrelude,"-XNoImplicitPrelude"),(RecordWildCards,"-XRecordWildCards"),(UnknownExtension "NoRecordWildCards","-XNoRecordWildCards"),(NamedFieldPuns,"-XNamedFieldPuns"),(UnknownExtension "NoNamedFieldPuns","-XNoNamedFieldPuns"),(RecordPuns,"-XRecordPuns"),(UnknownExtension "NoRecordPuns","-XNoRecordPuns"),(DisambiguateRecordFields,"-XDisambiguateRecordFields"),(UnknownExtension "NoDisambiguateRecordFields","-XNoDisambiguateRecordFields"),(OverloadedStrings,"-XOverloadedStrings"),(UnknownExtension "NoOverloadedStrings","-XNoOverloadedStrings"),(GADTs,"-XGADTs"),(UnknownExtension "NoGADTs","-XNoGADTs"),(UnknownExtension "GADTSyntax","-XGADTSyntax"),(UnknownExtension "NoGADTSyntax","-XNoGADTSyntax"),(ViewPatterns,"-XViewPatterns"),(UnknownExtension "NoViewPatterns","-XNoViewPatterns"),(TypeFamilies,"-XTypeFamilies"),(UnknownExtension "NoTypeFamilies","-XNoTypeFamilies"),(BangPatterns,"-XBangPatterns"),(UnknownExtension "NoBangPatterns","-XNoBangPatterns"),(NoMonomorphismRestriction,"-XNoMonomorphismRestriction"),(NoMonomorphismRestriction,"-XNoMonomorphismRestriction"),(NPlusKPatterns,"-XNPlusKPatterns"),(UnknownExtension "NoNPlusKPatterns","-XNoNPlusKPatterns"),(DoAndIfThenElse,"-XDoAndIfThenElse"),(UnknownExtension "NoDoAndIfThenElse","-XNoDoAndIfThenElse"),(RebindableSyntax,"-XRebindableSyntax"),(UnknownExtension "NoRebindableSyntax","-XNoRebindableSyntax"),(UnknownExtension "ConstraintKinds","-XConstraintKinds"),(UnknownExtension "NoConstraintKinds","-XNoConstraintKinds"),(UnknownExtension "PolyKinds","-XPolyKinds"),(UnknownExtension "NoPolyKinds","-XNoPolyKinds"),(UnknownExtension "DataKinds","-XDataKinds"),(UnknownExtension "NoDataKinds","-XNoDataKinds"),(NoMonoPatBinds,"-XNoMonoPatBinds"),(NoMonoPatBinds,"-XNoMonoPatBinds"),(ExplicitForAll,"-XExplicitForAll"),(UnknownExtension "NoExplicitForAll","-XNoExplicitForAll"),(UnknownExtension "AlternativeLayoutRule","-XAlternativeLayoutRule"),(UnknownExtension "NoAlternativeLayoutRule","-XNoAlternativeLayoutRule"),(UnknownExtension "AlternativeLayoutRuleTransitional","-XAlternativeLayoutRuleTransitional"),(UnknownExtension "NoAlternativeLayoutRuleTransitional","-XNoAlternativeLayoutRuleTransitional"),(DatatypeContexts,"-XDatatypeContexts"),(UnknownExtension "NoDatatypeContexts","-XNoDatatypeContexts"),(UnknownExtension "NondecreasingIndentation","-XNondecreasingIndentation"),(UnknownExtension "NoNondecreasingIndentation","-XNoNondecreasingIndentation"),(UnknownExtension "RelaxedLayout","-XRelaxedLayout"),(UnknownExtension "NoRelaxedLayout","-XNoRelaxedLayout"),(UnknownExtension "TraditionalRecordSyntax","-XTraditionalRecordSyntax"),(UnknownExtension "NoTraditionalRecordSyntax","-XNoTraditionalRecordSyntax"),(MonoLocalBinds,"-XMonoLocalBinds"),(UnknownExtension "NoMonoLocalBinds","-XNoMonoLocalBinds"),(RelaxedPolyRec,"-XRelaxedPolyRec"),(UnknownExtension "NoRelaxedPolyRec","-XNoRelaxedPolyRec"),(ExtendedDefaultRules,"-XExtendedDefaultRules"),(UnknownExtension "NoExtendedDefaultRules","-XNoExtendedDefaultRules"),(ImplicitParams,"-XImplicitParams"),(UnknownExtension "NoImplicitParams","-XNoImplicitParams"),(ScopedTypeVariables,"-XScopedTypeVariables"),(UnknownExtension "NoScopedTypeVariables","-XNoScopedTypeVariables"),(PatternSignatures,"-XPatternSignatures"),(UnknownExtension "NoPatternSignatures","-XNoPatternSignatures"),(UnboxedTuples,"-XUnboxedTuples"),(UnknownExtension "NoUnboxedTuples","-XNoUnboxedTuples"),(StandaloneDeriving,"-XStandaloneDeriving"),(UnknownExtension "NoStandaloneDeriving","-XNoStandaloneDeriving"),(DeriveDataTypeable,"-XDeriveDataTypeable"),(UnknownExtension "NoDeriveDataTypeable","-XNoDeriveDataTypeable"),(DeriveFunctor,"-XDeriveFunctor"),(UnknownExtension "NoDeriveFunctor","-XNoDeriveFunctor"),(DeriveTraversable,"-XDeriveTraversable"),(UnknownExtension "NoDeriveTraversable","-XNoDeriveTraversable"),(DeriveFoldable,"-XDeriveFoldable"),(UnknownExtension "NoDeriveFoldable","-XNoDeriveFoldable"),(UnknownExtension "DeriveGeneric","-XDeriveGeneric"),(UnknownExtension "NoDeriveGeneric","-XNoDeriveGeneric"),(UnknownExtension "DefaultSignatures","-XDefaultSignatures"),(UnknownExtension "NoDefaultSignatures","-XNoDefaultSignatures"),(TypeSynonymInstances,"-XTypeSynonymInstances"),(UnknownExtension "NoTypeSynonymInstances","-XNoTypeSynonymInstances"),(FlexibleContexts,"-XFlexibleContexts"),(UnknownExtension "NoFlexibleContexts","-XNoFlexibleContexts"),(FlexibleInstances,"-XFlexibleInstances"),(UnknownExtension "NoFlexibleInstances","-XNoFlexibleInstances"),(ConstrainedClassMethods,"-XConstrainedClassMethods"),(UnknownExtension "NoConstrainedClassMethods","-XNoConstrainedClassMethods"),(MultiParamTypeClasses,"-XMultiParamTypeClasses"),(UnknownExtension "NoMultiParamTypeClasses","-XNoMultiParamTypeClasses"),(FunctionalDependencies,"-XFunctionalDependencies"),(UnknownExtension "NoFunctionalDependencies","-XNoFunctionalDependencies"),(GeneralizedNewtypeDeriving,"-XGeneralizedNewtypeDeriving"),(UnknownExtension "NoGeneralizedNewtypeDeriving","-XNoGeneralizedNewtypeDeriving"),(OverlappingInstances,"-XOverlappingInstances"),(UnknownExtension "NoOverlappingInstances","-XNoOverlappingInstances"),(UndecidableInstances,"-XUndecidableInstances"),(UnknownExtension "NoUndecidableInstances","-XNoUndecidableInstances"),(IncoherentInstances,"-XIncoherentInstances"),(UnknownExtension "NoIncoherentInstances","-XNoIncoherentInstances"),(PackageImports,"-XPackageImports"),(UnknownExtension "NoPackageImports","-XNoPackageImports")]}, buildDir = "dist/build", scratchDir = "dist/scratch", libraryConfig = Just (ComponentLocalBuildInfo {componentPackageDeps = [(InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,5,0,0], versionTags = []}}),(InstalledPackageId "mtl-2.1.1-ae9b44386a2528180e60dcf2412689c0",PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,1,1], versionTags = []}}),(InstalledPackageId "template-haskell-2.7.0.0-e0ac8598212fa76f924e85dd1be6a701",PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,7,0,0], versionTags = []}})]}), executableConfigs = [], testSuiteConfigs = [], installedPkgs = PackageIndex (fromList [(InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0",InstalledPackageInfo {installedPackageId = InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0", sourcePackageId = PackageIdentifier {pkgName = PackageName "array", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package defines the classes @IArray@ of immutable arrays and\n@MArray@ of arrays mutable within appropriate monads, as well as\nsome instances of these classes.", category = "Data Structures", exposed = True, exposedModules = [ModuleName ["Data","Array","Base"],ModuleName ["Data","Array","IArray"],ModuleName ["Data","Array","IO"],ModuleName ["Data","Array","IO","Safe"],ModuleName ["Data","Array","IO","Internals"],ModuleName ["Data","Array","MArray"],ModuleName ["Data","Array","MArray","Safe"],ModuleName ["Data","Array","ST"],ModuleName ["Data","Array","ST","Safe"],ModuleName ["Data","Array","Storable"],ModuleName ["Data","Array","Storable","Safe"],ModuleName ["Data","Array","Storable","Internals"],ModuleName ["Data","Array","Unboxed"],ModuleName ["Data","Array","Unsafe"],ModuleName ["Data","Array"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/array-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/array-0.4.0.0"], hsLibraries = ["HSarray-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/array-0.4.0.0/array.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/array-0.4.0.0"]}),(InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageInfo {installedPackageId = InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384", sourcePackageId = PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,5,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains the Prelude and its support libraries,\nand a large collection of useful libraries ranging from data\nstructures to parsing combinators and debugging utilities.", category = "", exposed = True, exposedModules = [ModuleName ["Foreign","Concurrent"],ModuleName ["GHC","Arr"],ModuleName ["GHC","Base"],ModuleName ["GHC","Conc"],ModuleName ["GHC","Conc","IO"],ModuleName ["GHC","Conc","Signal"],ModuleName ["GHC","Conc","Sync"],ModuleName ["GHC","ConsoleHandler"],ModuleName ["GHC","Constants"],ModuleName ["GHC","Desugar"],ModuleName ["GHC","Enum"],ModuleName ["GHC","Environment"],ModuleName ["GHC","Err"],ModuleName ["GHC","Exception"],ModuleName ["GHC","Exts"],ModuleName ["GHC","Fingerprint"],ModuleName ["GHC","Fingerprint","Type"],ModuleName ["GHC","Float"],ModuleName ["GHC","Float","ConversionUtils"],ModuleName ["GHC","Float","RealFracMethods"],ModuleName ["GHC","Foreign"],ModuleName ["GHC","ForeignPtr"],ModuleName ["GHC","Handle"],ModuleName ["GHC","IO"],ModuleName ["GHC","IO","Buffer"],ModuleName ["GHC","IO","BufferedIO"],ModuleName ["GHC","IO","Device"],ModuleName ["GHC","IO","Encoding"],ModuleName ["GHC","IO","Encoding","CodePage"],ModuleName ["GHC","IO","Encoding","Failure"],ModuleName ["GHC","IO","Encoding","Iconv"],ModuleName ["GHC","IO","Encoding","Latin1"],ModuleName ["GHC","IO","Encoding","Types"],ModuleName ["GHC","IO","Encoding","UTF16"],ModuleName ["GHC","IO","Encoding","UTF32"],ModuleName ["GHC","IO","Encoding","UTF8"],ModuleName ["GHC","IO","Exception"],ModuleName ["GHC","IO","FD"],ModuleName ["GHC","IO","Handle"],ModuleName ["GHC","IO","Handle","FD"],ModuleName ["GHC","IO","Handle","Internals"],ModuleName ["GHC","IO","Handle","Text"],ModuleName ["GHC","IO","Handle","Types"],ModuleName ["GHC","IO","IOMode"],ModuleName ["GHC","IOArray"],ModuleName ["GHC","IOBase"],ModuleName ["GHC","IORef"],ModuleName ["GHC","Int"],ModuleName ["GHC","List"],ModuleName ["GHC","MVar"],ModuleName ["GHC","Num"],ModuleName ["GHC","PArr"],ModuleName ["GHC","Pack"],ModuleName ["GHC","Ptr"],ModuleName ["GHC","Read"],ModuleName ["GHC","Real"],ModuleName ["GHC","ST"],ModuleName ["GHC","Stack"],ModuleName ["GHC","Stats"],ModuleName ["GHC","Show"],ModuleName ["GHC","Stable"],ModuleName ["GHC","Storable"],ModuleName ["GHC","STRef"],ModuleName ["GHC","TopHandler"],ModuleName ["GHC","Unicode"],ModuleName ["GHC","Weak"],ModuleName ["GHC","Word"],ModuleName ["System","Timeout"],ModuleName ["GHC","Event"],ModuleName ["Control","Applicative"],ModuleName ["Control","Arrow"],ModuleName ["Control","Category"],ModuleName ["Control","Concurrent"],ModuleName ["Control","Concurrent","Chan"],ModuleName ["Control","Concurrent","MVar"],ModuleName ["Control","Concurrent","QSem"],ModuleName ["Control","Concurrent","QSemN"],ModuleName ["Control","Concurrent","SampleVar"],ModuleName ["Control","Exception"],ModuleName ["Control","Exception","Base"],ModuleName ["Control","OldException"],ModuleName ["Control","Monad"],ModuleName ["Control","Monad","Fix"],ModuleName ["Control","Monad","Instances"],ModuleName ["Control","Monad","ST"],ModuleName ["Control","Monad","ST","Safe"],ModuleName ["Control","Monad","ST","Unsafe"],ModuleName ["Control","Monad","ST","Lazy"],ModuleName ["Control","Monad","ST","Lazy","Safe"],ModuleName ["Control","Monad","ST","Lazy","Unsafe"],ModuleName ["Control","Monad","ST","Strict"],ModuleName ["Control","Monad","Zip"],ModuleName ["Data","Bits"],ModuleName ["Data","Bool"],ModuleName ["Data","Char"],ModuleName ["Data","Complex"],ModuleName ["Data","Dynamic"],ModuleName ["Data","Either"],ModuleName ["Data","Eq"],ModuleName ["Data","Data"],ModuleName ["Data","Fixed"],ModuleName ["Data","Foldable"],ModuleName ["Data","Function"],ModuleName ["Data","Functor"],ModuleName ["Data","HashTable"],ModuleName ["Data","IORef"],ModuleName ["Data","Int"],ModuleName ["Data","Ix"],ModuleName ["Data","List"],ModuleName ["Data","Maybe"],ModuleName ["Data","Monoid"],ModuleName ["Data","Ord"],ModuleName ["Data","Ratio"],ModuleName ["Data","STRef"],ModuleName ["Data","STRef","Lazy"],ModuleName ["Data","STRef","Strict"],ModuleName ["Data","String"],ModuleName ["Data","Traversable"],ModuleName ["Data","Tuple"],ModuleName ["Data","Typeable"],ModuleName ["Data","Typeable","Internal"],ModuleName ["Data","Unique"],ModuleName ["Data","Version"],ModuleName ["Data","Word"],ModuleName ["Debug","Trace"],ModuleName ["Foreign"],ModuleName ["Foreign","C"],ModuleName ["Foreign","C","Error"],ModuleName ["Foreign","C","String"],ModuleName ["Foreign","C","Types"],ModuleName ["Foreign","ForeignPtr"],ModuleName ["Foreign","ForeignPtr","Safe"],ModuleName ["Foreign","ForeignPtr","Unsafe"],ModuleName ["Foreign","Marshal"],ModuleName ["Foreign","Marshal","Alloc"],ModuleName ["Foreign","Marshal","Array"],ModuleName ["Foreign","Marshal","Error"],ModuleName ["Foreign","Marshal","Pool"],ModuleName ["Foreign","Marshal","Safe"],ModuleName ["Foreign","Marshal","Utils"],ModuleName ["Foreign","Marshal","Unsafe"],ModuleName ["Foreign","Ptr"],ModuleName ["Foreign","Safe"],ModuleName ["Foreign","StablePtr"],ModuleName ["Foreign","Storable"],ModuleName ["Numeric"],ModuleName ["Prelude"],ModuleName ["System","Console","GetOpt"],ModuleName ["System","CPUTime"],ModuleName ["System","Environment"],ModuleName ["System","Exit"],ModuleName ["System","IO"],ModuleName ["System","IO","Error"],ModuleName ["System","IO","Unsafe"],ModuleName ["System","Info"],ModuleName ["System","Mem"],ModuleName ["System","Mem","StableName"],ModuleName ["System","Mem","Weak"],ModuleName ["System","Posix","Internals"],ModuleName ["System","Posix","Types"],ModuleName ["Text","ParserCombinators","ReadP"],ModuleName ["Text","ParserCombinators","ReadPrec"],ModuleName ["Text","Printf"],ModuleName ["Text","Read"],ModuleName ["Text","Read","Lex"],ModuleName ["Text","Show"],ModuleName ["Text","Show","Functions"],ModuleName ["Unsafe","Coerce"]], hiddenModules = [ModuleName ["GHC","Event","Array"],ModuleName ["GHC","Event","Clock"],ModuleName ["GHC","Event","Control"],ModuleName ["GHC","Event","EPoll"],ModuleName ["GHC","Event","IntMap"],ModuleName ["GHC","Event","Internal"],ModuleName ["GHC","Event","KQueue"],ModuleName ["GHC","Event","Manager"],ModuleName ["GHC","Event","PSQ"],ModuleName ["GHC","Event","Poll"],ModuleName ["GHC","Event","Thread"],ModuleName ["GHC","Event","Unique"],ModuleName ["Control","Monad","ST","Imp"],ModuleName ["Control","Monad","ST","Lazy","Imp"],ModuleName ["Foreign","ForeignPtr","Imp"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0"], hsLibraries = ["HSbase-4.5.0.0"], extraLibraries = ["iconv"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0/include"], includes = ["HsBase.h"], depends = [InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a",InstalledPackageId "integer-gmp-0.4.0.0-ec87c5d9609a1d46da031ef5d51c4f79",InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/base-4.5.0.0/base.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/base-4.5.0.0"]}),(InstalledPackageId "builtin_rts",InstalledPackageInfo {installedPackageId = InstalledPackageId "builtin_rts", sourcePackageId = PackageIdentifier {pkgName = PackageName "rts", pkgVersion = Version {versionBranch = [1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "glasgow-haskell-users@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "", category = "", exposed = True, exposedModules = [], hiddenModules = [], importDirs = [], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1"], hsLibraries = ["HSrts"], extraLibraries = ["m","dl"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/include"], includes = ["Stg.h"], depends = [], hugsOptions = [], ccOptions = [], ldOptions = ["-u","_ghczmprim_GHCziTypes_Izh_static_info","-u","_ghczmprim_GHCziTypes_Czh_static_info","-u","_ghczmprim_GHCziTypes_Fzh_static_info","-u","_ghczmprim_GHCziTypes_Dzh_static_info","-u","_base_GHCziPtr_Ptr_static_info","-u","_base_GHCziWord_Wzh_static_info","-u","_base_GHCziInt_I8zh_static_info","-u","_base_GHCziInt_I16zh_static_info","-u","_base_GHCziInt_I32zh_static_info","-u","_base_GHCziInt_I64zh_static_info","-u","_base_GHCziWord_W8zh_static_info","-u","_base_GHCziWord_W16zh_static_info","-u","_base_GHCziWord_W32zh_static_info","-u","_base_GHCziWord_W64zh_static_info","-u","_base_GHCziStable_StablePtr_static_info","-u","_ghczmprim_GHCziTypes_Izh_con_info","-u","_ghczmprim_GHCziTypes_Czh_con_info","-u","_ghczmprim_GHCziTypes_Fzh_con_info","-u","_ghczmprim_GHCziTypes_Dzh_con_info","-u","_base_GHCziPtr_Ptr_con_info","-u","_base_GHCziPtr_FunPtr_con_info","-u","_base_GHCziStable_StablePtr_con_info","-u","_ghczmprim_GHCziTypes_False_closure","-u","_ghczmprim_GHCziTypes_True_closure","-u","_base_GHCziPack_unpackCString_closure","-u","_base_GHCziIOziException_stackOverflow_closure","-u","_base_GHCziIOziException_heapOverflow_closure","-u","_base_ControlziExceptionziBase_nonTermination_closure","-u","_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure","-u","_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure","-u","_base_ControlziExceptionziBase_nestedAtomically_closure","-u","_base_GHCziWeak_runFinalizzerBatch_closure","-u","_base_GHCziTopHandler_flushStdHandles_closure","-u","_base_GHCziTopHandler_runIO_closure","-u","_base_GHCziTopHandler_runNonIO_closure","-u","_base_GHCziConcziIO_ensureIOManagerIsRunning_closure","-u","_base_GHCziConcziSync_runSparks_closure","-u","_base_GHCziConcziSignal_runHandlers_closure","-Wl,-search_paths_first","-read_only_relocs","warning"], frameworkDirs = [], frameworks = [], haddockInterfaces = [], haddockHTMLs = []}),(InstalledPackageId "containers-0.4.2.1-7c54595400348f577b3b4a45691c5afd",InstalledPackageInfo {installedPackageId = InstalledPackageId "containers-0.4.2.1-7c54595400348f577b3b4a45691c5afd", sourcePackageId = PackageIdentifier {pkgName = PackageName "containers", pkgVersion = Version {versionBranch = [0,4,2,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "fox@ucw.cz", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains efficient general-purpose implementations\nof various basic immutable container types.  The declared cost of\neach operation is either worst-case or amortized, but remains\nvalid even if structures are shared.", category = "Data Structures", exposed = True, exposedModules = [ModuleName ["Data","Graph"],ModuleName ["Data","Sequence"],ModuleName ["Data","Tree"],ModuleName ["Data","IntMap"],ModuleName ["Data","IntSet"],ModuleName ["Data","Map"],ModuleName ["Data","Set"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/containers-0.4.2.1"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/containers-0.4.2.1"], hsLibraries = ["HScontainers-0.4.2.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0",InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "deepseq-1.3.0.0-6c19ec61ee16184ee322c1614ab60f0e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.2.1/containers.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.2.1"]}),(InstalledPackageId "deepseq-1.3.0.0-6c19ec61ee16184ee322c1614ab60f0e",InstalledPackageInfo {installedPackageId = InstalledPackageId "deepseq-1.3.0.0-6c19ec61ee16184ee322c1614ab60f0e", sourcePackageId = PackageIdentifier {pkgName = PackageName "deepseq", pkgVersion = Version {versionBranch = [1,3,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package provides methods for fully evaluating data structures\n(\\\"deep evaluation\\\"). Deep evaluation is often used for adding\nstrictness to a program, e.g. in order to force pending exceptions,\nremove space leaks, or force lazy I/O to happen. It is also useful\nin parallel programs, to ensure pending work does not migrate to the\nwrong thread.\n\nThe primary use of this package is via the 'deepseq' function, a\n\\\"deep\\\" version of 'seq'. It is implemented on top of an 'NFData'\ntypeclass (\\\"Normal Form Data\\\", data structures with no unevaluated\ncomponents) which defines strategies for fully evaluating different\ndata types.\n", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","DeepSeq"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/deepseq-1.3.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/deepseq-1.3.0.0"], hsLibraries = ["HSdeepseq-1.3.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0",InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/deepseq-1.3.0.0/deepseq.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/deepseq-1.3.0.0"]}),(InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a",InstalledPackageInfo {installedPackageId = InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a", sourcePackageId = PackageIdentifier {pkgName = PackageName "ghc-prim", pkgVersion = Version {versionBranch = [0,2,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "GHC primitives.", category = "", exposed = True, exposedModules = [ModuleName ["GHC","Prim"],ModuleName ["GHC","Classes"],ModuleName ["GHC","CString"],ModuleName ["GHC","Debug"],ModuleName ["GHC","Generics"],ModuleName ["GHC","Magic"],ModuleName ["GHC","PrimopWrappers"],ModuleName ["GHC","IntWord64"],ModuleName ["GHC","Tuple"],ModuleName ["GHC","Types"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/ghc-prim-0.2.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/ghc-prim-0.2.0.0"], hsLibraries = ["HSghc-prim-0.2.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0/ghc-prim.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0"]}),(InstalledPackageId "integer-gmp-0.4.0.0-ec87c5d9609a1d46da031ef5d51c4f79",InstalledPackageInfo {installedPackageId = InstalledPackageId "integer-gmp-0.4.0.0-ec87c5d9609a1d46da031ef5d51c4f79", sourcePackageId = PackageIdentifier {pkgName = PackageName "integer-gmp", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains an Integer library based on GMP.", category = "", exposed = True, exposedModules = [ModuleName ["GHC","Integer"],ModuleName ["GHC","Integer","GMP","Internals"],ModuleName ["GHC","Integer","GMP","Prim"],ModuleName ["GHC","Integer","Logarithms"],ModuleName ["GHC","Integer","Logarithms","Internals"]], hiddenModules = [ModuleName ["GHC","Integer","Type"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/integer-gmp-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/integer-gmp-0.4.0.0"], hsLibraries = ["HSinteger-gmp-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.4.0.0/integer-gmp.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.4.0.0"]}),(InstalledPackageId "mtl-2.1.1-ae9b44386a2528180e60dcf2412689c0",InstalledPackageInfo {installedPackageId = InstalledPackageId "mtl-2.1.1-ae9b44386a2528180e60dcf2412689c0", sourcePackageId = PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,1,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Edward Kmett <ekmett@gmail.com>", author = "Andy Gill", stability = "", homepage = "", pkgUrl = "", description = "Monad classes using functional dependencies, with instances\nfor various monad transformers, inspired by the paper\n/Functional Programming with Overloading and Higher-Order Polymorphism/,\nby Mark P Jones, in /Advanced School of Functional Programming/, 1995\n(<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","Monad","Cont"],ModuleName ["Control","Monad","Cont","Class"],ModuleName ["Control","Monad","Error"],ModuleName ["Control","Monad","Error","Class"],ModuleName ["Control","Monad","Identity"],ModuleName ["Control","Monad","List"],ModuleName ["Control","Monad","RWS"],ModuleName ["Control","Monad","RWS","Class"],ModuleName ["Control","Monad","RWS","Lazy"],ModuleName ["Control","Monad","RWS","Strict"],ModuleName ["Control","Monad","Reader"],ModuleName ["Control","Monad","Reader","Class"],ModuleName ["Control","Monad","State"],ModuleName ["Control","Monad","State","Class"],ModuleName ["Control","Monad","State","Lazy"],ModuleName ["Control","Monad","State","Strict"],ModuleName ["Control","Monad","Trans"],ModuleName ["Control","Monad","Writer"],ModuleName ["Control","Monad","Writer","Class"],ModuleName ["Control","Monad","Writer","Lazy"],ModuleName ["Control","Monad","Writer","Strict"]], hiddenModules = [], importDirs = ["/Users/matt/.cabal/lib/mtl-2.1.1/ghc-7.4.1"], libraryDirs = ["/Users/matt/.cabal/lib/mtl-2.1.1/ghc-7.4.1"], hsLibraries = ["HSmtl-2.1.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "transformers-0.3.0.0-f2303dfef836518cc2f6901210442e10"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/matt/.cabal/share/doc/mtl-2.1.1/html/mtl.haddock"], haddockHTMLs = ["/Users/matt/.cabal/share/doc/mtl-2.1.1/html"]}),(InstalledPackageId "pretty-1.1.1.0-7e118fa87f5698f5c005fe87b34befe8",InstalledPackageInfo {installedPackageId = InstalledPackageId "pretty-1.1.1.0-7e118fa87f5698f5c005fe87b34befe8", sourcePackageId = PackageIdentifier {pkgName = PackageName "pretty", pkgVersion = Version {versionBranch = [1,1,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "David Terei <dave.terei@gmail.com>", author = "", stability = "Stable", homepage = "http://github.com/haskell/pretty", pkgUrl = "", description = "This package contains a pretty-printing library, a set of API's\nthat provides a way to easily print out text in a consistent\nformat of your choosing. This is useful for compilers and related\ntools.\n\nThis library was originally designed by John Hughes's and has since\nbeen heavily modified by Simon Peyton Jones.", category = "Text", exposed = True, exposedModules = [ModuleName ["Text","PrettyPrint"],ModuleName ["Text","PrettyPrint","HughesPJ"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/pretty-1.1.1.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/pretty-1.1.1.0"], hsLibraries = ["HSpretty-1.1.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.1.1.0/pretty.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.1.1.0"]}),(InstalledPackageId "template-haskell-2.7.0.0-e0ac8598212fa76f924e85dd1be6a701",InstalledPackageInfo {installedPackageId = InstalledPackageId "template-haskell-2.7.0.0-e0ac8598212fa76f924e85dd1be6a701", sourcePackageId = PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,7,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "Facilities for manipulating Haskell source code using Template Haskell.", category = "", exposed = True, exposedModules = [ModuleName ["Language","Haskell","TH","Syntax","Internals"],ModuleName ["Language","Haskell","TH","Syntax"],ModuleName ["Language","Haskell","TH","PprLib"],ModuleName ["Language","Haskell","TH","Ppr"],ModuleName ["Language","Haskell","TH","Lib"],ModuleName ["Language","Haskell","TH","Quote"],ModuleName ["Language","Haskell","TH"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/template-haskell-2.7.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/template-haskell-2.7.0.0"], hsLibraries = ["HStemplate-haskell-2.7.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "containers-0.4.2.1-7c54595400348f577b3b4a45691c5afd",InstalledPackageId "pretty-1.1.1.0-7e118fa87f5698f5c005fe87b34befe8"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.7.0.0/template-haskell.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.7.0.0"]}),(InstalledPackageId "transformers-0.3.0.0-f2303dfef836518cc2f6901210442e10",InstalledPackageInfo {installedPackageId = InstalledPackageId "transformers-0.3.0.0-f2303dfef836518cc2f6901210442e10", sourcePackageId = PackageIdentifier {pkgName = PackageName "transformers", pkgVersion = Version {versionBranch = [0,3,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Ross Paterson <ross@soi.city.ac.uk>", author = "Andy Gill, Ross Paterson", stability = "", homepage = "", pkgUrl = "", description = "A portable library of functor and monad transformers, inspired by\nthe paper \\\"Functional Programming with Overloading and Higher-Order\nPolymorphism\\\", by Mark P Jones,\nin /Advanced School of Functional Programming/, 1995\n(<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).\n\nThis package contains:\n\n* the monad transformer class (in \"Control.Monad.Trans.Class\")\n\n* concrete functor and monad transformers, each with associated\noperations and functions to lift operations associated with other\ntransformers.\n\nIt can be used on its own in portable Haskell code, or with the monad\nclasses in the @mtl@ or @monads-tf@ packages, which automatically\nlift operations introduced by monad transformers through other\ntransformers.", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","Applicative","Backwards"],ModuleName ["Control","Applicative","Lift"],ModuleName ["Control","Monad","IO","Class"],ModuleName ["Control","Monad","Trans","Class"],ModuleName ["Control","Monad","Trans","Cont"],ModuleName ["Control","Monad","Trans","Error"],ModuleName ["Control","Monad","Trans","Identity"],ModuleName ["Control","Monad","Trans","List"],ModuleName ["Control","Monad","Trans","Maybe"],ModuleName ["Control","Monad","Trans","Reader"],ModuleName ["Control","Monad","Trans","RWS"],ModuleName ["Control","Monad","Trans","RWS","Lazy"],ModuleName ["Control","Monad","Trans","RWS","Strict"],ModuleName ["Control","Monad","Trans","State"],ModuleName ["Control","Monad","Trans","State","Lazy"],ModuleName ["Control","Monad","Trans","State","Strict"],ModuleName ["Control","Monad","Trans","Writer"],ModuleName ["Control","Monad","Trans","Writer","Lazy"],ModuleName ["Control","Monad","Trans","Writer","Strict"],ModuleName ["Data","Functor","Compose"],ModuleName ["Data","Functor","Constant"],ModuleName ["Data","Functor","Identity"],ModuleName ["Data","Functor","Product"],ModuleName ["Data","Functor","Reverse"]], hiddenModules = [], importDirs = ["/Users/matt/.cabal/lib/transformers-0.3.0.0/ghc-7.4.1"], libraryDirs = ["/Users/matt/.cabal/lib/transformers-0.3.0.0/ghc-7.4.1"], hsLibraries = ["HStransformers-0.3.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/matt/.cabal/share/doc/transformers-0.3.0.0/html/transformers.haddock"], haddockHTMLs = ["/Users/matt/.cabal/share/doc/transformers-0.3.0.0/html"]})]) (fromList [(PackageName "array",fromList [(Version {versionBranch = [0,4,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0", sourcePackageId = PackageIdentifier {pkgName = PackageName "array", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package defines the classes @IArray@ of immutable arrays and\n@MArray@ of arrays mutable within appropriate monads, as well as\nsome instances of these classes.", category = "Data Structures", exposed = True, exposedModules = [ModuleName ["Data","Array","Base"],ModuleName ["Data","Array","IArray"],ModuleName ["Data","Array","IO"],ModuleName ["Data","Array","IO","Safe"],ModuleName ["Data","Array","IO","Internals"],ModuleName ["Data","Array","MArray"],ModuleName ["Data","Array","MArray","Safe"],ModuleName ["Data","Array","ST"],ModuleName ["Data","Array","ST","Safe"],ModuleName ["Data","Array","Storable"],ModuleName ["Data","Array","Storable","Safe"],ModuleName ["Data","Array","Storable","Internals"],ModuleName ["Data","Array","Unboxed"],ModuleName ["Data","Array","Unsafe"],ModuleName ["Data","Array"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/array-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/array-0.4.0.0"], hsLibraries = ["HSarray-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/array-0.4.0.0/array.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/array-0.4.0.0"]}])]),(PackageName "base",fromList [(Version {versionBranch = [4,5,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384", sourcePackageId = PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,5,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains the Prelude and its support libraries,\nand a large collection of useful libraries ranging from data\nstructures to parsing combinators and debugging utilities.", category = "", exposed = True, exposedModules = [ModuleName ["Foreign","Concurrent"],ModuleName ["GHC","Arr"],ModuleName ["GHC","Base"],ModuleName ["GHC","Conc"],ModuleName ["GHC","Conc","IO"],ModuleName ["GHC","Conc","Signal"],ModuleName ["GHC","Conc","Sync"],ModuleName ["GHC","ConsoleHandler"],ModuleName ["GHC","Constants"],ModuleName ["GHC","Desugar"],ModuleName ["GHC","Enum"],ModuleName ["GHC","Environment"],ModuleName ["GHC","Err"],ModuleName ["GHC","Exception"],ModuleName ["GHC","Exts"],ModuleName ["GHC","Fingerprint"],ModuleName ["GHC","Fingerprint","Type"],ModuleName ["GHC","Float"],ModuleName ["GHC","Float","ConversionUtils"],ModuleName ["GHC","Float","RealFracMethods"],ModuleName ["GHC","Foreign"],ModuleName ["GHC","ForeignPtr"],ModuleName ["GHC","Handle"],ModuleName ["GHC","IO"],ModuleName ["GHC","IO","Buffer"],ModuleName ["GHC","IO","BufferedIO"],ModuleName ["GHC","IO","Device"],ModuleName ["GHC","IO","Encoding"],ModuleName ["GHC","IO","Encoding","CodePage"],ModuleName ["GHC","IO","Encoding","Failure"],ModuleName ["GHC","IO","Encoding","Iconv"],ModuleName ["GHC","IO","Encoding","Latin1"],ModuleName ["GHC","IO","Encoding","Types"],ModuleName ["GHC","IO","Encoding","UTF16"],ModuleName ["GHC","IO","Encoding","UTF32"],ModuleName ["GHC","IO","Encoding","UTF8"],ModuleName ["GHC","IO","Exception"],ModuleName ["GHC","IO","FD"],ModuleName ["GHC","IO","Handle"],ModuleName ["GHC","IO","Handle","FD"],ModuleName ["GHC","IO","Handle","Internals"],ModuleName ["GHC","IO","Handle","Text"],ModuleName ["GHC","IO","Handle","Types"],ModuleName ["GHC","IO","IOMode"],ModuleName ["GHC","IOArray"],ModuleName ["GHC","IOBase"],ModuleName ["GHC","IORef"],ModuleName ["GHC","Int"],ModuleName ["GHC","List"],ModuleName ["GHC","MVar"],ModuleName ["GHC","Num"],ModuleName ["GHC","PArr"],ModuleName ["GHC","Pack"],ModuleName ["GHC","Ptr"],ModuleName ["GHC","Read"],ModuleName ["GHC","Real"],ModuleName ["GHC","ST"],ModuleName ["GHC","Stack"],ModuleName ["GHC","Stats"],ModuleName ["GHC","Show"],ModuleName ["GHC","Stable"],ModuleName ["GHC","Storable"],ModuleName ["GHC","STRef"],ModuleName ["GHC","TopHandler"],ModuleName ["GHC","Unicode"],ModuleName ["GHC","Weak"],ModuleName ["GHC","Word"],ModuleName ["System","Timeout"],ModuleName ["GHC","Event"],ModuleName ["Control","Applicative"],ModuleName ["Control","Arrow"],ModuleName ["Control","Category"],ModuleName ["Control","Concurrent"],ModuleName ["Control","Concurrent","Chan"],ModuleName ["Control","Concurrent","MVar"],ModuleName ["Control","Concurrent","QSem"],ModuleName ["Control","Concurrent","QSemN"],ModuleName ["Control","Concurrent","SampleVar"],ModuleName ["Control","Exception"],ModuleName ["Control","Exception","Base"],ModuleName ["Control","OldException"],ModuleName ["Control","Monad"],ModuleName ["Control","Monad","Fix"],ModuleName ["Control","Monad","Instances"],ModuleName ["Control","Monad","ST"],ModuleName ["Control","Monad","ST","Safe"],ModuleName ["Control","Monad","ST","Unsafe"],ModuleName ["Control","Monad","ST","Lazy"],ModuleName ["Control","Monad","ST","Lazy","Safe"],ModuleName ["Control","Monad","ST","Lazy","Unsafe"],ModuleName ["Control","Monad","ST","Strict"],ModuleName ["Control","Monad","Zip"],ModuleName ["Data","Bits"],ModuleName ["Data","Bool"],ModuleName ["Data","Char"],ModuleName ["Data","Complex"],ModuleName ["Data","Dynamic"],ModuleName ["Data","Either"],ModuleName ["Data","Eq"],ModuleName ["Data","Data"],ModuleName ["Data","Fixed"],ModuleName ["Data","Foldable"],ModuleName ["Data","Function"],ModuleName ["Data","Functor"],ModuleName ["Data","HashTable"],ModuleName ["Data","IORef"],ModuleName ["Data","Int"],ModuleName ["Data","Ix"],ModuleName ["Data","List"],ModuleName ["Data","Maybe"],ModuleName ["Data","Monoid"],ModuleName ["Data","Ord"],ModuleName ["Data","Ratio"],ModuleName ["Data","STRef"],ModuleName ["Data","STRef","Lazy"],ModuleName ["Data","STRef","Strict"],ModuleName ["Data","String"],ModuleName ["Data","Traversable"],ModuleName ["Data","Tuple"],ModuleName ["Data","Typeable"],ModuleName ["Data","Typeable","Internal"],ModuleName ["Data","Unique"],ModuleName ["Data","Version"],ModuleName ["Data","Word"],ModuleName ["Debug","Trace"],ModuleName ["Foreign"],ModuleName ["Foreign","C"],ModuleName ["Foreign","C","Error"],ModuleName ["Foreign","C","String"],ModuleName ["Foreign","C","Types"],ModuleName ["Foreign","ForeignPtr"],ModuleName ["Foreign","ForeignPtr","Safe"],ModuleName ["Foreign","ForeignPtr","Unsafe"],ModuleName ["Foreign","Marshal"],ModuleName ["Foreign","Marshal","Alloc"],ModuleName ["Foreign","Marshal","Array"],ModuleName ["Foreign","Marshal","Error"],ModuleName ["Foreign","Marshal","Pool"],ModuleName ["Foreign","Marshal","Safe"],ModuleName ["Foreign","Marshal","Utils"],ModuleName ["Foreign","Marshal","Unsafe"],ModuleName ["Foreign","Ptr"],ModuleName ["Foreign","Safe"],ModuleName ["Foreign","StablePtr"],ModuleName ["Foreign","Storable"],ModuleName ["Numeric"],ModuleName ["Prelude"],ModuleName ["System","Console","GetOpt"],ModuleName ["System","CPUTime"],ModuleName ["System","Environment"],ModuleName ["System","Exit"],ModuleName ["System","IO"],ModuleName ["System","IO","Error"],ModuleName ["System","IO","Unsafe"],ModuleName ["System","Info"],ModuleName ["System","Mem"],ModuleName ["System","Mem","StableName"],ModuleName ["System","Mem","Weak"],ModuleName ["System","Posix","Internals"],ModuleName ["System","Posix","Types"],ModuleName ["Text","ParserCombinators","ReadP"],ModuleName ["Text","ParserCombinators","ReadPrec"],ModuleName ["Text","Printf"],ModuleName ["Text","Read"],ModuleName ["Text","Read","Lex"],ModuleName ["Text","Show"],ModuleName ["Text","Show","Functions"],ModuleName ["Unsafe","Coerce"]], hiddenModules = [ModuleName ["GHC","Event","Array"],ModuleName ["GHC","Event","Clock"],ModuleName ["GHC","Event","Control"],ModuleName ["GHC","Event","EPoll"],ModuleName ["GHC","Event","IntMap"],ModuleName ["GHC","Event","Internal"],ModuleName ["GHC","Event","KQueue"],ModuleName ["GHC","Event","Manager"],ModuleName ["GHC","Event","PSQ"],ModuleName ["GHC","Event","Poll"],ModuleName ["GHC","Event","Thread"],ModuleName ["GHC","Event","Unique"],ModuleName ["Control","Monad","ST","Imp"],ModuleName ["Control","Monad","ST","Lazy","Imp"],ModuleName ["Foreign","ForeignPtr","Imp"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0"], hsLibraries = ["HSbase-4.5.0.0"], extraLibraries = ["iconv"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/base-4.5.0.0/include"], includes = ["HsBase.h"], depends = [InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a",InstalledPackageId "integer-gmp-0.4.0.0-ec87c5d9609a1d46da031ef5d51c4f79",InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/base-4.5.0.0/base.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/base-4.5.0.0"]}])]),(PackageName "containers",fromList [(Version {versionBranch = [0,4,2,1], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "containers-0.4.2.1-7c54595400348f577b3b4a45691c5afd", sourcePackageId = PackageIdentifier {pkgName = PackageName "containers", pkgVersion = Version {versionBranch = [0,4,2,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "fox@ucw.cz", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains efficient general-purpose implementations\nof various basic immutable container types.  The declared cost of\neach operation is either worst-case or amortized, but remains\nvalid even if structures are shared.", category = "Data Structures", exposed = True, exposedModules = [ModuleName ["Data","Graph"],ModuleName ["Data","Sequence"],ModuleName ["Data","Tree"],ModuleName ["Data","IntMap"],ModuleName ["Data","IntSet"],ModuleName ["Data","Map"],ModuleName ["Data","Set"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/containers-0.4.2.1"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/containers-0.4.2.1"], hsLibraries = ["HScontainers-0.4.2.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0",InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "deepseq-1.3.0.0-6c19ec61ee16184ee322c1614ab60f0e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.2.1/containers.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.2.1"]}])]),(PackageName "deepseq",fromList [(Version {versionBranch = [1,3,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "deepseq-1.3.0.0-6c19ec61ee16184ee322c1614ab60f0e", sourcePackageId = PackageIdentifier {pkgName = PackageName "deepseq", pkgVersion = Version {versionBranch = [1,3,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package provides methods for fully evaluating data structures\n(\\\"deep evaluation\\\"). Deep evaluation is often used for adding\nstrictness to a program, e.g. in order to force pending exceptions,\nremove space leaks, or force lazy I/O to happen. It is also useful\nin parallel programs, to ensure pending work does not migrate to the\nwrong thread.\n\nThe primary use of this package is via the 'deepseq' function, a\n\\\"deep\\\" version of 'seq'. It is implemented on top of an 'NFData'\ntypeclass (\\\"Normal Form Data\\\", data structures with no unevaluated\ncomponents) which defines strategies for fully evaluating different\ndata types.\n", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","DeepSeq"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/deepseq-1.3.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/deepseq-1.3.0.0"], hsLibraries = ["HSdeepseq-1.3.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.4.0.0-0b32f6f98c0297dbb0e5cfc0087bd1f0",InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/deepseq-1.3.0.0/deepseq.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/deepseq-1.3.0.0"]}])]),(PackageName "ghc-prim",fromList [(Version {versionBranch = [0,2,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a", sourcePackageId = PackageIdentifier {pkgName = PackageName "ghc-prim", pkgVersion = Version {versionBranch = [0,2,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "GHC primitives.", category = "", exposed = True, exposedModules = [ModuleName ["GHC","Prim"],ModuleName ["GHC","Classes"],ModuleName ["GHC","CString"],ModuleName ["GHC","Debug"],ModuleName ["GHC","Generics"],ModuleName ["GHC","Magic"],ModuleName ["GHC","PrimopWrappers"],ModuleName ["GHC","IntWord64"],ModuleName ["GHC","Tuple"],ModuleName ["GHC","Types"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/ghc-prim-0.2.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/ghc-prim-0.2.0.0"], hsLibraries = ["HSghc-prim-0.2.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0/ghc-prim.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0"]}])]),(PackageName "integer-gmp",fromList [(Version {versionBranch = [0,4,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "integer-gmp-0.4.0.0-ec87c5d9609a1d46da031ef5d51c4f79", sourcePackageId = PackageIdentifier {pkgName = PackageName "integer-gmp", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains an Integer library based on GMP.", category = "", exposed = True, exposedModules = [ModuleName ["GHC","Integer"],ModuleName ["GHC","Integer","GMP","Internals"],ModuleName ["GHC","Integer","GMP","Prim"],ModuleName ["GHC","Integer","Logarithms"],ModuleName ["GHC","Integer","Logarithms","Internals"]], hiddenModules = [ModuleName ["GHC","Integer","Type"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/integer-gmp-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/integer-gmp-0.4.0.0"], hsLibraries = ["HSinteger-gmp-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "ghc-prim-0.2.0.0-bd29cb1ca1b712d64e00ac9207f87d0a"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.4.0.0/integer-gmp.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.4.0.0"]}])]),(PackageName "mtl",fromList [(Version {versionBranch = [2,1,1], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "mtl-2.1.1-ae9b44386a2528180e60dcf2412689c0", sourcePackageId = PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,1,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Edward Kmett <ekmett@gmail.com>", author = "Andy Gill", stability = "", homepage = "", pkgUrl = "", description = "Monad classes using functional dependencies, with instances\nfor various monad transformers, inspired by the paper\n/Functional Programming with Overloading and Higher-Order Polymorphism/,\nby Mark P Jones, in /Advanced School of Functional Programming/, 1995\n(<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","Monad","Cont"],ModuleName ["Control","Monad","Cont","Class"],ModuleName ["Control","Monad","Error"],ModuleName ["Control","Monad","Error","Class"],ModuleName ["Control","Monad","Identity"],ModuleName ["Control","Monad","List"],ModuleName ["Control","Monad","RWS"],ModuleName ["Control","Monad","RWS","Class"],ModuleName ["Control","Monad","RWS","Lazy"],ModuleName ["Control","Monad","RWS","Strict"],ModuleName ["Control","Monad","Reader"],ModuleName ["Control","Monad","Reader","Class"],ModuleName ["Control","Monad","State"],ModuleName ["Control","Monad","State","Class"],ModuleName ["Control","Monad","State","Lazy"],ModuleName ["Control","Monad","State","Strict"],ModuleName ["Control","Monad","Trans"],ModuleName ["Control","Monad","Writer"],ModuleName ["Control","Monad","Writer","Class"],ModuleName ["Control","Monad","Writer","Lazy"],ModuleName ["Control","Monad","Writer","Strict"]], hiddenModules = [], importDirs = ["/Users/matt/.cabal/lib/mtl-2.1.1/ghc-7.4.1"], libraryDirs = ["/Users/matt/.cabal/lib/mtl-2.1.1/ghc-7.4.1"], hsLibraries = ["HSmtl-2.1.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "transformers-0.3.0.0-f2303dfef836518cc2f6901210442e10"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/matt/.cabal/share/doc/mtl-2.1.1/html/mtl.haddock"], haddockHTMLs = ["/Users/matt/.cabal/share/doc/mtl-2.1.1/html"]}])]),(PackageName "pretty",fromList [(Version {versionBranch = [1,1,1,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "pretty-1.1.1.0-7e118fa87f5698f5c005fe87b34befe8", sourcePackageId = PackageIdentifier {pkgName = PackageName "pretty", pkgVersion = Version {versionBranch = [1,1,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "David Terei <dave.terei@gmail.com>", author = "", stability = "Stable", homepage = "http://github.com/haskell/pretty", pkgUrl = "", description = "This package contains a pretty-printing library, a set of API's\nthat provides a way to easily print out text in a consistent\nformat of your choosing. This is useful for compilers and related\ntools.\n\nThis library was originally designed by John Hughes's and has since\nbeen heavily modified by Simon Peyton Jones.", category = "Text", exposed = True, exposedModules = [ModuleName ["Text","PrettyPrint"],ModuleName ["Text","PrettyPrint","HughesPJ"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/pretty-1.1.1.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/pretty-1.1.1.0"], hsLibraries = ["HSpretty-1.1.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.1.1.0/pretty.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.1.1.0"]}])]),(PackageName "rts",fromList [(Version {versionBranch = [1,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "builtin_rts", sourcePackageId = PackageIdentifier {pkgName = PackageName "rts", pkgVersion = Version {versionBranch = [1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "glasgow-haskell-users@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "", category = "", exposed = True, exposedModules = [], hiddenModules = [], importDirs = [], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1"], hsLibraries = ["HSrts"], extraLibraries = ["m","dl"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/include"], includes = ["Stg.h"], depends = [], hugsOptions = [], ccOptions = [], ldOptions = ["-u","_ghczmprim_GHCziTypes_Izh_static_info","-u","_ghczmprim_GHCziTypes_Czh_static_info","-u","_ghczmprim_GHCziTypes_Fzh_static_info","-u","_ghczmprim_GHCziTypes_Dzh_static_info","-u","_base_GHCziPtr_Ptr_static_info","-u","_base_GHCziWord_Wzh_static_info","-u","_base_GHCziInt_I8zh_static_info","-u","_base_GHCziInt_I16zh_static_info","-u","_base_GHCziInt_I32zh_static_info","-u","_base_GHCziInt_I64zh_static_info","-u","_base_GHCziWord_W8zh_static_info","-u","_base_GHCziWord_W16zh_static_info","-u","_base_GHCziWord_W32zh_static_info","-u","_base_GHCziWord_W64zh_static_info","-u","_base_GHCziStable_StablePtr_static_info","-u","_ghczmprim_GHCziTypes_Izh_con_info","-u","_ghczmprim_GHCziTypes_Czh_con_info","-u","_ghczmprim_GHCziTypes_Fzh_con_info","-u","_ghczmprim_GHCziTypes_Dzh_con_info","-u","_base_GHCziPtr_Ptr_con_info","-u","_base_GHCziPtr_FunPtr_con_info","-u","_base_GHCziStable_StablePtr_con_info","-u","_ghczmprim_GHCziTypes_False_closure","-u","_ghczmprim_GHCziTypes_True_closure","-u","_base_GHCziPack_unpackCString_closure","-u","_base_GHCziIOziException_stackOverflow_closure","-u","_base_GHCziIOziException_heapOverflow_closure","-u","_base_ControlziExceptionziBase_nonTermination_closure","-u","_base_GHCziIOziException_blockedIndefinitelyOnMVar_closure","-u","_base_GHCziIOziException_blockedIndefinitelyOnSTM_closure","-u","_base_ControlziExceptionziBase_nestedAtomically_closure","-u","_base_GHCziWeak_runFinalizzerBatch_closure","-u","_base_GHCziTopHandler_flushStdHandles_closure","-u","_base_GHCziTopHandler_runIO_closure","-u","_base_GHCziTopHandler_runNonIO_closure","-u","_base_GHCziConcziIO_ensureIOManagerIsRunning_closure","-u","_base_GHCziConcziSync_runSparks_closure","-u","_base_GHCziConcziSignal_runHandlers_closure","-Wl,-search_paths_first","-read_only_relocs","warning"], frameworkDirs = [], frameworks = [], haddockInterfaces = [], haddockHTMLs = []}])]),(PackageName "template-haskell",fromList [(Version {versionBranch = [2,7,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "template-haskell-2.7.0.0-e0ac8598212fa76f924e85dd1be6a701", sourcePackageId = PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,7,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "Facilities for manipulating Haskell source code using Template Haskell.", category = "", exposed = True, exposedModules = [ModuleName ["Language","Haskell","TH","Syntax","Internals"],ModuleName ["Language","Haskell","TH","Syntax"],ModuleName ["Language","Haskell","TH","PprLib"],ModuleName ["Language","Haskell","TH","Ppr"],ModuleName ["Language","Haskell","TH","Lib"],ModuleName ["Language","Haskell","TH","Quote"],ModuleName ["Language","Haskell","TH"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/template-haskell-2.7.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/lib/ghc-7.4.1/template-haskell-2.7.0.0"], hsLibraries = ["HStemplate-haskell-2.7.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384",InstalledPackageId "containers-0.4.2.1-7c54595400348f577b3b4a45691c5afd",InstalledPackageId "pretty-1.1.1.0-7e118fa87f5698f5c005fe87b34befe8"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.7.0.0/template-haskell.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.4.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.7.0.0"]}])]),(PackageName "transformers",fromList [(Version {versionBranch = [0,3,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "transformers-0.3.0.0-f2303dfef836518cc2f6901210442e10", sourcePackageId = PackageIdentifier {pkgName = PackageName "transformers", pkgVersion = Version {versionBranch = [0,3,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Ross Paterson <ross@soi.city.ac.uk>", author = "Andy Gill, Ross Paterson", stability = "", homepage = "", pkgUrl = "", description = "A portable library of functor and monad transformers, inspired by\nthe paper \\\"Functional Programming with Overloading and Higher-Order\nPolymorphism\\\", by Mark P Jones,\nin /Advanced School of Functional Programming/, 1995\n(<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).\n\nThis package contains:\n\n* the monad transformer class (in \"Control.Monad.Trans.Class\")\n\n* concrete functor and monad transformers, each with associated\noperations and functions to lift operations associated with other\ntransformers.\n\nIt can be used on its own in portable Haskell code, or with the monad\nclasses in the @mtl@ or @monads-tf@ packages, which automatically\nlift operations introduced by monad transformers through other\ntransformers.", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","Applicative","Backwards"],ModuleName ["Control","Applicative","Lift"],ModuleName ["Control","Monad","IO","Class"],ModuleName ["Control","Monad","Trans","Class"],ModuleName ["Control","Monad","Trans","Cont"],ModuleName ["Control","Monad","Trans","Error"],ModuleName ["Control","Monad","Trans","Identity"],ModuleName ["Control","Monad","Trans","List"],ModuleName ["Control","Monad","Trans","Maybe"],ModuleName ["Control","Monad","Trans","Reader"],ModuleName ["Control","Monad","Trans","RWS"],ModuleName ["Control","Monad","Trans","RWS","Lazy"],ModuleName ["Control","Monad","Trans","RWS","Strict"],ModuleName ["Control","Monad","Trans","State"],ModuleName ["Control","Monad","Trans","State","Lazy"],ModuleName ["Control","Monad","Trans","State","Strict"],ModuleName ["Control","Monad","Trans","Writer"],ModuleName ["Control","Monad","Trans","Writer","Lazy"],ModuleName ["Control","Monad","Trans","Writer","Strict"],ModuleName ["Data","Functor","Compose"],ModuleName ["Data","Functor","Constant"],ModuleName ["Data","Functor","Identity"],ModuleName ["Data","Functor","Product"],ModuleName ["Data","Functor","Reverse"]], hiddenModules = [], importDirs = ["/Users/matt/.cabal/lib/transformers-0.3.0.0/ghc-7.4.1"], libraryDirs = ["/Users/matt/.cabal/lib/transformers-0.3.0.0/ghc-7.4.1"], hsLibraries = ["HStransformers-0.3.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.5.0.0-a732a3518af7589b6c46f83e8ceae384"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/matt/.cabal/share/doc/transformers-0.3.0.0/html/transformers.haddock"], haddockHTMLs = ["/Users/matt/.cabal/share/doc/transformers-0.3.0.0/html"]}])])]), pkgDescrFile = Just "./ImperativeHaskell.cabal", localPkgDescr = PackageDescription {package = PackageIdentifier {pkgName = PackageName "ImperativeHaskell", pkgVersion = Version {versionBranch = [2,0,0,0], versionTags = []}}, license = GPL (Just (Version {versionBranch = [3], versionTags = []})), licenseFile = "LICENSE", copyright = "", maintainer = "Matthew Mirman <mmirman@andrew.cmu.edu>", author = "Matthew Mirman", stability = "", testedWith = [], homepage = "https://github.com/mmirman/ImperativeHaskell", pkgUrl = "", bugReports = "", sourceRepos = [SourceRepo {repoKind = RepoHead, repoType = Just Git, repoLocation = Just "git://github.com/mmirman/ImperativeHaskell.git", repoModule = Nothing, repoBranch = Nothing, repoTag = Nothing, repoSubdir = Nothing}], synopsis = "A library for writing Imperative style haskell.", description = "A monad that uses GADTs and continuations to replicate what it is like to program\nin an imperative language like C, Java or Go with \"return\", \"for\", \"break\", \"continue\",\nand mutable references.\n\nIn Version 2:\n\n* Single return function: @return'@\n\n* A Go language style @defer'@ primitive.\n\n* Proper compiler errors when @break'@ and @continue'@ are used incorrectly\n\n* /Note/: Version 2 has a very different internal structure from version 1,\nand thus there will likely be type signature conflicts.\n\nFor more information see:\n\n* Examples on github <http://github.com/mmirman/ImperativeHaskell/blob/master/Main.hs>\n\n* The relevant blog post <http://kormacode.blogspot.com/2011/11/c-style-haskell_10.html>", category = "Control, Embedded, Development, Language", customFieldsPD = [], buildDepends = [Dependency (PackageName "base") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [4,0], versionTags = []})) (LaterVersion (Version {versionBranch = [4,0], versionTags = []}))) (EarlierVersion (Version {versionBranch = [5,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [4,5,0,0], versionTags = []}))),Dependency (PackageName "mtl") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [2,0], versionTags = []})) (LaterVersion (Version {versionBranch = [2,0], versionTags = []}))) (EarlierVersion (Version {versionBranch = [3,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [2,1,1], versionTags = []}))),Dependency (PackageName "template-haskell") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [2,6], versionTags = []})) (LaterVersion (Version {versionBranch = [2,6], versionTags = []}))) (EarlierVersion (Version {versionBranch = [3,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [2,7,0,0], versionTags = []})))], specVersionRaw = Right (UnionVersionRanges (ThisVersion (Version {versionBranch = [1,6], versionTags = []})) (LaterVersion (Version {versionBranch = [1,6], versionTags = []}))), buildType = Just Simple, library = Just (Library {exposedModules = [ModuleName ["Control","Monad","Imperative"],ModuleName ["Control","Monad","Imperative","Internals"],ModuleName ["Control","Monad","Imperative","Operators"],ModuleName ["Control","Monad","Imperative","FunctionFactory"]], libExposed = True, libBuildInfo = BuildInfo {buildable = True, buildTools = [], cppOptions = [], ccOptions = [], ldOptions = [], pkgconfigDepends = [], frameworks = [], cSources = [], hsSourceDirs = ["."], otherModules = [], defaultLanguage = Nothing, otherLanguages = [], defaultExtensions = [], otherExtensions = [], oldExtensions = [GADTs,EmptyDataDecls,GeneralizedNewtypeDeriving,MultiParamTypeClasses,FlexibleInstances,FlexibleContexts,TemplateHaskell,UndecidableInstances,TypeFamilies,FunctionalDependencies], extraLibs = [], extraLibDirs = [], includeDirs = [], includes = [], installIncludes = [], options = [], ghcProfOptions = [], ghcSharedOptions = [], customFieldsBI = [], targetBuildDepends = [Dependency (PackageName "base") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [4,0], versionTags = []})) (LaterVersion (Version {versionBranch = [4,0], versionTags = []}))) (EarlierVersion (Version {versionBranch = [5,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [4,5,0,0], versionTags = []}))),Dependency (PackageName "mtl") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [2,0], versionTags = []})) (LaterVersion (Version {versionBranch = [2,0], versionTags = []}))) (EarlierVersion (Version {versionBranch = [3,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [2,1,1], versionTags = []}))),Dependency (PackageName "template-haskell") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [2,6], versionTags = []})) (LaterVersion (Version {versionBranch = [2,6], versionTags = []}))) (EarlierVersion (Version {versionBranch = [3,0], versionTags = []}))) (ThisVersion (Version {versionBranch = [2,7,0,0], versionTags = []})))]}}), executables = [], testSuites = [], dataFiles = [], dataDir = "", extraSrcFiles = [], extraTmpFiles = []}, withPrograms = [("alex",ConfiguredProgram {programId = "alex", programVersion = Just (Version {versionBranch = [2,3,5], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/alex"}}),("ar",ConfiguredProgram {programId = "ar", programVersion = Nothing, programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ar"}}),("c2hs",ConfiguredProgram {programId = "c2hs", programVersion = Just (Version {versionBranch = [0,16,2], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/local/bin/c2hs"}}),("cpphs",ConfiguredProgram {programId = "cpphs", programVersion = Just (Version {versionBranch = [1,11], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/local/bin/cpphs"}}),("gcc",ConfiguredProgram {programId = "gcc", programVersion = Just (Version {versionBranch = [4,2,1], versionTags = []}), programDefaultArgs = ["-m32"], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/gcc"}}),("ghc",ConfiguredProgram {programId = "ghc", programVersion = Just (Version {versionBranch = [7,4,1], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ghc"}}),("ghc-pkg",ConfiguredProgram {programId = "ghc-pkg", programVersion = Just (Version {versionBranch = [7,4,1], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ghc-pkg"}}),("haddock",ConfiguredProgram {programId = "haddock", programVersion = Just (Version {versionBranch = [2,10,0], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/haddock"}}),("happy",ConfiguredProgram {programId = "happy", programVersion = Just (Version {versionBranch = [1,18,6], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/happy"}}),("hsc2hs",ConfiguredProgram {programId = "hsc2hs", programVersion = Just (Version {versionBranch = [0,67], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/hsc2hs"}}),("hscolour",ConfiguredProgram {programId = "hscolour", programVersion = Just (Version {versionBranch = [1,17], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/Users/matt/.cabal/bin/HsColour"}}),("ld",ConfiguredProgram {programId = "ld", programVersion = Nothing, programDefaultArgs = ["-x","-arch","i386"], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ld"}}),("pkg-config",ConfiguredProgram {programId = "pkg-config", programVersion = Just (Version {versionBranch = [0,23], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/sw/bin/pkg-config"}}),("ranlib",ConfiguredProgram {programId = "ranlib", programVersion = Nothing, programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ranlib"}}),("strip",ConfiguredProgram {programId = "strip", programVersion = Nothing, programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/strip"}}),("tar",ConfiguredProgram {programId = "tar", programVersion = Nothing, programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/sw/bin/tar"}})], withPackageDB = [GlobalPackageDB,UserPackageDB], withVanillaLib = True, withProfLib = False, withSharedLib = False, withProfExe = False, withOptimization = NormalOptimisation, withGHCiLib = True, splitObjs = False, stripExes = True, progPrefix = "", progSuffix = ""}