packages feed

hobbits (empty) → 1.0

raw patch · 113 files changed

+3252/−0 lines, 113 filesdep +basedep +deepseqdep +mtlsetup-changedbinary-added

Dependencies added: base, deepseq, mtl, parsec, syb, tagged, template-haskell, type-equality

Files

+ Data/Binding/Hobbits.hs view
@@ -0,0 +1,46 @@+{-# LANGUAGE TypeOperators #-}++-- |+-- Module      : Data.Binding.Hobbits+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- This library implements multi-bindings as described in the paper+-- E. Westbrook, N. Frisby, P. Brauner, \"Hobbits for Haskell: A Library for+-- Higher-Order Encodings in Functional Programming Languages\".++module Data.Binding.Hobbits (+  -- * Values under multi-bindings+  module Data.Binding.Hobbits.Mb,+  -- | The 'Data.Binding.Hobbits.Mb.Mb' type modeling multi-bindings is the+  -- central abstract type of the library++  -- * Ancilliary modules+  module Data.Type.List,+  -- | Type lists track the types of bound variables.+  module Data.Binding.Hobbits.SuperComb,+  -- | The 'Data.Binding.Hobbits.SuperComb.SuperComb' type models+  -- super-combinators, which are safe functions to apply under+  -- 'Data.Binding.Hobbits.Mb.Mb'.+  module Data.Binding.Hobbits.QQ,+  -- | The 'Data.Binding.Hobbits.QQ.nuQQ' quasiquoter allows safe pattern+  -- matching on 'Data.Binding.Hobbits.Mb.Mb' values.+  module Data.Binding.Hobbits.PatternParser,+  -- | A simple parser for Haskell patterns.+  module Data.Binding.Hobbits.NuElim+  -- | The "Data.Binding.Hobbits.NuElim" module allows elimination of+  -- bindings and multi-bindings; NOTE: this module is not covered in+  -- the \"Hobbits for Haskell\" paper.+                            ) where++import Data.Type.List+import Data.Binding.Hobbits.Mb+import Data.Binding.Hobbits.SuperComb+import Data.Binding.Hobbits.QQ+import Data.Binding.Hobbits.PatternParser+import Data.Binding.Hobbits.NuElim
+ Data/Binding/Hobbits/Examples/LambdaLifting.hs view
@@ -0,0 +1,223 @@+{-# LANGUAGE QuasiQuotes, ViewPatterns #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE GADTs #-}++{-# OPTIONS_GHC -fwarn-incomplete-patterns #-}++-- |+-- Module      : Data.Binding.Hobbits.Examples.LambdaLifting+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- The lambda lifting example from the paper E. Westbrook, N. Frisby,+-- P. Brauner, \"Hobbits for Haskell: A Library for Higher-Order Encodings in+-- Functional Programming Languages\".++-------------------------------------------------------------------------+-- lambda lifting for the lambda calculus with top-level declarations+-------------------------------------------------------------------------++module Data.Binding.Hobbits.Examples.LambdaLifting (+  -- * Term data types, using 'Data.Binding.Hobbits.Mb'+  module Data.Binding.Hobbits.Examples.LambdaLifting.Terms,+  -- * The lambda-lifting function+  lambdaLift, mbLambdaLift+  ) where++import Data.Binding.Hobbits+import qualified Data.Type.List.Map as C+import qualified Data.Type.List.Proof.Member as Mem++import Data.Binding.Hobbits.Examples.LambdaLifting.Terms+import Data.Binding.Hobbits.Examples.LambdaLifting.Examples++import Control.Monad.Cont (Cont, runCont, cont)++------------------------------------------------------------+-- "peeling" lambdas off of a term+------------------------------------------------------------++data LType a where LType :: LType (L a)+type LC c = MapC LType c++type family AddArrows c b+type instance AddArrows Nil b = b+type instance AddArrows (c :> L a) b = AddArrows c (a -> b)++data PeelRet c a where+  PeelRet :: lc ~ (lc0 :> b) => LC lc -> Mb (c :++: lc) (Term a) ->+             PeelRet c (AddArrows lc a)++peelLambdas :: Mb c (Binding (L b) (Term a)) -> PeelRet c (b -> a)+peelLambdas b = peelLambdasH Nil LType (combineMb b)++peelLambdasH ::+  lc ~ (lc0 :> b) => LC lc0 -> LType b -> Mb (c :++: lc) (Term a) ->+                     PeelRet c (AddArrows lc a)+peelLambdasH lc0 isl [nuQQ| Lam b |] =+  peelLambdasH (lc0 :> isl) LType (combineMb b)+peelLambdasH lc0 ilt t = PeelRet (lc0 :> ilt) t+++++boundParams ::+  lc ~ (lc0 :> b) => LC lc -> (MapC Name lc -> DTerm a) ->+                     Decl (AddArrows lc a)+boundParams (lc0 :> LType) k = -- flagged as non-exhaustive, in spite of type+  freeParams lc0 (\ns -> Decl_One $ nu $ \n -> k (ns :> n))++freeParams ::+  LC lc -> (MapC Name lc -> Decl a) -> Decl (AddArrows lc a)+freeParams Nil k = k C.empty+freeParams (lc :> LType) k =+    freeParams lc (\names -> Decl_Cons $ nu $ \x -> k (names :> x))++------------------------------------------------------------+-- sub-contexts+------------------------------------------------------------++-- FIXME: use this type in place of functions+type SubC c' c = MapC Name c -> MapC Name c'++------------------------------------------------------------+-- operations on contexts of free variables+------------------------------------------------------------++data MbLName c a where+    MbLName :: Mb c (Name (L a)) -> MbLName c (L a)++type FVList c fvs = MapC (MbLName c) fvs++-- unioning free variable contexts: the data structure+data FVUnionRet c fvs1 fvs2 where+    FVUnionRet :: FVList c fvs -> SubC fvs1 fvs -> SubC fvs2 fvs ->+                  FVUnionRet c fvs1 fvs2++fvUnion :: FVList c fvs1 -> FVList c fvs2 -> FVUnionRet c fvs1 fvs2+fvUnion Nil Nil = FVUnionRet Nil (\_ -> Nil) (\_ -> Nil)+fvUnion Nil (fvs2 :> fv2) = case fvUnion Nil fvs2 of+  FVUnionRet fvs f1 f2 -> case elemMC fv2 fvs of+    Nothing -> FVUnionRet (fvs :> fv2)+               -- flagged as non-exhaustive, in spite of type+               (\(xs :> x) -> f1 xs) (\(xs :> x) -> f2 xs :> x)+    Just idx -> FVUnionRet fvs f1 (\xs -> f2 xs :> C.lookup idx xs)+fvUnion (fvs1 :> fv1) fvs2 = case fvUnion fvs1 fvs2 of+  FVUnionRet fvs f1 f2 -> case elemMC fv1 fvs of+    Nothing -> FVUnionRet (fvs :> fv1)+               -- flagged as non-exhaustive, in spite of type+               (\(xs :> x) -> f1 xs :> x) (\(xs :> x) -> f2 xs)+    Just idx -> FVUnionRet fvs (\xs -> f1 xs :> C.lookup idx xs) f2++elemMC :: MbLName c a -> FVList c fvs -> Maybe (Member fvs a)+elemMC _ Nil = Nothing+elemMC mbLN@(MbLName n) (mc :> MbLName n') = case mbCmpName n n' of+  Just Refl -> Just Member_Base+  Nothing -> fmap Member_Step (elemMC mbLN mc)++------------------------------------------------------------+-- deBruijn terms, i.e., closed terms+------------------------------------------------------------++data STerm c a where+    SWeaken :: SubC c1 c -> STerm c1 a -> STerm c a+    SVar :: Member c (L a) -> STerm c a+    SDVar :: Name (D a) -> STerm c a+    SApp :: STerm c (a -> b) -> STerm c a -> STerm c b++skelSubst :: STerm c a -> MapC Name c -> DTerm a+skelSubst (SWeaken f db) names = skelSubst db $ f names+skelSubst (SVar inC) names = TVar $ C.lookup inC names+skelSubst (SDVar dTVar) _ = TDVar dTVar+skelSubst (SApp db1 db2) names = TApp (skelSubst db1 names) (skelSubst db2 names)++-- applying a STerm to a context of names+skelAppMultiNames ::+  STerm fvs (AddArrows fvs a) -> FVList c fvs -> STerm fvs a+skelAppMultiNames db args = skelAppMultiNamesH db args (C.members args) where+  skelAppMultiNamesH ::+    STerm fvs (AddArrows args a) -> FVList c args -> MapC (Member fvs) args ->+    STerm fvs a+  skelAppMultiNamesH fvs Nil _ = fvs+  -- flagged as non-exhaustive, in spite of type+  skelAppMultiNamesH fvs (args :> MbLName _) (inCs :> inC) =+    SApp (skelAppMultiNamesH fvs args inCs) (SVar inC)++------------------------------------------------------------+-- STerms combined with their free variables+------------------------------------------------------------++data FVSTerm c lc a where+    FVSTerm :: FVList c fvs -> STerm (fvs :++: lc) a -> FVSTerm c lc a++fvSSepLTVars ::+  MapC f lc -> FVSTerm (c :++: lc) Nil a -> FVSTerm c lc a+fvSSepLTVars lc (FVSTerm fvs db) = case fvSSepLTVarsH lc Proxy fvs of+  SepRet fvs' f -> FVSTerm fvs' (SWeaken f db)++data SepRet lc c fvs where+  SepRet :: FVList c fvs' -> SubC fvs (fvs' :++: lc) -> SepRet lc c fvs++fvSSepLTVarsH ::+  MapC f lc -> Proxy c -> FVList (c :++: lc) fvs -> SepRet lc c fvs+fvSSepLTVarsH _ _ Nil = SepRet Nil (\_ -> Nil)+fvSSepLTVarsH lc c (fvs :> fv@(MbLName n)) = case fvSSepLTVarsH lc c fvs of+  SepRet m f -> case raiseAppName (C.mkMonoAppend c lc) n of+    Left idx -> SepRet m (\xs -> f xs :> C.lookup (Mem.weakenL (C.proxy m) idx) xs)+    Right n -> SepRet (m :> MbLName n)+               (\xs -> case C.split (C.mkMonoAppend c' lc) xs of+                         -- flagged as non-exhaustive, in spite of type+                         (fvs' :> fv', lcs) ->+                           f (C.append fvs' lcs) :> fv')+    where c' = proxyCons (C.proxy m) fv++raiseAppName ::+  Append c1 c2 c -> Mb c (Name a) -> Either (Member c2 a) (Mb c1 (Name a))+raiseAppName app n =+  case mbToplevel $(superComb [| mbNameBoundP |]) (separateMb app n) of+    [nuQQ| Left mem |] -> Left $ mbLift mem+    [nuQQ| Right n |] -> Right n++------------------------------------------------------------+-- lambda-lifting, woo hoo!+------------------------------------------------------------++type LLBodyRet b c a = Cont (Decls b) (FVSTerm c Nil a)++llBody :: LC c -> Mb c (Term a) -> LLBodyRet b c a+llBody c [nuQQ| Var v |] =+  return $ FVSTerm (Nil :> MbLName v) $ SVar Member_Base+llBody c [nuQQ| App t1 t2 |] = do+  FVSTerm fvs1 db1 <- llBody c t1+  FVSTerm fvs2 db2 <- llBody c t2+  FVUnionRet names sub1 sub2 <- return $ fvUnion fvs1 fvs2+  return $ FVSTerm names $ SApp (SWeaken sub1 db1) (SWeaken sub2 db2)+llBody c [nuQQ| Lam b |] = do+  PeelRet lc body <- return $ peelLambdas b+  llret <- llBody (C.append c lc) body+  FVSTerm fvs db <- return $ fvSSepLTVars lc llret+  cont $ \k ->+    Decls_Cons (freeParams (fvsToLC fvs) $ \names1 ->+                boundParams lc $ \names2 ->+                skelSubst db (C.append names1 names2))+      $ nu $ \d -> k $ FVSTerm fvs (skelAppMultiNames (SDVar d) fvs)+  where+    fvsToLC :: FVList c lc -> LC lc+    fvsToLC = C.mapC mbLNameToProof where+      mbLNameToProof :: MbLName c a -> LType a+      mbLNameToProof (MbLName _) = LType++-- the top-level lambda-lifting function+lambdaLift :: Term a -> Decls a+lambdaLift t = runCont (llBody Nil (emptyMb t)) $ \(FVSTerm fvs db) ->+  Decls_Base (skelSubst db (C.mapC (\(MbLName mbn) -> elimEmptyMb mbn) fvs))++mbLambdaLift :: Mb c (Term a) -> Mb c (Decls a)+mbLambdaLift = mbToplevel $(superComb [| lambdaLift |])
+ Data/Binding/Hobbits/Examples/LambdaLifting/Examples.hs view
@@ -0,0 +1,52 @@+-- |+-- Module      : Data.Binding.Hobbits.SuperComb+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--++module Data.Binding.Hobbits.Examples.LambdaLifting.Examples where++import Data.Binding.Hobbits.Examples.LambdaLifting.Terms+import Data.Binding.Hobbits++------------------------------------------------------------+-- examples+------------------------------------------------------------++ex1 :: Term ((b1 -> b) -> b1 -> b)+ex1 = lam (\f -> (lam $ \x -> App f x))++ex2 :: Term ((((b2 -> b1) -> b2 -> b1) -> b) -> b)+ex2 = lam (\f1 -> App f1 (lam (\f2 -> lam (\x -> App f2 x))))++ex3 :: Term (b3 -> (((b3 -> b2 -> b1) -> b2 -> b1) -> b) -> b)+ex3 = lam (\x -> lam (\f1 -> App f1 (lam (\f2 -> lam (\y -> f2 `App` x `App` y)))))++ex4+  :: Term+       (((b1 -> b) -> b2 -> b)+        -> (((b1 -> b) -> b2 -> b) -> b2 -> b1)+        -> b2+        -> b1)+ex4 = lam $ \x -> lam $ \f1 ->+      App f1 (lam $ \f2 -> lam $ \y -> f2 `App` (f1 `App` x `App` y))++ex5 :: Term (((b2 -> b1) -> b) -> (b2 -> b1) -> b)+ex5 = lam (\f1 -> lam $ \f2 -> App f1 (lam $ \x -> App f2 x))++-- lambda-lift with a free variable (use mbLambdaLift)+ex6 :: Binding (L ((b -> b) -> a)) (Term a)+ex6 = nu (\f -> App (Var f) (lam $ \x -> x))++-- lambda-lift with a free variable as part of a lambda's environment+ex7 :: Binding (L ((b2 -> b2) -> b1)) (Term ((b1 -> b) -> b))+ex7 = nu (\f -> lam $ \y -> App y $ App (Var f) (lam $ \x -> x))++-- example from paper's Section 4+exP :: Term (((b1 -> b1) -> b) -> (b1 -> b1) -> b)+exP = lam $ \f -> lam $ \g -> App f $ lam $ \x -> App g $ App g x
+ Data/Binding/Hobbits/Examples/LambdaLifting/Terms.hs view
@@ -0,0 +1,127 @@+{-# LANGUAGE EmptyDataDecls #-}+{-# LANGUAGE QuasiQuotes, ViewPatterns #-}+{-# LANGUAGE GADTs, KindSignatures #-}++-- |+-- Module      : Data.Binding.Hobbits.SuperComb+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--++module Data.Binding.Hobbits.Examples.LambdaLifting.Terms+  (L, D,+   Term(..), lam,+   DTerm(..), Decl(..), Decls(..)+  ) where++import Data.Binding.Hobbits+import qualified Data.Type.List.Map as C++-- dummy datatypes for distinguishing Decl names from Lam names+data L a+data D a++------------------------------------------------------------+-- source terms+------------------------------------------------------------++-- Term datatype; no Ds since there's no declarations yet+data Term :: * -> * where+  Var :: Name (L a) -> Term a+  Lam :: Binding (L b) (Term a) -> Term (b -> a)+  App :: Term (b -> a) -> Term b -> Term a++instance Show (Term a) where show = tpretty++-- helps to build terms without explicitly using nu or Var+lam :: (Term a -> Term b) -> Term (a -> b)+lam f = Lam $ nu (f . Var)++-- pretty print terms+tpretty :: Term a -> String+tpretty t = pretty' (emptyMb t) C.empty 0+  where pretty' :: Mb c (Term a) -> MapC StringF c -> Int -> String+        pretty' [nuQQ| Var b |] varnames n =+            case mbNameBoundP b of+              Left pf  -> unStringF (C.lookup pf varnames)+              Right n -> "(free-var " ++ show n ++ ")"+        pretty' [nuQQ| Lam b |] varnames n =+            let x = "x" ++ show n in+            "(\\" ++ x ++ "." ++ pretty' (combineMb b) (varnames :> (StringF x)) (n+1) ++ ")"+        pretty' [nuQQ| App b1 b2 |] varnames n =+            "(" ++ pretty' b1 varnames n ++ " " ++ pretty' b2 varnames n ++ ")"++------------------------------------------------------------+-- target terms+------------------------------------------------------------++-- terms under declarations+data DTerm :: * -> * where+  TVar :: Name (L a) -> DTerm a+  TDVar :: Name (D a) -> DTerm a+  TApp :: DTerm (a -> b) -> DTerm a -> DTerm b++instance Show (DTerm a) where show = pretty++-- we use this type for a definiens instead of putting lambdas on the front+data Decl :: * -> * where+  Decl_One :: Binding (L a) (DTerm b) -> Decl (a -> b)+  Decl_Cons :: Binding (L a) (Decl b) -> Decl (a -> b)++-- top-level declarations with a return value+data Decls :: * -> * where+  Decls_Base :: DTerm a -> Decls a+  Decls_Cons :: Decl b -> Binding (D b) (Decls a) -> Decls a++instance Show (Decls a) where show = decls_pretty++------------------------------------------------------------+-- pretty printing+------------------------------------------------------------++-- to make a function for MapC (for pretty)+newtype StringF x = StringF String+unStringF (StringF str) = str++-- pretty print terms+pretty :: DTerm a -> String+pretty t = mpretty (emptyMb t) C.empty++mpretty :: Mb c (DTerm a) -> MapC StringF c -> String+mpretty [nuQQ| TVar b |] varnames =+    mprettyName (mbNameBoundP b) varnames+mpretty [nuQQ| TDVar b |] varnames =+    mprettyName (mbNameBoundP b) varnames+mpretty [nuQQ| TApp b1 b2 |] varnames =+    "(" ++ mpretty b1 varnames+        ++ " " ++ mpretty b2 varnames ++ ")"++mprettyName (Left pf) varnames = unStringF (C.lookup pf varnames)+mprettyName (Right n) varnames = "(free-var " ++ (show n) ++ ")"+        ++-- pretty print decls+decls_pretty :: Decls a -> String+decls_pretty decls =+    "let\n" ++ (mdecls_pretty (emptyMb decls) C.empty 0)++mdecls_pretty :: Mb c (Decls a) -> MapC StringF c -> Int -> String+mdecls_pretty [nuQQ| Decls_Base t |] varnames n =+    "in " ++ (mpretty t varnames)+mdecls_pretty [nuQQ| Decls_Cons decl rest |] varnames n =+    let fname = "F" ++ show n in+    fname ++ " " ++ (mdecl_pretty decl varnames 0) ++ "\n"+    ++ mdecls_pretty (combineMb rest) (varnames :> (StringF fname)) (n+1)++mdecl_pretty :: Mb c (Decl a) -> MapC StringF c -> Int -> String+mdecl_pretty [nuQQ| Decl_One t|] varnames n =+  let vname = "x" ++ show n in+  vname ++ " = " ++ mpretty (combineMb t) (varnames :> StringF vname)+mdecl_pretty [nuQQ| Decl_Cons d|] varnames n =+  let vname = "x" ++ show n in+  vname ++ " " ++ mdecl_pretty (combineMb d) (varnames :> StringF vname) (n+1)
+ Data/Binding/Hobbits/Internal.hs view
@@ -0,0 +1,101 @@+{-# LANGUAGE GADTs, DeriveDataTypeable #-}++-- |+-- Module      : Data.Binding.Hobbits.Internal+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- This module is internal to the Hobbits library, and should not be used+-- directly.++module Data.Binding.Hobbits.Internal where++import Data.Typeable+import Data.Type.List+import Unsafe.Coerce (unsafeCoerce)+import Data.IORef (IORef, newIORef, readIORef, writeIORef)+import System.IO.Unsafe (unsafePerformIO)++-- | A @Name a@ is a bound name that is associated with type @a@.+newtype Name a = MkName Int deriving (Typeable, Eq)++{-|+  An @Mb ctx b@ is a multi-binding that binds exactly one name for each+  type in @ctx@, where @ctx@ has the form @'Nil' ':>' t1 ':>' ... ':>' tn@.+-}+data Mb ctx b  = MkMb [Int] b deriving Typeable++{-+instance Typeable a => Typeable (Mb ctx a) where+    typeOf (MkMb _ x) = mkTyConApp (mkTyCon "Mb")+                          [mkTyConApp (mkTyCon "Nil") [], typeOf x]+-}+++-- building an arbitrary InCtx proof with a given length+-- (this is used internally in HobbitLib)++data ExMember where ExMember :: Member c a -> ExMember++-- creating some Member proof of length i+memberFromLen :: Int -> ExMember+memberFromLen 0 = ExMember Member_Base+memberFromLen n = case memberFromLen (n - 1) of+  ExMember mem -> ExMember (Member_Step mem)++-- unsafely creating a *specific* member proof from length i;+-- this is for when we know the ith element of c must be type a+unsafeLookupC :: Int -> Member c a+unsafeLookupC n = case memberFromLen n of+  ExMember mem -> unsafeCoerce mem+++-- building a proxy for each type in some unknown context+data ExProxy where ExProxy :: MapC Proxy ctx -> ExProxy+proxyFromLen :: Int -> ExProxy+proxyFromLen 0 = ExProxy Nil+proxyFromLen n = case proxyFromLen (n - 1) of+                   ExProxy proxy -> ExProxy (proxy :> Proxy)++-- unsafely building a proxy for each type in ctx from the length n+-- of ctx; this is only safe when we know the length of ctx = n+unsafeProxyFromLen :: Int -> MapC Proxy ctx+unsafeProxyFromLen n = case proxyFromLen n of+                         ExProxy proxy -> unsafeCoerce proxy++-- unsafely convert a list of Ints, used to represent names, to+-- names of certain, given types; note that the first name in the+-- list becomes the last name in the output, with the same reversal+-- used in the Mb representation (see, e.g., combineMb)+unsafeNamesFromInts :: [Int] -> MapC Name ctx+unsafeNamesFromInts [] = unsafeCoerce Nil+unsafeNamesFromInts (x:xs) =+    unsafeCoerce $ unsafeNamesFromInts xs :> MkName x++-------------------------------------------------------------------------------+-- encapsulated impurity+-------------------------------------------------------------------------------++-- README: we *cannot* inline counter, because we want all uses+-- of counter to be the same IORef+counter :: IORef Int+{-# NOINLINE counter #-}+counter = unsafePerformIO (newIORef 0)++-- README: fresh_name takes a dummy argument that is used in a dummy+-- way to avoid let-floating its body (and thus getting a fresh name+-- exactly once)+-- README: it *is* ok to inline fresh_name because we don't care in+-- what order fresh names are created+fresh_name :: a -> Int+fresh_name a = unsafePerformIO $ do +    dummyRef <- newIORef a+    x <- readIORef counter+    writeIORef counter (x+1)+    return x+
+ Data/Binding/Hobbits/Mb.hs view
@@ -0,0 +1,209 @@+{-# LANGUAGE GADTs, TypeOperators, FlexibleInstances, OverlappingInstances #-}++-- |+-- Module      : Data.Binding.Hobbits.Mb+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- This module defines multi-bindings as the type 'Mb', as well as a number of+-- operations on multi-bindings. See the paper E. Westbrook, N. Frisby,+-- P. Brauner, \"Hobbits for Haskell: A Library for Higher-Order Encodings in+-- Functional Programming Languages\" for more information.++module Data.Binding.Hobbits.Mb (+  -- * Abstract types+  Name(),      -- hides Name implementation+  Binding(),   -- hides Binding implementation+  Mb(),        -- hides MultiBind implementation+  -- * Multi-binding constructors+  nu, emptyMb, nuMulti,+  -- * Operations on multi-bindings+  elimEmptyMb, combineMb, separateMb, mbToProxy,+  -- * Queries on names+  cmpName, mbCmpName, mbNameBoundP,+  -- * type classes for lifting data out of bindings+  Liftable(..), Liftable1(..), Liftable2(..),+  -- * Optimized, safe multi-binding eliminators+  mbList+) where++import Data.Type.List+import qualified Data.Type.List.Proof.Member as Mem+import qualified Data.Type.List.Proof.Append as App+import Data.Binding.Hobbits.Internal+import qualified Data.Binding.Hobbits.Internal as I++import Data.List (elemIndex)++import Unsafe.Coerce (unsafeCoerce)++-------------------------------------------------------------------------------+-- bindings+-------------------------------------------------------------------------------++-- | A @Binding@ is simply a multi-binding that binds one name+type Binding a = Mb (Nil :> a)++instance Show (Name a) where+  showsPrec _ (MkName n) = showChar '#' . shows n . showChar '#'++-- note: we reverse l to show the inner-most bindings last+instance Show a => Show (Mb c a) where+  showsPrec p (MkMb l b) = showParen (p > 10) $+    showChar '#' . shows (reverse l) . showChar '.' . shows b++-- README: we pass f to fresh_name to avoid let-floating the results+-- of fresh_name (which would always give the same name for each nu)+-- README: is *is* ok to do CSE on multiple copies of nu, because+-- the programmer cannot tell if two distinct (non-nested) nus get the+-- same fresh integer, and two nus that look the same to the CSE engine+-- cannot be nested+-- README: it *is* ok to inline nu because we don't care in+-- what order fresh names are created+{-|+  @nu f@ creates a binding which binds a fresh name @n@ and whose+  body is the result of @f n@.+-}+nu :: (Name a -> b) -> Binding a b+nu f = let n = fresh_name f in n `seq` MkMb [n] (f (MkName n))++-- README: inner-most bindings come FIRST+-- | Combines a binding inside another binding into a single binding.+combineMb :: Mb c1 (Mb c2 b) -> Mb (c1 :++: c2) b+combineMb (MkMb l1 (MkMb l2 b)) = MkMb (l2 ++ l1) b++{-|+  Separates a binding into two nested bindings. The first argument, of+  type @'Append' c1 c2 c@, is a \"phantom\" argument to indicate how+  the context @c@ should be split.+-}+separateMb :: Append c1 c2 c -> Mb c a -> Mb c1 (Mb c2 a)+separateMb app (MkMb l a) = MkMb d (MkMb t a) where+  (d, t) = splitAt (App.length app) l++-- | Returns a proxy object that enumerates all the types in ctx.+mbToProxy :: Mb ctx a -> MapC Proxy ctx+mbToProxy (MkMb l _) = unsafeProxyFromLen (length l)++-- | Creates an empty binding that binds 0 names.+emptyMb :: a -> Mb Nil a+emptyMb t = MkMb [] t++{-|+  The expression @nuMulti p f@ creates a multi-binding of zero or more+  names, one for each element of the vector @p@. The bound names are+  passed the names to @f@, which returns the body of the+  multi-binding.  The argument @p@, of type @'Mb' f ctx@, acts as a+  \"phantom\" argument, used to reify the list of types @ctx@ at the+  term level; thus it is unimportant what the type function @f@ is.+-}+nuMulti :: MapC f ctx -> (MapC Name ctx -> b) -> Mb ctx b+nuMulti Nil f = emptyMb $ f Nil+nuMulti (proxies :> proxy) f =+    combineMb $ nuMulti proxies $ \names -> nu $ \n -> f (names :> n)++{-|+  Eliminates an empty binding, returning its body. Note that+  @elimEmptyMb@ is the inverse of @emptyMb@.+-}+elimEmptyMb :: Mb Nil a -> a+elimEmptyMb (MkMb [] t) = t+elimEmptyMb _ = error "Should not happen! (elimEmptyMb)"++{-|+  @cmpName n m@ compares names @n@ and @m@ of types @Name a@ and @Name b@,+  respectively. When they are equal, @Some e@ is returned for @e@ a proof+  of type @a :=: b@ that their types are equal. Otherwise, @None@ is returned.++  For example:++> nu $ \n -> nu $ \m -> cmpName n n   ==   nu $ \n -> nu $ \m -> Some Refl+> nu $ \n -> nu $ \m -> cmpName n m   ==   nu $ \n -> nu $ \m -> None+-}+cmpName :: Name a -> Name b -> Maybe (a :=: b)+cmpName (MkName n1) (MkName n2)+  | n1 == n2 = Just $ unsafeCoerce Refl+  | otherwise = Nothing++{-|+  Checks if a name is bound in a multi-binding, returning @Left mem@+  when the name is bound, where @mem@ is a proof that the type of the+  name is in the type list for the multi-binding, and returning+  @Right n@ when the name is not bound, where @n@ is the name.++  For example:++> nu $ \n -> mbNameBoundP (nu $ \m -> m)  ==  nu $ \n -> Left Member_Base+> nu $ \n -> mbNameBoundP (nu $ \m -> n)  ==  nu $ \n -> Right n+-}+mbNameBoundP :: Mb ctx (Name a) -> Either (Member ctx a) (Name a)+mbNameBoundP (MkMb names (MkName n)) = case elemIndex n names of+  Nothing -> Right (MkName n)+  Just i -> Left (I.unsafeLookupC i)++{-|+  Compares two names inside bindings, taking alpha-equivalence into+  account; i.e., if both are the @i@th name, or both are the same name+  not bound in their respective multi-bindings, then they compare as+  equal. The return values are the same as for 'cmpName', so that+  @Some Refl@ is returned when the names are equal and @Nothing@ is+  returned when they are not.+-}+mbCmpName :: Mb c (Name a) -> Mb c (Name b) -> Maybe (a :=: b)+mbCmpName b1 b2 = case (mbNameBoundP b1, mbNameBoundP b2) of+  (Left mem1, Left mem2) -> Mem.same mem1 mem2+  (Right n1, Right n2) -> cmpName n1 n2+  _ -> Nothing++{-|+  The class @Liftable a@ gives a \"lifting function\" for a, which can+  take any data of type @a@ out of a multi-binding of type @'Mb' ctx a@.+-}+class Liftable a where+    mbLift :: Mb ctx a -> a++instance Liftable Int where+    mbLift (MkMb _ i) = i++instance Liftable Char where+    mbLift (MkMb _ c) = c++{-+instance Liftable a => Liftable [a] where+    mbLift (MkMb _ []) = []+    mbLift (MkMb names (x : xs)) =+        (mbLift (MkMb names x)) : (mbLift (MkMb names xs))+-}++instance Liftable (Member c a) where+    mbLift (MkMb _ mem) = mem++{-|+  The class @Liftable1 f@ gives a lifting function for each type @f a@+  when @a@ itself is @Liftable@.+-}+class Liftable1 f where+    mbLift1 :: Liftable a => Mb ctx (f a) -> f a++instance (Liftable1 f, Liftable a) => Liftable (f a) where+    mbLift = mbLift1++{-|+  The class @Liftable2 f@ gives a lifting function for each type @f a b@+  when @a@ and @b@ are @Liftable@.+-}+class Liftable2 f where+    mbLift2 :: (Liftable a, Liftable b) => Mb ctx (f a b) -> f a b++instance (Liftable2 f, Liftable a) => Liftable1 (f a) where+    mbLift1 = mbLift2++-- | Lift a list (but not its elements) out of a multi-binding+mbList :: Mb c [a] -> [Mb c a]+mbList (MkMb names []) = []+mbList (MkMb names (x : xs)) = (MkMb names x) : (mbList (MkMb names xs))
+ Data/Binding/Hobbits/NuElim.hs view
@@ -0,0 +1,492 @@+{-# LANGUAGE GADTs, RankNTypes, TypeOperators, ViewPatterns, TypeFamilies, FlexibleInstances, FlexibleContexts, TemplateHaskell #-}++{-|++  This module defines the NuElim typeclass, which allows eliminations+  of (multi-) bindings. The high-level idea is that, when a fresh name+  is created with 'nu', the fresh name can also be substituted for the+  bound name in a binding. See the documentation for 'nuWithElim1' and+  'nuWithElimMulti' for details.+-}++module Data.Binding.Hobbits.NuElim (+  nuWithElimMulti, nuWithElim, nuWithElim1,+  NuElim(..), mkNuElimData, NuElimList(..),+  NuElimProof(),+) where++--import Data.Data+import Data.Binding.Hobbits.Internal+--import Data.Binding.Hobbits.Context+import Data.Binding.Hobbits.Mb+import Data.Type.List+import Language.Haskell.TH hiding (Name)+import qualified Language.Haskell.TH as TH+--import Unsafe.Coerce (unsafeCoerce)+import Control.Monad.State+import Control.Monad.Identity++-- "proofs" that type a is an allowed type for nu-elimination; i.e.,+-- that the multi-binding of an Mb ctx a can be eliminated by nuWithElim+data NuElimProof a where+    NuElimName :: NuElimProof (Name a)+    NuElimMb :: NuElimProof a -> NuElimProof (Mb ctx a)+    NuElimFun :: NuElimProof a -> NuElimProof b -> NuElimProof (a -> b)+    NuElimData :: NuElimDataProof a -> NuElimProof a++data NuElimDataProof a =+    NuElimDataProof (forall ctx. MapC Name ctx -> MapC Name ctx -> a -> a)+++-- map the names in one MapC to the corresponding ones in another+mapNamesPf :: NuElimProof a -> MapC Name ctx -> MapC Name ctx -> a -> a+mapNamesPf NuElimName Nil Nil n = n+mapNamesPf NuElimName (names :> m) (names' :> m') n =+    case cmpName m n of+      Just Refl -> m'+      Nothing -> mapNamesPf NuElimName names names' n+mapNamesPf NuElimName _ _ _ = error "Should not be possible! (in mapNamesPf)"+mapNamesPf (NuElimMb nuElim) names1 names2 (MkMb ns b) =+    undefined+{- FIXME: something like this...+    let names2' = fresh_names ns in+    MkMb names2' $ mapNamesPf (names1 |++> ns) (names2 |++> names2') b+-}+mapNamesPf (NuElimFun nuElimIn nuElimOut) names names' f =+    (mapNamesPf nuElimOut names names') . f . (mapNamesPf nuElimIn names' names)+mapNamesPf (NuElimData (NuElimDataProof mapFun)) names names' x =+    mapFun names names' x+++-- just like mapNamesPf, except use the NuElim class+mapNames :: NuElim a => MapC Name ctx -> MapC Name ctx -> a -> a+mapNames = mapNamesPf nuElimProof+++{-|+  Instances of the @NuElim a@ class allow the type @a@ to be used with+  'nuWithElimMulti' and 'nuWithElim1'. The structure of this class is+  mostly hidden from the user; see 'mkNuElimData' to see how to create+  instances of the @NuElim@ class.+-}+class NuElim a where+    nuElimProof :: NuElimProof a++instance NuElim (Name a) where+    nuElimProof = NuElimName++instance (NuElim a, NuElim b) => NuElim (a -> b) where+    nuElimProof = NuElimFun nuElimProof nuElimProof++{-+instance NuElim a => NuElim (Mb Nil a) where+    nuElimProof = NuElimMbNil nuElimProof++instance NuElim (Mb ctx a) => NuElim (Mb (ctx :> c) a) where+    nuElimProof = NuElimMbCons nuElimProof+-}++instance NuElim a => NuElim (Mb ctx a) where+    nuElimProof = NuElimMb nuElimProof++instance NuElim Int where+    nuElimProof = NuElimData (NuElimDataProof $ (\c1 c2 -> id))++instance NuElim Char where+    nuElimProof = NuElimData (NuElimDataProof $ (\c1 c2 -> id))++instance NuElim a => NuElim [a] where+    nuElimProof = NuElimData (NuElimDataProof $ (\c1 c2 -> map (mapNames c1 c2)))++instance (NuElim a, NuElim b) => NuElim (a,b) where+    nuElimProof = NuElimData (NuElimDataProof $ (\c1 c2 (a,b) -> (mapNames c1 c2 a, mapNames c1 c2 b)))++instance (NuElim a, NuElim b) => NuElim (Either a b) where+    nuElimProof = NuElimData+                  (NuElimDataProof+                   $ (\c1 c2 x -> case x of+                                    Left l -> Left (mapNames c1 c2 l)+                                    Right r -> Right (mapNames c1 c2 r)))+++{-+type family NuElimListProof args+type instance NuElimListProof Nil = ()+type instance NuElimListProof (args :> arg) = (NuElimListProof args, NuElimProof arg)++-- the NuElimList class, for saying that NuElim holds for a context of types+class NuElimList args where+    nuElimListProof :: NuElimListProof args++instance NuElimList Nil where+    nuElimListProof = ()++instance (NuElimList args, NuElim a) => NuElimList (args :> a) where+    nuElimListProof = (nuElimListProof, nuElimProof)+-}++-- the NuElimList class, for saying that NuElim holds for a context of types+class NuElimList args where+    nuElimListProof :: MapC NuElimProof args++instance NuElimList Nil where+    nuElimListProof = Nil++instance (NuElimList args, NuElim a) => NuElimList (args :> a) where+    nuElimListProof = nuElimListProof :> nuElimProof+++-- filter out names from a MapC Name+{-+data FilterRes where+    FilterRes :: (MapC Name ctx, MapC Name ctx) -> FilterRes++filterName :: Name a -> MapC Name ctx -> MapC Name ctx -> FilterRes+filterName n Nil Nil = Nil+filterName ++filterNames :: [Int] -> MapC Name ctx -> MapC Name ctx -> FilterRes+filterNames Nil names1 names2 = FilterRes names1 names2+Nil Nil = FilterRes Nil+filterNames (names1 :> n1)+-}++-- FIXME: add more examples!!+{-|+  The expression @nuWithElimMulti args f@ takes a sequence @args@ of+  zero or more multi-bindings, each of type @Mb ctx ai@ for the same+  type context @ctx@ of bound names, and a function @f@ and does the+  following:++  * Creates a multi-binding that binds names @n1,...,nn@, one name for+    each type in @ctx@;++  * Substitutes the names @n1,...,nn@ for the names bound by each+    argument in the @args@ sequence, yielding the bodies of the @args@+    (using the new name @n@); and then++  * Passes the sequence @n1,...,nn@ along with the result of+    substituting into @args@ to the function @f@, which then returns+    the value for the newly created binding.++  Note that the types in @args@ must each have a @NuElim@ instance;+  this is represented with the @NuElimList@ type class.++  Here are some examples:++> commuteFun :: (NuElim a, NuElim b) => Mb ctx (a -> b) -> Mb ctx a -> Mb ctx b+> commuteFun f a =+>     nuWithElimMulti ('mbToProxy' f) ('Nil' :> f :> a)+>                     (\_ ('Nil' :> 'Identity' f' :> 'Identity' a') -> f' a')+-}+nuWithElimMulti :: NuElimList args => MapC f ctx -> MapC (Mb ctx) args ->+                   (MapC Name ctx -> MapC Identity args -> b) -> Mb ctx b+nuWithElimMulti nameProxies args f =+    nuMulti nameProxies $ \names -> f names (mapArgs nuElimListProof args names)+    where+      mapArgs :: MapC NuElimProof args -> MapC (Mb ctx) args ->+                 MapC Name ctx -> MapC Identity args+      mapArgs Nil Nil _ = Nil+      mapArgs (proofs :> proof) (args :> arg) names =+          mapArgs proofs args names :>+                      (Identity $ mapNamesSubst proof names arg)+      mapArgs _ _ _ = error "Should not be possible! (in mapArgs)"++      mapNamesSubst :: NuElimProof arg -> MapC Name ctx -> Mb ctx arg -> arg+      mapNamesSubst proof names (MkMb namesOld arg) =+          mapNamesPf proof (unsafeNamesFromInts namesOld) names arg+++{-|+  Similar to 'nuWithElimMulti' but binds only one name.+-}+nuWithElim :: NuElimList args => MapC (Mb (Nil :> a)) args ->+              (Name a -> MapC Identity args -> b) -> Binding a b+nuWithElim args f =+    nuWithElimMulti (Nil :> Proxy) args (\(Nil :> n) -> f n)+++{-|+  Similar to 'nuWithElimMulti' but takes only one argument that binds+  a single name.+-}+nuWithElim1 :: NuElim arg => Binding a arg ->+               (Name a -> arg -> b) -> Binding a b+nuWithElim1 (MkMb [nOld] arg) f =+    nu $ \n -> f n (mapNames (Nil :> MkName nOld) (Nil :> n) arg)+nuWithElim1 (MkMb _ arg) f =+    error "Internal error in nuWithElim1"+++-- now we define some TH to create NuElimDataProofs++natsFrom i = i : natsFrom (i+1)++fst3 :: (a,b,c) -> a+fst3 (x,_,_) = x++snd3 :: (a,b,c) -> b+snd3 (_,y,_) = y++thd3 :: (a,b,c) -> c+thd3 (_,_,z) = z+++type Names = (TH.Name, TH.Name, TH.Name, TH.Name)++mapNamesType a = [t| forall ctx. MapC Name ctx -> MapC Name ctx -> $a -> $a |]++{-|+  Template Haskell function for creating NuElim instances for (G)ADTs.+  Typical usage is to include the following line in the source file for+  (G)ADT @T@ (here assumed to have two type arguments):++> $(mkNuElimData [t| forall a b . T a b |])++  The 'mkNuElimData' call here will create an instance declaration for+  @'NuElim' (T a b)@. It is also possible to include a context in the+  forall type; for example, if we define the 'ID' data type as follows:++> data ID a = ID a++  then we can create a 'NuElim' instance for it like this:++> $( mkNuElimData [t| NuElim a => ID a |])++  Note that, when a context is included, the Haskell parser will add+  the @forall a@ for you.+-}+mkNuElimData :: Q Type -> Q [Dec]+mkNuElimData tQ =+    do t <- tQ+       (cxt, cType, tName, constrs, tyvars) <- getNuElimInfoTop t+       fName <- newName "f"+       x1Name <- newName "x1"+       x2Name <- newName "x2"+       clauses <- mapM (getClause (tName, fName, x1Name, x2Name)) constrs+       mapNamesT <- mapNamesType (return cType)+       return [InstanceD+               cxt (AppT (ConT ''NuElim) cType)+               [ValD (VarP 'nuElimProof)+                (NormalB+                 $ AppE (ConE 'NuElimData)+                   $ AppE (ConE 'NuElimDataProof)+                         $ LetE [SigD fName+                                 $ ForallT (map PlainTV tyvars) cxt mapNamesT,+                                 FunD fName clauses]+                               (VarE fName)) []]]++       {-+       return (LetE+               [SigD fName+                     (ForallT tyvars reqCxt+                     $ foldl AppT ArrowT+                           [foldl AppT (ConT conName)+                                      (map tyVarToType tyvars)]),+                FunD fname clauses]+               (VarE fname))+        -}+    where+      -- extract the name from a TyVarBndr+      tyBndrToName (PlainTV n) = n+      tyBndrToName (KindedTV n _) = n++      -- fail for getNuElimInfo+      getNuElimInfoFail t =+          fail ("mkNuElimData: " ++ show t+                ++ " is not a type constructor for a (G)ADT applied to zero or more distinct type variables")++      -- get info for conName (top-level call)+      getNuElimInfoTop t = getNuElimInfo [] [] t t++      -- get info for conName+      getNuElimInfo ctx tyvars topT (ConT tName) =+          do info <- reify tName+             case info of+               TyConI (DataD _ _ tyvarsReq constrs _) ->+                   let tyvarsRet = if tyvars == [] && ctx == []+                                   then map tyBndrToName tyvarsReq+                                   else tyvars in+                   return (ctx,+                           foldl AppT (ConT tName)+                                     (map VarT tyvars),+                           tName, constrs, tyvarsRet)+               _ -> getNuElimInfoFail topT++      getNuElimInfo ctx tyvars topT (AppT f (VarT argName)) =+          if elem argName tyvars then+              getNuElimInfoFail topT+          else+              getNuElimInfo ctx (argName:tyvars) topT f++      getNuElimInfo ctx tyvars topT (ForallT _ ctx' t) =+          getNuElimInfo (ctx ++ ctx') tyvars topT t++      getNuElimInfo ctx tyvars topT t = getNuElimInfoFail topT++      -- get the name from a data type+      getTCtor t = getTCtorHelper t t []+      getTCtorHelper (ConT tName) topT tyvars = Just (topT, tName, tyvars)+      getTCtorHelper (AppT t1 (VarT var)) topT tyvars =+          getTCtorHelper t1 topT (tyvars ++ [var])+      getTCtorHelper (SigT t1 _) topT tyvars = getTCtorHelper t1 topT tyvars+      getTCtorHelper _ _ _ = Nothing++      -- get a list of Clauses, one for each constructor in constrs+      getClauses :: Names -> [Con] -> Q [Clause]+      getClauses names constrs = mapM (getClause names) constrs++      getClause :: Names -> Con -> Q Clause+      getClause names (NormalC cName cTypes) =+          getClauseHelper names (map snd cTypes)+                          (natsFrom 0)+                          (\l -> ConP cName (map (VarP . fst3) l))+                          (\l -> foldl AppE (ConE cName) (map fst3 l))++      getClause names (RecC cName cVarTypes) =+          getClauseHelper names (map thd3 cVarTypes)+                         (map fst3 cVarTypes)+                         (\l -> RecP cName+                                (map (\(var,_,field) -> (field, VarP var)) l))+                         (\l -> RecConE cName+                                (map (\(exp,_,field) -> (field, exp)) l))++      getClause names (InfixC cType1 cName cType2) =+          undefined -- FIXME++      getClause names (ForallC _ _ con) =  getClause names con++      getClauseHelper :: Names -> [Type] -> [a] ->+                         ([(TH.Name,Type,a)] -> Pat) ->+                         ([(Exp,Type,a)] -> Exp) ->+                         Q Clause+      getClauseHelper names@(tName, fName, x1Name, x2Name) cTypes cData pFun eFun =+          do varNames <- mapM (newName . ("x" ++) . show . fst)+                         $ zip (natsFrom 0) cTypes+             let varsTypesData = zip3 varNames cTypes cData+             let expsTypesData = map (mkExpTypeData names) varsTypesData+             return $ Clause [(VarP x1Name), (VarP x2Name), (pFun varsTypesData)]+                        (NormalB $ eFun expsTypesData) []++      mkExpTypeData :: Names -> (TH.Name,Type,a) -> (Exp,Type,a)+      mkExpTypeData (tName, fName, x1Name, x2Name)+                    (varName, getTCtor -> Just (t, tName', _), cData)+          | tName == tName' =+              -- the type of the arg is the same as the (G)ADT we are+              -- recursing over; apply the recursive function+              (foldl AppE (VarE fName)+                         [(VarE x1Name), (VarE x2Name), (VarE varName)],+               t, cData)+      mkExpTypeData (tName, fName, x1Name, x2Name) (varName, t, cData) =+          -- the type of the arg is not the same as the (G)ADT; call mapNames+          (foldl AppE (VarE 'mapNames)+                     [(VarE x1Name), (VarE x2Name), (VarE varName)],+           t, cData)++-- FIXME: old stuff below++type CxtStateQ a = StateT Cxt Q a++-- create a NuElimDataProof for a (G)ADT+mkNuElimDataProofOld :: Q TH.Name -> Q Exp+mkNuElimDataProofOld conNameQ =+    do conName <- conNameQ+       (cxt, name, tyvars, constrs) <- getNuElimInfo conName+       (clauses, reqCxt) <- runStateT (getClauses cxt name tyvars constrs) []+       fname <- newName "f"+       return (LetE+               [SigD fname+                     (ForallT tyvars reqCxt+                     $ foldl AppT ArrowT+                           [foldl AppT (ConT conName)+                                      (map tyVarToType tyvars)]),+                FunD fname clauses]+               (VarE fname))+    where+      -- convert a TyVar to a Name+      tyVarToType (PlainTV n) = VarT n+      tyVarToType (KindedTV n _) = VarT n++      -- get info for conName+      getNuElimInfo conName =+          reify conName >>= \info ->+              case info of+                TyConI (DataD cxt name tyvars constrs _) ->+                    return (cxt, name, tyvars, constrs)+                _ -> fail ("mkNuElimDataProof: " ++ show conName+                           ++ " is not a (G)ADT")+      {-+      -- report failure+      getNuElimInfoFail t =+          fail ("mkNuElimDataProof: " ++ show t+                ++ " is not a fully applied (G)ADT")++      getNuElimInfo (ConT conName) topT =+          reify conName >>= \info ->+              case info of+                TyConI (DataD cxt name tyvars constrs _) ->+                    return (cxt, name, tyvars, constrs)+                _ -> getNuElimInfoFail topT+      getNuElimInfo (AppT t _) topT = getNuElimInfo t topT+      getNuElimInfo (SigT t _) topT = getNuElimInfo t topT+      getNuElimInfo _ topT = getNuElimInfoFail topT+       -}++      -- get a list of Clauses, one for each constructor in constrs+      getClauses :: Cxt -> TH.Name -> [TyVarBndr] -> [Con] -> CxtStateQ [Clause]+      getClauses cxt name tyvars constrs =+          mapM (getClause cxt name tyvars []) constrs++      getClause :: Cxt -> TH.Name -> [TyVarBndr] -> [TyVarBndr] -> Con ->+                   CxtStateQ Clause+      getClause cxt name tyvars locTyvars (NormalC cName cTypes) =+          getClauseHelper cxt name tyvars locTyvars (map snd cTypes)+                          (natsFrom 0)+                          (\l -> ConP cName (map (VarP . fst3) l))+                          (\l -> foldl AppE (ConE cName) (map (VarE . fst3) l))++      getClause cxt name tyvars locTyvars (RecC cName cVarTypes) =+          getClauseHelper cxt name tyvars locTyvars (map thd3 cVarTypes)+                         (map fst3 cVarTypes)+                         (\l -> RecP cName+                                (map (\(var,_,field) -> (field, VarP var)) l))+                         (\l -> RecConE cName+                                (map (\(var,_,field) -> (field, VarE var)) l))++      getClause cxt name tyvars locTyvars (InfixC cType1 cName cType2) =+          undefined -- FIXME++      getClause cxt name tyvars locTyvars (ForallC tyvars2 cxt2 con) =+          getClause (cxt ++ cxt2) name tyvars (locTyvars ++ tyvars2) con++      getClauseHelper :: Cxt -> TH.Name -> [TyVarBndr] -> [TyVarBndr] ->+                         [Type] -> [a] ->+                         ([(TH.Name,Type,a)] -> Pat) ->+                         ([(TH.Name,Type,a)] -> Exp) ->+                         CxtStateQ Clause+      getClauseHelper cxt name tyvars locTyvars cTypes cData pFun eFun =+          do varNames <- mapM (lift . newName . ("x" ++) . show . fst)+                         $ zip (natsFrom 0) cTypes+             () <- ensureCxt cxt locTyvars cTypes+             let varsTypesData = zip3 varNames cTypes cData+             return $ Clause [(pFun varsTypesData)]+                        (NormalB $ eFun varsTypesData) []++      -- ensure that NuElim a holds for each type a in cTypes+      ensureCxt :: Cxt -> [TyVarBndr] -> [Type] -> CxtStateQ ()+      ensureCxt cxt locTyvars cTypes =+          foldM (const (ensureCxt1 cxt locTyvars)) () cTypes++      -- FIXME: it is not possible (or, at least, not easy) to determine+      -- if NuElim a is implied from a current Cxt... so we just add+      -- everything we need to the returned Cxt, except for +      ensureCxt1 :: Cxt -> [TyVarBndr] -> Type -> CxtStateQ ()+      ensureCxt1 cxt locTyvars t = undefined+      {-+      ensureCxt1 cxt locTyvars t = do+        curCxt = get+        let fullCxt = cxt ++ curCxt+        isOk <- isNuElim fullCxt ++      isNuElim +       -}
+ Data/Binding/Hobbits/PatternParser.hs view
@@ -0,0 +1,202 @@+{-# LANGUAGE TemplateHaskell #-}++-- |+-- Module      : Data.Binding.Hobbits.PatternParser+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- A simple parser for Haskell patterns. Currently does not handle:+--+-- - Record patterns @Pt { pointx = x }@+--+-- - Signature patterns @p :: t@+--+-- - View patterns @e -> p@++module Data.Binding.Hobbits.PatternParser (parsePattern, parseVar) where++import Text.ParserCombinators.Parsec+import Language.Haskell.TH+import Data.Char+++varStartChars = ['a'..'z']+ctorStartChars = ['A'..'Z']++identChars = varStartChars ++ ctorStartChars ++ ['0'..'9'] ++ "'_"+infixChars = "!#$%&*+./<=>?@"++varParser :: GenParser Char st String+varParser =+    do char1 <- oneOf varStartChars+       char_rest <- many (oneOf identChars)+       return (char1 : char_rest)++ctorParser :: GenParser Char st String+ctorParser =+    do char1 <- oneOf ctorStartChars+       char_rest <- many (oneOf identChars)+       return (char1 : char_rest)++infixParser :: GenParser Char st String+infixParser =+    do char1 <- char ':'+       char_rest <- many (oneOf infixChars)+       return (char1 : char_rest)++stringParser :: GenParser Char st String+stringParser =+    do char '"'+       res <- stringContentsParser+       return res++stringContentsParser =+    many (noneOf "\\\"") >>= \prefix ->+        (char '"' >> return prefix)+        <|>+        (char '\\' >> do c <- anyChar+                         rest <- stringContentsParser+                         return $ prefix ++ [c] ++ rest)++charParser :: GenParser Char st Char+charParser =+    do char '\''+       c <- ((char '\\' >> anyChar) <|> anyChar)+       char '\''+       return c++digitsToInt digits = helper digits 0+    where helper [] accum = accum+          helper (digit:digits) accum =+              helper digits (accum * 10 + (digitToInt digit))++intToRational :: Int -> Rational+intToRational = fromIntegral++digitsToFrac digits = helper digits+    where helper [] = 0.0+          helper (digit:digits) = ((helper digits) + (intToRational $ digitToInt digit)) / 10++numParser :: GenParser Char st Lit+numParser =+    do base_digits <- many1 (oneOf ['0'..'9'])+       ((do char '.'+            frac_digits <- many1 (oneOf ['0'..'9'])+            return (RationalL $ (intToRational $ digitsToInt base_digits) + digitsToFrac frac_digits))+        <|> return (IntegerL $ fromIntegral $ digitsToInt base_digits))++litParser :: GenParser Char st Lit+litParser = (charParser >>= return . CharL) <|>+            (stringParser >>= return . StringL) <|>+            numParser++commaSepParser :: GenParser Char st [Pat]+commaSepParser =+    (do first <- pattParser 0+        rest <- (char ',' >> commaSepParser) <|> (return [])+        return (first:rest)) <|> (return [])+++-- the int gives the "level":+--   0 = parse anything+--   1 = parse ctor args but not infix ops+--   2 = do not parse ctor args or infix ops+tokenParser :: Int -> GenParser Char st Pat+tokenParser i =+    -- literals+    (litParser >>= return . LitP) <|>++    -- wildcards+    (char '_' >> return WildP) <|>++    -- bangs+    (do char '!'+        patt <- pattParser i+        return $ BangP patt) <|>++    -- tildes+    (do char '~'+        patt <- pattParser i+        return $ TildeP patt) <|>++    -- as-patterns+    (try (do var <- varParser+             wsParser+             char '@'+             patt <- pattParser i+             return $ AsP (mkName var) patt)) <|>++    -- vars+    (varParser >>= return . VarP . mkName) <|>++    -- tuples; NOTE: we parse any parenthesized expression as a tuple,+    -- and remove the TupP constructor when there are no commas+    (do char '('+        tup <- commaSepParser+        char ')'+        return (case tup of+                  [] -> ConP '() []+                  [patt] -> patt+                  _ -> TupP tup)) <|>++    -- constructor applications+    (do ctor <- ctorParser+        args <- if i < 2 then many (try $ pattParser 2) else return []+        return $ ConP (mkName ctor) args) <|>++    -- lists+    (do char '['+        elems <- commaSepParser+        char ']'+        return $ ListP elems)++++wsParser :: GenParser Char st ()+wsParser = many (oneOf " \t\n\r") >> return ()++pattParser :: Int -> GenParser Char st Pat+pattParser i =+    do wsParser+       res <- if i == 0 then+                  -- infix constructor applications+                  try (do lhs <- pattParser 1+                          op <- infixParser+                          rhs <- pattParser 0+                          return $ ConP (mkName op) [lhs, rhs]) <|>+                  tokenParser i+              else+                  tokenParser i+       wsParser+       return res++varOnlyParser :: GenParser Char st String+varOnlyParser = do wsParser+                   res <- varParser+                   wsParser+                   eof+                   return res+++----------------------------------------+-- Finally, the external interface... --+----------------------------------------++-- | Parse a string into a Template Haskell pattern.+parsePattern str = case parse (pattParser 0) "" str of+                  Left err -> error $ show err+                  Right patt -> patt++{-|+  Parse a string for a Haskell variable; return the string on success+  (if the string is a valid Haskell variable) and signal an error+  otherwise.+-}+parseVar str = case parse varOnlyParser "" str of+                 Left err -> error $ show err+                 Right str -> str
+ Data/Binding/Hobbits/QQ.hs view
@@ -0,0 +1,71 @@+{-# LANGUAGE TemplateHaskell #-}++-- |+-- Module      : Data.Binding.Hobbits.QQ+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- Defines a quasi-quoter for writing patterns that match the bodies+-- of 'Mb' multi-bindings. Uses the+-- "Data.Binding.Hobbits.PatternParser" module, and thus only supports+-- the pattern forms listed there. If @P@ is a (supported) Haskell+-- pattern, then @[nuQQ| P ]@ defines a pattern that will match an+-- multi-binding whose body matches @P@. Any variables matched by @P@+-- will remain inside the binding; thus, for example, in the pattern+-- @[nuQQ| x |]@, @x@ matches the entire multi-binding.+--+-- Examples:+--+-- > case (nu Left) of [nuQQ| Left x |] -> x  ==  nu id+--++module Data.Binding.Hobbits.QQ (nuQQ) where++import Data.Binding.Hobbits.Internal (Mb(..))+import Data.Binding.Hobbits.PatternParser (parsePattern)++import Language.Haskell.TH.Syntax as TH+import Language.Haskell.TH.Quote++import Control.DeepSeq+import qualified Control.Exception as CE++import qualified Data.Generics as SYB++------------------------------------------------------------+-- matching under binders using a quasi-quoter+------------------------------------------------------------++hobbitNamesPattVar n = mkName $ "hobbit$$names" ++ (show n)++-- internPattVars replaces all subterms (VarP "x") with (MkMb ln -> VarP "x")+internPattVars :: TH.Name -> TH.Name -> Pat -> Pat+internPattVars mb ln = SYB.everywhere (SYB.mkT wrapVars) where+  mkView p = ViewP (InfixE+                    (Just $ VarE 'same_ctx `AppE` VarE mb)+                    (VarE '(.))+                    (Just $ ConE 'MkMb `AppE` VarE ln)) p+  wrapVars p @ (VarP _) = mkView p+  wrapVars (AsP v p) = mkView (AsP v (ConP 'MkMb [WildP, p]))+  wrapVars p = p++syb_rnf :: SYB.Data a => a -> ()+syb_rnf = (`seq` ()) . rnf . SYB.gmapQ syb_rnf++same_ctx :: Mb ctx a -> Mb ctx b -> Mb ctx b+same_ctx _ x = x++nuQQPatt :: String -> Q Pat+nuQQPatt str = do+  mb <- newName "mb"+  ln <- newName "bs"+  pat <- runIO $ CE.evaluate (let x = parsePattern str in syb_rnf x `seq` x) `catch` \err ->+           (error $ "error parsing string |" ++ str ++ "|: " ++ show err)+  return $ AsP mb $ ConP 'MkMb [VarP ln, internPattVars mb ln pat]++nuQQ = QuasiQuoter (error "nuQQ Exp") nuQQPatt (error "nuQQ Type") (error "nuQQ Decs")
+ Data/Binding/Hobbits/SuperComb.hs view
@@ -0,0 +1,66 @@+{-# LANGUAGE TemplateHaskell #-}++-- |+-- Module      : Data.Binding.Hobbits.SuperComb+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- This module uses Template Haskell to distinguish super-combinators, so that+-- the library can trust such functions to not contain any @Name@ values in+-- their closure.++module Data.Binding.Hobbits.SuperComb (+  -- * Abstract types+  SuperComb(),+  -- * Operators involving 'SuperComb'+  superComb, mbToplevel,+) where++import Data.Binding.Hobbits.Internal (Mb(..))++import Language.Haskell.TH as TH++import qualified Data.Generics as SYB+import qualified Language.Haskell.TH.Syntax as TH++------------------------------------------------------------+-- applying top-level functions under binders+------------------------------------------------------------++{-|+  The type @SuperComb a@ represents a super-combinator of type @a@,+  i.e., an expression of type @a@ with no free (Haskell) variables.+  Since this cannot be checked directly in the Haskell type system,+  the @SuperComb@ data type is hidden, and the user can only create+  super-combinators using Template Haskell, through the 'superComb'+  operator.+-}+newtype SuperComb a = SuperComb { unSuperComb :: a }++-- | An quoted expression is a CAF if all of its names are bound globally or+-- within the quotation+isSuperComb :: Exp -> Bool+isSuperComb = SYB.everything (&&) (SYB.mkQ True nameOK) where+  nameOK (TH.Name _ flav) = case flav of+    TH.NameG {} -> True -- bound globally+    TH.NameU {} -> True -- bound within this same quotation+    _ -> False++-- | @superComb@ is used with Template Haskell to create super-combinators;+-- see documentation for 'mbToplevel' to see how it is used.+superComb :: Q Exp -> Q Exp+superComb m = do+  e <- m+  if isSuperComb e then return (TH.AppE (TH.ConE 'SuperComb) e) else fail ("not a super combinator:\n\t" ++ TH.pprint e)++-- | @mbToplevel@ @f@ @b@ applies super-combinator @f@ to the body of+-- multi-binding @b@. For example:+--+-- > mbToplevel $(superComb [| f |]) (nu $ \n -> n)   =   nu f+mbToplevel :: SuperComb (a -> b) -> Mb ctx a -> Mb ctx b+mbToplevel f (MkMb names i) = MkMb names (unSuperComb f i)
+ Data/Type/HList.hi view

binary file changed (absent → 1372 bytes)

+ Data/Type/HList.o view

binary file changed (absent → 936 bytes)

+ Data/Type/List.hs view
@@ -0,0 +1,35 @@+{-# LANGUAGE TypeOperators, EmptyDataDecls #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE GADTs #-}++-- |+-- Module      : Data.Type.List+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- A /type list/ contains types as elements. We use GADT proofs terms to+-- establish membership and append relations. A @Data.Type.List.Map.MapC@ @f@+-- is a vector indexed by a type list, where @f :: * -> *@ is applied to each+-- type element.++module Data.Type.List (+  module Data.Type.List.List, -- | Type-level nil, cons, and +++  module Data.Type.List.Map, -- | Vectors parameterized by a @* -> *@ and indexed by a type list+  module Data.Type.List.Proof.Member, -- | Membership functions and proofs+  module Data.Type.List.Proof.Append, -- | Append functions and proofs+  module Data.Type.Equality,+  module Data.Proxy+  ) where++import Data.Type.List.List+import Data.Type.List.Map (MapC(..))+import Data.Type.List.Proof.Member (Member(..))+import Data.Type.List.Proof.Append (Append(..))++import Data.Type.Equality ((:=:)(..))+import Data.Proxy (Proxy(..))
+ Data/Type/List/HList.hi view

binary file changed (absent → 1247 bytes)

+ Data/Type/List/HList.o view

binary file changed (absent → 936 bytes)

+ Data/Type/List/List.hs view
@@ -0,0 +1,35 @@+{-# LANGUAGE EmptyDataDecls #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE DeriveDataTypeable #-}++-- |+-- Module      : Data.Type.List.List+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- The type-level constructors of type lists.++module Data.Type.List.List where++import Data.Proxy (Proxy(..))+import Data.Typeable++-------------------------------------------------------------------------------+-- type-level lists+-------------------------------------------------------------------------------++data Nil deriving Typeable+data r :> a deriving Typeable; infixr 5 :>++type family (r1 :++: r2); infixr 5 :++:+type instance r :++: Nil = r+type instance r1 :++: r2 :> a = (r1 :++: r2) :> a++proxyCons :: Proxy r -> f a -> Proxy (r :> a)+proxyCons _ _ = Proxy
+ Data/Type/List/Map.hs view
@@ -0,0 +1,84 @@+{-# LANGUAGE GADTs, TypeOperators, RankNTypes #-}++-- |+-- Module      : Data.Type.List.Map+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- Vectors indexed by a type list++module Data.Type.List.Map where++import Data.Type.List.List+import Data.Type.List.Proof.Append (Append(..))+import Data.Type.List.Proof.Member (Member(..))+import Data.Proxy (Proxy(..))+--import Data.Typeable++-------------------------------------------------------------------------------+-- a vector of functor values, indexed by an List+-------------------------------------------------------------------------------++{-|+  A @MapC f c@ is a vector with exactly one element of type @f a@ for+  each type @a@ in the type list @c@.+-}+data MapC f c where+  Nil :: MapC f Nil -- Creates an empty vector+  (:>) :: MapC f c -> f a -> MapC f (c :> a) -- Appends an element to the end of a vector++-- | Create an empty 'MapC' vector.+empty :: MapC f Nil+empty = Nil++-- | Create a singleton 'MapC' vector.+singleton :: f a -> MapC f (Nil :> a)+singleton x = Nil :> x++-- | Look up an element of a 'MapC' vector using a 'Member' proof.+lookup :: Member c a -> MapC f c -> f a+lookup Member_Base (_ :> x) = x+lookup (Member_Step mem') (mc :> _) = Data.Type.List.Map.lookup mem' mc+lookup _ _ = error "Should not happen! (Map.lookup)"++-- | Map a function to all elements of a 'MapC' vector.+mapC :: (forall x. f x -> g x) -> MapC f c -> MapC g c+mapC _ Nil = Nil+mapC f (mc :> x) = mapC f mc :> f x++-- | Append two 'MapC' vectors.+append :: MapC f c1 -> MapC f c2 -> MapC f (c1 :++: c2)+append mc Nil = mc+append mc1 (mc2 :> x) = append mc1 mc2 :> x++-- | Make an 'Append' proof from any 'MapC' vector for the second+-- argument of the append.+mkAppend :: MapC f c2 -> Append c1 c2 (c1 :++: c2)+mkAppend Nil = Append_Base+mkAppend (c :> _) = Append_Step (mkAppend c)++-- | A version of 'mkAppend' that takes in a 'Proxy' argument.+mkMonoAppend :: Proxy c1 -> MapC f c2 -> Append c1 c2 (c1 :++: c2)+mkMonoAppend tag = mkAppend++-- | Split a 'MapC' vector into two pieces.+split :: Append c1 c2 c -> MapC f c -> (MapC f c1, MapC f c2)+split Append_Base mc = (mc, Nil)+split (Append_Step app) (mc :> x) = (mc1, mc2 :> x)+  where (mc1, mc2) = split app mc+split _ _ = error "Should not happen! (Map.split)"++-- | Create a 'Proxy' object for the type list of a 'MapC' vector.+proxy :: MapC f c -> Proxy c+proxy _ = Proxy++-- | Create a vector of proofs that each type in @c@ is a 'Member' of @c@.+members :: MapC f c -> MapC (Member c) c+members Nil = Nil+members (c :> _) =+  mapC Member_Step (members c) :> Member_Base
+ Data/Type/List/Proof/Append.hi view

binary file changed (absent → 1389 bytes)

+ Data/Type/List/Proof/Append.hs view
@@ -0,0 +1,40 @@+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE GADTs #-}++-- |+-- Module      : Data.Type.List.Proof.Append+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- Proofs regarding a type list as an append of two others.++module Data.Type.List.Proof.Append where++import Data.Type.List.List++------------------------------------------------------------+-- proofs about appended lists+------------------------------------------------------------++{-|+  An @Append ctx1 ctx2 ctx@ is a \"proof\" that @ctx = ctx1 ':++:' ctx2@.+-}+data Append ctx1 ctx2 ctx where+  Append_Base :: Append ctx Nil ctx+  Append_Step :: Append ctx1 ctx2 ctx -> Append ctx1 (ctx2 :> a) (ctx :> a)++-- | Appends two 'Append' proofs.+trans ::+  Append ctx1 ctx2 ex_ctx -> Append ex_ctx ctx3 ctx -> Append ctx1 (ctx2 :++: ctx3) ctx+trans app Append_Base = app+trans app (Append_Step app') = Append_Step (trans app app')++-- | Returns the length of an 'Append' proof.+length :: Append ctx1 ctx2 ctx3 -> Int+length Append_Base = 0+length (Append_Step app) = 1 + Data.Type.List.Proof.Append.length app
+ Data/Type/List/Proof/Append.o view

binary file changed (absent → 4024 bytes)

+ Data/Type/List/Proof/Member.hi view

binary file changed (absent → 2392 bytes)

+ Data/Type/List/Proof/Member.hs view
@@ -0,0 +1,85 @@+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE DeriveDataTypeable #-}++-- |+-- Module      : Data.Type.List.Proof.Member+-- Copyright   : (c) 2011 Edwin Westbrook, Nicolas Frisby, and Paul Brauner+--+-- License     : BSD3+--+-- Maintainer  : emw4@rice.edu+-- Stability   : experimental+-- Portability : GHC+--+-- Proofs regarding membership of a type in a type list.++module Data.Type.List.Proof.Member (+  -- * Abstract data types+  Member(..),+  -- * Operators on 'Member' proofs+  toEq, weakenL, same, weakenR, split+  ) where++import Data.Type.List.List+import Data.Type.List.Proof.Append++import Data.Type.Equality ((:=:)(..))+import Data.Proxy (Proxy(..))+import Data.Typeable++import Unsafe.Coerce++-------------------------------------------------------------------------------+-- proof of membership+-------------------------------------------------------------------------------++{-|+  A @Member ctx a@ is a \"proof\" that the type @a@ is in the type+  list @ctx@, meaning that @ctx@ equals++>  t0 ':>' a ':>' t1 ':>' ... ':>' tn++  for some types @t0,t1,...,tn@.+-}+data Member ctx a where+  Member_Base :: Member (ctx :> a) a+  Member_Step :: Member ctx a -> Member (ctx :> b) a+  deriving Typeable++instance Show (Member r a) where showsPrec p = showsPrecMember (p > 10)++showsPrecMember _ Member_Base = showString "Member_Base"+showsPrecMember p (Member_Step prf) = showParen p $+  showString "Member_Step" . showsPrec 10 prf++toEq :: Member (Nil :> a) b -> b :=: a+toEq Member_Base = Refl+toEq _ = error "Should not happen! (toEq)"++weakenL :: Proxy r1 -> Member r2 a -> Member (r1 :++: r2) a+weakenL tag Member_Base = Member_Base+weakenL tag (Member_Step mem) = Member_Step (weakenL tag mem)++same :: Member r a -> Member r b -> Maybe (a :=: b)+same Member_Base Member_Base = Just $ unsafeCoerce Refl+same (Member_Step mem1) (Member_Step mem2) = same mem1 mem2+same _ _ = Nothing++-------------------------------------------------------------------------------+-- relations between Member and Append+-------------------------------------------------------------------------------++weakenR :: Member r1 a -> Append r1 r2 r -> Member r a+weakenR mem Append_Base = mem+weakenR mem (Append_Step app) = Member_Step (weakenR mem app)++split ::+  Append r1 r2 r -> Member r a -> Either (Member r1 a) (Member r2 a)+split app mem = case app of+  Append_Base -> Left mem+  Append_Step app' -> case mem of+    Member_Base -> Right Member_Base+    Member_Step mem' -> case split app' mem' of+      Left prf -> Left prf+      Right prf -> Right (Member_Step prf)
+ Data/Type/List/Proof/Member.o view

binary file changed (absent → 10976 bytes)

+ LICENSE view
@@ -0,0 +1,10 @@+HobbitLib is Copyright (c) Edwin Westbrook, Nicolas Frisby, Paul Brauner, 2011.+All rights reserved.++Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:++- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.++- Neither name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ dist/build/Data/Binding/Hobbits.hi view

binary file changed (absent → 3836 bytes)

+ dist/build/Data/Binding/Hobbits.o view

binary file changed (absent → 1108 bytes)

+ dist/build/Data/Binding/Hobbits/Context.hi view

binary file changed (absent → 3362 bytes)

+ dist/build/Data/Binding/Hobbits/Context.o view

binary file changed (absent → 10932 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting.hi view

binary file changed (absent → 7931 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting.o view

binary file changed (absent → 41004 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting/Examples.hi view

binary file changed (absent → 19387 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting/Examples.o view

binary file changed (absent → 31748 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting/Terms.hi view

binary file changed (absent → 9087 bytes)

+ dist/build/Data/Binding/Hobbits/Examples/LambdaLifting/Terms.o view

binary file changed (absent → 42752 bytes)

+ dist/build/Data/Binding/Hobbits/Internal.hi view

binary file changed (absent → 6247 bytes)

+ dist/build/Data/Binding/Hobbits/Internal.o view

binary file changed (absent → 17292 bytes)

+ dist/build/Data/Binding/Hobbits/Mb.hi view

binary file changed (absent → 14405 bytes)

+ dist/build/Data/Binding/Hobbits/Mb.o view

binary file changed (absent → 31212 bytes)

+ dist/build/Data/Binding/Hobbits/NuElim.hi view

binary file changed (absent → 13119 bytes)

+ dist/build/Data/Binding/Hobbits/NuElim.o view

binary file changed (absent → 73632 bytes)

+ dist/build/Data/Binding/Hobbits/PatternParser.hi view

binary file changed (absent → 3526 bytes)

+ dist/build/Data/Binding/Hobbits/PatternParser.o view

binary file changed (absent → 164168 bytes)

+ dist/build/Data/Binding/Hobbits/QQ.hi view

binary file changed (absent → 2942 bytes)

+ dist/build/Data/Binding/Hobbits/QQ.o view

binary file changed (absent → 20560 bytes)

+ dist/build/Data/Binding/Hobbits/SuperComb.hi view

binary file changed (absent → 2421 bytes)

+ dist/build/Data/Binding/Hobbits/SuperComb.o view

binary file changed (absent → 9680 bytes)

+ dist/build/Data/Type/HList.hi view

binary file changed (absent → 1379 bytes)

+ dist/build/Data/Type/HList.o view

binary file changed (absent → 1008 bytes)

+ dist/build/Data/Type/HList/HList.hi view

binary file changed (absent → 1403 bytes)

+ dist/build/Data/Type/HList/HList.o view

binary file changed (absent → 1004 bytes)

+ dist/build/Data/Type/HList/Proof/Append.hi view

binary file changed (absent → 1631 bytes)

+ dist/build/Data/Type/HList/Proof/Append.o view

binary file changed (absent → 4428 bytes)

+ dist/build/Data/Type/HList/Proof/Member.hi view

binary file changed (absent → 4376 bytes)

+ dist/build/Data/Type/HList/Proof/Member.o view

binary file changed (absent → 14272 bytes)

+ dist/build/Data/Type/List.hi view

binary file changed (absent → 1508 bytes)

+ dist/build/Data/Type/List.o view

binary file changed (absent → 1076 bytes)

+ dist/build/Data/Type/List/List.hi view

binary file changed (absent → 3213 bytes)

+ dist/build/Data/Type/List/List.o view

binary file changed (absent → 7344 bytes)

+ dist/build/Data/Type/List/Map.hi view

binary file changed (absent → 3329 bytes)

+ dist/build/Data/Type/List/Map.o view

binary file changed (absent → 11164 bytes)

+ dist/build/Data/Type/List/Proof/Append.hi view

binary file changed (absent → 1644 bytes)

+ dist/build/Data/Type/List/Proof/Append.o view

binary file changed (absent → 4392 bytes)

+ dist/build/Data/Type/List/Proof/Member.hi view

binary file changed (absent → 5556 bytes)

+ dist/build/Data/Type/List/Proof/Member.o view

binary file changed (absent → 17956 bytes)

+ dist/build/HShobbits-1.0.o view

binary file changed (absent → 398976 bytes)

+ dist/build/autogen/Paths_hobbits.hs view
@@ -0,0 +1,29 @@+module Paths_hobbits (+    version,+    getBinDir, getLibDir, getDataDir, getLibexecDir,+    getDataFileName+  ) where++import Data.Version (Version(..))+import System.Environment (getEnv)++version :: Version+version = Version {versionBranch = [1,0], versionTags = []}++bindir, libdir, datadir, libexecdir :: FilePath++bindir     = "/Users/eddy/.cabal/bin"+libdir     = "/Users/eddy/.cabal/lib/hobbits-1.0/ghc-7.0.1"+datadir    = "/Users/eddy/.cabal/share/hobbits-1.0"+libexecdir = "/Users/eddy/.cabal/libexec"++getBinDir, getLibDir, getDataDir, getLibexecDir :: IO FilePath+getBinDir = catch (getEnv "hobbits_bindir") (\_ -> return bindir)+getLibDir = catch (getEnv "hobbits_libdir") (\_ -> return libdir)+getDataDir = catch (getEnv "hobbits_datadir") (\_ -> return datadir)+getLibexecDir = catch (getEnv "hobbits_libexecdir") (\_ -> return libexecdir)++getDataFileName :: FilePath -> IO FilePath+getDataFileName name = do+  dir <- getDataDir+  return (dir ++ "/" ++ name)
+ dist/build/autogen/cabal_macros.h view
@@ -0,0 +1,58 @@+/* DO NOT EDIT: This file is automatically generated by Cabal */++/* package base-4.3.0.0 */+#define VERSION_base "4.3.0.0"+#define MIN_VERSION_base(major1,major2,minor) (\+  (major1) <  4 || \+  (major1) == 4 && (major2) <  3 || \+  (major1) == 4 && (major2) == 3 && (minor) <= 0)++/* package deepseq-1.1.0.2 */+#define VERSION_deepseq "1.1.0.2"+#define MIN_VERSION_deepseq(major1,major2,minor) (\+  (major1) <  1 || \+  (major1) == 1 && (major2) <  1 || \+  (major1) == 1 && (major2) == 1 && (minor) <= 0)++/* package mtl-2.0.1.0 */+#define VERSION_mtl "2.0.1.0"+#define MIN_VERSION_mtl(major1,major2,minor) (\+  (major1) <  2 || \+  (major1) == 2 && (major2) <  0 || \+  (major1) == 2 && (major2) == 0 && (minor) <= 1)++/* package parsec-3.1.1 */+#define VERSION_parsec "3.1.1"+#define MIN_VERSION_parsec(major1,major2,minor) (\+  (major1) <  3 || \+  (major1) == 3 && (major2) <  1 || \+  (major1) == 3 && (major2) == 1 && (minor) <= 1)++/* package syb-0.3.3 */+#define VERSION_syb "0.3.3"+#define MIN_VERSION_syb(major1,major2,minor) (\+  (major1) <  0 || \+  (major1) == 0 && (major2) <  3 || \+  (major1) == 0 && (major2) == 3 && (minor) <= 3)++/* package tagged-0.2.2.1 */+#define VERSION_tagged "0.2.2.1"+#define MIN_VERSION_tagged(major1,major2,minor) (\+  (major1) <  0 || \+  (major1) == 0 && (major2) <  2 || \+  (major1) == 0 && (major2) == 2 && (minor) <= 2)++/* package template-haskell-2.5.0.0 */+#define VERSION_template_haskell "2.5.0.0"+#define MIN_VERSION_template_haskell(major1,major2,minor) (\+  (major1) <  2 || \+  (major1) == 2 && (major2) <  5 || \+  (major1) == 2 && (major2) == 5 && (minor) <= 0)++/* package type-equality-0.1.0 */+#define VERSION_type_equality "0.1.0"+#define MIN_VERSION_type_equality(major1,major2,minor) (\+  (major1) <  0 || \+  (major1) == 0 && (major2) <  1 || \+  (major1) == 0 && (major2) == 1 && (minor) <= 0)+
+ dist/build/libHShobbits-1.0.a view

binary file changed (absent → 533160 bytes)

+ dist/doc/html/hobbits/Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting.Examples</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</p></div><div id="description"><p class="caption">Description</p><div class="doc empty">&nbsp;</div></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><a name="v:ex1" class="def">ex1</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> ((b1 -&gt; b) -&gt; b1 -&gt; b)</p></div><div class="top"><p class="src"><a name="v:ex2" class="def">ex2</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> ((((b2 -&gt; b1) -&gt; b2 -&gt; b1) -&gt; b) -&gt; b)</p></div><div class="top"><p class="src"><a name="v:ex3" class="def">ex3</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (b3 -&gt; (((b3 -&gt; b2 -&gt; b1) -&gt; b2 -&gt; b1) -&gt; b) -&gt; b)</p></div><div class="top"><p class="src"><a name="v:ex4" class="def">ex4</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (((b1 -&gt; b) -&gt; b2 -&gt; b) -&gt; (((b1 -&gt; b) -&gt; b2 -&gt; b) -&gt; b2 -&gt; b1) -&gt; b2 -&gt; b1)</p></div><div class="top"><p class="src"><a name="v:ex5" class="def">ex5</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (((b2 -&gt; b1) -&gt; b) -&gt; (b2 -&gt; b1) -&gt; b)</p></div><div class="top"><p class="src"><a name="v:ex6" class="def">ex6</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> ((b -&gt; b) -&gt; a)) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a)</p></div><div class="top"><p class="src"><a name="v:ex7" class="def">ex7</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> ((b2 -&gt; b2) -&gt; b1)) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> ((b1 -&gt; b) -&gt; b))</p></div><div class="top"><p class="src"><a name="v:exP" class="def">exP</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (((b1 -&gt; b1) -&gt; b) -&gt; (b1 -&gt; b1) -&gt; b)</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting.Terms</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</p></div><div id="description"><p class="caption">Description</p><div class="doc empty">&nbsp;</div></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:L" class="def">L</a> a </p></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:D" class="def">D</a> a </p></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Term" class="def">Term</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Var" class="def">Var</a> ::  <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:Lam" class="def">Lam</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> b) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (b -&gt; a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:App" class="def">App</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (b -&gt; a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> b -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a</td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:Term" class="caption collapser" onclick="toggleSection('i:Term')">Instances</p><div id="section.i:Term" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><a name="v:lam" class="def">lam</a> ::  (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> b) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> (a -&gt; b)</p></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:DTerm" class="def">DTerm</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:TVar" class="def">TVar</a> ::  <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> a</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:TDVar" class="def">TDVar</a> ::  <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:D">D</a> a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> a</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:TApp" class="def">TApp</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> (a -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> a -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> b</td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:DTerm" class="caption collapser" onclick="toggleSection('i:DTerm')">Instances</p><div id="section.i:DTerm" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Decl" class="def">Decl</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Decl_One" class="def">Decl_One</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> a) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> b) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl">Decl</a> (a -&gt; b)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:Decl_Cons" class="def">Decl_Cons</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">L</a> a) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl">Decl</a> b) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl">Decl</a> (a -&gt; b)</td><td class="doc empty">&nbsp;</td></tr></table></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Decls" class="def">Decls</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Decls_Base" class="def">Decls_Base</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">DTerm</a> a -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:Decls_Cons" class="def">Decls_Cons</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl">Decl</a> b -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:D">D</a> b) (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a) -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a</td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:Decls" class="caption collapser" onclick="toggleSection('i:Decls')">Instances</p><div id="section.i:Decls" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-Examples-LambdaLifting.html view
@@ -0,0 +1,11 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-Examples-LambdaLifting.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#1">Term data types, using <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code>+</a></li><li><a href="#2">The lambda-lifting function+</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>The lambda lifting example from the paper E. Westbrook, N. Frisby,+ P. Brauner, &quot;Hobbits for Haskell: A Library for Higher-Order Encodings in+ Functional Programming Languages&quot;.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short">module <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a></li><li class="src short"><a href="#v:lambdaLift">lambdaLift</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a</li><li class="src short"><a href="#v:mbLambdaLift">mbLambdaLift</a> ::  <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a)</li></ul></div><div id="interface"><h1 id="1">Term data types, using <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code>+</h1><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a></p></div><h1 id="2">The lambda-lifting function+</h1><div class="top"><p class="src"><a name="v:lambdaLift" class="def">lambdaLift</a> ::  <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a -&gt; <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a</p></div><div class="top"><p class="src"><a name="v:mbLambdaLift" class="def">mbLambdaLift</a> ::  <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Term</a> a) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Decls</a> a)</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-Internal.html view
@@ -0,0 +1,9 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Internal</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-Internal.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.Internal</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>This module is internal to the Hobbits library, and should not be used+ directly.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">newtype</span>  <a href="#t:Name">Name</a> a = <a href="#v:MkName">MkName</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></li><li class="src short"><span class="keyword">data</span>  <a href="#t:Mb">Mb</a> ctx b = <a href="#v:MkMb">MkMb</a> [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a>] b</li><li class="src short"><span class="keyword">data</span>  <a href="#t:ExMember">ExMember</a>  <span class="keyword">where</span><ul class="subs"><li><a href="#v:ExMember">ExMember</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExMember">ExMember</a>  </li></ul></li><li class="src short"><a href="#v:memberFromLen">memberFromLen</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExMember">ExMember</a></li><li class="src short"><a href="#v:unsafeLookupC">unsafeLookupC</a> ::  <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a</li><li class="src short"><span class="keyword">data</span>  <a href="#t:ExProxy">ExProxy</a>  <span class="keyword">where</span><ul class="subs"><li><a href="#v:ExProxy">ExProxy</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExProxy">ExProxy</a>  </li></ul></li><li class="src short"><a href="#v:proxyFromLen">proxyFromLen</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExProxy">ExProxy</a></li><li class="src short"><a href="#v:unsafeProxyFromLen">unsafeProxyFromLen</a> ::  <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx</li><li class="src short"><a href="#v:unsafeNamesFromInts">unsafeNamesFromInts</a> ::  [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a>] -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> ctx</li><li class="src short"><a href="#v:counter">counter</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-IORef.html#t:IORef">IORef</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></li><li class="src short"><a href="#v:fresh_name">fresh_name</a> ::  a -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></li></ul></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><span class="keyword">newtype</span>  <a name="t:Name" class="def">Name</a> a </p><div class="doc"><p>A <code>Name a</code> is a bound name that is associated with type <code>a</code>.+</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:MkName" class="def">MkName</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:Name" class="caption collapser" onclick="toggleSection('i:Name')">Instances</p><div id="section.i:Name" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable1">Typeable1</a> <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Eq.html#t:Eq">Eq</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Mb" class="def">Mb</a> ctx b </p><div class="doc"><p>An <code>Mb ctx b</code> is a multi-binding that binds exactly one name for each+  type in <code>ctx</code>, where <code>ctx</code> has the form <code><code><a href="Data-Type-List-List.html#t:Nil">Nil</a></code> <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> t1 <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> ... <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> tn</code>.+</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:MkMb" class="def">MkMb</a> [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a>] b</td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:Mb" class="caption collapser" onclick="toggleSection('i:Mb')">Instances</p><div id="section.i:Mb" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable2">Typeable2</a> <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> a =&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> c a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:ExMember" class="def">ExMember</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:ExMember" class="def">ExMember</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExMember">ExMember</a></td><td class="doc empty">&nbsp;</td></tr></table></div></div><div class="top"><p class="src"><a name="v:memberFromLen" class="def">memberFromLen</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExMember">ExMember</a></p></div><div class="top"><p class="src"><a name="v:unsafeLookupC" class="def">unsafeLookupC</a> ::  <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a</p></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:ExProxy" class="def">ExProxy</a>  <span class="keyword">where</span></p><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:ExProxy" class="def">ExProxy</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExProxy">ExProxy</a></td><td class="doc empty">&nbsp;</td></tr></table></div></div><div class="top"><p class="src"><a name="v:proxyFromLen" class="def">proxyFromLen</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:ExProxy">ExProxy</a></p></div><div class="top"><p class="src"><a name="v:unsafeProxyFromLen" class="def">unsafeProxyFromLen</a> ::  <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a> -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx</p></div><div class="top"><p class="src"><a name="v:unsafeNamesFromInts" class="def">unsafeNamesFromInts</a> ::  [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a>] -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> ctx</p></div><div class="top"><p class="src"><a name="v:counter" class="def">counter</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-IORef.html#t:IORef">IORef</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></p></div><div class="top"><p class="src"><a name="v:fresh_name" class="def">fresh_name</a> ::  a -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-Mb.html view
@@ -0,0 +1,66 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Mb</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-Mb.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.Mb</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#1">Abstract types+</a></li><li><a href="#2">Multi-binding constructors+</a></li><li><a href="#3">Operations on multi-bindings+</a></li><li><a href="#4">Queries on names+</a></li><li><a href="#5">type classes for lifting data out of bindings+</a></li><li><a href="#6">Optimized, safe multi-binding eliminators+</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>This module defines multi-bindings as the type <code><a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a></code>, as well as a number of+ operations on multi-bindings. See the paper E. Westbrook, N. Frisby,+ P. Brauner, &quot;Hobbits for Haskell: A Library for Higher-Order Encodings in+ Functional Programming Languages&quot; for more information.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">data</span>  <a href="#t:Name">Name</a> a</li><li class="src short"><span class="keyword">type</span> <a href="#t:Binding">Binding</a> a = <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</li><li class="src short"><span class="keyword">data</span>  <a href="#t:Mb">Mb</a> ctx b</li><li class="src short"><a href="#v:nu">nu</a> ::  (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a b</li><li class="src short"><a href="#v:emptyMb">emptyMb</a> ::  a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a> a</li><li class="src short"><a href="#v:nuMulti">nuMulti</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f ctx -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> ctx -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx b</li><li class="src short"><a href="#v:elimEmptyMb">elimEmptyMb</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a> a -&gt; a</li><li class="src short"><a href="#v:combineMb">combineMb</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c1 (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c2 b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2) b</li><li class="src short"><a href="#v:separateMb">separateMb</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 c -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c1 (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c2 a)</li><li class="src short"><a href="#v:mbToProxy">mbToProxy</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx</li><li class="src short"><a href="#v:cmpName">cmpName</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> b -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</li><li class="src short"><a href="#v:mbCmpName">mbCmpName</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> b) -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</li><li class="src short"><a href="#v:mbNameBoundP">mbNameBoundP</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a) -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Either.html#t:Either">Either</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> ctx a) (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a)</li><li class="src short"><span class="keyword">class</span>  <a href="#t:Liftable">Liftable</a> a  <span class="keyword">where</span><ul class="subs"><li><a href="#v:mbLift">mbLift</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx a -&gt; a</li></ul></li><li class="src short"><span class="keyword">class</span>  <a href="#t:Liftable1">Liftable1</a> f  <span class="keyword">where</span><ul class="subs"><li><a href="#v:mbLift1">mbLift1</a> :: <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (f a) -&gt; f a</li></ul></li><li class="src short"><span class="keyword">class</span>  <a href="#t:Liftable2">Liftable2</a> f  <span class="keyword">where</span><ul class="subs"><li><a href="#v:mbLift2">mbLift2</a> :: (<a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a, <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> b) =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (f a b) -&gt; f a b</li></ul></li><li class="src short"><a href="#v:mbList">mbList</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c [a] -&gt; [<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c a]</li></ul></div><div id="interface"><h1 id="1">Abstract types+</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Name" class="def">Name</a> a </p><div class="doc"><p>A <code>Name a</code> is a bound name that is associated with type <code>a</code>.+</p></div><div class="subs instances"><p id="control.i:Name" class="caption collapser" onclick="toggleSection('i:Name')">Instances</p><div id="section.i:Name" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable1">Typeable1</a> <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Eq.html#t:Eq">Eq</a> (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">type</span> <a name="t:Binding" class="def">Binding</a> a = <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</p><div class="doc"><p>A <code>Binding</code> is simply a multi-binding that binds one name+</p></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Mb" class="def">Mb</a> ctx b </p><div class="doc"><p>An <code>Mb ctx b</code> is a multi-binding that binds exactly one name for each+  type in <code>ctx</code>, where <code>ctx</code> has the form <code><code><a href="Data-Type-List-List.html#t:Nil">Nil</a></code> <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> t1 <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> ... <code><a href="Data-Type-List-List.html#t::-62-">:&gt;</a></code> tn</code>.+</p></div><div class="subs instances"><p id="control.i:Mb" class="caption collapser" onclick="toggleSection('i:Mb')">Instances</p><div id="section.i:Mb" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable2">Typeable2</a> <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> a =&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><h1 id="2">Multi-binding constructors+</h1><div class="top"><p class="src"><a name="v:nu" class="def">nu</a> ::  (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a b</p><div class="doc"><p><code>nu f</code> creates a binding which binds a fresh name <code>n</code> and whose+  body is the result of <code>f n</code>.+</p></div></div><div class="top"><p class="src"><a name="v:emptyMb" class="def">emptyMb</a> ::  a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a> a</p><div class="doc"><p>Creates an empty binding that binds 0 names.+</p></div></div><div class="top"><p class="src"><a name="v:nuMulti" class="def">nuMulti</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f ctx -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> ctx -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx b</p><div class="doc"><p>The expression <code>nuMulti p f</code> creates a multi-binding of zero or more+  names, one for each element of the vector <code>p</code>. The bound names are+  passed the names to <code>f</code>, which returns the body of the+  multi-binding.  The argument <code>p</code>, of type <code><code><a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a></code> f ctx</code>, acts as a+  &quot;phantom&quot; argument, used to reify the list of types <code>ctx</code> at the+  term level; thus it is unimportant what the type function <code>f</code> is.+</p></div></div><h1 id="3">Operations on multi-bindings+</h1><div class="top"><p class="src"><a name="v:elimEmptyMb" class="def">elimEmptyMb</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a> a -&gt; a</p><div class="doc"><p>Eliminates an empty binding, returning its body. Note that+  <code>elimEmptyMb</code> is the inverse of <code>emptyMb</code>.+</p></div></div><div class="top"><p class="src"><a name="v:combineMb" class="def">combineMb</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c1 (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c2 b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2) b</p><div class="doc"><p>Combines a binding inside another binding into a single binding.+</p></div></div><div class="top"><p class="src"><a name="v:separateMb" class="def">separateMb</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 c -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c1 (<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c2 a)</p><div class="doc"><p>Separates a binding into two nested bindings. The first argument, of+  type <code><code><a href="Data-Type-List-Proof-Append.html#t:Append">Append</a></code> c1 c2 c</code>, is a &quot;phantom&quot; argument to indicate how+  the context <code>c</code> should be split.+</p></div></div><div class="top"><p class="src"><a name="v:mbToProxy" class="def">mbToProxy</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Proxy ctx</p><div class="doc"><p>Returns a proxy object that enumerates all the types in ctx.+</p></div></div><h1 id="4">Queries on names+</h1><div class="top"><p class="src"><a name="v:cmpName" class="def">cmpName</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> b -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</p><div class="doc"><p><code>cmpName n m</code> compares names <code>n</code> and <code>m</code> of types <code>Name a</code> and <code>Name b</code>,+  respectively. When they are equal, <code>Some e</code> is returned for <code>e</code> a proof+  of type <code>a :=: b</code> that their types are equal. Otherwise, <code>None</code> is returned.+</p><p>For example:+</p><pre> nu $ \n -&gt; nu $ \m -&gt; cmpName n n   ==   nu $ \n -&gt; nu $ \m -&gt; Some Refl+ nu $ \n -&gt; nu $ \m -&gt; cmpName n m   ==   nu $ \n -&gt; nu $ \m -&gt; None+</pre></div></div><div class="top"><p class="src"><a name="v:mbCmpName" class="def">mbCmpName</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> b) -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</p><div class="doc"><p>Compares two names inside bindings, taking alpha-equivalence into+  account; i.e., if both are the <code>i</code>th name, or both are the same name+  not bound in their respective multi-bindings, then they compare as+  equal. The return values are the same as for <code><a href="Data-Binding-Hobbits-Mb.html#v:cmpName">cmpName</a></code>, so that+  <code>Some Refl</code> is returned when the names are equal and <code>Nothing</code> is+  returned when they are not.+</p></div></div><div class="top"><p class="src"><a name="v:mbNameBoundP" class="def">mbNameBoundP</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a) -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Either.html#t:Either">Either</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> ctx a) (<a href="Data-Binding-Hobbits-Mb.html#t:Name">Name</a> a)</p><div class="doc"><p>Checks if a name is bound in a multi-binding, returning <code>Left mem</code>+  when the name is bound, where <code>mem</code> is a proof that the type of the+  name is in the type list for the multi-binding, and returning+  <code>Right n</code> when the name is not bound, where <code>n</code> is the name.+</p><p>For example:+</p><pre> nu $ \n -&gt; mbNameBoundP (nu $ \m -&gt; m)  ==  nu $ \n -&gt; Left Member_Base+ nu $ \n -&gt; mbNameBoundP (nu $ \m -&gt; n)  ==  nu $ \n -&gt; Right n+</pre></div></div><h1 id="5">type classes for lifting data out of bindings+</h1><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:Liftable" class="def">Liftable</a> a  <span class="keyword">where</span></p><div class="doc"><p>The class <code>Liftable a</code> gives a &quot;lifting function&quot; for a, which can+  take any data of type <code>a</code> out of a multi-binding of type <code><code><a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a></code> ctx a</code>.+</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:mbLift" class="def">mbLift</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx a -&gt; a</p></div><div class="subs instances"><p id="control.i:Liftable" class="caption collapser" onclick="toggleSection('i:Liftable')">Instances</p><div id="section.i:Liftable" class="show"><table><tr><td class="src"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Char.html#t:Char">Char</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binding-Hobbits-Mb.html#t:Liftable1">Liftable1</a> f, <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a) =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> (f a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:Liftable1" class="def">Liftable1</a> f  <span class="keyword">where</span></p><div class="doc"><p>The class <code>Liftable1 f</code> gives a lifting function for each type <code>f a</code>+  when <code>a</code> itself is <code>Liftable</code>.+</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:mbLift1" class="def">mbLift1</a> :: <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (f a) -&gt; f a</p></div><div class="subs instances"><p id="control.i:Liftable1" class="caption collapser" onclick="toggleSection('i:Liftable1')">Instances</p><div id="section.i:Liftable1" class="show"><table><tr><td class="src">(<a href="Data-Binding-Hobbits-Mb.html#t:Liftable2">Liftable2</a> f, <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a) =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Liftable1">Liftable1</a> (f a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:Liftable2" class="def">Liftable2</a> f  <span class="keyword">where</span></p><div class="doc"><p>The class <code>Liftable2 f</code> gives a lifting function for each type <code>f a b</code>+  when <code>a</code> and <code>b</code> are <code>Liftable</code>.+</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:mbLift2" class="def">mbLift2</a> :: (<a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> a, <a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> b) =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> ctx (f a b) -&gt; f a b</p></div></div><h1 id="6">Optimized, safe multi-binding eliminators+</h1><div class="top"><p class="src"><a name="v:mbList" class="def">mbList</a> ::  <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c [a] -&gt; [<a href="Data-Binding-Hobbits-Mb.html#t:Mb">Mb</a> c a]</p><div class="doc"><p>Lift a list (but not its elements) out of a multi-binding+</p></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-NuElim.html view
@@ -0,0 +1,46 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.NuElim</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-NuElim.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><p class="caption">Data.Binding.Hobbits.NuElim</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>This module defines the NuElim typeclass, which allows eliminations+  of (multi-) bindings. The high-level idea is that, when a fresh name+  is created with <code><a href="Data-Binding-Hobbits-Mb.html#v:nu">nu</a></code>, the fresh name can also be substituted for the+  bound name in a binding. See the documentation for <code><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElim1">nuWithElim1</a></code> and+  <code><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElimMulti">nuWithElimMulti</a></code> for details.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><a href="#v:nuWithElimMulti">nuWithElimMulti</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> args =&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f ctx -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx) args -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> ctx -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Identity args -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx b</li><li class="src short"><a href="#v:nuWithElim1">nuWithElim1</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> arg =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a arg -&gt; (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a -&gt; arg -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a b</li><li class="src short"><span class="keyword">class</span>  <a href="#t:NuElim">NuElim</a> a  <span class="keyword">where</span><ul class="subs"><li><a href="#v:nuElimProof">nuElimProof</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof">NuElimProof</a> a</li></ul></li><li class="src short"><a href="#v:mkNuElimData">mkNuElimData</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Type">Type</a> -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Dec">Dec</a>]</li><li class="src short"><span class="keyword">class</span>  <a href="#t:NuElimList">NuElimList</a> args  <span class="keyword">where</span><ul class="subs"><li><a href="#v:nuElimListProof">nuElimListProof</a> :: <a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof">NuElimProof</a> args</li></ul></li><li class="src short"><span class="keyword">data</span>  <a href="#t:NuElimProof">NuElimProof</a> a</li></ul></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><a name="v:nuWithElimMulti" class="def">nuWithElimMulti</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> args =&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f ctx -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx) args -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> ctx -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> Identity args -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx b</p><div class="doc"><p>The expression <code>nuWithElimMulti args f</code> takes a sequence <code>args</code> of+  zero or more multi-bindings, each of type <code>Mb ctx ai</code> for the same+  type context <code>ctx</code> of bound names, and a function <code>f</code> and does the+  following:+</p><ul><li> Creates a multi-binding that binds names <code>n1,...,nn</code>, one name for+    each type in <code>ctx</code>;+</li><li> Substitutes the names <code>n1,...,nn</code> for the names bound by each+    argument in the <code>args</code> sequence, yielding the bodies of the <code>args</code>+    (using the new name <code>n</code>); and then+</li><li> Passes the sequence <code>n1,...,nn</code> along with the result of+    substituting into <code>args</code> to the function <code>f</code>, which then returns+    the value for the newly created binding.+</li></ul><p>Note that the types in <code>args</code> must each have a <code>NuElim</code> instance;+  this is represented with the <code>NuElimList</code> type class.+</p><p>Here are some examples:+</p><pre> commuteFun :: (NuElim a, NuElim b) =&gt; Mb ctx (a -&gt; b) -&gt; Mb ctx a -&gt; Mb ctx b+ commuteFun f a =+     nuWithElimMulti ('mbToProxy' f) ('Nil' :&gt; f :&gt; a)+                     (\_ ('Nil' :&gt; 'Identity' f' :&gt; 'Identity' a') -&gt; f' a')+</pre></div></div><div class="top"><p class="src"><a name="v:nuWithElim1" class="def">nuWithElim1</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> arg =&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a arg -&gt; (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a -&gt; arg -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Mb.html#t:Binding">Binding</a> a b</p><div class="doc"><p>Similar to <code><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElimMulti">nuWithElimMulti</a></code> but takes only one argument that binds+  a single name.+</p></div></div><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:NuElim" class="def">NuElim</a> a  <span class="keyword">where</span></p><div class="doc"><p>Instances of the <code>NuElim a</code> class allow the type <code>a</code> to be used with+  <code><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElimMulti">nuWithElimMulti</a></code> and <code><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElim1">nuWithElim1</a></code>. The structure of this class is+  mostly hidden from the user; see <code><a href="Data-Binding-Hobbits-NuElim.html#v:mkNuElimData">mkNuElimData</a></code> to see how to create+  instances of the <code>NuElim</code> class.+</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:nuElimProof" class="def">nuElimProof</a> :: <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof">NuElimProof</a> a</p></div><div class="subs instances"><p id="control.i:NuElim" class="caption collapser" onclick="toggleSection('i:NuElim')">Instances</p><div id="section.i:NuElim" class="show"><table><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Char.html#t:Char">Char</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> [a]</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Name">Name</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a, <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> b) =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (a -&gt; b)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> (<a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><a name="v:mkNuElimData" class="def">mkNuElimData</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Type">Type</a> -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Dec">Dec</a>]</p><div class="doc"><p>Template Haskell function for creating NuElim instances for (G)ADTs.+  Typical usage is to include the following line in the source file for+  (G)ADT <code>T</code> (here assumed to have two type arguments):+</p><pre> $(mkNuElimData [t| forall a b . T a b |])+</pre><p>The <code><a href="Data-Binding-Hobbits-NuElim.html#v:mkNuElimData">mkNuElimData</a></code> call here will create an instance declaration for+  <code><code><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a></code> (T a b)</code>. It is also possible to include a context in the+  forall type; for example, if we define the <code>ID</code> data type as follows:+</p><pre> data ID a = ID a+</pre><p>then we can create a <code><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a></code> instance for it like this:+</p><pre> $( mkNuElimData [t| NuElim a =&gt; ID a |])+</pre><p>Note that, when a context is included, the Haskell parser will add+  the <code>forall a</code> for you.+</p></div></div><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:NuElimList" class="def">NuElimList</a> args  <span class="keyword">where</span></p><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:nuElimListProof" class="def">nuElimListProof</a> :: <a href="Data-Type-List-Map.html#t:MapC">MapC</a> <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof">NuElimProof</a> args</p></div><div class="subs instances"><p id="control.i:NuElimList" class="caption collapser" onclick="toggleSection('i:NuElimList')">Instances</p><div id="section.i:NuElimList" class="show"><table><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> args, <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a) =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> (<a href="Data-Type-List-List.html#t::-62-">:&gt;</a> args a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:NuElimProof" class="def">NuElimProof</a> a </p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-PatternParser.html view
@@ -0,0 +1,8 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.PatternParser</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-PatternParser.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.PatternParser</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>A simple parser for Haskell patterns. Currently does not handle:+</p><ul><li> Record patterns <code>Pt { pointx = x }</code>+</li><li> Signature patterns <code>p :: t</code>+</li><li> View patterns <code>e -&gt; p</code>+</li></ul></div></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><a name="v:parsePattern" class="def">parsePattern</a> :: [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Char.html#t:Char">Char</a>] -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Pat">Pat</a></p></div><div class="top"><p class="src"><a name="v:parseVar" class="def">parseVar</a> :: [<a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Char.html#t:Char">Char</a>] -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Char.html#t:String">String</a></p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-QQ.html view
@@ -0,0 +1,14 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.QQ</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-QQ.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.QQ</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Defines a quasi-quoter for writing patterns that match the bodies+ of <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code> multi-bindings. Uses the+ <a href="Data-Binding-Hobbits-PatternParser.html">Data.Binding.Hobbits.PatternParser</a> module, and thus only supports+ the pattern forms listed there. If <code>P</code> is a (supported) Haskell+ pattern, then <code>[nuQQ| P ]</code> defines a pattern that will match an+ multi-binding whose body matches <code>P</code>. Any variables matched by <code>P</code>+ will remain inside the binding; thus, for example, in the pattern+ <code>[nuQQ| x |]</code>, <code>x</code> matches the entire multi-binding.+</p><p>Examples:+</p><pre> case (nu Left) of [nuQQ| Left x |] -&gt; x  ==  nu id+</pre></div></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><a name="v:nuQQ" class="def">nuQQ</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Quote.html#t:QuasiQuoter">QuasiQuoter</a></p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits-SuperComb.html view
@@ -0,0 +1,22 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.SuperComb</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits-SuperComb.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits.SuperComb</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#1">Abstract types+</a></li><li><a href="#2">Operators involving <code><a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a></code>+</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>This module uses Template Haskell to distinguish super-combinators, so that+ the library can trust such functions to not contain any <code>Name</code> values in+ their closure.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">data</span>  <a href="#t:SuperComb">SuperComb</a> a</li><li class="src short"><a href="#v:superComb">superComb</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Exp">Exp</a> -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Exp">Exp</a></li><li class="src short"><a href="#v:mbToplevel">mbToplevel</a> ::  <a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a> (a -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx a -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx b</li></ul></div><div id="interface"><h1 id="1">Abstract types+</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:SuperComb" class="def">SuperComb</a> a </p><div class="doc"><p>The type <code>SuperComb a</code> represents a super-combinator of type <code>a</code>,+  i.e., an expression of type <code>a</code> with no free (Haskell) variables.+  Since this cannot be checked directly in the Haskell type system,+  the <code>SuperComb</code> data type is hidden, and the user can only create+  super-combinators using Template Haskell, through the <code><a href="Data-Binding-Hobbits-SuperComb.html#v:superComb">superComb</a></code>+  operator.+</p></div></div><h1 id="2">Operators involving <code><a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a></code>+</h1><div class="top"><p class="src"><a name="v:superComb" class="def">superComb</a> :: <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Exp">Exp</a> -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Q">Q</a> <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/Language-Haskell-TH-Syntax.html#t:Exp">Exp</a></p><div class="doc"><p><code>superComb</code> is used with Template Haskell to create super-combinators;+ see documentation for <code><a href="Data-Binding-Hobbits-SuperComb.html#v:mbToplevel">mbToplevel</a></code> to see how it is used.+</p></div></div><div class="top"><p class="src"><a name="v:mbToplevel" class="def">mbToplevel</a> ::  <a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a> (a -&gt; b) -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx a -&gt; <a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a> ctx b</p><div class="doc"><p><code>mbToplevel</code> <code>f</code> <code>b</code> applies super-combinator <code>f</code> to the body of+ multi-binding <code>b</code>. For example:+</p><pre> mbToplevel $(superComb [| f |]) (nu $ \n -&gt; n)   =   nu f+</pre></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Binding-Hobbits.html view
@@ -0,0 +1,23 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Binding-Hobbits.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Binding.Hobbits</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#1">Values under multi-bindings+</a></li><li><a href="#2">Ancilliary modules+</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>This library implements multi-bindings as described in the paper+ E. Westbrook, N. Frisby, P. Brauner, &quot;Hobbits for Haskell: A Library for+ Higher-Order Encodings in Functional Programming Languages&quot;.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short">module <a href="Data-Binding-Hobbits-Mb.html">Data.Binding.Hobbits.Mb</a></li><li class="src short">module <a href="Data-Type-List.html">Data.Type.List</a></li><li class="src short">module <a href="Data-Binding-Hobbits-SuperComb.html">Data.Binding.Hobbits.SuperComb</a></li><li class="src short">module <a href="Data-Binding-Hobbits-QQ.html">Data.Binding.Hobbits.QQ</a></li><li class="src short">module <a href="Data-Binding-Hobbits-PatternParser.html">Data.Binding.Hobbits.PatternParser</a></li><li class="src short">module <a href="Data-Binding-Hobbits-NuElim.html">Data.Binding.Hobbits.NuElim</a></li></ul></div><div id="interface"><h1 id="1">Values under multi-bindings+</h1><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-Mb.html">Data.Binding.Hobbits.Mb</a></p></div><div class="doc"><p>The <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code> type modeling multi-bindings is the+ central abstract type of the library+</p></div><h1 id="2">Ancilliary modules+</h1><div class="top"><p class="src">module <a href="Data-Type-List.html">Data.Type.List</a></p></div><div class="doc"><p>Type lists track the types of bound variables.+</p></div><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-SuperComb.html">Data.Binding.Hobbits.SuperComb</a></p></div><div class="doc"><p>The <code><a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a></code> type models+ super-combinators, which are safe functions to apply under+ <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code>.+</p></div><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-QQ.html">Data.Binding.Hobbits.QQ</a></p></div><div class="doc"><p>The <code><a href="Data-Binding-Hobbits-QQ.html#v:nuQQ">nuQQ</a></code> quasiquoter allows safe pattern+ matching on <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code> values.+</p></div><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-PatternParser.html">Data.Binding.Hobbits.PatternParser</a></p></div><div class="doc"><p>A simple parser for Haskell patterns.+</p></div><div class="top"><p class="src">module <a href="Data-Binding-Hobbits-NuElim.html">Data.Binding.Hobbits.NuElim</a></p></div><div class="doc"><p>The <a href="Data-Binding-Hobbits-NuElim.html">Data.Binding.Hobbits.NuElim</a> module allows elimination of+ bindings and multi-bindings; NOTE: this module is not covered in+ the &quot;Hobbits for Haskell&quot; paper.+</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Type-List-List.html view
@@ -0,0 +1,5 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.List</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Type-List-List.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Type.List.List</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>The type-level constructors of type lists.+</p></div></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Nil" class="def">Nil</a>  </p><div class="subs instances"><p id="control.i:Nil" class="caption collapser" onclick="toggleSection('i:Nil')">Instances</p><div id="section.i:Nil" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable">Typeable</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> <a href="Data-Type-List-List.html#t:Nil">Nil</a></td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">data</span>  r <a name="t::-62-" class="def">:&gt;</a> a </p><div class="subs instances"><p id="control.i::-62-" class="caption collapser" onclick="toggleSection('i::-62-')">Instances</p><div id="section.i::-62-" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Typeable.html#t:Typeable2">Typeable2</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> args, <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">NuElim</a> a) =&gt; <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">NuElimList</a> (<a href="Data-Type-List-List.html#t::-62-">:&gt;</a> args a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">type family</span> r1 <a name="t::-43--43-:" class="def">:++:</a> r2 </p></div><div class="top"><p class="src"><a name="v:proxyCons" class="def">proxyCons</a> ::  Proxy r -&gt; f a -&gt; Proxy (r <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Type-List-Map.html view
@@ -0,0 +1,18 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Map</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Type-List-Map.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Type.List.Map</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Vectors indexed by a type list+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">data</span>  <a href="#t:MapC">MapC</a> f c <span class="keyword">where</span><ul class="subs"><li><a href="#v:Nil">Nil</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f <a href="Data-Type-List-List.html#t:Nil">Nil</a>  </li><li><a href="#v::-62-">:&gt;</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; f a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (c <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)  </li></ul></li><li class="src short"><a href="#v:empty">empty</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f <a href="Data-Type-List-List.html#t:Nil">Nil</a></li><li class="src short"><a href="#v:singleton">singleton</a> ::  f a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</li><li class="src short"><a href="#v:lookup">lookup</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; f a</li><li class="src short"><a href="#v:mapC">mapC</a> ::  (<span class="keyword">forall</span> x.  f x -&gt; g x) -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> g c</li><li class="src short"><a href="#v:append">append</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c1 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</li><li class="src short"><a href="#v:mkAppend">mkAppend</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</li><li class="src short"><a href="#v:mkMonoAppend">mkMonoAppend</a> ::  Proxy c1 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</li><li class="src short"><a href="#v:split">split</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c1, <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2)</li><li class="src short"><a href="#v:proxy">proxy</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; Proxy c</li><li class="src short"><a href="#v:members">members</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c) c</li></ul></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:MapC" class="def">MapC</a> f c <span class="keyword">where</span></p><div class="doc"><p>A <code>MapC f c</code> is a vector with exactly one element of type <code>f a</code> for+  each type <code>a</code> in the type list <code>c</code>.+</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Nil" class="def">Nil</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f <a href="Data-Type-List-List.html#t:Nil">Nil</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v::-62-" class="def">:&gt;</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; f a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (c <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div><div class="top"><p class="src"><a name="v:empty" class="def">empty</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f <a href="Data-Type-List-List.html#t:Nil">Nil</a></p><div class="doc"><p>Create an empty <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector.+</p></div></div><div class="top"><p class="src"><a name="v:singleton" class="def">singleton</a> ::  f a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</p><div class="doc"><p>Create a singleton <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector.+</p></div></div><div class="top"><p class="src"><a name="v:lookup" class="def">lookup</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; f a</p><div class="doc"><p>Look up an element of a <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector using a <code><a href="Data-Type-List-Proof-Member.html#t:Member">Member</a></code> proof.+</p></div></div><div class="top"><p class="src"><a name="v:mapC" class="def">mapC</a> ::  (<span class="keyword">forall</span> x.  f x -&gt; g x) -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> g c</p><div class="doc"><p>Map a function to all elements of a <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector.+</p></div></div><div class="top"><p class="src"><a name="v:append" class="def">append</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c1 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</p><div class="doc"><p>Append two <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vectors.+</p></div></div><div class="top"><p class="src"><a name="v:mkAppend" class="def">mkAppend</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</p><div class="doc"><p>Make an <code><a href="Data-Type-List-Proof-Append.html#t:Append">Append</a></code> proof from any <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector for the second+ argument of the append.+</p></div></div><div class="top"><p class="src"><a name="v:mkMonoAppend" class="def">mkMonoAppend</a> ::  Proxy c1 -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2 -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 (c1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> c2)</p><div class="doc"><p>A version of <code><a href="Data-Type-List-Map.html#v:mkAppend">mkAppend</a></code> that takes in a <code>Proxy</code> argument.+</p></div></div><div class="top"><p class="src"><a name="v:split" class="def">split</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> c1 c2 c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; (<a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c1, <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c2)</p><div class="doc"><p>Split a <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector into two pieces.+</p></div></div><div class="top"><p class="src"><a name="v:proxy" class="def">proxy</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; Proxy c</p><div class="doc"><p>Create a <code>Proxy</code> object for the type list of a <code><a href="Data-Type-List-Map.html#t:MapC">MapC</a></code> vector.+</p></div></div><div class="top"><p class="src"><a name="v:members" class="def">members</a> ::  <a href="Data-Type-List-Map.html#t:MapC">MapC</a> f c -&gt; <a href="Data-Type-List-Map.html#t:MapC">MapC</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c) c</p><div class="doc"><p>Create a vector of proofs that each type in <code>c</code> is a <code><a href="Data-Type-List-Proof-Member.html#t:Member">Member</a></code> of <code>c</code>.+</p></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Type-List-Proof-Append.html view
@@ -0,0 +1,8 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Proof.Append</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Type-List-Proof-Append.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Type.List.Proof.Append</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Proofs regarding a type list as an append of two others.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">data</span>  <a href="#t:Append">Append</a> ctx1 ctx2 ctx <span class="keyword">where</span><ul class="subs"><li><a href="#v:Append_Base">Append_Base</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx <a href="Data-Type-List-List.html#t:Nil">Nil</a> ctx  </li><li><a href="#v:Append_Step">Append_Step</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 (ctx2 <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)  </li></ul></li><li class="src short"><a href="#v:trans">trans</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ex_ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ex_ctx ctx3 ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 (ctx2 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> ctx3) ctx</li><li class="src short"><a href="#v:length">length</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ctx3 -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></li></ul></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Append" class="def">Append</a> ctx1 ctx2 ctx <span class="keyword">where</span></p><div class="doc"><p>An <code>Append ctx1 ctx2 ctx</code> is a &quot;proof&quot; that <code>ctx = ctx1 <code><a href="Data-Type-List-List.html#t::-43--43-:">:++:</a></code> ctx2</code>.+</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Append_Base" class="def">Append_Base</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx <a href="Data-Type-List-List.html#t:Nil">Nil</a> ctx</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:Append_Step" class="def">Append_Step</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 (ctx2 <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div><div class="top"><p class="src"><a name="v:trans" class="def">trans</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ex_ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ex_ctx ctx3 ctx -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 (ctx2 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> ctx3) ctx</p><div class="doc"><p>Appends two <code><a href="Data-Type-List-Proof-Append.html#t:Append">Append</a></code> proofs.+</p></div></div><div class="top"><p class="src"><a name="v:length" class="def">length</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> ctx1 ctx2 ctx3 -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Int.html#t:Int">Int</a></p><div class="doc"><p>Returns the length of an <code><a href="Data-Type-List-Proof-Append.html#t:Append">Append</a></code> proof.+</p></div></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Type-List-Proof-Member.html view
@@ -0,0 +1,13 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Proof.Member</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Type-List-Proof-Member.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Type.List.Proof.Member</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#1">Abstract data types+</a></li><li><a href="#2">Operators on <code><a href="Data-Type-List-Proof-Member.html#t:Member">Member</a></code> proofs+</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Proofs regarding membership of a type in a type list.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">data</span>  <a href="#t:Member">Member</a> ctx a <span class="keyword">where</span><ul class="subs"><li><a href="#v:Member_Base">Member_Base</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) a  </li><li><a href="#v:Member_Step">Member_Step</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> ctx a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> b) a  </li></ul></li><li class="src short"><a href="#v:toEq">toEq</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) b -&gt; b :=: a</li><li class="src short"><a href="#v:weakenL">weakenL</a> ::  Proxy r1 -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r2 a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (r1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> r2) a</li><li class="src short"><a href="#v:same">same</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r b -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</li><li class="src short"><a href="#v:weakenR">weakenR</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r1 a -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> r1 r2 r -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a</li><li class="src short"><a href="#v:split">split</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> r1 r2 r -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Either.html#t:Either">Either</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r1 a) (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r2 a)</li></ul></div><div id="interface"><h1 id="1">Abstract data types+</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Member" class="def">Member</a> ctx a <span class="keyword">where</span></p><div class="doc"><p>A <code>Member ctx a</code> is a &quot;proof&quot; that the type <code>a</code> is in the type+  list <code>ctx</code>, meaning that <code>ctx</code> equals+</p><pre>  t0 ':&gt;' a ':&gt;' t1 ':&gt;' ... ':&gt;' tn+</pre><p>for some types <code>t0,t1,...,tn</code>.+</p></div><div class="subs constructors"><p class="caption">Constructors</p><table><tr><td class="src"><a name="v:Member_Base" class="def">Member_Base</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) a</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a name="v:Member_Step" class="def">Member_Step</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> ctx a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (ctx <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> b) a</td><td class="doc empty">&nbsp;</td></tr></table></div><div class="subs instances"><p id="control.i:Member" class="caption collapser" onclick="toggleSection('i:Member')">Instances</p><div id="section.i:Member" class="show"><table><tr><td class="src"><a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Text-Show.html#t:Show">Show</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Liftable</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> c a)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><h1 id="2">Operators on <code><a href="Data-Type-List-Proof-Member.html#t:Member">Member</a></code> proofs+</h1><div class="top"><p class="src"><a name="v:toEq" class="def">toEq</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (<a href="Data-Type-List-List.html#t:Nil">Nil</a> <a href="Data-Type-List-List.html#t::-62-">:&gt;</a> a) b -&gt; b :=: a</p></div><div class="top"><p class="src"><a name="v:weakenL" class="def">weakenL</a> ::  Proxy r1 -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r2 a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> (r1 <a href="Data-Type-List-List.html#t::-43--43-:">:++:</a> r2) a</p></div><div class="top"><p class="src"><a name="v:same" class="def">same</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r b -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Maybe.html#t:Maybe">Maybe</a> (a :=: b)</p></div><div class="top"><p class="src"><a name="v:weakenR" class="def">weakenR</a> ::  <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r1 a -&gt; <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> r1 r2 r -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a</p></div><div class="top"><p class="src"><a name="v:split" class="def">split</a> ::  <a href="Data-Type-List-Proof-Append.html#t:Append">Append</a> r1 r2 r -&gt; <a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r a -&gt; <a href="/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/Data-Either.html#t:Either">Either</a> (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r1 a) (<a href="Data-Type-List-Proof-Member.html#t:Member">Member</a> r2 a)</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/Data-Type-List.html view
@@ -0,0 +1,12 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();setSynopsis("mini_Data-Type-List.html");};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>GHC</td></tr><tr><th>Stability</th><td>experimental</td></tr><tr><th>Maintainer</th><td>emw4@rice.edu</td></tr></table><p class="caption">Data.Type.List</p></div><div id="description"><p class="caption">Description</p><div class="doc"><p>A <em>type list</em> contains types as elements. We use GADT proofs terms to+ establish membership and append relations. A <code>Data.Type.List.Map.MapC</code> <code>f</code>+ is a vector indexed by a type list, where <code>f :: * -&gt; *</code> is applied to each+ type element.+</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short">module <a href="Data-Type-List-List.html">Data.Type.List.List</a></li><li class="src short">module <a href="Data-Type-List-Map.html">Data.Type.List.Map</a></li><li class="src short">module <a href="Data-Type-List-Proof-Member.html">Data.Type.List.Proof.Member</a></li><li class="src short">module <a href="Data-Type-List-Proof-Append.html">Data.Type.List.Proof.Append</a></li></ul></div><div id="interface"><h1>Documentation</h1><div class="top"><p class="src">module <a href="Data-Type-List-List.html">Data.Type.List.List</a></p></div><div class="doc"><p>Type-level nil, cons, and +++</p></div><div class="top"><p class="src">module <a href="Data-Type-List-Map.html">Data.Type.List.Map</a></p></div><div class="doc"><p>Vectors parameterized by a <code>* -&gt; *</code> and indexed by a type list+</p></div><div class="top"><p class="src">module <a href="Data-Type-List-Proof-Member.html">Data.Type.List.Proof.Member</a></p></div><div class="doc"><p>Membership functions and proofs+</p></div><div class="top"><p class="src">module <a href="Data-Type-List-Proof-Append.html">Data.Type.List.Proof.Append</a></p></div><div class="doc"><p>Append functions and proofs+</p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/doc-index.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>hobbits-1.0: A library for canonically representing terms with binding (Index)</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="index"><p class="caption">Index</p><table><tr><td class="src">:++:</td><td class="module"><a href="Data-Type-List-List.html#t::-43--43-:">Data.Type.List.List</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">:=:</td><td class="module">Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">:&gt;</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Type/Class)</td><td class="module"><a href="Data-Type-List-List.html#t::-62-">Data.Type.List.List</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="alt">2 (Data Constructor)</td><td class="module"><a href="Data-Type-List-Map.html#v::-62-">Data.Type.List.Map</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">App</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:App">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Append</td><td class="module"><a href="Data-Type-List-Proof-Append.html#t:Append">Data.Type.List.Proof.Append</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">append</td><td class="module"><a href="Data-Type-List-Map.html#v:append">Data.Type.List.Map</a></td></tr><tr><td class="src">Append_Base</td><td class="module"><a href="Data-Type-List-Proof-Append.html#v:Append_Base">Data.Type.List.Proof.Append</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">Append_Step</td><td class="module"><a href="Data-Type-List-Proof-Append.html#v:Append_Step">Data.Type.List.Proof.Append</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">Binding</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#t:Binding">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">cmpName</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:cmpName">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">combineMb</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:combineMb">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">counter</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:counter">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">D</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:D">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decl</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decls</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decls_Base</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Decls_Base">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decls_Cons</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Decls_Cons">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decl_Cons</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Decl_Cons">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Decl_One</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Decl_One">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">DTerm</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">elimEmptyMb</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:elimEmptyMb">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">empty</td><td class="module"><a href="Data-Type-List-Map.html#v:empty">Data.Type.List.Map</a></td></tr><tr><td class="src">emptyMb</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:emptyMb">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">ex1</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex1">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex2</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex2">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex3</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex3">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex4</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex4">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex5</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex5">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex6</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex6">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ex7</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex7">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ExMember</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Type/Class)</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#t:ExMember">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="alt">2 (Data Constructor)</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:ExMember">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">exP</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:exP">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></td></tr><tr><td class="src">ExProxy</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Type/Class)</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#t:ExProxy">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="alt">2 (Data Constructor)</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:ExProxy">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">fresh_name</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:fresh_name">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">L</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Lam</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Lam">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">lam</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:lam">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">lambdaLift</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html#v:lambdaLift">Data.Binding.Hobbits.Examples.LambdaLifting</a></td></tr><tr><td class="src">length</td><td class="module"><a href="Data-Type-List-Proof-Append.html#v:length">Data.Type.List.Proof.Append</a></td></tr><tr><td class="src">Liftable</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Liftable1</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable1">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Liftable2</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#t:Liftable2">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">lookup</td><td class="module"><a href="Data-Type-List-Map.html#v:lookup">Data.Type.List.Map</a></td></tr><tr><td class="src">MapC</td><td class="module"><a href="Data-Type-List-Map.html#t:MapC">Data.Type.List.Map</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">mapC</td><td class="module"><a href="Data-Type-List-Map.html#v:mapC">Data.Type.List.Map</a></td></tr><tr><td class="src">Mb</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Data.Binding.Hobbits.Internal</a>, <a href="Data-Binding-Hobbits-Mb.html#t:Mb">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbCmpName</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbCmpName">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbLambdaLift</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html#v:mbLambdaLift">Data.Binding.Hobbits.Examples.LambdaLifting</a></td></tr><tr><td class="src">mbLift</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbLift">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbLift1</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbLift1">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbLift2</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbLift2">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbList</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbList">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbNameBoundP</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbNameBoundP">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbToplevel</td><td class="module"><a href="Data-Binding-Hobbits-SuperComb.html#v:mbToplevel">Data.Binding.Hobbits.SuperComb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">mbToProxy</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:mbToProxy">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Member</td><td class="module"><a href="Data-Type-List-Proof-Member.html#t:Member">Data.Type.List.Proof.Member</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">memberFromLen</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:memberFromLen">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">members</td><td class="module"><a href="Data-Type-List-Map.html#v:members">Data.Type.List.Map</a></td></tr><tr><td class="src">Member_Base</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:Member_Base">Data.Type.List.Proof.Member</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">Member_Step</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:Member_Step">Data.Type.List.Proof.Member</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">mkAppend</td><td class="module"><a href="Data-Type-List-Map.html#v:mkAppend">Data.Type.List.Map</a></td></tr><tr><td class="src">MkMb</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:MkMb">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">mkMonoAppend</td><td class="module"><a href="Data-Type-List-Map.html#v:mkMonoAppend">Data.Type.List.Map</a></td></tr><tr><td class="src">MkName</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:MkName">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">mkNuElimData</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#v:mkNuElimData">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Name</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#t:Name">Data.Binding.Hobbits.Internal</a>, <a href="Data-Binding-Hobbits-Mb.html#t:Name">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Nil</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Type/Class)</td><td class="module"><a href="Data-Type-List-List.html#t:Nil">Data.Type.List.List</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="alt">2 (Data Constructor)</td><td class="module"><a href="Data-Type-List-Map.html#v:Nil">Data.Type.List.Map</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">nu</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:nu">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">NuElim</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElim">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">NuElimList</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuElimListProof</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#v:nuElimListProof">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">NuElimProof</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuElimProof</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#v:nuElimProof">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuMulti</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:nuMulti">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuQQ</td><td class="module"><a href="Data-Binding-Hobbits-QQ.html#v:nuQQ">Data.Binding.Hobbits.QQ</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuWithElim1</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElim1">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">nuWithElimMulti</td><td class="module"><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElimMulti">Data.Binding.Hobbits.NuElim</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">parsePattern</td><td class="module"><a href="Data-Binding-Hobbits-PatternParser.html#v:parsePattern">Data.Binding.Hobbits.PatternParser</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">parseVar</td><td class="module"><a href="Data-Binding-Hobbits-PatternParser.html#v:parseVar">Data.Binding.Hobbits.PatternParser</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">Proxy</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Data Constructor)</td><td class="module">Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="alt">2 (Type/Class)</td><td class="module">Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">proxy</td><td class="module"><a href="Data-Type-List-Map.html#v:proxy">Data.Type.List.Map</a></td></tr><tr><td class="src">proxyCons</td><td class="module"><a href="Data-Type-List-List.html#v:proxyCons">Data.Type.List.List</a>, Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">proxyFromLen</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:proxyFromLen">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">Refl</td><td class="module">Data.Type.List, Data.Binding.Hobbits</td></tr><tr><td class="src">same</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:same">Data.Type.List.Proof.Member</a></td></tr><tr><td class="src">separateMb</td><td class="module"><a href="Data-Binding-Hobbits-Mb.html#v:separateMb">Data.Binding.Hobbits.Mb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">singleton</td><td class="module"><a href="Data-Type-List-Map.html#v:singleton">Data.Type.List.Map</a></td></tr><tr><td class="src">split</td><td>&nbsp;</td></tr><tr><td class="alt">1 (Function)</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:split">Data.Type.List.Proof.Member</a></td></tr><tr><td class="alt">2 (Function)</td><td class="module"><a href="Data-Type-List-Map.html#v:split">Data.Type.List.Map</a></td></tr><tr><td class="src">SuperComb</td><td class="module"><a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">Data.Binding.Hobbits.SuperComb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">superComb</td><td class="module"><a href="Data-Binding-Hobbits-SuperComb.html#v:superComb">Data.Binding.Hobbits.SuperComb</a>, Data.Binding.Hobbits</td></tr><tr><td class="src">TApp</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:TApp">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">TDVar</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:TDVar">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">Term</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">toEq</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:toEq">Data.Type.List.Proof.Member</a></td></tr><tr><td class="src">trans</td><td class="module"><a href="Data-Type-List-Proof-Append.html#v:trans">Data.Type.List.Proof.Append</a></td></tr><tr><td class="src">TVar</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:TVar">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">unsafeLookupC</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeLookupC">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">unsafeNamesFromInts</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeNamesFromInts">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">unsafeProxyFromLen</td><td class="module"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeProxyFromLen">Data.Binding.Hobbits.Internal</a></td></tr><tr><td class="src">Var</td><td class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:Var">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a>, Data.Binding.Hobbits.Examples.LambdaLifting</td></tr><tr><td class="src">weakenL</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:weakenL">Data.Type.List.Proof.Member</a></td></tr><tr><td class="src">weakenR</td><td class="module"><a href="Data-Type-List-Proof-Member.html#v:weakenR">Data.Type.List.Proof.Member</a></td></tr></table></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/frames.html view
@@ -0,0 +1,28 @@+<!DOCTYPE html +     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">+<html xmlns="http://www.w3.org/1999/xhtml">+<head>+<script src="haddock-util.js" type="text/javascript"></script>+<script type="text/javascript"><!--+/*++  The synopsis frame needs to be updated using javascript, so we hide+  it by default and only show it if javascript is enabled.++  TODO: provide some means to disable it.+*/+function load() {+  var d = document.getElementById("inner-fs");+  d.rows = "50%,50%";+  postReframe();+}+--></script>+<frameset id="outer-fs" cols="25%,75%" onload="load()">+  <frameset id="inner-fs" rows="100%,0%">+    <frame src="index-frames.html" name="modules">+    <frame src="" name="synopsis">+  </frameset>+  <frame src="index.html" name="main">+</frameset>+</html>
+ dist/doc/html/hobbits/haddock-util.js view
@@ -0,0 +1,311 @@+// Haddock JavaScript utilities++var rspace = /\s\s+/g,+	  rtrim = /^\s+|\s+$/g;++function spaced(s) { return (" " + s + " ").replace(rspace, " "); }+function trim(s)   { return s.replace(rtrim, ""); }++function hasClass(elem, value) {+  var className = spaced(elem.className || "");+  return className.indexOf( " " + value + " " ) >= 0;+}++function addClass(elem, value) {+  var className = spaced(elem.className || "");+  if ( className.indexOf( " " + value + " " ) < 0 ) {+    elem.className = trim(className + " " + value);+  }+}++function removeClass(elem, value) {+  var className = spaced(elem.className || "");+  className = className.replace(" " + value + " ", " ");+  elem.className = trim(className);+}++function toggleClass(elem, valueOn, valueOff, bool) {+  if (bool == null) { bool = ! hasClass(elem, valueOn); }+  if (bool) {+    removeClass(elem, valueOff);+    addClass(elem, valueOn);+  }+  else {+    removeClass(elem, valueOn);+    addClass(elem, valueOff);+  }+  return bool;+}+++function makeClassToggle(valueOn, valueOff)+{+  return function(elem, bool) {+    return toggleClass(elem, valueOn, valueOff, bool);+  }+}++toggleShow = makeClassToggle("show", "hide");+toggleCollapser = makeClassToggle("collapser", "expander");++function toggleSection(id)+{+  var b = toggleShow(document.getElementById("section." + id))+  toggleCollapser(document.getElementById("control." + id), b)+  return b;+}+++function setCookie(name, value) {+  document.cookie = name + "=" + escape(value) + ";path=/;";+}++function clearCookie(name) {+  document.cookie = name + "=;path=/;expires=Thu, 01-Jan-1970 00:00:01 GMT;";+}++function getCookie(name) {+  var nameEQ = name + "=";+  var ca = document.cookie.split(';');+  for(var i=0;i < ca.length;i++) {+    var c = ca[i];+    while (c.charAt(0)==' ') c = c.substring(1,c.length);+    if (c.indexOf(nameEQ) == 0) {+      return unescape(c.substring(nameEQ.length,c.length));+    }+  }+  return null;+}++++var max_results = 75; // 50 is not enough to search for map in the base libraries+var shown_range = null;+var last_search = null;++function quick_search()+{+    perform_search(false);+}++function full_search()+{+    perform_search(true);+}+++function perform_search(full)+{+    var text = document.getElementById("searchbox").value.toLowerCase();+    if (text == last_search && !full) return;+    last_search = text;+    +    var table = document.getElementById("indexlist");+    var status = document.getElementById("searchmsg");+    var children = table.firstChild.childNodes;+    +    // first figure out the first node with the prefix+    var first = bisect(-1);+    var last = (first == -1 ? -1 : bisect(1));++    if (first == -1)+    {+        table.className = "";+        status.innerHTML = "No results found, displaying all";+    }+    else if (first == 0 && last == children.length - 1)+    {+        table.className = "";+        status.innerHTML = "";+    }+    else if (last - first >= max_results && !full)+    {+        table.className = "";+        status.innerHTML = "More than " + max_results + ", press Search to display";+    }+    else+    {+        // decide what you need to clear/show+        if (shown_range)+            setclass(shown_range[0], shown_range[1], "indexrow");+        setclass(first, last, "indexshow");+        shown_range = [first, last];+        table.className = "indexsearch";+        status.innerHTML = "";+    }++    +    function setclass(first, last, status)+    {+        for (var i = first; i <= last; i++)+        {+            children[i].className = status;+        }+    }+    +    +    // do a binary search, treating 0 as ...+    // return either -1 (no 0's found) or location of most far match+    function bisect(dir)+    {+        var first = 0, finish = children.length - 1;+        var mid, success = false;++        while (finish - first > 3)+        {+            mid = Math.floor((finish + first) / 2);++            var i = checkitem(mid);+            if (i == 0) i = dir;+            if (i == -1)+                finish = mid;+            else+                first = mid;+        }+        var a = (dir == 1 ? first : finish);+        var b = (dir == 1 ? finish : first);+        for (var i = b; i != a - dir; i -= dir)+        {+            if (checkitem(i) == 0) return i;+        }+        return -1;+    }    +    +    +    // from an index, decide what the result is+    // 0 = match, -1 is lower, 1 is higher+    function checkitem(i)+    {+        var s = getitem(i).toLowerCase().substr(0, text.length);+        if (s == text) return 0;+        else return (s > text ? -1 : 1);+    }+    +    +    // from an index, get its string+    // this abstracts over alternates+    function getitem(i)+    {+        for ( ; i >= 0; i--)+        {+            var s = children[i].firstChild.firstChild.data;+            if (s.indexOf(' ') == -1)+                return s;+        }+        return ""; // should never be reached+    }+}++function setSynopsis(filename) {+    if (parent.window.synopsis) {+        if (parent.window.synopsis.location.replace) {+            // In Firefox this avoids adding the change to the history.+            parent.window.synopsis.location.replace(filename);+        } else {+            parent.window.synopsis.location = filename;+        }+    }+}++function addMenuItem(html) {+  var menu = document.getElementById("page-menu");+  if (menu) {+    var btn = menu.firstChild.cloneNode(false);+    btn.innerHTML = html;+    menu.appendChild(btn);+  }+}++function adjustForFrames() {+  var bodyCls;+  +  if (parent.location.href == window.location.href) {+    // not in frames, so add Frames button+    addMenuItem("<a href='#' onclick='reframe();return true;'>Frames</a>");+    bodyCls = "no-frame";+  }+  else {+    bodyCls = "in-frame";+  }+  addClass(document.body, bodyCls);+}++function reframe() {+  setCookie("haddock-reframe", document.URL);+  window.location = "frames.html";+}++function postReframe() {+  var s = getCookie("haddock-reframe");+  if (s) {+    parent.window.main.location = s;+    clearCookie("haddock-reframe");+  }+}++function styles() {+  var i, a, es = document.getElementsByTagName("link"), rs = [];+  for (i = 0; a = es[i]; i++) {+    if(a.rel.indexOf("style") != -1 && a.title) {+      rs.push(a);+    }+  }+  return rs;+}++function addStyleMenu() {+  var as = styles();+  var i, a, btns = "";+  for(i=0; a = as[i]; i++) {+    btns += "<li><a href='#' onclick=\"setActiveStyleSheet('"+      + a.title + "'); return false;\">"+      + a.title + "</a></li>"+  }+  if (as.length > 1) {+    var h = "<div id='style-menu-holder'>"+      + "<a href='#' onclick='styleMenu(); return false;'>Style &#9662;</a>"+      + "<ul id='style-menu' class='hide'>" + btns + "</ul>"+      + "</div>";+    addMenuItem(h);+  }+}++function setActiveStyleSheet(title) {+  var as = styles();+  var i, a, found;+  for(i=0; a = as[i]; i++) {+    a.disabled = true;+          // need to do this always, some browsers are edge triggered+    if(a.title == title) {+      found = a;+    }+  }+  if (found) {+    found.disabled = false;+    setCookie("haddock-style", title);+  }+  else {+    as[0].disabled = false;+    clearCookie("haddock-style");+  }+  styleMenu(false);+}++function resetStyle() {+  var s = getCookie("haddock-style");+  if (s) setActiveStyleSheet(s);+}+++function styleMenu(show) {+  var m = document.getElementById('style-menu');+  if (m) toggleShow(m, show);+}+++function pageLoad() {+  addStyleMenu();+  adjustForFrames();+  resetStyle();+}+
+ dist/doc/html/hobbits/hobbits.haddock view

binary file changed (absent → 37170 bytes)

+ dist/doc/html/hobbits/hslogo-16.png view

binary file changed (absent → 1684 bytes)

+ dist/doc/html/hobbits/index-frames.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>hobbits-1.0: A library for canonically representing terms with binding</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-list"><p class="caption">Modules</p><ul><li class="module"><a href="Data-Binding-Hobbits.html" target="main">Data.Binding.Hobbits</a></li><li class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html" target="main">Data.Binding.Hobbits.Examples.LambdaLifting</a></li><li class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html" target="main">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></li><li class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html" target="main">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a></li><li class="module"><a href="Data-Binding-Hobbits-Internal.html" target="main">Data.Binding.Hobbits.Internal</a></li><li class="module"><a href="Data-Binding-Hobbits-Mb.html" target="main">Data.Binding.Hobbits.Mb</a></li><li class="module"><a href="Data-Binding-Hobbits-NuElim.html" target="main">Data.Binding.Hobbits.NuElim</a></li><li class="module"><a href="Data-Binding-Hobbits-PatternParser.html" target="main">Data.Binding.Hobbits.PatternParser</a></li><li class="module"><a href="Data-Binding-Hobbits-QQ.html" target="main">Data.Binding.Hobbits.QQ</a></li><li class="module"><a href="Data-Binding-Hobbits-SuperComb.html" target="main">Data.Binding.Hobbits.SuperComb</a></li><li class="module"><a href="Data-Type-List.html" target="main">Data.Type.List</a></li><li class="module"><a href="Data-Type-List-List.html" target="main">Data.Type.List.List</a></li><li class="module"><a href="Data-Type-List-Map.html" target="main">Data.Type.List.Map</a></li><li class="module"><a href="Data-Type-List-Proof-Append.html" target="main">Data.Type.List.Proof.Append</a></li><li class="module"><a href="Data-Type-List-Proof-Member.html" target="main">Data.Type.List.Proof.Member</a></li></ul></div></body></html>
+ dist/doc/html/hobbits/index.html view
@@ -0,0 +1,7 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>hobbits-1.0: A library for canonically representing terms with binding</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">hobbits-1.0: A library for canonically representing terms with binding</p></div><div id="content"><div id="description" class="doc"><h1>hobbits-1.0: A library for canonically representing terms with binding</h1><p>A library for canonically representing terms with binding via a+constructor for introducing fresh names and a restricted API that avoids the+need for alpha-equivalence.+</p></div><div id="module-list"><p class="caption">Modules</p><ul><li><span id="control.n.1" class="module collapser" onclick="toggleSection('n.1')">Data</span><ul id="section.n.1" class="show"><li><span id="control.n.1.1" class="module collapser" onclick="toggleSection('n.1.1')">Binding</span><ul id="section.n.1.1" class="show"><li><span class="module"><span id="control.n.1.1.1" class="collapser" onclick="toggleSection('n.1.1.1')">&nbsp;</span><a href="Data-Binding-Hobbits.html">Data.Binding.Hobbits</a></span><ul id="section.n.1.1.1" class="show"><li><span id="control.n.1.1.1.1" class="module collapser" onclick="toggleSection('n.1.1.1.1')">Examples</span><ul id="section.n.1.1.1.1" class="show"><li><span class="module"><span id="control.n.1.1.1.1.1" class="collapser" onclick="toggleSection('n.1.1.1.1.1')">&nbsp;</span><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html">Data.Binding.Hobbits.Examples.LambdaLifting</a></span><ul id="section.n.1.1.1.1.1" class="show"><li><span class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</a></span></li></ul></li></ul></li><li><span class="module"><a href="Data-Binding-Hobbits-Internal.html">Data.Binding.Hobbits.Internal</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-Mb.html">Data.Binding.Hobbits.Mb</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-NuElim.html">Data.Binding.Hobbits.NuElim</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-PatternParser.html">Data.Binding.Hobbits.PatternParser</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-QQ.html">Data.Binding.Hobbits.QQ</a></span></li><li><span class="module"><a href="Data-Binding-Hobbits-SuperComb.html">Data.Binding.Hobbits.SuperComb</a></span></li></ul></li></ul></li><li><span id="control.n.1.2" class="module collapser" onclick="toggleSection('n.1.2')">Type</span><ul id="section.n.1.2" class="show"><li><span class="module"><span id="control.n.1.2.1" class="collapser" onclick="toggleSection('n.1.2.1')">&nbsp;</span><a href="Data-Type-List.html">Data.Type.List</a></span><ul id="section.n.1.2.1" class="show"><li><span class="module"><a href="Data-Type-List-List.html">Data.Type.List.List</a></span></li><li><span class="module"><a href="Data-Type-List-Map.html">Data.Type.List.Map</a></span></li><li><span id="control.n.1.2.1.3" class="module collapser" onclick="toggleSection('n.1.2.1.3')">Proof</span><ul id="section.n.1.2.1.3" class="show"><li><span class="module"><a href="Data-Type-List-Proof-Append.html">Data.Type.List.Proof.Append</a></span></li><li><span class="module"><a href="Data-Type-List-Proof-Member.html">Data.Type.List.Proof.Member</a></span></li></ul></li></ul></li></ul></li></ul></li></ul></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.8.0</p></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting.Examples</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting.Examples</p></div><div id="interface"><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex1" target="main">ex1</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex2" target="main">ex2</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex3" target="main">ex3</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex4" target="main">ex4</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex5" target="main">ex5</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex6" target="main">ex6</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:ex7" target="main">ex7</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Examples.html#v:exP" target="main">exP</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting.Terms</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting.Terms</p></div><div id="interface"><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:L" target="main">L</a> a</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:D" target="main">D</a> a</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Term" target="main">Term</a> </p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#v:lam" target="main">lam</a></p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:DTerm" target="main">DTerm</a> </p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decl" target="main">Decl</a> </p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Examples-LambdaLifting-Terms.html#t:Decls" target="main">Decls</a> </p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-Examples-LambdaLifting.html view
@@ -0,0 +1,6 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Examples.LambdaLifting</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.Examples.LambdaLifting</p></div><div id="interface"><h1>Term data types, using <code><a href="Data-Binding-Hobbits-Internal.html#t:Mb">Mb</a></code>+</h1><h1>The lambda-lifting function+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html#v:lambdaLift" target="main">lambdaLift</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Examples-LambdaLifting.html#v:mbLambdaLift" target="main">mbLambdaLift</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-Internal.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Internal</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.Internal</p></div><div id="interface"><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Internal.html#t:Name" target="main">Name</a> a</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Internal.html#t:Mb" target="main">Mb</a> ctx b</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Internal.html#t:ExMember" target="main">ExMember</a> </p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:memberFromLen" target="main">memberFromLen</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeLookupC" target="main">unsafeLookupC</a></p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Internal.html#t:ExProxy" target="main">ExProxy</a> </p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:proxyFromLen" target="main">proxyFromLen</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeProxyFromLen" target="main">unsafeProxyFromLen</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:unsafeNamesFromInts" target="main">unsafeNamesFromInts</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:counter" target="main">counter</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Internal.html#v:fresh_name" target="main">fresh_name</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-Mb.html view
@@ -0,0 +1,10 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.Mb</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.Mb</p></div><div id="interface"><h1>Abstract types+</h1><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Mb.html#t:Name" target="main">Name</a> a</p></div><div class="top"><p class="src"><span class="keyword">type</span> <a href="Data-Binding-Hobbits-Mb.html#t:Binding" target="main">Binding</a> a</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-Mb.html#t:Mb" target="main">Mb</a> ctx b</p></div><h1>Multi-binding constructors+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:nu" target="main">nu</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:emptyMb" target="main">emptyMb</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:nuMulti" target="main">nuMulti</a></p></div><h1>Operations on multi-bindings+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:elimEmptyMb" target="main">elimEmptyMb</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:combineMb" target="main">combineMb</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:separateMb" target="main">separateMb</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:mbToProxy" target="main">mbToProxy</a></p></div><h1>Queries on names+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:cmpName" target="main">cmpName</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:mbCmpName" target="main">mbCmpName</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:mbNameBoundP" target="main">mbNameBoundP</a></p></div><h1>type classes for lifting data out of bindings+</h1><div class="top"><p class="src"><span class="keyword">class</span> <a href="Data-Binding-Hobbits-Mb.html#t:Liftable" target="main">Liftable</a> a</p></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Data-Binding-Hobbits-Mb.html#t:Liftable1" target="main">Liftable1</a> f</p></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Data-Binding-Hobbits-Mb.html#t:Liftable2" target="main">Liftable2</a> f</p></div><h1>Optimized, safe multi-binding eliminators+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-Mb.html#v:mbList" target="main">mbList</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-NuElim.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.NuElim</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.NuElim</p></div><div id="interface"><div class="top"><p class="src"><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElimMulti" target="main">nuWithElimMulti</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-NuElim.html#v:nuWithElim1" target="main">nuWithElim1</a></p></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Data-Binding-Hobbits-NuElim.html#t:NuElim" target="main">NuElim</a> a</p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-NuElim.html#v:mkNuElimData" target="main">mkNuElimData</a></p></div><div class="top"><p class="src"><span class="keyword">class</span> <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimList" target="main">NuElimList</a> args</p></div><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-NuElim.html#t:NuElimProof" target="main">NuElimProof</a> a</p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-PatternParser.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.PatternParser</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.PatternParser</p></div><div id="interface"><div class="top"><p class="src"><a href="Data-Binding-Hobbits-PatternParser.html#v:parsePattern" target="main">parsePattern</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-PatternParser.html#v:parseVar" target="main">parseVar</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-QQ.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.QQ</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.QQ</p></div><div id="interface"><div class="top"><p class="src"><a href="Data-Binding-Hobbits-QQ.html#v:nuQQ" target="main">nuQQ</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits-SuperComb.html view
@@ -0,0 +1,6 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits.SuperComb</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits.SuperComb</p></div><div id="interface"><h1>Abstract types+</h1><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb" target="main">SuperComb</a> a</p></div><h1>Operators involving <code><a href="Data-Binding-Hobbits-SuperComb.html#t:SuperComb">SuperComb</a></code>+</h1><div class="top"><p class="src"><a href="Data-Binding-Hobbits-SuperComb.html#v:superComb" target="main">superComb</a></p></div><div class="top"><p class="src"><a href="Data-Binding-Hobbits-SuperComb.html#v:mbToplevel" target="main">mbToplevel</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Binding-Hobbits.html view
@@ -0,0 +1,6 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binding.Hobbits</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Binding.Hobbits</p></div><div id="interface"><h1>Values under multi-bindings+</h1><h1>Ancilliary modules+</h1></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Type-List-List.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.List</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Type.List.List</p></div><div id="interface"><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Type-List-List.html#t:Nil" target="main">Nil</a> </p></div><div class="top"><p class="src"><span class="keyword">data</span> r <a href="Data-Type-List-List.html#t::-62-" target="main">:&gt;</a> a</p></div><div class="top"><p class="src"><span class="keyword">type family</span> r1 <a href="#t::-43--43-:">:++:</a> r2 </p></div><div class="top"><p class="src"><a href="Data-Type-List-List.html#v:proxyCons" target="main">proxyCons</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Type-List-Map.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Map</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Type.List.Map</p></div><div id="interface"><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Type-List-Map.html#t:MapC" target="main">MapC</a> f c</p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:empty" target="main">empty</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:singleton" target="main">singleton</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:lookup" target="main">lookup</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:mapC" target="main">mapC</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:append" target="main">append</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:mkAppend" target="main">mkAppend</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:mkMonoAppend" target="main">mkMonoAppend</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:split" target="main">split</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:proxy" target="main">proxy</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Map.html#v:members" target="main">members</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Type-List-Proof-Append.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Proof.Append</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Type.List.Proof.Append</p></div><div id="interface"><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Type-List-Proof-Append.html#t:Append" target="main">Append</a> ctx1 ctx2 ctx</p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Append.html#v:trans" target="main">trans</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Append.html#v:length" target="main">length</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Type-List-Proof-Member.html view
@@ -0,0 +1,6 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List.Proof.Member</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Type.List.Proof.Member</p></div><div id="interface"><h1>Abstract data types+</h1><div class="top"><p class="src"><span class="keyword">data</span> <a href="Data-Type-List-Proof-Member.html#t:Member" target="main">Member</a> ctx a</p></div><h1>Operators on <code><a href="Data-Type-List-Proof-Member.html#t:Member">Member</a></code> proofs+</h1><div class="top"><p class="src"><a href="Data-Type-List-Proof-Member.html#v:toEq" target="main">toEq</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Member.html#v:weakenL" target="main">weakenL</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Member.html#v:same" target="main">same</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Member.html#v:weakenR" target="main">weakenR</a></p></div><div class="top"><p class="src"><a href="Data-Type-List-Proof-Member.html#v:split" target="main">split</a></p></div></div></body></html>
+ dist/doc/html/hobbits/mini_Data-Type-List.html view
@@ -0,0 +1,4 @@+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Type.List</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[+window.onload = function () {pageLoad();};+//]]>+</script></head><body id="mini"><div id="module-header"><p class="caption">Data.Type.List</p></div><div id="interface"></div></body></html>
+ dist/doc/html/hobbits/minus.gif view

binary file changed (absent → 56 bytes)

+ dist/doc/html/hobbits/ocean.css view
@@ -0,0 +1,542 @@+/* @group Fundamentals */++* { margin: 0; padding: 0 }++/* Is this portable? */+html {+  background-color: white;+  width: 100%;+  height: 100%;+}++body {+  background: white;+  color: black;+  text-align: left;+  min-height: 100%;+  position: relative;+}++p {+  margin: 0.8em 0;+}++ul, ol {+  margin: 0.8em 0 0.8em 2em;+}++dl {+  margin: 0.8em 0;+}++dt {+  font-weight: bold;+}+dd {+  margin-left: 2em;+}++a { text-decoration: none; }+a[href]:link { color: rgb(196,69,29); }+a[href]:visited { color: rgb(171,105,84); }+a[href]:hover { text-decoration:underline; }++/* @end */++/* @group Fonts & Sizes */++/* Basic technique & IE workarounds from YUI 3+   For reasons, see:+      http://yui.yahooapis.com/3.1.1/build/cssfonts/fonts.css+ */+ +body {+	font:13px/1.4 sans-serif;+	*font-size:small; /* for IE */+	*font:x-small; /* for IE in quirks mode */+}++h1 { font-size: 146.5%; /* 19pt */ } +h2 { font-size: 131%;   /* 17pt */ }+h3 { font-size: 116%;   /* 15pt */ }+h4 { font-size: 100%;   /* 13pt */ }+h5 { font-size: 100%;   /* 13pt */ }++select, input, button, textarea {+	font:99% sans-serif;+}++table {+	font-size:inherit;+	font:100%;+}++pre, code, kbd, samp, tt, .src {+	font-family:monospace;+	*font-size:108%;+	line-height: 124%;+}++.links, .link {+  font-size: 85%; /* 11pt */+}++#module-header .caption {+  font-size: 182%; /* 24pt */+}++.info  {+  font-size: 85%; /* 11pt */+}++#table-of-contents, #synopsis  {+  /* font-size: 85%; /* 11pt */+}+++/* @end */++/* @group Common */++.caption, h1, h2, h3, h4, h5, h6 { +  font-weight: bold;+  color: rgb(78,98,114);+  margin: 0.8em 0 0.4em;+}++* + h1, * + h2, * + h3, * + h4, * + h5, * + h6 {+  margin-top: 2em;+}++h1 + h2, h2 + h3, h3 + h4, h4 + h5, h5 + h6 {+  margin-top: inherit;+}++ul.links {+  list-style: none;+  text-align: left;+  float: right;+  display: inline-table;+  margin: 0 0 0 1em;+}++ul.links li {+  display: inline;+  border-left: 1px solid #d5d5d5; +  white-space: nowrap;+  padding: 0;+}++ul.links li a {+  padding: 0.2em 0.5em;+}++.hide { display: none; }+.show { display: inherit; }+.clear { clear: both; }++.collapser {+  background-image: url(minus.gif);+  background-repeat: no-repeat;+}+.expander {+  background-image: url(plus.gif);+  background-repeat: no-repeat;+}+p.caption.collapser,+p.caption.expander {+  background-position: 0 0.4em;+}+.collapser, .expander {+  padding-left: 14px;+  margin-left: -14px;+  cursor: pointer;+}++pre {+  padding: 0.25em;+  margin: 0.8em 0;+  background: rgb(229,237,244);+  overflow: auto;+  border-bottom: 0.25em solid white;+  /* white border adds some space below the box to compensate+     for visual extra space that paragraphs have between baseline+     and the bounding box */+}++.src {+  background: #f0f0f0;+  padding: 0.2em 0.5em;+}++.keyword { font-weight: normal; }+.def { font-weight: bold; }+++/* @end */++/* @group Page Structure */++#content {+  margin: 0 auto;+  padding: 0 2em 6em;+}++#package-header {+  background: rgb(41,56,69);+  border-top: 5px solid rgb(78,98,114);+  color: #ddd;+  padding: 0.2em;+  position: relative;+  text-align: left;+}++#package-header .caption {+  background: url(hslogo-16.png) no-repeat 0em;+  color: white;+  margin: 0 2em;+  font-weight: normal;+  font-style: normal;+  padding-left: 2em;+}++#package-header a:link, #package-header a:visited { color: white; }+#package-header a:hover { background: rgb(78,98,114); }++#module-header .caption {+  color: rgb(78,98,114);+  font-weight: bold;+  border-bottom: 1px solid #ddd;+}++table.info {+  float: right;+  padding: 0.5em 1em;+  border: 1px solid #ddd;+  color: rgb(78,98,114);+  background-color: #fff;+  max-width: 40%;+  border-spacing: 0;+  position: relative;+  top: -0.5em;+  margin: 0 0 0 2em;+}++.info th {+	padding: 0 1em 0 0;+}++div#style-menu-holder {+  position: relative;+  z-index: 2;+  display: inline;+}++#style-menu {+  position: absolute;+  z-index: 1;+  overflow: visible;+  background: #374c5e;+  margin: 0;+  text-align: center;+  right: 0;+  padding: 0;+  top: 1.25em;+}++#style-menu li {+	display: list-item;+	border-style: none;+	margin: 0;+	padding: 0;+	color: #000;+	list-style-type: none;+}++#style-menu li + li {+	border-top: 1px solid #919191;+}++#style-menu a {+  width: 6em;+  padding: 3px;+  display: block;+}++#footer {+  background: #ddd;+  border-top: 1px solid #aaa;+  padding: 0.5em 0;+  color: #666;+  text-align: center;+  position: absolute;+  bottom: 0;+  width: 100%;+  height: 3em;+}++/* @end */++/* @group Front Matter */++#table-of-contents {+  float: right;+  clear: right;+  background: #faf9dc;+  border: 1px solid #d8d7ad;+  padding: 0.5em 1em;+  max-width: 20em;+  margin: 0.5em 0 1em 1em;+}++#table-of-contents .caption {+  text-align: center;+  margin: 0;+}++#table-of-contents ul {+  list-style: none;+  margin: 0;+}++#table-of-contents ul ul {+  margin-left: 2em;+}++#description .caption {+  display: none;+}++#synopsis {+  display: none;+}++.no-frame #synopsis {+  display: block;+  position: fixed;+  right: 0;+  height: 80%;+  top: 10%;+  padding: 0;+}++#synopsis .caption {+  float: left;+  width: 29px;+  color: rgba(255,255,255,0);+  height: 110px;+  margin: 0;+  font-size: 1px;+  padding: 0;+}++#synopsis p.caption.collapser {+  background: url(synopsis.png) no-repeat -64px -8px;+}++#synopsis p.caption.expander {+  background: url(synopsis.png) no-repeat 0px -8px;+}++#synopsis ul {+  height: 100%;+  overflow: auto;+  padding: 0.5em;+  margin: 0;+}++#synopsis ul ul {+  overflow: hidden;+}++#synopsis ul,+#synopsis ul li.src {+  background-color: #faf9dc;+  white-space: nowrap;+  list-style: none;+  margin-left: 0;+}++/* @end */++/* @group Main Content */++#interface div.top { margin: 2em 0; }+#interface h1 + div.top,+#interface h2 + div.top,+#interface h3 + div.top,+#interface h4 + div.top,+#interface h5 + div.top {+ 	margin-top: 1em;+}+#interface p.src .link {+  float: right;+  color: #919191;+  border-left: 1px solid #919191;+  background: #f0f0f0;+  padding: 0 0.5em 0.2em;+  margin: 0 -0.5em 0 0.5em;+}++#interface table { border-spacing: 2px; }+#interface td {+  vertical-align: top;+  padding-left: 0.5em;+}+#interface td.src {+  white-space: nowrap;+}+#interface td.doc p {+  margin: 0;+}+#interface td.doc p + p {+  margin-top: 0.8em;+}++.subs dl {+  margin: 0;+}++.subs dt {+  float: left;+  clear: left;+  display: block;+  margin: 1px 0;+}++.subs dd {+  float: right;+  width: 90%;+  display: block;+  padding-left: 0.5em;+  margin-bottom: 0.5em;+}++.subs dd.empty {+  display: none;+}++.subs dd p {+  margin: 0;+}++.top p.src {+  border-top: 1px solid #ccc;+}++.subs, .doc {+  /* use this selector for one level of indent */+  padding-left: 2em;+}++.arguments {+  margin-top: -0.4em;+}+.arguments .caption {+  display: none;+}++.fields { padding-left: 1em; }++.fields .caption { display: none; }++.fields p { margin: 0 0; }++/* this seems bulky to me+.methods, .constructors {+  background: #f8f8f8;+  border: 1px solid #eee;+}+*/++/* @end */++/* @group Auxillary Pages */++#mini {+  margin: 0 auto;+  padding: 0 1em 1em;+}++#mini > * {+  font-size: 93%; /* 12pt */  +}++#mini #module-list .caption,+#mini #module-header .caption {+  font-size: 125%; /* 15pt */+}++#mini #interface h1,+#mini #interface h2,+#mini #interface h3,+#mini #interface h4 {+  font-size: 109%; /* 13pt */+  margin: 1em 0 0;+}++#mini #interface .top,+#mini #interface .src {+  margin: 0;+}++#mini #module-list ul {+  list-style: none;+  margin: 0;+}++#alphabet ul {+	list-style: none;+	padding: 0;+	margin: 0.5em 0 0;+	text-align: center;+}++#alphabet li {+	display: inline;+	margin: 0 0.25em;+}++#alphabet a {+	font-weight: bold;+}++#index .caption,+#module-list .caption { font-size: 131%; /* 17pt */ }++#index table {+  margin-left: 2em;+}++#index .src {+  font-weight: bold;+}+#index .alt {+  font-size: 77%; /* 10pt */+  font-style: italic;+  padding-left: 2em;+}++#index td + td {+  padding-left: 1em;+}++#module-list ul {+  list-style: none;+  margin: 0 0 0 2em;+}++#module-list li {+  clear: right;+}++#module-list span.collapser,+#module-list span.expander {+  background-position: 0 0.3em;+}++#module-list .package {+  float: right;+}++/* @end */
+ dist/doc/html/hobbits/plus.gif view

binary file changed (absent → 59 bytes)

+ dist/doc/html/hobbits/synopsis.png view

binary file changed (absent → 11327 bytes)

+ dist/package.conf.inplace view
@@ -0,0 +1,2 @@+[InstalledPackageInfo {installedPackageId = InstalledPackageId "hobbits-1.0-inplace", sourcePackageId = PackageIdentifier {pkgName = PackageName "hobbits", pkgVersion = Version {versionBranch = [1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "emw4@rice.edu", author = "Eddy Westbrook, Nicolas Frisby, Paul Brauner", stability = "", homepage = "", pkgUrl = "", description = "A library for canonically representing terms with binding via a\nconstructor for introducing fresh names and a restricted API that avoids the\nneed for alpha-equivalence.", category = "Data Structures", exposed = True, exposedModules = ["Data.Type.List","Data.Type.List.List","Data.Type.List.Map","Data.Type.List.Proof.Append","Data.Type.List.Proof.Member","Data.Binding.Hobbits","Data.Binding.Hobbits.Mb","Data.Binding.Hobbits.SuperComb","Data.Binding.Hobbits.QQ","Data.Binding.Hobbits.Internal","Data.Binding.Hobbits.PatternParser","Data.Binding.Hobbits.NuElim","Data.Binding.Hobbits.Examples.LambdaLifting","Data.Binding.Hobbits.Examples.LambdaLifting.Terms","Data.Binding.Hobbits.Examples.LambdaLifting.Examples"], hiddenModules = [], importDirs = ["/Users/eddy/rice/nominal-patch-tag/hackage/dist/build"], libraryDirs = ["/Users/eddy/rice/nominal-patch-tag/hackage/dist/build"], hsLibraries = ["HShobbits-1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "deepseq-1.1.0.2-05098fd181f7a90abfdf1482f46b9727",InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf",InstalledPackageId "parsec-3.1.1-feb87b0750c4a6becf906976b2dd6e10",InstalledPackageId "syb-0.3.3-f550926985bf2b6a02a79e58143b9352",InstalledPackageId "tagged-0.2.2.1-b99cc5d0afca8afcb6b81fac05c923ac",InstalledPackageId "template-haskell-2.5.0.0-f262af1f92a427f5cf4133bff041044f",InstalledPackageId "type-equality-0.1.0-a69589747ca60eebd5594393768bbf2d"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/rice/nominal-patch-tag/hackage/dist/doc/html/hobbits/hobbits.haddock"], haddockHTMLs = ["/Users/eddy/rice/nominal-patch-tag/hackage/dist/doc/html/hobbits"]}+]
+ dist/setup-config view
@@ -0,0 +1,2 @@+Saved package config for hobbits-1.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/eddy/.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,3,0,0], versionTags = []})),Dependency (PackageName "deepseq") (ThisVersion (Version {versionBranch = [1,1,0,2], versionTags = []})),Dependency (PackageName "mtl") (ThisVersion (Version {versionBranch = [2,0,1,0], versionTags = []})),Dependency (PackageName "parsec") (ThisVersion (Version {versionBranch = [3,1,1], versionTags = []})),Dependency (PackageName "syb") (ThisVersion (Version {versionBranch = [0,3,3], versionTags = []})),Dependency (PackageName "tagged") (ThisVersion (Version {versionBranch = [0,2,2,1], versionTags = []})),Dependency (PackageName "template-haskell") (ThisVersion (Version {versionBranch = [2,5,0,0], versionTags = []})),Dependency (PackageName "type-equality") (ThisVersion (Version {versionBranch = [0,1,0], versionTags = []}))], configConfigurationsFlags = [], configTests = Flag False}, extraConfigArgs = [], installDirTemplates = InstallDirs {prefix = "/Users/eddy/.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,0,1], versionTags = []}), compilerLanguages = [(Haskell98,"-XHaskell98"),(Haskell2010,"-XHaskell2010")], compilerExtensions = [(UnknownExtension "Haskell98","-XHaskell98"),(UnknownExtension "Haskell2010","-XHaskell2010"),(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"),(ForeignFunctionInterface,"-XForeignFunctionInterface"),(UnknownExtension "NoForeignFunctionInterface","-XNoForeignFunctionInterface"),(UnliftedFFITypes,"-XUnliftedFFITypes"),(UnknownExtension "NoUnliftedFFITypes","-XNoUnliftedFFITypes"),(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 "PArr","-XPArr"),(UnknownExtension "NoPArr","-XNoPArr"),(TemplateHaskell,"-XTemplateHaskell"),(UnknownExtension "NoTemplateHaskell","-XNoTemplateHaskell"),(QuasiQuotes,"-XQuasiQuotes"),(UnknownExtension "NoQuasiQuotes","-XNoQuasiQuotes"),(Generics,"-XGenerics"),(UnknownExtension "NoGenerics","-XNoGenerics"),(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"),(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"),(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"),(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"),(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"),(NewQualifiedOperators,"-XNewQualifiedOperators"),(UnknownExtension "NoNewQualifiedOperators","-XNoNewQualifiedOperators")]}, buildDir = "dist/build", scratchDir = "dist/scratch", libraryConfig = Just (ComponentLocalBuildInfo {componentPackageDeps = [(InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,3,0,0], versionTags = []}}),(InstalledPackageId "deepseq-1.1.0.2-05098fd181f7a90abfdf1482f46b9727",PackageIdentifier {pkgName = PackageName "deepseq", pkgVersion = Version {versionBranch = [1,1,0,2], versionTags = []}}),(InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf",PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,0,1,0], versionTags = []}}),(InstalledPackageId "parsec-3.1.1-feb87b0750c4a6becf906976b2dd6e10",PackageIdentifier {pkgName = PackageName "parsec", pkgVersion = Version {versionBranch = [3,1,1], versionTags = []}}),(InstalledPackageId "syb-0.3.3-f550926985bf2b6a02a79e58143b9352",PackageIdentifier {pkgName = PackageName "syb", pkgVersion = Version {versionBranch = [0,3,3], versionTags = []}}),(InstalledPackageId "tagged-0.2.2.1-b99cc5d0afca8afcb6b81fac05c923ac",PackageIdentifier {pkgName = PackageName "tagged", pkgVersion = Version {versionBranch = [0,2,2,1], versionTags = []}}),(InstalledPackageId "template-haskell-2.5.0.0-f262af1f92a427f5cf4133bff041044f",PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,5,0,0], versionTags = []}}),(InstalledPackageId "type-equality-0.1.0-a69589747ca60eebd5594393768bbf2d",PackageIdentifier {pkgName = PackageName "type-equality", pkgVersion = Version {versionBranch = [0,1,0], versionTags = []}})]}), executableConfigs = [], testSuiteConfigs = [], installedPkgs = PackageIndex (fromList [(InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618",InstalledPackageInfo {installedPackageId = InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618", sourcePackageId = PackageIdentifier {pkgName = PackageName "array", pkgVersion = Version {versionBranch = [0,3,0,2], 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","Internals"],ModuleName ["Data","Array","MArray"],ModuleName ["Data","Array","ST"],ModuleName ["Data","Array","Storable"],ModuleName ["Data","Array","Unboxed"],ModuleName ["Data","Array"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/array-0.3.0.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/array-0.3.0.2"], hsLibraries = ["HSarray-0.3.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/array-0.3.0.2/array.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/array-0.3.0.2"]}),(InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageInfo {installedPackageId = InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e", sourcePackageId = PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,3,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","Classes"],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","Float"],ModuleName ["GHC","ForeignPtr"],ModuleName ["GHC","MVar"],ModuleName ["GHC","IO"],ModuleName ["GHC","IO","IOMode"],ModuleName ["GHC","IO","Buffer"],ModuleName ["GHC","IO","Device"],ModuleName ["GHC","IO","BufferedIO"],ModuleName ["GHC","IO","FD"],ModuleName ["GHC","IO","Exception"],ModuleName ["GHC","IO","Encoding"],ModuleName ["GHC","IO","Encoding","Latin1"],ModuleName ["GHC","IO","Encoding","UTF8"],ModuleName ["GHC","IO","Encoding","UTF16"],ModuleName ["GHC","IO","Encoding","UTF32"],ModuleName ["GHC","IO","Encoding","Types"],ModuleName ["GHC","IO","Encoding","Iconv"],ModuleName ["GHC","IO","Encoding","CodePage"],ModuleName ["GHC","IO","Handle"],ModuleName ["GHC","IO","Handle","Types"],ModuleName ["GHC","IO","Handle","Internals"],ModuleName ["GHC","IO","Handle","FD"],ModuleName ["GHC","IO","Handle","Text"],ModuleName ["GHC","IOBase"],ModuleName ["GHC","Handle"],ModuleName ["GHC","IORef"],ModuleName ["GHC","IOArray"],ModuleName ["GHC","Int"],ModuleName ["GHC","List"],ModuleName ["GHC","Num"],ModuleName ["GHC","PArr"],ModuleName ["GHC","Pack"],ModuleName ["GHC","Ptr"],ModuleName ["GHC","Read"],ModuleName ["GHC","Real"],ModuleName ["GHC","ST"],ModuleName ["GHC","STRef"],ModuleName ["GHC","Show"],ModuleName ["GHC","Stable"],ModuleName ["GHC","Storable"],ModuleName ["GHC","TopHandler"],ModuleName ["GHC","Unicode"],ModuleName ["GHC","Weak"],ModuleName ["GHC","Word"],ModuleName ["System","Timeout"],ModuleName ["System","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","Lazy"],ModuleName ["Control","Monad","ST","Strict"],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","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","Marshal"],ModuleName ["Foreign","Marshal","Alloc"],ModuleName ["Foreign","Marshal","Array"],ModuleName ["Foreign","Marshal","Error"],ModuleName ["Foreign","Marshal","Pool"],ModuleName ["Foreign","Marshal","Utils"],ModuleName ["Foreign","Ptr"],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 ["System","Event","Array"],ModuleName ["System","Event","Clock"],ModuleName ["System","Event","Control"],ModuleName ["System","Event","EPoll"],ModuleName ["System","Event","IntMap"],ModuleName ["System","Event","Internal"],ModuleName ["System","Event","KQueue"],ModuleName ["System","Event","Manager"],ModuleName ["System","Event","PSQ"],ModuleName ["System","Event","Poll"],ModuleName ["System","Event","Thread"],ModuleName ["System","Event","Unique"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0"], hsLibraries = ["HSbase-4.3.0.0"], extraLibraries = ["iconv"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0/include"], includes = ["HsBase.h"], depends = [InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054",InstalledPackageId "integer-gmp-0.2.0.2-bfb191b8468e4d812a2bb92622cb246e",InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/base.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0"]}),(InstalledPackageId "builtin_ffi",InstalledPackageInfo {installedPackageId = InstalledPackageId "builtin_ffi", sourcePackageId = PackageIdentifier {pkgName = PackageName "ffi", 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.0.1-i386/usr/lib/ghc-7.0.1"], hsLibraries = ["HSffi"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/include"], includes = [], depends = [], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = [], haddockHTMLs = []}),(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.0.1-i386/usr/lib/ghc-7.0.1"], hsLibraries = ["HSrts"], extraLibraries = ["m","dl"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/include"], includes = ["Stg.h"], depends = [InstalledPackageId "builtin_ffi"], 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_GHCziBool_False_closure","-u","_ghczmprim_GHCziBool_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_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 "bytestring-0.9.1.8-2e812324817b74c7c5038e2cb74d96a9",InstalledPackageInfo {installedPackageId = InstalledPackageId "bytestring-0.9.1.8-2e812324817b74c7c5038e2cb74d96a9", sourcePackageId = PackageIdentifier {pkgName = PackageName "bytestring", pkgVersion = Version {versionBranch = [0,9,1,8], versionTags = []}}, license = BSD3, copyright = "Copyright (c) Don Stewart   2005-2009,\n(c) Duncan Coutts 2006-2009,\n(c) David Roundy  2003-2005.", maintainer = "dons@galois.com, duncan@haskell.org", author = "Don Stewart, Duncan Coutts", stability = "", homepage = "http://www.cse.unsw.edu.au/~dons/fps.html", pkgUrl = "", description = "A time and space-efficient implementation of byte vectors using\npacked Word8 arrays, suitable for high performance use, both in terms\nof large data quantities, or high speed requirements. Byte vectors\nare encoded as strict 'Word8' arrays of bytes, and lazy lists of\nstrict chunks, held in a 'ForeignPtr', and can be passed between C\nand Haskell with little effort.\n\nTest coverage data for this library is available at:\n<http://code.haskell.org/~dons/tests/bytestring/hpc_index.html>", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","ByteString"],ModuleName ["Data","ByteString","Char8"],ModuleName ["Data","ByteString","Unsafe"],ModuleName ["Data","ByteString","Internal"],ModuleName ["Data","ByteString","Lazy"],ModuleName ["Data","ByteString","Lazy","Char8"],ModuleName ["Data","ByteString","Lazy","Internal"],ModuleName ["Data","ByteString","Fusion"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8"], hsLibraries = ["HSbytestring-0.9.1.8"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8/include"], includes = ["fpstring.h"], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/bytestring-0.9.1.8/bytestring.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/bytestring-0.9.1.8"]}),(InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01",InstalledPackageInfo {installedPackageId = InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01", sourcePackageId = PackageIdentifier {pkgName = PackageName "containers", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", 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.0.1-i386/usr/lib/ghc-7.0.1/containers-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/containers-0.4.0.0"], hsLibraries = ["HScontainers-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618",InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.0.0/containers.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.0.0"]}),(InstalledPackageId "data-default-0.2.0.1-343b61b704d63b2bc6e0c12e5e329d8a",InstalledPackageInfo {installedPackageId = InstalledPackageId "data-default-0.2.0.1-343b61b704d63b2bc6e0c12e5e329d8a", sourcePackageId = PackageIdentifier {pkgName = PackageName "data-default", pkgVersion = Version {versionBranch = [0,2,0,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "<l.mai@web.de>", author = "Lukas Mai", stability = "", homepage = "", pkgUrl = "", description = "", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","Default"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/data-default-0.2.0.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/data-default-0.2.0.1/ghc-7.0.1"], hsLibraries = ["HSdata-default-0.2.0.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/data-default-0.2.0.1/html/data-default.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/data-default-0.2.0.1/html"]}),(InstalledPackageId "deepseq-1.1.0.2-05098fd181f7a90abfdf1482f46b9727",InstalledPackageInfo {installedPackageId = InstalledPackageId "deepseq-1.1.0.2-05098fd181f7a90abfdf1482f46b9727", sourcePackageId = PackageIdentifier {pkgName = PackageName "deepseq", pkgVersion = Version {versionBranch = [1,1,0,2], 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.", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","DeepSeq"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/deepseq-1.1.0.2/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/deepseq-1.1.0.2/ghc-7.0.1"], hsLibraries = ["HSdeepseq-1.1.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618",InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/deepseq-1.1.0.2/html/deepseq.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/deepseq-1.1.0.2/html"]}),(InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054",InstalledPackageInfo {installedPackageId = InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054", 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","Bool"],ModuleName ["GHC","Debug"],ModuleName ["GHC","Generics"],ModuleName ["GHC","Magic"],ModuleName ["GHC","Ordering"],ModuleName ["GHC","PrimopWrappers"],ModuleName ["GHC","IntWord32"],ModuleName ["GHC","IntWord64"],ModuleName ["GHC","Tuple"],ModuleName ["GHC","Types"],ModuleName ["GHC","Unit"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/ghc-prim-0.2.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.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.0.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0/ghc-prim.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0"]}),(InstalledPackageId "integer-gmp-0.2.0.2-bfb191b8468e4d812a2bb92622cb246e",InstalledPackageInfo {installedPackageId = InstalledPackageId "integer-gmp-0.2.0.2-bfb191b8468e4d812a2bb92622cb246e", sourcePackageId = PackageIdentifier {pkgName = PackageName "integer-gmp", pkgVersion = Version {versionBranch = [0,2,0,2], 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"]], hiddenModules = [ModuleName ["GHC","Integer","Type"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/integer-gmp-0.2.0.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/integer-gmp-0.2.0.2"], hsLibraries = ["HSinteger-gmp-0.2.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.2.0.2/integer-gmp.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.2.0.2"]}),(InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf",InstalledPackageInfo {installedPackageId = InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf", sourcePackageId = PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,0,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", 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/eddy/.cabal/lib/mtl-2.0.1.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/mtl-2.0.1.0/ghc-7.0.1"], hsLibraries = ["HSmtl-2.0.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "transformers-0.2.2.0-2b42e771f1a8057e2ab6dac97c917eed"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/mtl-2.0.1.0/html/mtl.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/mtl-2.0.1.0/html"]}),(InstalledPackageId "parsec-3.1.1-feb87b0750c4a6becf906976b2dd6e10",InstalledPackageInfo {installedPackageId = InstalledPackageId "parsec-3.1.1-feb87b0750c4a6becf906976b2dd6e10", sourcePackageId = PackageIdentifier {pkgName = PackageName "parsec", pkgVersion = Version {versionBranch = [3,1,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Antoine Latter <aslatter@gmail.com>", author = "Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>", stability = "", homepage = "http://www.cs.uu.nl/~daan/parsec.html", pkgUrl = "", description = "Parsec is designed from scratch as an industrial-strength parser\nlibrary.  It is simple, safe, well documented (on the package\nhomepage), has extensive libraries and good error messages,\nand is also fast.  It is defined as a monad transformer that can be\nstacked on arbitrary monads, and it is also parametric in the\ninput stream type.", category = "Parsing", exposed = True, exposedModules = [ModuleName ["Text","Parsec"],ModuleName ["Text","Parsec","String"],ModuleName ["Text","Parsec","ByteString"],ModuleName ["Text","Parsec","ByteString","Lazy"],ModuleName ["Text","Parsec","Pos"],ModuleName ["Text","Parsec","Error"],ModuleName ["Text","Parsec","Prim"],ModuleName ["Text","Parsec","Char"],ModuleName ["Text","Parsec","Combinator"],ModuleName ["Text","Parsec","Token"],ModuleName ["Text","Parsec","Expr"],ModuleName ["Text","Parsec","Language"],ModuleName ["Text","Parsec","Perm"],ModuleName ["Text","ParserCombinators","Parsec"],ModuleName ["Text","ParserCombinators","Parsec","Char"],ModuleName ["Text","ParserCombinators","Parsec","Combinator"],ModuleName ["Text","ParserCombinators","Parsec","Error"],ModuleName ["Text","ParserCombinators","Parsec","Expr"],ModuleName ["Text","ParserCombinators","Parsec","Language"],ModuleName ["Text","ParserCombinators","Parsec","Perm"],ModuleName ["Text","ParserCombinators","Parsec","Pos"],ModuleName ["Text","ParserCombinators","Parsec","Prim"],ModuleName ["Text","ParserCombinators","Parsec","Token"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/parsec-3.1.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/parsec-3.1.1/ghc-7.0.1"], hsLibraries = ["HSparsec-3.1.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "bytestring-0.9.1.8-2e812324817b74c7c5038e2cb74d96a9",InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/parsec-3.1.1/html/parsec.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/parsec-3.1.1/html"]}),(InstalledPackageId "pretty-1.0.1.2-f6587152d238225a12c4fab838d74356",InstalledPackageInfo {installedPackageId = InstalledPackageId "pretty-1.0.1.2-f6587152d238225a12c4fab838d74356", sourcePackageId = PackageIdentifier {pkgName = PackageName "pretty", pkgVersion = Version {versionBranch = [1,0,1,2], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains John Hughes's pretty-printing library,\nheavily 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.0.1-i386/usr/lib/ghc-7.0.1/pretty-1.0.1.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/pretty-1.0.1.2"], hsLibraries = ["HSpretty-1.0.1.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.0.1.2/pretty.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.0.1.2"]}),(InstalledPackageId "semigroups-0.5.0.2-c8b60de290fb9972e0f7991aad26cb1c",InstalledPackageInfo {installedPackageId = InstalledPackageId "semigroups-0.5.0.2-c8b60de290fb9972e0f7991aad26cb1c", sourcePackageId = PackageIdentifier {pkgName = PackageName "semigroups", pkgVersion = Version {versionBranch = [0,5,0,2], versionTags = []}}, license = BSD3, copyright = "Copyright (C) 2011 Edward A. Kmett", maintainer = "Edward A. Kmett <ekmett@gmail.com>", author = "Edward A. Kmett", stability = "provisional", homepage = "http://github.com/ekmett/semigroups/", pkgUrl = "", description = "Haskell 98 semigroups", category = "Algebra, Data, Data Structures, Math", exposed = True, exposedModules = [ModuleName ["Data","Semigroup"],ModuleName ["Data","List","NonEmpty"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/semigroups-0.5.0.2/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/semigroups-0.5.0.2/ghc-7.0.1"], hsLibraries = ["HSsemigroups-0.5.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/semigroups-0.5.0.2/html/semigroups.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/semigroups-0.5.0.2/html"]}),(InstalledPackageId "syb-0.3.3-f550926985bf2b6a02a79e58143b9352",InstalledPackageInfo {installedPackageId = InstalledPackageId "syb-0.3.3-f550926985bf2b6a02a79e58143b9352", sourcePackageId = PackageIdentifier {pkgName = PackageName "syb", pkgVersion = Version {versionBranch = [0,3,3], versionTags = []}}, license = BSD3, copyright = "", maintainer = "generics@haskell.org", author = "Ralf Lammel, Simon Peyton Jones", stability = "provisional", homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB", pkgUrl = "", description = "This package contains the generics system described in the\n/Scrap Your Boilerplate/ papers (see\n<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).\nIt defines the @Data@ class of types permitting folding and unfolding\nof constructor applications, instances of this class for primitive\ntypes, and a variety of traversals.", category = "Generics", exposed = True, exposedModules = [ModuleName ["Data","Generics"],ModuleName ["Data","Generics","Basics"],ModuleName ["Data","Generics","Instances"],ModuleName ["Data","Generics","Aliases"],ModuleName ["Data","Generics","Schemes"],ModuleName ["Data","Generics","Text"],ModuleName ["Data","Generics","Twins"],ModuleName ["Data","Generics","Builders"],ModuleName ["Generics","SYB"],ModuleName ["Generics","SYB","Basics"],ModuleName ["Generics","SYB","Instances"],ModuleName ["Generics","SYB","Aliases"],ModuleName ["Generics","SYB","Schemes"],ModuleName ["Generics","SYB","Text"],ModuleName ["Generics","SYB","Twins"],ModuleName ["Generics","SYB","Builders"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/syb-0.3.3/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/syb-0.3.3/ghc-7.0.1"], hsLibraries = ["HSsyb-0.3.3"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/syb-0.3.3/html/syb.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/syb-0.3.3/html"]}),(InstalledPackageId "tagged-0.2.2.1-b99cc5d0afca8afcb6b81fac05c923ac",InstalledPackageInfo {installedPackageId = InstalledPackageId "tagged-0.2.2.1-b99cc5d0afca8afcb6b81fac05c923ac", sourcePackageId = PackageIdentifier {pkgName = PackageName "tagged", pkgVersion = Version {versionBranch = [0,2,2,1], versionTags = []}}, license = BSD3, copyright = "2009-2011 Edward A. Kmett", maintainer = "Edward A. Kmett <ekmett@gmail.com>", author = "Edward A. Kmett", stability = "experimental", homepage = "http://github.com/ekmett/tagged", pkgUrl = "", description = "Provides newtype wrappers for phantom types to avoid unsafely passing dummy arguments", category = "Data, Phantom Types", exposed = True, exposedModules = [ModuleName ["Data","Tagged"],ModuleName ["Data","Proxy"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/tagged-0.2.2.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/tagged-0.2.2.1/ghc-7.0.1"], hsLibraries = ["HStagged-0.2.2.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "data-default-0.2.0.1-343b61b704d63b2bc6e0c12e5e329d8a",InstalledPackageId "semigroups-0.5.0.2-c8b60de290fb9972e0f7991aad26cb1c"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/tagged-0.2.2.1/html/tagged.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/tagged-0.2.2.1/html"]}),(InstalledPackageId "template-haskell-2.5.0.0-f262af1f92a427f5cf4133bff041044f",InstalledPackageInfo {installedPackageId = InstalledPackageId "template-haskell-2.5.0.0-f262af1f92a427f5cf4133bff041044f", sourcePackageId = PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,5,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.0.1-i386/usr/lib/ghc-7.0.1/template-haskell-2.5.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/template-haskell-2.5.0.0"], hsLibraries = ["HStemplate-haskell-2.5.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01",InstalledPackageId "pretty-1.0.1.2-f6587152d238225a12c4fab838d74356"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/template-haskell.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0"]}),(InstalledPackageId "transformers-0.2.2.0-2b42e771f1a8057e2ab6dac97c917eed",InstalledPackageInfo {installedPackageId = InstalledPackageId "transformers-0.2.2.0-2b42e771f1a8057e2ab6dac97c917eed", sourcePackageId = PackageIdentifier {pkgName = PackageName "transformers", pkgVersion = Version {versionBranch = [0,2,2,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Ross Paterson <ross@soi.city.ac.uk>", author = "Andy Gill, Ross Paterson", stability = "", homepage = "", pkgUrl = "", description = "Haskell 98 part of a monad transformer library, 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>).\n\nThis part contains the monad transformer class, the concrete monad\ntransformers, operations and liftings.  It can be used on its own\nin Haskell 98 code, or with the monad classes in the @monads-fd@ or\n@monads-tf@ packages, which automatically lift operations introduced\nby monad transformers through other transformers.", category = "Control", exposed = True, exposedModules = [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"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/transformers-0.2.2.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/transformers-0.2.2.0/ghc-7.0.1"], hsLibraries = ["HStransformers-0.2.2.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/transformers-0.2.2.0/html/transformers.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/transformers-0.2.2.0/html"]}),(InstalledPackageId "type-equality-0.1.0-a69589747ca60eebd5594393768bbf2d",InstalledPackageInfo {installedPackageId = InstalledPackageId "type-equality-0.1.0-a69589747ca60eebd5594393768bbf2d", sourcePackageId = PackageIdentifier {pkgName = PackageName "type-equality", pkgVersion = Version {versionBranch = [0,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "hesselink@gmail.com", author = "Erik Hesselink, Martijn van Steenbergen", stability = "experimental", homepage = "http://github.com/hesselink/type-equality/", pkgUrl = "", description = "In the presence of GADTs, sometimes a proof is\nneeded that two types are equal. This package\ncontains an equality type for this purpose, plus its\nproperties (reflexive, symmetric, transitive) and\nsome useful operations (substitution, congruence,\ncoercion/cast). It also contains a type class for\nproducing equality proofs, providing some form of\ndecidable equality on types.", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","Type","Equality"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/type-equality-0.1.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/type-equality-0.1.0/ghc-7.0.1"], hsLibraries = ["HStype-equality-0.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/type-equality-0.1.0/html/type-equality.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/type-equality-0.1.0/html"]})]) (fromList [(PackageName "array",fromList [(Version {versionBranch = [0,3,0,2], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618", sourcePackageId = PackageIdentifier {pkgName = PackageName "array", pkgVersion = Version {versionBranch = [0,3,0,2], 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","Internals"],ModuleName ["Data","Array","MArray"],ModuleName ["Data","Array","ST"],ModuleName ["Data","Array","Storable"],ModuleName ["Data","Array","Unboxed"],ModuleName ["Data","Array"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/array-0.3.0.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/array-0.3.0.2"], hsLibraries = ["HSarray-0.3.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/array-0.3.0.2/array.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/array-0.3.0.2"]}])]),(PackageName "base",fromList [(Version {versionBranch = [4,3,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e", sourcePackageId = PackageIdentifier {pkgName = PackageName "base", pkgVersion = Version {versionBranch = [4,3,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","Classes"],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","Float"],ModuleName ["GHC","ForeignPtr"],ModuleName ["GHC","MVar"],ModuleName ["GHC","IO"],ModuleName ["GHC","IO","IOMode"],ModuleName ["GHC","IO","Buffer"],ModuleName ["GHC","IO","Device"],ModuleName ["GHC","IO","BufferedIO"],ModuleName ["GHC","IO","FD"],ModuleName ["GHC","IO","Exception"],ModuleName ["GHC","IO","Encoding"],ModuleName ["GHC","IO","Encoding","Latin1"],ModuleName ["GHC","IO","Encoding","UTF8"],ModuleName ["GHC","IO","Encoding","UTF16"],ModuleName ["GHC","IO","Encoding","UTF32"],ModuleName ["GHC","IO","Encoding","Types"],ModuleName ["GHC","IO","Encoding","Iconv"],ModuleName ["GHC","IO","Encoding","CodePage"],ModuleName ["GHC","IO","Handle"],ModuleName ["GHC","IO","Handle","Types"],ModuleName ["GHC","IO","Handle","Internals"],ModuleName ["GHC","IO","Handle","FD"],ModuleName ["GHC","IO","Handle","Text"],ModuleName ["GHC","IOBase"],ModuleName ["GHC","Handle"],ModuleName ["GHC","IORef"],ModuleName ["GHC","IOArray"],ModuleName ["GHC","Int"],ModuleName ["GHC","List"],ModuleName ["GHC","Num"],ModuleName ["GHC","PArr"],ModuleName ["GHC","Pack"],ModuleName ["GHC","Ptr"],ModuleName ["GHC","Read"],ModuleName ["GHC","Real"],ModuleName ["GHC","ST"],ModuleName ["GHC","STRef"],ModuleName ["GHC","Show"],ModuleName ["GHC","Stable"],ModuleName ["GHC","Storable"],ModuleName ["GHC","TopHandler"],ModuleName ["GHC","Unicode"],ModuleName ["GHC","Weak"],ModuleName ["GHC","Word"],ModuleName ["System","Timeout"],ModuleName ["System","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","Lazy"],ModuleName ["Control","Monad","ST","Strict"],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","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","Marshal"],ModuleName ["Foreign","Marshal","Alloc"],ModuleName ["Foreign","Marshal","Array"],ModuleName ["Foreign","Marshal","Error"],ModuleName ["Foreign","Marshal","Pool"],ModuleName ["Foreign","Marshal","Utils"],ModuleName ["Foreign","Ptr"],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 ["System","Event","Array"],ModuleName ["System","Event","Clock"],ModuleName ["System","Event","Control"],ModuleName ["System","Event","EPoll"],ModuleName ["System","Event","IntMap"],ModuleName ["System","Event","Internal"],ModuleName ["System","Event","KQueue"],ModuleName ["System","Event","Manager"],ModuleName ["System","Event","PSQ"],ModuleName ["System","Event","Poll"],ModuleName ["System","Event","Thread"],ModuleName ["System","Event","Unique"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0"], hsLibraries = ["HSbase-4.3.0.0"], extraLibraries = ["iconv"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/base-4.3.0.0/include"], includes = ["HsBase.h"], depends = [InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054",InstalledPackageId "integer-gmp-0.2.0.2-bfb191b8468e4d812a2bb92622cb246e",InstalledPackageId "builtin_rts"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0/base.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/base-4.3.0.0"]}])]),(PackageName "bytestring",fromList [(Version {versionBranch = [0,9,1,8], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "bytestring-0.9.1.8-2e812324817b74c7c5038e2cb74d96a9", sourcePackageId = PackageIdentifier {pkgName = PackageName "bytestring", pkgVersion = Version {versionBranch = [0,9,1,8], versionTags = []}}, license = BSD3, copyright = "Copyright (c) Don Stewart   2005-2009,\n(c) Duncan Coutts 2006-2009,\n(c) David Roundy  2003-2005.", maintainer = "dons@galois.com, duncan@haskell.org", author = "Don Stewart, Duncan Coutts", stability = "", homepage = "http://www.cse.unsw.edu.au/~dons/fps.html", pkgUrl = "", description = "A time and space-efficient implementation of byte vectors using\npacked Word8 arrays, suitable for high performance use, both in terms\nof large data quantities, or high speed requirements. Byte vectors\nare encoded as strict 'Word8' arrays of bytes, and lazy lists of\nstrict chunks, held in a 'ForeignPtr', and can be passed between C\nand Haskell with little effort.\n\nTest coverage data for this library is available at:\n<http://code.haskell.org/~dons/tests/bytestring/hpc_index.html>", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","ByteString"],ModuleName ["Data","ByteString","Char8"],ModuleName ["Data","ByteString","Unsafe"],ModuleName ["Data","ByteString","Internal"],ModuleName ["Data","ByteString","Lazy"],ModuleName ["Data","ByteString","Lazy","Char8"],ModuleName ["Data","ByteString","Lazy","Internal"],ModuleName ["Data","ByteString","Fusion"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8"], hsLibraries = ["HSbytestring-0.9.1.8"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/bytestring-0.9.1.8/include"], includes = ["fpstring.h"], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/bytestring-0.9.1.8/bytestring.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/bytestring-0.9.1.8"]}])]),(PackageName "containers",fromList [(Version {versionBranch = [0,4,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01", sourcePackageId = PackageIdentifier {pkgName = PackageName "containers", pkgVersion = Version {versionBranch = [0,4,0,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", 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.0.1-i386/usr/lib/ghc-7.0.1/containers-0.4.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/containers-0.4.0.0"], hsLibraries = ["HScontainers-0.4.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618",InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.0.0/containers.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/containers-0.4.0.0"]}])]),(PackageName "data-default",fromList [(Version {versionBranch = [0,2,0,1], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "data-default-0.2.0.1-343b61b704d63b2bc6e0c12e5e329d8a", sourcePackageId = PackageIdentifier {pkgName = PackageName "data-default", pkgVersion = Version {versionBranch = [0,2,0,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "<l.mai@web.de>", author = "Lukas Mai", stability = "", homepage = "", pkgUrl = "", description = "", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","Default"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/data-default-0.2.0.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/data-default-0.2.0.1/ghc-7.0.1"], hsLibraries = ["HSdata-default-0.2.0.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/data-default-0.2.0.1/html/data-default.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/data-default-0.2.0.1/html"]}])]),(PackageName "deepseq",fromList [(Version {versionBranch = [1,1,0,2], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "deepseq-1.1.0.2-05098fd181f7a90abfdf1482f46b9727", sourcePackageId = PackageIdentifier {pkgName = PackageName "deepseq", pkgVersion = Version {versionBranch = [1,1,0,2], 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.", category = "Control", exposed = True, exposedModules = [ModuleName ["Control","DeepSeq"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/deepseq-1.1.0.2/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/deepseq-1.1.0.2/ghc-7.0.1"], hsLibraries = ["HSdeepseq-1.1.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "array-0.3.0.2-197667a808e421fc275e1d8f73f58618",InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/deepseq-1.1.0.2/html/deepseq.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/deepseq-1.1.0.2/html"]}])]),(PackageName "ffi",fromList [(Version {versionBranch = [1,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "builtin_ffi", sourcePackageId = PackageIdentifier {pkgName = PackageName "ffi", 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.0.1-i386/usr/lib/ghc-7.0.1"], hsLibraries = ["HSffi"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/include"], includes = [], depends = [], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = [], haddockHTMLs = []}])]),(PackageName "ghc-prim",fromList [(Version {versionBranch = [0,2,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054", 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","Bool"],ModuleName ["GHC","Debug"],ModuleName ["GHC","Generics"],ModuleName ["GHC","Magic"],ModuleName ["GHC","Ordering"],ModuleName ["GHC","PrimopWrappers"],ModuleName ["GHC","IntWord32"],ModuleName ["GHC","IntWord64"],ModuleName ["GHC","Tuple"],ModuleName ["GHC","Types"],ModuleName ["GHC","Unit"]], hiddenModules = [], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/ghc-prim-0.2.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.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.0.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0/ghc-prim.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/ghc-prim-0.2.0.0"]}])]),(PackageName "integer-gmp",fromList [(Version {versionBranch = [0,2,0,2], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "integer-gmp-0.2.0.2-bfb191b8468e4d812a2bb92622cb246e", sourcePackageId = PackageIdentifier {pkgName = PackageName "integer-gmp", pkgVersion = Version {versionBranch = [0,2,0,2], 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"]], hiddenModules = [ModuleName ["GHC","Integer","Type"]], importDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/integer-gmp-0.2.0.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/integer-gmp-0.2.0.2"], hsLibraries = ["HSinteger-gmp-0.2.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "ghc-prim-0.2.0.0-0713122c5f9038c6f0355a37e294e054"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.2.0.2/integer-gmp.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/integer-gmp-0.2.0.2"]}])]),(PackageName "mtl",fromList [(Version {versionBranch = [2,0,1,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf", sourcePackageId = PackageIdentifier {pkgName = PackageName "mtl", pkgVersion = Version {versionBranch = [2,0,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", 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/eddy/.cabal/lib/mtl-2.0.1.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/mtl-2.0.1.0/ghc-7.0.1"], hsLibraries = ["HSmtl-2.0.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "transformers-0.2.2.0-2b42e771f1a8057e2ab6dac97c917eed"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/mtl-2.0.1.0/html/mtl.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/mtl-2.0.1.0/html"]}])]),(PackageName "parsec",fromList [(Version {versionBranch = [3,1,1], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "parsec-3.1.1-feb87b0750c4a6becf906976b2dd6e10", sourcePackageId = PackageIdentifier {pkgName = PackageName "parsec", pkgVersion = Version {versionBranch = [3,1,1], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Antoine Latter <aslatter@gmail.com>", author = "Daan Leijen <daan@microsoft.com>, Paolo Martini <paolo@nemail.it>", stability = "", homepage = "http://www.cs.uu.nl/~daan/parsec.html", pkgUrl = "", description = "Parsec is designed from scratch as an industrial-strength parser\nlibrary.  It is simple, safe, well documented (on the package\nhomepage), has extensive libraries and good error messages,\nand is also fast.  It is defined as a monad transformer that can be\nstacked on arbitrary monads, and it is also parametric in the\ninput stream type.", category = "Parsing", exposed = True, exposedModules = [ModuleName ["Text","Parsec"],ModuleName ["Text","Parsec","String"],ModuleName ["Text","Parsec","ByteString"],ModuleName ["Text","Parsec","ByteString","Lazy"],ModuleName ["Text","Parsec","Pos"],ModuleName ["Text","Parsec","Error"],ModuleName ["Text","Parsec","Prim"],ModuleName ["Text","Parsec","Char"],ModuleName ["Text","Parsec","Combinator"],ModuleName ["Text","Parsec","Token"],ModuleName ["Text","Parsec","Expr"],ModuleName ["Text","Parsec","Language"],ModuleName ["Text","Parsec","Perm"],ModuleName ["Text","ParserCombinators","Parsec"],ModuleName ["Text","ParserCombinators","Parsec","Char"],ModuleName ["Text","ParserCombinators","Parsec","Combinator"],ModuleName ["Text","ParserCombinators","Parsec","Error"],ModuleName ["Text","ParserCombinators","Parsec","Expr"],ModuleName ["Text","ParserCombinators","Parsec","Language"],ModuleName ["Text","ParserCombinators","Parsec","Perm"],ModuleName ["Text","ParserCombinators","Parsec","Pos"],ModuleName ["Text","ParserCombinators","Parsec","Prim"],ModuleName ["Text","ParserCombinators","Parsec","Token"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/parsec-3.1.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/parsec-3.1.1/ghc-7.0.1"], hsLibraries = ["HSparsec-3.1.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "bytestring-0.9.1.8-2e812324817b74c7c5038e2cb74d96a9",InstalledPackageId "mtl-2.0.1.0-53db6a067853ff76cc2a84d2eb4d3dbf"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/parsec-3.1.1/html/parsec.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/parsec-3.1.1/html"]}])]),(PackageName "pretty",fromList [(Version {versionBranch = [1,0,1,2], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "pretty-1.0.1.2-f6587152d238225a12c4fab838d74356", sourcePackageId = PackageIdentifier {pkgName = PackageName "pretty", pkgVersion = Version {versionBranch = [1,0,1,2], versionTags = []}}, license = BSD3, copyright = "", maintainer = "libraries@haskell.org", author = "", stability = "", homepage = "", pkgUrl = "", description = "This package contains John Hughes's pretty-printing library,\nheavily 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.0.1-i386/usr/lib/ghc-7.0.1/pretty-1.0.1.2"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/pretty-1.0.1.2"], hsLibraries = ["HSpretty-1.0.1.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.0.1.2/pretty.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/pretty-1.0.1.2"]}])]),(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.0.1-i386/usr/lib/ghc-7.0.1"], hsLibraries = ["HSrts"], extraLibraries = ["m","dl"], extraGHCiLibraries = [], includeDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/include"], includes = ["Stg.h"], depends = [InstalledPackageId "builtin_ffi"], 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_GHCziBool_False_closure","-u","_ghczmprim_GHCziBool_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_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 "semigroups",fromList [(Version {versionBranch = [0,5,0,2], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "semigroups-0.5.0.2-c8b60de290fb9972e0f7991aad26cb1c", sourcePackageId = PackageIdentifier {pkgName = PackageName "semigroups", pkgVersion = Version {versionBranch = [0,5,0,2], versionTags = []}}, license = BSD3, copyright = "Copyright (C) 2011 Edward A. Kmett", maintainer = "Edward A. Kmett <ekmett@gmail.com>", author = "Edward A. Kmett", stability = "provisional", homepage = "http://github.com/ekmett/semigroups/", pkgUrl = "", description = "Haskell 98 semigroups", category = "Algebra, Data, Data Structures, Math", exposed = True, exposedModules = [ModuleName ["Data","Semigroup"],ModuleName ["Data","List","NonEmpty"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/semigroups-0.5.0.2/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/semigroups-0.5.0.2/ghc-7.0.1"], hsLibraries = ["HSsemigroups-0.5.0.2"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/semigroups-0.5.0.2/html/semigroups.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/semigroups-0.5.0.2/html"]}])]),(PackageName "syb",fromList [(Version {versionBranch = [0,3,3], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "syb-0.3.3-f550926985bf2b6a02a79e58143b9352", sourcePackageId = PackageIdentifier {pkgName = PackageName "syb", pkgVersion = Version {versionBranch = [0,3,3], versionTags = []}}, license = BSD3, copyright = "", maintainer = "generics@haskell.org", author = "Ralf Lammel, Simon Peyton Jones", stability = "provisional", homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB", pkgUrl = "", description = "This package contains the generics system described in the\n/Scrap Your Boilerplate/ papers (see\n<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).\nIt defines the @Data@ class of types permitting folding and unfolding\nof constructor applications, instances of this class for primitive\ntypes, and a variety of traversals.", category = "Generics", exposed = True, exposedModules = [ModuleName ["Data","Generics"],ModuleName ["Data","Generics","Basics"],ModuleName ["Data","Generics","Instances"],ModuleName ["Data","Generics","Aliases"],ModuleName ["Data","Generics","Schemes"],ModuleName ["Data","Generics","Text"],ModuleName ["Data","Generics","Twins"],ModuleName ["Data","Generics","Builders"],ModuleName ["Generics","SYB"],ModuleName ["Generics","SYB","Basics"],ModuleName ["Generics","SYB","Instances"],ModuleName ["Generics","SYB","Aliases"],ModuleName ["Generics","SYB","Schemes"],ModuleName ["Generics","SYB","Text"],ModuleName ["Generics","SYB","Twins"],ModuleName ["Generics","SYB","Builders"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/syb-0.3.3/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/syb-0.3.3/ghc-7.0.1"], hsLibraries = ["HSsyb-0.3.3"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/syb-0.3.3/html/syb.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/syb-0.3.3/html"]}])]),(PackageName "tagged",fromList [(Version {versionBranch = [0,2,2,1], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "tagged-0.2.2.1-b99cc5d0afca8afcb6b81fac05c923ac", sourcePackageId = PackageIdentifier {pkgName = PackageName "tagged", pkgVersion = Version {versionBranch = [0,2,2,1], versionTags = []}}, license = BSD3, copyright = "2009-2011 Edward A. Kmett", maintainer = "Edward A. Kmett <ekmett@gmail.com>", author = "Edward A. Kmett", stability = "experimental", homepage = "http://github.com/ekmett/tagged", pkgUrl = "", description = "Provides newtype wrappers for phantom types to avoid unsafely passing dummy arguments", category = "Data, Phantom Types", exposed = True, exposedModules = [ModuleName ["Data","Tagged"],ModuleName ["Data","Proxy"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/tagged-0.2.2.1/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/tagged-0.2.2.1/ghc-7.0.1"], hsLibraries = ["HStagged-0.2.2.1"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "data-default-0.2.0.1-343b61b704d63b2bc6e0c12e5e329d8a",InstalledPackageId "semigroups-0.5.0.2-c8b60de290fb9972e0f7991aad26cb1c"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/tagged-0.2.2.1/html/tagged.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/tagged-0.2.2.1/html"]}])]),(PackageName "template-haskell",fromList [(Version {versionBranch = [2,5,0,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "template-haskell-2.5.0.0-f262af1f92a427f5cf4133bff041044f", sourcePackageId = PackageIdentifier {pkgName = PackageName "template-haskell", pkgVersion = Version {versionBranch = [2,5,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.0.1-i386/usr/lib/ghc-7.0.1/template-haskell-2.5.0.0"], libraryDirs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/lib/ghc-7.0.1/template-haskell-2.5.0.0"], hsLibraries = ["HStemplate-haskell-2.5.0.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e",InstalledPackageId "containers-0.4.0.0-5e5729c8cc8101038443c9bd0115af01",InstalledPackageId "pretty-1.0.1.2-f6587152d238225a12c4fab838d74356"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0/template-haskell.haddock"], haddockHTMLs = ["/Library/Frameworks/GHC.framework/Versions/7.0.1-i386/usr/share/doc/ghc/html/libraries/template-haskell-2.5.0.0"]}])]),(PackageName "transformers",fromList [(Version {versionBranch = [0,2,2,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "transformers-0.2.2.0-2b42e771f1a8057e2ab6dac97c917eed", sourcePackageId = PackageIdentifier {pkgName = PackageName "transformers", pkgVersion = Version {versionBranch = [0,2,2,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "Ross Paterson <ross@soi.city.ac.uk>", author = "Andy Gill, Ross Paterson", stability = "", homepage = "", pkgUrl = "", description = "Haskell 98 part of a monad transformer library, 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>).\n\nThis part contains the monad transformer class, the concrete monad\ntransformers, operations and liftings.  It can be used on its own\nin Haskell 98 code, or with the monad classes in the @monads-fd@ or\n@monads-tf@ packages, which automatically lift operations introduced\nby monad transformers through other transformers.", category = "Control", exposed = True, exposedModules = [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"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/transformers-0.2.2.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/transformers-0.2.2.0/ghc-7.0.1"], hsLibraries = ["HStransformers-0.2.2.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/transformers-0.2.2.0/html/transformers.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/transformers-0.2.2.0/html"]}])]),(PackageName "type-equality",fromList [(Version {versionBranch = [0,1,0], versionTags = []},[InstalledPackageInfo {installedPackageId = InstalledPackageId "type-equality-0.1.0-a69589747ca60eebd5594393768bbf2d", sourcePackageId = PackageIdentifier {pkgName = PackageName "type-equality", pkgVersion = Version {versionBranch = [0,1,0], versionTags = []}}, license = BSD3, copyright = "", maintainer = "hesselink@gmail.com", author = "Erik Hesselink, Martijn van Steenbergen", stability = "experimental", homepage = "http://github.com/hesselink/type-equality/", pkgUrl = "", description = "In the presence of GADTs, sometimes a proof is\nneeded that two types are equal. This package\ncontains an equality type for this purpose, plus its\nproperties (reflexive, symmetric, transitive) and\nsome useful operations (substitution, congruence,\ncoercion/cast). It also contains a type class for\nproducing equality proofs, providing some form of\ndecidable equality on types.", category = "Data", exposed = True, exposedModules = [ModuleName ["Data","Type","Equality"]], hiddenModules = [], importDirs = ["/Users/eddy/.cabal/lib/type-equality-0.1.0/ghc-7.0.1"], libraryDirs = ["/Users/eddy/.cabal/lib/type-equality-0.1.0/ghc-7.0.1"], hsLibraries = ["HStype-equality-0.1.0"], extraLibraries = [], extraGHCiLibraries = [], includeDirs = [], includes = [], depends = [InstalledPackageId "base-4.3.0.0-1ea085b64a078bd9d5eaa9d8d525e35e"], hugsOptions = [], ccOptions = [], ldOptions = [], frameworkDirs = [], frameworks = [], haddockInterfaces = ["/Users/eddy/.cabal/share/doc/type-equality-0.1.0/html/type-equality.haddock"], haddockHTMLs = ["/Users/eddy/.cabal/share/doc/type-equality-0.1.0/html"]}])])]), pkgDescrFile = Just "./hobbits.cabal", localPkgDescr = PackageDescription {package = PackageIdentifier {pkgName = PackageName "hobbits", pkgVersion = Version {versionBranch = [1,0], versionTags = []}}, license = BSD3, licenseFile = "LICENSE", copyright = "", maintainer = "emw4@rice.edu", author = "Eddy Westbrook, Nicolas Frisby, Paul Brauner", stability = "", testedWith = [], homepage = "", pkgUrl = "", bugReports = "", sourceRepos = [], synopsis = "A library for canonically representing terms with binding", description = "A library for canonically representing terms with binding via a\nconstructor for introducing fresh names and a restricted API that avoids the\nneed for alpha-equivalence.", category = "Data Structures", customFieldsPD = [], buildDepends = [Dependency (PackageName "base") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [4], versionTags = []})) (LaterVersion (Version {versionBranch = [4], versionTags = []}))) (EarlierVersion (Version {versionBranch = [5], versionTags = []}))) (ThisVersion (Version {versionBranch = [4,3,0,0], versionTags = []}))),Dependency (PackageName "deepseq") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [1,1,0,2], versionTags = []}))),Dependency (PackageName "mtl") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [2,0,1,0], versionTags = []}))),Dependency (PackageName "parsec") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [3,1,1], versionTags = []}))),Dependency (PackageName "syb") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,3,3], versionTags = []}))),Dependency (PackageName "tagged") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,2,2,1], versionTags = []}))),Dependency (PackageName "template-haskell") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [2,5,0,0], versionTags = []}))),Dependency (PackageName "type-equality") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,1,0], versionTags = []})))], specVersionRaw = Right (UnionVersionRanges (ThisVersion (Version {versionBranch = [1,6,0,1], versionTags = []})) (LaterVersion (Version {versionBranch = [1,6,0,1], versionTags = []}))), buildType = Just Simple, library = Just (Library {exposedModules = [ModuleName ["Data","Type","List"],ModuleName ["Data","Type","List","List"],ModuleName ["Data","Type","List","Map"],ModuleName ["Data","Type","List","Proof","Append"],ModuleName ["Data","Type","List","Proof","Member"],ModuleName ["Data","Binding","Hobbits"],ModuleName ["Data","Binding","Hobbits","Mb"],ModuleName ["Data","Binding","Hobbits","SuperComb"],ModuleName ["Data","Binding","Hobbits","QQ"],ModuleName ["Data","Binding","Hobbits","Internal"],ModuleName ["Data","Binding","Hobbits","PatternParser"],ModuleName ["Data","Binding","Hobbits","NuElim"],ModuleName ["Data","Binding","Hobbits","Examples","LambdaLifting"],ModuleName ["Data","Binding","Hobbits","Examples","LambdaLifting","Terms"],ModuleName ["Data","Binding","Hobbits","Examples","LambdaLifting","Examples"]], libExposed = True, libBuildInfo = BuildInfo {buildable = True, buildTools = [], cppOptions = [], ccOptions = [], ldOptions = [], pkgconfigDepends = [], frameworks = [], cSources = [], hsSourceDirs = ["."], otherModules = [], defaultLanguage = Nothing, otherLanguages = [], defaultExtensions = [], otherExtensions = [], oldExtensions = [], extraLibs = [], extraLibDirs = [], includeDirs = [], includes = [], installIncludes = [], options = [(GHC,["-fwarn-incomplete-patterns","-fwarn-unused-imports"])], ghcProfOptions = [], ghcSharedOptions = [], customFieldsBI = [], targetBuildDepends = [Dependency (PackageName "base") (IntersectVersionRanges (IntersectVersionRanges (UnionVersionRanges (ThisVersion (Version {versionBranch = [4], versionTags = []})) (LaterVersion (Version {versionBranch = [4], versionTags = []}))) (EarlierVersion (Version {versionBranch = [5], versionTags = []}))) (ThisVersion (Version {versionBranch = [4,3,0,0], versionTags = []}))),Dependency (PackageName "deepseq") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [1,1,0,2], versionTags = []}))),Dependency (PackageName "mtl") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [2,0,1,0], versionTags = []}))),Dependency (PackageName "parsec") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [3,1,1], versionTags = []}))),Dependency (PackageName "syb") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,3,3], versionTags = []}))),Dependency (PackageName "tagged") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,2,2,1], versionTags = []}))),Dependency (PackageName "template-haskell") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [2,5,0,0], versionTags = []}))),Dependency (PackageName "type-equality") (IntersectVersionRanges AnyVersion (ThisVersion (Version {versionBranch = [0,1,0], versionTags = []})))]}}), executables = [], testSuites = [], dataFiles = [], dataDir = "", extraSrcFiles = [], extraTmpFiles = []}, withPrograms = [("ar",ConfiguredProgram {programId = "ar", programVersion = Nothing, programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ar"}}),("gcc",ConfiguredProgram {programId = "gcc", programVersion = Just (Version {versionBranch = [4,0,1], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/gcc"}}),("ghc",ConfiguredProgram {programId = "ghc", programVersion = Just (Version {versionBranch = [7,0,1], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ghc"}}),("ghc-pkg",ConfiguredProgram {programId = "ghc-pkg", programVersion = Just (Version {versionBranch = [7,0,1], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/ghc-pkg"}}),("haddock",ConfiguredProgram {programId = "haddock", programVersion = Just (Version {versionBranch = [2,8,0], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/haddock"}}),("hsc2hs",ConfiguredProgram {programId = "hsc2hs", programVersion = Just (Version {versionBranch = [0,67], versionTags = []}), programDefaultArgs = [], programOverrideArgs = [], programLocation = FoundOnSystem {locationPath = "/usr/bin/hsc2hs"}}),("ld",ConfiguredProgram {programId = "ld", programVersion = Nothing, programDefaultArgs = ["-x"], 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 = "/usr/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 = "/usr/bin/tar"}})], withPackageDB = [GlobalPackageDB,UserPackageDB], withVanillaLib = True, withProfLib = False, withSharedLib = False, withProfExe = False, withOptimization = NormalOptimisation, withGHCiLib = True, splitObjs = False, stripExes = True, progPrefix = "", progSuffix = ""}
+ hobbits.cabal view
@@ -0,0 +1,48 @@+Name:                hobbits+Version:             1.0+Synopsis:            A library for canonically representing terms with binding++Description: A library for canonically representing terms with binding via a+             constructor for introducing fresh names and a restricted API that avoids the+             need for alpha-equivalence.++License:             BSD3+License-file:        LICENSE+Author:              Eddy Westbrook, Nicolas Frisby, Paul Brauner+Maintainer:          emw4@rice.edu++Category:            Data Structures++Cabal-version: >= 1.6.0.1+Build-Type:    Simple++Library+  Build-Depends: base >= 4 && < 5+  Build-Depends: template-haskell+  Build-Depends: type-equality, tagged++  Build-Depends: syb+  Build-Depends: deepseq+  Build-Depends: parsec+  Build-Depends: mtl++  GHC-Options: -fwarn-incomplete-patterns -fwarn-unused-imports++  Exposed-Modules: Data.Type.List,+                   Data.Type.List.List,+                   Data.Type.List.Map,+                   Data.Type.List.Proof.Append,+                   Data.Type.List.Proof.Member,++                   Data.Binding.Hobbits,+                   Data.Binding.Hobbits.Mb,+                   Data.Binding.Hobbits.SuperComb,+                   Data.Binding.Hobbits.QQ,++                   Data.Binding.Hobbits.Internal,+                   Data.Binding.Hobbits.PatternParser,+                   Data.Binding.Hobbits.NuElim,++                   Data.Binding.Hobbits.Examples.LambdaLifting,+                   Data.Binding.Hobbits.Examples.LambdaLifting.Terms,+                   Data.Binding.Hobbits.Examples.LambdaLifting.Examples