diff --git a/AUTHORS b/AUTHORS new file mode 100644 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,101 @@ +Andrew J. Bromage aka Pseudonym on #haskell + * the 'bot itself + +Shae M. Erisson aka shapr on #haskell + * FactModule + * FortuneModule + * StateModule + * SystemModule + +Taylor Campbell aka Riastradh on #haskell + * KarmaModule + +Derek Elkins aka Darius on #haskell + * EvalModule + +Sven M. Hallberg aka pesco on #haskell + * TopicModule + +Tom Moertel aka tmoertel on #haskell + * DictModule + +Mats-Ola Persson aka polli on #haskell + * rewrite of the plugin system + +Ganesh Sittampalam aka Heffalump on #haskell + * Various restructuring to improve bot robustness + * Dynamic module loading + +Don Stewart aka dons on #haskell + * New build system, 6.4 port + * dynamic module loading with hs-plugins + * Simplfied module interface + * @babel, @plugs, @version, @code, @spell, @djinn, @unlambda, @hylo, @freshname + * Offline mode + * General hacking + * Cabalised build system + * GHCi build system + +Jesper Louis Andersen aka jlouis on #haskell + * Code/Documentation cleanups + +Thomas Jäger aka TheHunter on #haskell + * PlModule + * General hacking/refactoring. + +Stefan Wehr aka stefanw on #haskell + * DarcsPatchWatch module + +Simon Winwood + * Babel module + * Log module + +Mark Wotton (blackdog) + * Vixen + +Paolo Martini (xerox) + * @hoogle, @botsnack, work on @karma + +Vaclav Haisman + * Tweaks to textual interface + +Joel Koerwer + * google calculator + +Josef Svenningsson + * @elite + +Ketil Malde + * Improved @seen + +Echo Nolan + * grammar + +Samuel Bronson + * Improved search code. @google + +Peter Davis + * @moos ++ + +andres@cs.uu.nl + * line breaks, topics, + +Kenneth Hoste + * @vote + +softpro@gmx.net + * @pretty + +tatd2@kent.ac.uk + * actions / slapping + +rizzix + * Minor fixed and workarounds + * @gsite + +David House + * Instances, Tell. + +Pete Kazmier + * Url page title chaser + * Contextual messages diff --git a/Boot.hs b/Boot.hs new file mode 100644 --- /dev/null +++ b/Boot.hs @@ -0,0 +1,99 @@ +-- +-- Copyright (c) 2004-5 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | Boot loader for lambdabot. +-- This is a small stub that loads the dynamic code, then jumps to it. +-- It solves the problem of unnecessary code linking. As such, we only +-- want to do plugin-related stuff here. +-- +-- We should have no static dependencies on any other part of lambdabot. +-- +-- This is the only module that depends on -package plugins. +-- +-- Compile with: +-- ghc-6.4 -fglasgow-exts -package plugins -main-is Boot.main Boot.hs +-- + +module Boot ( main ) where + +import qualified Shared as S + +import System.Plugins.Load + +import Data.Map (Map) +import qualified Data.Map as M hiding (Map) +import Data.IORef +import System.IO.Unsafe ( unsafePerformIO ) +import System.Exit ( exitFailure ) + +lambdabotMain :: [Char] +lambdabotMain = lambdaPath ++ "Main.o" -- entry point into yi lib + +-- path to plugins +lambdaPath :: String +lambdaPath = "./dist/build/lambdabot/lambdabot-tmp/" + +mainSym :: Symbol +mainSym = "dynmain" -- main entry point + +-- | get a handle to Main.dynamic_main, and jump to it. 6.2.2 will need posix. +-- +-- todo, link statically and dynamically, a module with a Module type we +-- can convert hs-plugins type to. +-- +main :: IO () +main = do + status <- load lambdabotMain [lambdaPath] [] mainSym + dynmain <- case status of + LoadSuccess _ v -> return (v :: MainType) -- should stick module in ioref + LoadFailure e -> do putStrLn "Unable to load Main, exiting" + mapM_ putStrLn e + exitFailure + + dynmain hsplugins + +------------------------------------------------------------------------ +-- Plugin.Loader wrappers passed over to the + +type MainType = S.DynLoad -> IO () + +-- | should insert m into a local IORef, for unload to work +dLoad :: String -> String -> IO (S.Module,a) +dLoad p s = do + mm <- load_ (lambdaPath ++ p) [lambdaPath] s + case mm of + LoadFailure e -> error ("dLoad: "++show e) -- throw this back to DynamicModule + LoadSuccess m v -> do + atomicModifyIORef modules $ \fm -> (M.insert (path m) m fm, ()) + return (S.Module (path m),v) + +-- | Unload a module, given the path to that module +dUnload :: S.Module -> IO () +dUnload (S.Module p) = do + mm <- atomicModifyIORef modules $ \fm -> + case M.lookup p fm of + Nothing -> (fm,Nothing) -- fail silently + Just m -> (M.delete p fm, Just m) + case mm of + Nothing -> return () + Just m -> unload m + +-- +-- | Dynamic loader package we pass over. +-- +hsplugins :: S.DynLoad +hsplugins = S.DynLoad { + S.dynload = dLoad, + S.unload = dUnload + } + +-- +-- map module paths to hs-plugins' Module type. Saves us linking +-- hs-plugins statically and dynamically (code bloat) +-- +modules :: IORef (Map FilePath Module) +modules = unsafePerformIO $ newIORef (M.empty) +{-# NOINLINE modules #-} diff --git a/COMMENTARY b/COMMENTARY new file mode 100644 --- /dev/null +++ b/COMMENTARY @@ -0,0 +1,94 @@ + COMMENTARY ON LAMBDABOT + ------------------------ + +Authors: Don Stewart + +------------------------------------------------------------------------ + +Current module tree. + +(lambdabot : static) + +- Boot -+- hs-plugins + -+- Shared + -+- Map + +(plugins : dynamic) + +-- Main + IRC + Shared + Config + DeepSeq + ErrorUtils + ExceptionError + MonadException + Map + Util + Modules -+ SystemModule + BaseModule + DynamicModule ...... [*Module.o plugins] + +Set + +MiniHTTP ... + +The static binary only contains hs-plugins. + +------------------------------------------------------------------------ + +Plugins live in Plugins/ and inhabit the Plugins.* namespace. + +------------------------------------------------------------------------ + +INOVKING COMMANDS + +Each plugin lists the commands it will provide in its Module instance. +Commands to lambdabot are prefixed with certain magic characters, +described in Plugins/Base.hs. + +ONLINE/OFFLINE MODES + +Lambdabot can run in an offline mode. This is in fact the default mode +now, and invoking lambdabot with --online is the way to connect to an +irc server. Otherwise you just get a prompt, and a chance to interact +with the plugins. + +DEVELOPMENT + +When testing out a new plugin, + 0) test out the plugin in ghci in isolation. don't both linking the + rest of the bot. +then try: + b) don't go online, just use offline mode + +GHCI: + + You can quickly develop lambdabot inside ghci. + See the build details in README. + It works best if you've already compiled the objects once, then you + can quickly reload (interpreted) just the modules you're developing. + +ADDING A NEW PLUGIN + +* Just create the module in Plugins/* +* add a PLUGIN Foo tag +* implements the Module class (see Hello.hs for the bare minimum). +* import Plugin to get most common functions +* Add your plugin's canonical name to Modules.hs + +PLUGIN STATE + +Plugins may have local state. If a plugin provides an Serialiser (via +the moduleSerialize method), this state will be automatically read and +written to disk on module load/unload, respectively. + +A default state may be provided via the `moduleDefState` method. + +LIBRARIES + +Libraries of common functoins are in Lib, they include code for: + * munging strings + * getting random elements + * serialising data + * doing regexes on packed strings +read the Lib/README for more info + +Most of these libs are available when you import Plugin, some require +explicit imports. diff --git a/COPYING b/COPYING new file mode 100644 --- /dev/null +++ b/COPYING @@ -0,0 +1,22 @@ +Copyright (c) 2003 Andrew J. Bromage +Portions Copyright (c) 2003 Shae Erisson, Sven M. Hallberg, Taylor Campbell +Portions Copyright (c) 2003-2006 Members of the AUTHORS file + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject +to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Config.hs b/Config.hs new file mode 100644 --- /dev/null +++ b/Config.hs @@ -0,0 +1,78 @@ +-- +-- | Configuration data for lambdabot +-- +module Config where + +data Protocol = Irc | Xmpp + +-- | The 'Config' type provides configurations for lambdabot. It is used +-- when lambdabot is started to determine the name of lambdabot, what +-- IRC-network lambdabot should join, which channels lambdabot should +-- join upon successful connection, etc. +-- +data Config = Config { + name :: String, -- ^ The nickname of lambdabot + userinfo :: String, -- ^ The userinfo string for lambdabot + host :: String, -- ^ Host to join + port :: Int, -- ^ The port number to use on the host + protocol :: Protocol, -- ^ either irc or xmpp/jabber + verbose :: Bool, -- ^ Should lambdabot be verbose? + textwidth :: Int, -- ^ How many columns should we use + autojoin :: [String], -- ^ List of channels to autojoin + admins :: [String], -- ^ List of nicknames that are admins + proxy :: Maybe ([Char], Integer), -- ^ A proxy given as + -- a pair of host and port. + + -- | The 'path' component is a string to the location where the fortune files + -- are located. On some systems, this is /usr/share/games/fortunes, on others + -- this is /usr/share/games/fortune. Alter this to suit your configuration + fortunePath :: FilePath, + + -- | Path to the top of $fptools, used by @code + fptoolsPath :: FilePath, + + -- which ghci to use (in @type) + ghci :: FilePath, + outputDir :: FilePath, + + -- what prefixes to use for commands + commandPrefixes :: [String], + + -- what prefixes to use for Haskell evalution + evalPrefixes :: [String] +} + +-- +-- Useful defaults for #haskell. +-- +config :: Config +config = Config { + name = "lambdabot", + userinfo = "Lambda_Robots:_100%_Loyal", + host = "chat.freenode.net", + protocol = Irc, + + port = 6667, + verbose = True, + textwidth = 350, + proxy = Just ("www-proxy",3128), + autojoin = ["#haskell","#haskell-blah","#flippi" + ,"#haskell-overflow","#gentoo-haskell" + ,"#haskell_ru", "#darcs" , "#perl6" + ,"#haskell.it","#haskell.se", "#haskell.es","#ScannedInAvian"], + + + admins = [ + "Pseudonym", "shapr", "Heffalump", "Igloo", + "Cale", "dons", "TheHunter", "musasabi" + ], + + fortunePath = "/home/dons/fortune/", + fptoolsPath = "/home/dons/fptools", + + ghci = "ghci", + outputDir = "State/", + + commandPrefixes = ["@","?"], + evalPrefixes = [">"] + } diff --git a/IRC.hs b/IRC.hs new file mode 100644 --- /dev/null +++ b/IRC.hs @@ -0,0 +1,331 @@ +-- +-- | The IRC module processes the IRC protocol and provides a nice API for sending +-- and recieving IRC messages with an IRC server. +-- +module IRC ( IrcMessage + , readerLoop + , writerLoop + , offlineReaderLoop + , offlineWriterLoop + , privmsg + , quit + , timeReply + , errShowMsg -- TODO: remove + , user + , setNick + ) where + +import Message +import Lib.Util (split, breakOnGlue, clean) +import qualified Lib.Util as Util (concatWith) + +import Data.List (isPrefixOf) +import Data.Char (chr,isSpace) + +import Control.Concurrent +import Control.Exception +import Control.Monad.Trans ( MonadIO, liftIO ) +import Control.Monad (when) + +import System.IO (Handle, hGetLine) +import System.Console.Readline (readline, addHistory) + +import qualified Data.ByteString.Char8 as P (pack, hPut, hPutStrLn) + + +-- | An IRC message is a prefix, a command and a list of parameters. +data IrcMessage + = IrcMessage { + msgPrefix :: !String, + msgCommand :: !String, + msgParams :: ![String] + } + deriving (Show) + +instance Message IrcMessage where + nick = IRC.nick + fullName = IRC.fullName + names = IRC.names + channels = IRC.channels + joinChannel = IRC.join + partChannel = IRC.part + getTopic = IRC.getTopic + setTopic = IRC.setTopic + body = IRC.msgParams + command = IRC.msgCommand + +-- | 'mkMessage' creates a new message from a cmd and a list of parameters. +mkMessage :: String -- ^ Command + -> [String] -- ^ Parameters + -> IrcMessage -- ^ Returns: The created message + +mkMessage cmd params = IrcMessage { msgPrefix = "", msgCommand = cmd, msgParams = params } + +-- | 'nick' extracts the nickname involved in a given message. +nick :: IrcMessage -> String +nick = fst . breakOnGlue "!" . msgPrefix + +-- | 'fullName' extracts the full user name involved in a given message. +fullName :: IrcMessage -> String +fullName = snd . breakOnGlue "!" . msgPrefix + +-- | 'channels' extracts the channels a IrcMessage operate on. +channels :: IrcMessage -> [String] +channels msg + = let cstr = head $ msgParams msg + in map (\(x:xs) -> if x == ':' then xs else x:xs) (split "," cstr) + -- solves what seems to be an inconsistency in the parser + +-- | 'privmsg' creates a private message to the person designated. +privmsg :: String -- ^ Who should recieve the message (nick) + -> String -- ^ What is the message? + -> IrcMessage -- ^ Constructed message +privmsg who msg = if action then mkMessage "PRIVMSG" [who, ':':(chr 0x1):("ACTION " ++ clean_msg ++ ((chr 0x1):[]))] + else mkMessage "PRIVMSG" [who, ':' : clean_msg] + where cleaned_msg = case concatMap clean msg of + str@('@':_) -> ' ':str + str -> str + (clean_msg,action) = case cleaned_msg of + ('/':'m':'e':r) -> (dropWhile isSpace r,True) + str -> (str,False) + +-- | 'setTopic' takes a channel and a topic. It then returns the message +-- which sets the channels topic. +setTopic :: String -- ^ Channel + -> String -- ^ Topic + -> IrcMessage +setTopic chan topic = mkMessage "TOPIC" [chan, ':' : topic] + +-- | 'getTopic' Returns the topic for a channel, given as a String +getTopic :: String -> IrcMessage +getTopic chan = mkMessage "TOPIC" [chan] + +-- | 'quit' creates a server QUIT message. The input string given is the +-- quit message, given to other parties when leaving the network. +quit :: String -> IrcMessage +quit msg = mkMessage "QUIT" [':' : msg] + +-- | 'join' creates a join message. String given is the location (channel) +-- to join. +join :: String -> IrcMessage +join loc = mkMessage "JOIN" [loc] + +-- | 'part' parts the channel given. +part :: String -> IrcMessage +part loc = mkMessage "PART" [loc] + +-- | 'names' builds a NAMES message from a list of channels. +names :: [String] -> IrcMessage +names chans = mkMessage "NAMES" [Util.concatWith "," chans] + +-- | Construct a privmsg from the CTCP TIME notice, to feed up to +-- the @localtime-reply plugin, which then passes the output to +-- the appropriate client. +timeReply :: IrcMessage -> IrcMessage +timeReply msg = + IrcMessage { msgPrefix = msgPrefix (msg) + , msgCommand = "PRIVMSG" + , msgParams = [head (msgParams msg) + ,":@localtime-reply " ++ (IRC.nick msg) ++ ":" ++ + (init $ drop 7 (last (msgParams msg))) ] + } + +-- Only needed for Base.hs +errShowMsg :: IrcMessage -> String +errShowMsg msg = "ERROR> <" ++ msgPrefix msg ++ + "> [" ++ msgCommand msg ++ "] " ++ show (msgParams msg) + +user :: String -> String -> String -> IrcMessage +user nick_ server ircname = IRC.mkMessage "USER" [nick_, "localhost", server, ircname] + +setNick :: String -> IrcMessage +setNick nick_ = IRC.mkMessage "NICK" [nick_] +---------------------------------------------------------------------- +-- Encoding and decoding of messages + +-- | 'encodeMessage' takes a message and converts it to a function. +-- giving this function a string will attach the string to the message +-- and output a string containing IRC protocol commands ready for writing +-- on the outgoing stream socket. +encodeMessage :: IrcMessage -> String -> String +encodeMessage msg + = encodePrefix (msgPrefix msg) . encodeCommand (msgCommand msg) + . encodeParams (msgParams msg) + where + encodePrefix [] = id + encodePrefix prefix = showChar ':' . showString prefix . showChar ' ' + + encodeCommand cmd = showString cmd + + encodeParams [] = id + encodeParams (p:ps) = showChar ' ' . showString p . encodeParams ps + +-- | 'decodeMessage' Takes an input line from the IRC protocol stream +-- and decodes it into a message. +decodeMessage :: String -> IrcMessage +decodeMessage line = + let (prefix, rest1) = decodePrefix (,) line + (cmd, rest2) = decodeCmd (,) rest1 + params = decodeParams rest2 + in IrcMessage { msgPrefix = prefix, msgCommand = cmd, msgParams = params } + where + decodePrefix k (':':cs) = decodePrefix' k cs + where decodePrefix' j "" = j "" "" + decodePrefix' j (' ':ds) = j "" ds + decodePrefix' j (c:ds) = decodePrefix' (j . (c:)) ds + + decodePrefix k cs = k "" cs + + decodeCmd k [] = k "" "" + decodeCmd k (' ':cs) = k "" cs + decodeCmd k (c:cs) = decodeCmd (k . (c:)) cs + + decodeParams :: String -> [String] + decodeParams xs = decodeParams' [] [] xs + where + decodeParams' param params [] + | null param = reverse params + | otherwise = reverse (reverse param : params) + decodeParams' param params (' ' : cs) + | null param = decodeParams' [] params cs + | otherwise = decodeParams' [] (reverse param : params) cs + decodeParams' param params rest@(c@':' : cs) + | null param = reverse (rest : params) + | otherwise = decodeParams' (c:param) params cs + decodeParams' param params (c:cs) = decodeParams' (c:param) params cs + +------------------------------------------------------------------------ +-- +-- Lambdabot is asynchronous. We has reader and writer threads, and they +-- don't know about each other. +-- +-- However, in Offline mode, we need to keep them in lock step. this +-- complicates things. +-- +-- Online reader loop, the mvars are unused + +readerLoop :: ThreadId -> Pipe IrcMessage -> Pipe IrcMessage -> Handle -> MVar () -> MVar () -> IO () +readerLoop th chanr chanw h _ _ = handleIO th $ do + io (putStrLn "Forking threads ...") + readerLoop' + where + readerLoop' = do + line <- hGetLine h + let line' = filter (\c -> c /= '\n' && c /= '\r') line + if pING `isPrefixOf` line' + then writeChan chanw (Just $ IRC.mkMessage "PONG" [drop 5 line']) + else writeChan chanr (Just $ IRC.decodeMessage line') + readerLoop' + + pING = "PING " +{-# INLINE readerLoop #-} + +-- +-- online writer loop +-- +-- Implements flood control: RFC 2813, section 5.8 +-- +writerLoop :: ThreadId -> Pipe IrcMessage -> Handle -> MVar () -> MVar () -> IO () +writerLoop th chanw h _ _ = handleIO th $ do + sem1 <- newQSem 0 + sem2 <- newQSem 5 + forkIO $ sequence_ . repeat $ do + waitQSem sem1 + threadDelay 2000000 + signalQSem sem2 + writerLoop' (sem1,sem2) + where + writerLoop' sems@(sem1,sem2) = do + mmsg <- readChan chanw + waitQSem sem2 + case mmsg of + Nothing -> return () + Just msg -> P.hPut h $ P.pack $ IRC.encodeMessage msg "\r" + signalQSem sem1 + writerLoop' sems +{-# INLINE writerLoop #-} + + +-- +-- Offline reader and writer loops. A prompt with line editing +-- Takes a string from stdin, wraps it as an irc message, and _blocks_ +-- waiting for the writer thread (to keep things in sync). +-- +-- We (incorrectly) assume there's at least one write for every read. +-- If a command returns no output (i.e. @more on an empty buffer) then +-- we block in offline mode :( +-- +-- the mvars are used to keep the normally async threads in step. +-- +offlineReaderLoop :: ThreadId -> Pipe IrcMessage -> Pipe IrcMessage -> Handle + -> MVar () -> MVar () -> IO () +offlineReaderLoop th chanr _chanw _h syncR syncW = handleIO th readerLoop' + where + readerLoop' = do + takeMVar syncR -- wait till writer lets us proceed + s <- readline "lambdabot> " -- read stdin + case s of + Nothing -> error "" + Just x -> let s' = dropWhile isSpace x + in if null s' then putMVar syncR () >> readerLoop' else do + addHistory s' + + let mmsg = case s' of + "quit" -> Nothing + '>':xs -> Just $ "@run " ++ xs + _ -> Just $ "@" ++ dropWhile (== ' ') s' + + msg <- case mmsg of + Nothing -> error "" + Just msg' -> return msg' + + let m = IRC.IrcMessage { IRC.msgPrefix = "null!n=user@null" + , IRC.msgCommand = "PRIVMSG" + , IRC.msgParams = ["#haskell",":" ++ msg ] } + writeChan chanr (Just m) + putMVar syncW () -- let writer go + readerLoop' + +-- +-- Offline writer. Print to stdout +-- +offlineWriterLoop :: ThreadId -> Pipe IrcMessage -> Handle -> MVar () -> MVar () -> IO () +offlineWriterLoop th chanw h syncR syncW = handleIO th writerLoop' + where + writerLoop' = do + + takeMVar syncW -- wait for reader to let us go + + let loop = do + mmsg <- readChan chanw + case mmsg of + Nothing -> return () + Just msg -> do + let str = case (tail . IRC.msgParams) msg of + [] -> [] + (x:_) -> tail x + P.hPutStrLn h (P.pack str) + threadDelay 25 -- just for fun. + b <- isEmptyChan chanw + when (not b) loop + loop + + putMVar syncR () -- now allow writer to go + writerLoop' + +-- | convenience: +io :: forall a (m :: * -> *). (MonadIO m) => IO a -> m a +io = liftIO +{-# INLINE io #-} + +-- Thread handler, just catch particular things we want to throw out to +-- the main thread, to force an exit. errorCalls are used by the +-- reader/writer loops to exit. ioErrors are probably sockets closing. +handleIO :: ThreadId -> IO () -> IO () +handleIO th = handleJust + (\e -> case () of { _ + | Just _ <- errorCalls e -> Just e + | Just _ <- ioErrors e -> Just e + | otherwise -> Nothing + }) (\e -> throwTo th (error (show e))) + diff --git a/LBState.hs b/LBState.hs new file mode 100644 --- /dev/null +++ b/LBState.hs @@ -0,0 +1,136 @@ +-- +-- Support for the LB (LambdaBot) monad +-- +module LBState ( + -- ** Functions to access the module's state + readMS, withMS, modifyMS, writeMS, + accessorMS, + + -- ** Utility functions for modules that need state for each target. + GlobalPrivate(global), mkGlobalPrivate, withPS, readPS, withGS, readGS, + writePS, writeGS, + + -- * more LB support + forkLB, liftLB + ) where + +import Lambdabot +import Lib.Util (withMWriter, timeout) + +import Control.Concurrent +import Control.Monad.Reader +import Control.Monad.Trans (liftIO) + +-- withMWriter :: MVar a -> (a -> (a -> IO ()) -> IO b) -> IO b +-- | Update the module's private state. +-- This is the preferred way of changing the state. The state will be locked +-- until the body returns. The function is exception-safe, i.e. even if +-- an error occurs or the thread is killed (e.g. because it deadlocked and +-- therefore exceeded its time limit), the state from the last write operation +-- will be restored. If the writer escapes, calling it will have no observable +-- effect. +-- @withMS@ is not composable, in the sense that a readMS from within the body +-- will cause a dead-lock. However, all other possibilies to access the state +-- that came to my mind had even more serious deficiencies such as being prone +-- to race conditions or semantic obscurities. +withMS :: (s -> (s -> LB ()) -> LB a) -> ModuleT s LB a +withMS f = lbIO $ \conv -> withMWriter ?ref $ \x writer -> + conv $ f x (liftIO . writer) + +-- | Read the module's private state. +readMS :: ModuleT s LB s +readMS = liftIO $ readMVar ?ref + +-- | Produces a with-function. Needs a better name. +accessorMS :: (s -> (t, t -> s)) -> + (t -> (t -> LB ()) -> LB a) -> ModuleT s LB a +accessorMS decompose f = withMS $ \s writer -> + let (t,k) = decompose s in f t (writer . k) + +-- | Modify the module's private state. +modifyMS :: (s -> s) -> ModuleT s LB () +modifyMS f = liftIO $ modifyMVar_ ?ref (return . f) + +-- | Write the module's private state. Try to use withMS instead. +writeMS :: s -> ModuleT s LB () +writeMS (x :: s) = modifyMS . const $ x -- need to help out 6.5 + +-- | This datatype allows modules to conviently maintain both global +-- (i.e. for all clients they're interacting with) and private state. +-- It is implemented on top of readMS\/withMS. +-- +-- This simple implementation is linear in the number of private states used. +data GlobalPrivate g p = GP { + global :: !g, + private :: ![(String,MVar (Maybe p))], + maxSize :: Int +} + +-- | Creates a @GlobalPrivate@ given the value of the global state. No private +-- state for clients will be created. +mkGlobalPrivate :: Int -> g -> GlobalPrivate g p +mkGlobalPrivate ms g = GP { + global = g, + private = [], + maxSize = ms +} + +-- Needs a better interface. The with-functions are hardly useful. +-- | Writes private state. For now, it locks everything. +withPS :: String -- ^ The target + -> (Maybe p -> (Maybe p -> LB ()) -> LB a) + -- ^ @Just x@ writes x in the user's private state, @Nothing@ removes it. + -> ModuleT (GlobalPrivate g p) LB a +withPS who f = do + mvar <- accessPS return id who + lbIO $ \conv -> withMWriter mvar $ \x writer -> conv $ f x (liftIO . writer) + +-- | Reads private state. +readPS :: String -> ModuleT (GlobalPrivate g p) LB (Maybe p) +readPS = accessPS (liftIO . readMVar) (\_ -> return Nothing) + +-- | Reads private state, executes one of the actions success and failure +-- which take an MVar and an action producing a @Nothing@ MVar, respectively. +accessPS :: (MVar (Maybe p) -> LB a) -> (LB (MVar (Maybe p)) -> LB a) -> String + -> ModuleT (GlobalPrivate g p) LB a +accessPS success failure who = withMS $ \state writer -> + case lookup who $ private state of + Just mvar -> do + let newPrivate = (who,mvar): + filter ((/=who) . fst) (private state) + length newPrivate `seq` writer (state { private = newPrivate }) + success mvar + Nothing -> failure $ do + mvar <- liftIO $ newMVar Nothing + let newPrivate = take (maxSize state) $ (who,mvar): private state + length newPrivate `seq` writer (state { private = newPrivate }) + return mvar + +-- | Writes global state. Locks everything +withGS :: (g -> (g -> LB ()) -> LB ()) -> ModuleT (GlobalPrivate g p) LB () +withGS f = withMS $ \state writer -> + f (global state) $ \g -> writer $ state { global = g } + +-- | Reads global state. +readGS :: ModuleT (GlobalPrivate g p) LB g +readGS = global `fmap` readMS + + +-- The old interface, as we don't wanna be too fancy right now. +writePS :: String -> Maybe p -> ModuleT (GlobalPrivate g p) LB () +writePS who x = withPS who (\_ writer -> writer x) + +writeGS :: g -> ModuleT (GlobalPrivate g p) LB () +writeGS g = withGS (\_ writer -> writer g) + +-- | run an IO action in another thread, with a timeout, lifted into LB +forkLB :: LB a -> LB () +forkLB f = (`liftLB` f) $ \g -> do + forkIO $ do + timeout (15 * 1000 * 1000) g + return () + return () + +-- | lift an io transformer into LB +liftLB :: (IO a -> IO b) -> LB a -> LB b +liftLB f = LB . mapReaderT f . runLB -- lbIO (\conv -> f (conv lb)) diff --git a/Lambdabot.hs b/Lambdabot.hs new file mode 100644 --- /dev/null +++ b/Lambdabot.hs @@ -0,0 +1,684 @@ +{-# OPTIONS -cpp #-} +-- +-- | The guts of lambdabot. +-- +-- The LB/Lambdabot monad +-- Generic server connection,disconnection +-- The module typeclass, type and operations on modules +-- +module Lambdabot ( + MODULE(..), Module(..), + ModuleT, ModState, ModuleLB, Mode(..), + + IRCRState(..), IRCRWState(..), IRCError(..), + module Msg, + + LB(..), lbIO, + + withModule, withAllModules, getDictKeys, + + send, send_, + ircPrivmsg, ircPrivmsg', -- not generally used + ircQuit, ircReconnect, + ircGetChannels, + ircSignalConnect, Callback, ircInstallOutputFilter, OutputFilter, + ircInstallModule, ircUnloadModule, + serverSignOn, + ircRead, + + ircLoad, ircUnload, + + checkPrivs, mkCN, handleIrc, catchIrc, runIrc, + ) where + +import qualified Message as Msg +import qualified Shared as S +import qualified Config (config, name, admins, host, port, Protocol(..)) +import qualified IRC (IrcMessage, quit, privmsg, readerLoop + ,writerLoop, offlineReaderLoop, offlineWriterLoop, user, setNick) + +import Lib.Signals +import Lib.Util +import Lib.Serial + +import Prelude hiding (mod, catch) + +import Network (withSocketsDo, connectTo, PortID(PortNumber)) + +import System.Exit +import System.IO +import System.Posix.Process +import System.Posix.Signals + +import Data.Char +import Data.IORef (newIORef, IORef, readIORef, writeIORef) +import Data.List (isSuffixOf, inits, tails) +import Data.Maybe (isJust) +import Data.Map (Map) +import qualified Data.Map as M hiding (Map) +import qualified Data.ByteString.Char8 as P + +import Control.Concurrent +import Control.Exception +import Control.Monad.Error (MonadError (..)) +import Control.Monad.Reader +import Control.Monad.State +import Control.Monad.Trans ( liftIO ) + +#if __GLASGOW_HASKELL__ >= 605 +import GHC.Err +#endif + +------------------------------------------------------------------------ +-- +-- Lambdabot state +-- + +-- | Global read-only state. +data IRCRState + = IRCRState { + ircServer :: String, + ircReadChan :: Pipe, + ircReadThread :: ThreadId, + ircWriteChan :: Pipe, + ircWriteThread :: ThreadId + } + +type Pipe = Chan (Maybe IRC.IrcMessage) + +type Callback = IRC.IrcMessage -> LB () + +type OutputFilter = String -> [String] -> LB [String] + +-- | Global read\/write state. +data IRCRWState = IRCRWState { + ircPrivilegedUsers :: Map String Bool, + + ircChannels :: Map ChanName String, + -- ^ maps channel names to topics + + ircModules :: Map String ModuleRef, + ircCallbacks :: Map String [(String,Callback)], + ircOutputFilters :: [(String,OutputFilter)], + -- ^ Output filters, invoked from right to left + + ircCommands :: Map String ModuleRef, + ircPrivCommands :: [String], + ircStayConnected :: Bool, + ircDynLoad :: S.DynLoad + } + +newtype ChanName = ChanName { getCN :: String } -- should be abstract, always lowercase + deriving (Eq, Ord) + +instance Show ChanName where show (ChanName x) = show x + +-- | only use the "smart constructor": +mkCN :: String -> ChanName +mkCN = ChanName . map toLower + +-- --------------------------------------------------------------------- +-- +-- The LB (LambdaBot) monad +-- + +-- | The IRC Monad. The reader transformer holds information about the +-- connection to the IRC server. +-- +-- instances Monad, Functor, MonadIO, MonadState, MonadError + + +newtype LB a = LB { runLB :: ReaderT (IORef (Maybe IRCRState),IORef IRCRWState) IO a } + deriving (Monad,Functor,MonadIO) + +-- Actually, this isn't a reader anymore +instance MonadReader IRCRState LB where + ask = LB $ fmap (maybe (error "No connection") id) $ + io . readIORef =<< asks fst + local = error "You are not supposed to call local" + +instance MonadState IRCRWState LB where + get = LB $ do + ref <- asks snd + lift $ readIORef ref + put x = LB $ do + ref <- asks snd + lift $ writeIORef ref x + +-- And now a MonadError instance to map IRCErrors to MonadError in LB, +-- so throwError and catchError "just work" +instance MonadError IRCError LB where + throwError (IRCRaised e) = io $ throwIO e + throwError (SignalCaught e) = io $ evaluate (throwDyn $ SignalException e) + m `catchError` h = lbIO $ \conv -> (conv m + `catchDyn` \(SignalException e) -> conv $ h $ SignalCaught e) + `catch` \e -> conv $ h $ IRCRaised e + +-- A type for handling both Haskell exceptions and external signals +data IRCError = IRCRaised Exception | SignalCaught Signal deriving Show + +-- lbIO return :: LB (LB a -> IO a) +-- CPS to work around predicativiy of haskell's type system. +lbIO :: ((forall a. LB a -> IO a) -> IO b) -> LB b +lbIO k = LB . ReaderT $ \r -> k (\(LB m) -> m `runReaderT` r) + +-- | Take a state, and a lambdabot monad action, run the action, +-- preserving the state before and after you run the action. +localLB :: Maybe IRCRState -> LB a -> LB a +localLB new (LB m) = LB $ do + ref <- asks fst + old <- io $ readIORef ref + io $ writeIORef ref new + res <- m + io $ writeIORef ref old + return res + +-- | run a computation in the LB monad +evalLB :: LB a -> IRCRWState -> IO a +evalLB (LB lb) rws = do + ref <- newIORef rws + ref' <- newIORef Nothing + lb `runReaderT` (ref',ref) + +-- May wish to add more things to the things caught, or restructure things +-- a bit. Can't just catch everything - in particular EOFs from the socket +-- loops get thrown to this thread and we musn't just ignore them. +handleIrc :: MonadError IRCError m => (IRCError -> m ()) -> m () -> m () +handleIrc handler m = catchError m handler + +-- Like handleIrc, but with arguments reversed +catchIrc :: MonadError IRCError m => m () -> (IRCError -> m ()) -> m () +catchIrc = flip handleIrc + +------------------------------------------------------------------------ +-- +-- Lambdabot modes, networked , or command line +-- +data Mode = Online | Offline deriving Eq + +-- +-- | The Lambdabot entry point. +-- Initialise plugins, connect, and run the bot in the LB monad +-- +-- Also, handle any fatal exceptions (such as non-recoverable signals), +-- (i.e. print a message and exit). Non-fatal exceptions should be dealt +-- with in the mainLoop or further down. +-- +runIrc :: Mode -> LB a -> LB () -> S.DynLoad -> IO () +runIrc mode initialise loop ld = withSocketsDo $ do + r <- try $ evalLB (do withDebug "Initialising plugins" initialise + withIrcSignalCatch (mainLoop mode loop)) + (initState (Config.admins Config.config) ld) + + -- clean up and go home + case r of + Left _ -> exitWith (ExitFailure 1) -- won't happen. exitImmediately cleans it all up + Right _ -> exitWith ExitSuccess + +-- +-- | Default rw state +-- +initState :: [String] -> S.DynLoad -> IRCRWState +initState as ld = IRCRWState { + ircPrivilegedUsers = M.fromList $ zip as (repeat True), + ircChannels = M.empty, + ircModules = M.empty, + ircCallbacks = M.empty, + ircOutputFilters = [ + ([],cleanOutput), + ([],lineify), + ([],cleanOutput), + ([],reduceIndent), + ([],checkRecip) ], + ircCommands = M.empty, + ircPrivCommands = [], + ircStayConnected = True, + ircDynLoad = ld + } + +-- +-- Actually connect to the irc server +-- +mainLoop :: Mode -> LB a -> LB () +mainLoop mode loop = do + + -- in offline mode we connect to stdin/stdout. in online mode our + -- handles are network pipes + (hin,hout,rloop,wloop) <- case mode of + Online -> do + let portnum = PortNumber $ fromIntegral (Config.port Config.config) + s <- io $ connectTo (Config.host Config.config) portnum + return (s,s,IRC.readerLoop,IRC.writerLoop) + Offline -> return (stdin, stdout, IRC.offlineReaderLoop, IRC.offlineWriterLoop) + + io $ hSetBuffering hout NoBuffering + io $ hSetBuffering hin NoBuffering + threadmain <- io myThreadId + chanr <- io newChan + chanw <- io newChan + syncR <- io $ newMVar () -- used in offline to make threads synchronous + syncW <- io newEmptyMVar + threadr <- io $ forkIO $ rloop threadmain chanr chanw hin syncR syncW + threadw <- io $ forkIO $ wloop threadmain chanw hout syncR syncW + + let chans = IRCRState { + ircServer = Config.host Config.config, + ircReadChan = chanr, + ircReadThread = threadr, + ircWriteChan = chanw, + ircWriteThread = threadw + } + + catchIrc + (localLB (Just chans) loop >> return ()) + (\e -> do -- catch anything, print informative message, and clean up + io $ hPutStrLn stderr $ + (case e of + IRCRaised ex -> "Exception: " ++ show ex + SignalCaught s -> "Signal: " ++ ircSignalMessage s) + withDebug "Running exit handlers" runExitHandlers + withDebug "Writing persistent state" flushModuleState + io $ do hPutStrLn stderr "Exiting ... " + exitImmediately (ExitFailure 1)) + -- throwError e) + +-- | run 'exit' handler on modules +runExitHandlers:: LB () +runExitHandlers = withAllModules moduleExit >> return () + +-- | flush state of modules +flushModuleState :: LB () +flushModuleState = withAllModules (\m -> writeGlobalState m ?name) >> return () + +------------------------------------------------------------------------ + +-- | The Module type class. +-- Minimal complete definition: @moduleHelp@, @moduleCmds@, and +-- either @process@ or @process_@ +class Module m s | m -> s where + -- | If the module wants its state to be saved, this function should + -- return a Serial. + -- + -- The default implementation returns Nothing. + moduleSerialize :: m -> Maybe (Serial s) + + -- | If the module maintains state, this method specifies the default state + -- (for example in case the state can't be read from a state). + -- + -- The default implementation returns an error and assumes the state is + -- never accessed. + moduleDefState :: m -> LB s + + -- | Is the module sticky? Sticky modules (as well as static ones) can't be + -- unloaded. By default, modules are not sticky. + moduleSticky :: m -> Bool + + -- | The commands the module listenes to. + moduleCmds :: m -> [String] + + -- | This method should return a help string for every command it defines. + moduleHelp :: m -> String -> String + + -- | The privileged commands the module listenes to. + modulePrivs :: m -> [String] + + -- | Initialize the module. The default implementation does nothing. + moduleInit :: m -> ModuleT s LB () + + -- | Finalize the module. The default implementation does nothing. + moduleExit :: m -> ModuleT s LB () + + -- | Process a command a user sent, the resulting string is draw in + -- some fashion. If the `process' function doesn't exist, we catch + -- an exception when we try to call it, and instead call `process_' + -- which is guaranteed to at least have a default instance. + -- This magic (well, for Haskell) occurs in Base.hs + -- + process :: Msg.Message a + => m -- ^ phantom (required) + -> a -- ^ the message (uneeded by most?) + -> String -- ^ target + -> String -- ^ command + -> String -- ^ the arguments to the command + -> ModuleLB s -- ^ maybe output + + -- | Process contextual input. A plugin that implements 'contextual' + -- is able to respond to text not part of a normal command. + contextual :: Msg.Message a + => m -- ^ phantom (required) + -> a -- ^ the message + -> String -- ^ target + -> String -- ^ the text + -> ModuleLB s -- ^ maybe output + + -- | Like process, but uncommonly used args are ignored + -- Lambdabot will attempt to run process first, and then fall back + -- to process_, which in turn has a default instance. + -- + process_ :: m -- ^ phantom + -> String -> String -- ^ command, args + -> ModuleLB s -- ^ maybe output + +------------------------------------------------------------------------ + + contextual _ _ _ _ = return [] + process_ _ _ _ = return [] + + moduleHelp m _ = concat (map ('@':) (moduleCmds m)) + modulePrivs _ = [] + moduleCmds _ = [] + moduleExit _ = return () + moduleInit _ = return () + moduleSticky _ = False + moduleSerialize _ = Nothing + moduleDefState _ = return $ error "state not initalized" + +-- work around weird issue in 6.5, where the missing default fails +#if __GLASGOW_HASKELL__ >= 605 + process _ _ _ _ _ = GHC.Err.noMethodBindingError "Lambdabot.process"# +#endif + +-- | An existential type holding a module, used to represent modules on +-- the value level, for manipluation at runtime by the dynamic linker. +-- +data MODULE = forall m s. (Module m s) => MODULE m + +data ModuleRef = forall m s. (Module m s) => ModuleRef m (MVar s) String + +-- +-- | This \"transformer\" encodes the additional information a module might +-- need to access its name or its state. +-- +-- TODO: remove implicit parameters. It won't be valid Haskell' +-- +type ModuleT s m a = (?ref :: MVar s, ?name :: String) => m a + +-- Name !!! +type ModState s a = (?ref :: MVar s, ?name :: String) => a + +-- | A nicer synonym for some ModuleT stuffs +type ModuleLB m = ModuleT m LB [String] + +-- --------------------------------------------------------------------- +-- +-- Handling global state +-- + +-- | Peristence: write the global state out +writeGlobalState :: Module m s => m -> String -> ModuleT s LB () +writeGlobalState mod name = case moduleSerialize mod of + Nothing -> return () + Just ser -> do + state <- io $ readMVar ?ref -- readMS + case serialize ser state of + Nothing -> return () -- do not write any state + Just out -> io $ P.writeFile (toFilename name) out + +-- | Read it in +readGlobalState :: Module m s => m -> String -> IO (Maybe s) +readGlobalState mod name = case moduleSerialize mod of + Nothing -> return Nothing + Just ser -> do + state <- Just `fmap` P.readFile (toFilename name) `catch` \_ -> return Nothing + let state' = deserialize ser =<< state -- Monad Maybe + return $ maybe Nothing (Just $) state' + +-- | helper +toFilename :: String -> String +toFilename = ("State/"++) + +------------------------------------------------------------------------ +-- +-- | Register a module in the irc state +-- +ircInstallModule :: MODULE -> String -> LB () +ircInstallModule (MODULE mod) modname = do + savedState <- io $ readGlobalState mod modname + state <- maybe (moduleDefState mod) return savedState + ref <- io $ newMVar state + + let modref = ModuleRef mod ref modname + + -- TODO + let ?ref = ref; ?name = modname -- yikes + moduleInit mod + let cmds = moduleCmds mod + privs = modulePrivs mod + + s <- get + let modmap = ircModules s + cmdmap = ircCommands s + put $ s { + ircModules = M.insert modname modref modmap, + ircCommands = addList [ (cmd,modref) | cmd <- cmds++privs ] cmdmap, + ircPrivCommands = ircPrivCommands s ++ privs + } + io $ hPutStr stderr "." >> hFlush stderr + +-- +-- | Unregister a module's entry in the irc state +-- +ircUnloadModule :: String -> LB () +ircUnloadModule modname = withModule ircModules modname (error "module not loaded") (\m -> do + when (moduleSticky m) $ error "module is sticky" + moduleExit m + writeGlobalState m modname + s <- get + let modmap = ircModules s + cmdmap = ircCommands s + cbs = ircCallbacks s + ofs = ircOutputFilters s + put $ s { ircCommands = M.filter (\(ModuleRef _ _ name) -> name /= modname) cmdmap } + { ircModules = M.delete modname modmap } + { ircCallbacks = filter ((/=modname) . fst) `fmap` cbs } + { ircOutputFilters = filter ((/=modname) . fst) ofs } + ) + +-- +-- | Binding to dynamic loader functions (stored as a bundle in state) +-- passed from Boot. DynamicModule goes through here to get at them. +-- +ircLoad :: FilePath -> S.Symbol -> LB (S.Module, a) +ircLoad mod sym = do + s <- get + let fn = S.dynload (ircDynLoad s) + io $ (fn mod sym) + +-- +-- | Dynamically unload a module +-- +ircUnload :: FilePath -> LB () +ircUnload mod = do + s <- get + io $ (S.unload (ircDynLoad s)) (S.Module mod) + +------------------------------------------------------------------------ + +ircSignalConnect :: String -> Callback -> ModuleT s LB () +ircSignalConnect str f = do + s <- get + let cbs = ircCallbacks s + case M.lookup str cbs of -- TODO + Nothing -> put (s { ircCallbacks = M.insert str [(?name,f)] cbs}) + Just fs -> put (s { ircCallbacks = M.insert str ((?name,f):fs) cbs}) + +ircInstallOutputFilter :: OutputFilter -> ModuleT s LB () +ircInstallOutputFilter f = + modify $ \s -> + s { ircOutputFilters = (?name, f): ircOutputFilters s } + +-- | Checks if the given user has admin permissions and excecute the action +-- only in this case. +checkPrivs :: IRC.IrcMessage -> LB Bool +checkPrivs msg = gets (isJust . M.lookup (Msg.nick msg) . ircPrivilegedUsers) + +------------------------------------------------------------------------ +-- Some generic server operations + +serverSignOn :: Config.Protocol -> String -> String -> LB () +serverSignOn Config.Irc nick userinfo = ircSignOn nick userinfo +serverSignOn Config.Xmpp nick _ = jabberSignOn nick + +jabberSignOn :: String -> LB () +jabberSignOn _ = undefined + +ircSignOn :: String -> String -> LB () +ircSignOn nick ircname = do + server <- asks ircServer + + -- password support. TODO: Move this to IRC? + -- If plugin initialising was delayed till after we connected, we'd + -- be able to write a Passwd plugin. + send . Just $ IRC.user nick server ircname + send . Just $ IRC.setNick nick + mpasswd <- liftIO (handleJust ioErrors (const (return "")) $ + readFile "State/passwd") + case readM mpasswd of + Nothing -> return () + Just passwd -> ircPrivmsg "nickserv" $ Just $ "identify " ++ passwd + +ircGetChannels :: LB [String] +ircGetChannels = (map getCN . M.keys) `fmap` gets ircChannels + +-- Send a quit message, settle and wait for the server to drop our +-- handle. At which point the main thread gets a closed handle eof +-- exceptoin, we clean up and go home +ircQuit :: String -> LB () +ircQuit msg = do + modify $ \state -> state { ircStayConnected = False } + send . Just $ IRC.quit msg + liftIO $ threadDelay 1000 + io $ hPutStrLn stderr "Quit" + +ircReconnect :: String -> LB () +ircReconnect msg = do + send . Just $ IRC.quit msg + liftIO $ threadDelay 1000 + +ircRead :: LB (Maybe IRC.IrcMessage) +ircRead = do + chanr <- asks ircReadChan + liftIO (readChan chanr) + +-- +-- convenient wrapper +-- +send_ :: IRC.IrcMessage -> LB () +send_ = send . Just + +send :: Maybe IRC.IrcMessage -> LB () +send line = do + chanw <- asks ircWriteChan + io (writeChan chanw line) + +-- | Send a message to a channel\/user. If the message is too long, the rest +-- of it is saved in the (global) more-state. +ircPrivmsg :: String -- ^ The channel\/user. + -> Maybe String -- ^ The message. + -> LB () + +ircPrivmsg who Nothing = ircPrivmsg' who Nothing +ircPrivmsg who (Just msg) = do + filters <- gets ircOutputFilters + sendlines <- foldr (\f -> (=<<) (f who)) ((return . lines) msg) $ map snd filters + mapM_ (\s -> ircPrivmsg' who (Just $ take textwidth s)) (take 10 sendlines) + +-- A raw send version +ircPrivmsg' :: String -> Maybe String -> LB () +ircPrivmsg' who (Just "") = ircPrivmsg' who (Just " ") +ircPrivmsg' who (Just msg) = send . Just $ IRC.privmsg who msg +ircPrivmsg' _ Nothing = send Nothing + +------------------------------------------------------------------------ +-- Module handling + +-- | Interpret an expression in the context of a module. +-- Arguments are which map to use (@ircModules@ and @ircCommands@ are +-- the only sensible arguments here), the name of the module\/command, +-- action for the case that the lookup fails, action if the lookup +-- succeeds. +-- +withModule :: (Ord k) + => (IRCRWState -> Map k ModuleRef) + -> k + -> LB a + -> (forall mod s. Module mod s => mod -> ModuleT s LB a) + -> LB a + +withModule dict modname def f = do + maybemod <- gets (M.lookup modname . dict) + case maybemod of + -- TODO stick this ref stuff in a monad instead. more portable in + -- the long run. + Just (ModuleRef m ref name) -> let ?ref = ref; ?name = name in f m + _ -> def + +-- | Interpret a function in the context of all modules +withAllModules :: (forall mod s. Module mod s => mod -> ModuleT s LB a) -> LB [a] +withAllModules f = do + mods <- gets $ M.elems . ircModules :: LB [ModuleRef] + (`mapM` mods) $ \(ModuleRef m ref name) -> do + let ?ref = ref; ?name = name + f m + +getDictKeys :: (MonadState s m) => (s -> Map k a) -> m [k] +getDictKeys dict = gets (M.keys . dict) + +------------------------------------------------------------------------ + +-- | Print a debug message, and perform an action +withDebug :: String -> LB a -> LB () +withDebug s a = do + io $ hPutStr stderr (s ++ " ...") >> hFlush stderr + a + io $ hPutStrLn stderr " done." >> hFlush stderr + +---------------------------------------------------------------------- +-- Output filters + +textwidth :: Int +textwidth = 200 -- IRC maximum msg length, minus a bit for safety. + +-- | For now, this just checks for duplicate empty lines. +cleanOutput :: OutputFilter +cleanOutput _ msg = return $ remDups True msg' + where + remDups True ([]:xs) = remDups True xs + remDups False ([]:xs) = []:remDups True xs + remDups _ (x: xs) = x: remDups False xs + remDups _ [] = [] + msg' = map dropSpaceEnd msg + +-- | wrap long lines. +lineify :: OutputFilter +lineify = const (return . mlines . unlines) + +-- | break into lines +mlines :: String -> [String] +mlines = (mbreak =<<) . lines + where + mbreak :: String -> [String] + mbreak xs + | null bs = [as] + | otherwise = (as++cs) : filter (not . null) (mbreak ds) + where + (as,bs) = splitAt (w-n) xs + breaks = filter (not . isAlphaNum . last . fst) $ drop 1 $ + take n $ zip (inits bs) (tails bs) + (cs,ds) = last $ (take n bs, drop n bs): breaks + w = textwidth + n = 10 + +-- | Don't send any output to alleged bots. +checkRecip :: OutputFilter +checkRecip who msg + | who == Config.name Config.config = return [] + | "bot" `isSuffixOf` lowerCaseString who = return [] + | otherwise = return msg + +-- | Divide the lines' indent by two +reduceIndent :: OutputFilter +reduceIndent _ msg = return $ map redLine msg + where + redLine (' ':' ':xs) = ' ':redLine xs + redLine xs = xs diff --git a/Lib/AltTime.hs b/Lib/AltTime.hs new file mode 100644 --- /dev/null +++ b/Lib/AltTime.hs @@ -0,0 +1,104 @@ +-- +-- | Time compatibility layer +-- +module Lib.AltTime ( + ClockTime, + getClockTime, diffClockTimes, addToClockTime, timeDiffPretty, + module System.Time + ) where + +import Lib.Util (listToStr) +import Lib.Binary + +import Control.Arrow (first) + +import System.Time (TimeDiff(..), noTimeDiff) +import qualified System.Time as T + (ClockTime(..), getClockTime, diffClockTimes, addToClockTime) + +-- | Wrapping ClockTime (which doesn't provide a Read instance!) seems +-- easier than talking care of the serialization of UserStatus +-- ourselves. +-- +newtype ClockTime = ClockTime (T.ClockTime) + +instance Eq ClockTime where + ClockTime (T.TOD x1 y1) == ClockTime (T.TOD x2 y2) = + x1 == x2 && y1 == y2 + +instance Show ClockTime where + showsPrec p (ClockTime (T.TOD x y)) = showsPrec p (x,y) + +instance Read ClockTime where + readsPrec p = map (first $ ClockTime . uncurry T.TOD) . readsPrec p + +-- | Retrieve the current clocktime +getClockTime :: IO ClockTime +getClockTime = ClockTime `fmap` T.getClockTime + +-- | Difference of two clock times +diffClockTimes :: ClockTime -> ClockTime -> TimeDiff +diffClockTimes (ClockTime ct1) (ClockTime ct2) = +-- This is an ugly hack (we don't care about picoseconds...) to avoid the +-- "Time.toClockTime: picoseconds out of range" +-- error. I think time arithmetic is broken in GHC. + (T.diffClockTimes ct1 ct2) { tdPicosec = 0 } + +-- | @'addToClockTime' d t@ adds a time difference @d@ and a -- clock +-- time @t@ to yield a new clock time. +addToClockTime :: TimeDiff -> ClockTime -> ClockTime +addToClockTime td (ClockTime ct) = ClockTime $ T.addToClockTime td ct + +-- | Pretty-print a TimeDiff. Both positive and negative Timediffs produce +-- the same output. +timeDiffPretty :: TimeDiff -> String +timeDiffPretty td = listToStr "and" $ filter (not . null) [ + prettyP years "year", + prettyP (months `mod` 12) "month", + prettyP (days `mod` 28) "day", + prettyP (hours `mod` 24) "hour", + prettyP (mins `mod` 60) "minute", + prettyP (secs `mod` 60) "second"] + where + prettyP i str | i == 0 = "" + | i == 1 = "1 " ++ str + | otherwise = show i ++ " " ++ str ++ "s" + + secs = abs $ tdSec td -- This is a hack, but there wasn't an sane output + -- for negative TimeDiffs anyway. + mins = secs `div` 60 + hours = mins `div` 60 + days = hours `div` 24 + months = days `div` 28 + years = months `div` 12 + +------------------------------------------------------------------------ + +instance Binary ClockTime where + put_ bh (ClockTime (T.TOD i j)) = do + put_ bh i + put_ bh j + get bh = do + i <- get bh + j <- get bh + return (ClockTime (T.TOD i j)) + +instance Binary TimeDiff where + put_ bh (TimeDiff ye mo da ho mi se ps) = do + put_ bh ye + put_ bh mo + put_ bh da + put_ bh ho + put_ bh mi + put_ bh se + put_ bh ps + get bh = do + ye <- get bh + mo <- get bh + da <- get bh + ho <- get bh + mi <- get bh + se <- get bh + ps <- get bh + return (TimeDiff ye mo da ho mi se ps) + diff --git a/Lib/Binary.hs b/Lib/Binary.hs new file mode 100644 --- /dev/null +++ b/Lib/Binary.hs @@ -0,0 +1,287 @@ +{-# OPTIONS -cpp -fasm #-} +-- +-- (c) The University of Glasgow 2002 +-- (c) Don Stewart 2005-6 +-- +-- Binary I/O library, with special tweaks for GHC +-- and +-- Unboxed mutable Ints +-- +-- Based on the nhc98 Binary library, which is copyright +-- (c) Malcolm Wallace and Colin Runciman, University of York, 1998. +-- Under the terms of the license for that software, we must tell you +-- where you can obtain the original version of the Binary library, namely +-- http://www.cs.york.ac.uk/fp/nhc98/ + +module Lib.Binary ( Binary(..), openBinIO_, putByte, getWord8 ) where + +#include "MachDeps.h" + +#ifndef SIZEOF_HSINT +#define SIZEOF_HSINT INT_SIZE_IN_BYTES +#endif + +import Data.Char (ord, chr) +import Foreign (Int32, Int64, Word8, Word32, Word64 + ,Bits(shiftR, shiftL, (.|.), (.&.))) +import System.IO as IO (Handle, hPutChar, hGetChar) + +import GHC.IOBase (IO(..)) +import GHC.Exts + +import qualified Data.ByteString as P (hGet,hPut) +import qualified Data.ByteString.Base as P (ByteString(..)) + +------------------------------------------------------------------------ + +data BinHandle = BinIO {-# UNPACK #-} !FastMutInt {-# UNPACK #-} !IO.Handle + +class Binary a where + put_ :: BinHandle -> a -> IO () + get :: BinHandle -> IO a + +openBinIO_ :: IO.Handle -> IO BinHandle +openBinIO_ h = openBinIO h (error "Binary.BinHandle: no user data") + +openBinIO :: Handle -> t -> IO BinHandle +openBinIO h _mod = do + r <- newFastMutInt + writeFastMutInt r 0 + return (BinIO r h) + +-- ----------------------------------------------------------------------------- +-- Low-level reading/writing of bytes + +putWord8 :: BinHandle -> Word8 -> IO () +putWord8 (BinIO ix_r h) w = do + ix <- readFastMutInt ix_r + hPutChar h (chr (fromIntegral w)) -- XXX not really correct + writeFastMutInt ix_r (ix+1) + return () + +getWord8 :: BinHandle -> IO Word8 +getWord8 (BinIO ix_r h) = do + ix <- readFastMutInt ix_r + c <- hGetChar h + writeFastMutInt ix_r (ix+1) + return $! (fromIntegral (ord c)) -- XXX not really correct + +getByte :: BinHandle -> IO Word8 +getByte = getWord8 +{-# INLINE getByte #-} + +putByte :: BinHandle -> Word8 -> IO () +putByte bh w = put_ bh w + +-- ----------------------------------------------------------------------------- +-- Primitve Word writes + +instance Binary Word8 where + put_ = putWord8 + get = getWord8 + +instance Binary Word32 where + put_ h w = do + putByte h (fromIntegral (w `shiftR` 24)) + putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff)) + putByte h (fromIntegral (w .&. 0xff)) + get h = do + w1 <- getWord8 h + w2 <- getWord8 h + w3 <- getWord8 h + w4 <- getWord8 h + return $! ((fromIntegral w1 `shiftL` 24) .|. + (fromIntegral w2 `shiftL` 16) .|. + (fromIntegral w3 `shiftL` 8) .|. + (fromIntegral w4)) + +instance Binary Word64 where + put_ h w = do + putByte h (fromIntegral (w `shiftR` 56)) + putByte h (fromIntegral ((w `shiftR` 48) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 40) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 32) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 24) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff)) + putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff)) + putByte h (fromIntegral (w .&. 0xff)) + get h = do + w1 <- getWord8 h + w2 <- getWord8 h + w3 <- getWord8 h + w4 <- getWord8 h + w5 <- getWord8 h + w6 <- getWord8 h + w7 <- getWord8 h + w8 <- getWord8 h + return $! ((fromIntegral w1 `shiftL` 56) .|. + (fromIntegral w2 `shiftL` 48) .|. + (fromIntegral w3 `shiftL` 40) .|. + (fromIntegral w4 `shiftL` 32) .|. + (fromIntegral w5 `shiftL` 24) .|. + (fromIntegral w6 `shiftL` 16) .|. + (fromIntegral w7 `shiftL` 8) .|. + (fromIntegral w8)) + +instance Binary Int32 where + put_ h w = put_ h (fromIntegral w :: Word32) + get h = do w <- get h; return $! (fromIntegral (w::Word32)) + +instance Binary Int64 where + put_ h w = put_ h (fromIntegral w :: Word64) + get h = do w <- get h; return $! (fromIntegral (w::Word64)) + +-- ----------------------------------------------------------------------------- +-- Instances for standard types + +instance Binary Int where +#if SIZEOF_HSINT == 4 + put_ bh i = put_ bh (fromIntegral i :: Int32) + get bh = do + x <- get bh + return $! (fromIntegral (x :: Int32)) +#elif SIZEOF_HSINT == 8 + put_ bh i = put_ bh (fromIntegral i :: Int64) + get bh = do + x <- get bh + return $! (fromIntegral (x :: Int64)) +#else +#error "unsupported sizeof(HsInt)" +#endif +-- getF bh = getBitsF bh 32 + +instance Binary Integer where + put_ bh (S# i#) = do putByte bh 0; put_ bh (I# i#) + put_ bh (J# s# a#) = do + putByte bh 1; + put_ bh (I# s#) + let sz# = sizeofByteArray# a# -- in *bytes* + put_ bh (I# sz#) -- in *bytes* + putByteArray bh a# sz# + + get bh = do + b <- getByte bh + case b of + 0 -> do (I# i#) <- get bh + return (S# i#) + _ -> do (I# s#) <- get bh + sz <- get bh + (BA a#) <- getByteArray bh sz + return (J# s# a#) + +putByteArray :: BinHandle -> ByteArray# -> Int# -> IO () +putByteArray bh a s# = loop 0# + where loop n# + | n# ==# s# = return () + | otherwise = do + putByte bh (indexByteArray a n#) + loop (n# +# 1#) + +getByteArray :: BinHandle -> Int -> IO ByteArray +getByteArray bh (I# sz) = do + (MBA arr) <- newByteArray sz + let loop n + | n ==# sz = return () + | otherwise = do + w <- getByte bh + writeByteArray arr n w + loop (n +# 1#) + loop 0# + freezeByteArray arr + +data ByteArray = BA ByteArray# +data MBA = MBA (MutableByteArray# RealWorld) + +newByteArray :: Int# -> IO MBA +newByteArray sz = IO $ \s -> + case newByteArray# sz s of { (# s', arr #) -> + (# s', MBA arr #) } + +freezeByteArray :: MutableByteArray# RealWorld -> IO ByteArray +freezeByteArray arr = IO $ \s -> + case unsafeFreezeByteArray# arr s of { (# s', arr' #) -> + (# s', BA arr' #) } + +writeByteArray :: MutableByteArray# RealWorld -> Int# -> Word8 -> IO () + +writeByteArray arr i w8 = IO $ \s -> + case fromIntegral w8 of { W# w# -> + case writeCharArray# arr i (chr# (word2Int# w#)) s of { s' -> + (# s' , () #) }} + +indexByteArray :: (Num b) => ByteArray# -> Int# -> b +indexByteArray a# n# = fromIntegral (I# (ord# (indexCharArray# a# n#))) + +instance (Binary a, Binary b) => Binary (a,b) where + put_ bh (a,b) = do put_ bh a; put_ bh b + get bh = do a <- get bh + b <- get bh + return (a,b) + +instance Binary a => Binary [a] where + put_ bh l = + do put_ bh (length l) + mapM (put_ bh) l + return () + get bh = + do len <- get bh + mapM (\_ -> get bh) [1..(len::Int)] + +instance Binary a => Binary (Maybe a) where + put_ bh Nothing = putByte bh 0 + put_ bh (Just a) = do putByte bh 1; put_ bh a + get bh = do h <- getWord8 bh + case h of + 0 -> return Nothing + _ -> do x <- get bh; return (Just x) + +-- Instances for FastPackedStrings +instance Binary P.ByteString where + put_ bh@(BinIO ix_r h) ps@(P.PS _ptr _s l) = do + put_ bh l -- size + ix <- readFastMutInt ix_r + P.hPut h ps + writeFastMutInt ix_r (ix+l) + return () + + get bh@(BinIO ix_r h) = do + l <- get bh + ix <- readFastMutInt ix_r + ps <- {-#SCC "Binary.ByteString.get" #-}P.hGet h l + writeFastMutInt ix_r (ix+l) + return $! ps + +{- + ps <- P.generate l $ \ptr -> do + let loop p n# | n# ==# l# = return () + | otherwise = do + c <- hGetChar h + poke p (c2w c) + loop (p `plusPtr` 1) (n# +# 1#) + loop ptr 0# + return l + where + c2w = fromIntegral . ord +-} + +------------------------------------------------------------------------ +-- FastMutInt +-- +data FastMutInt = FastMutInt !(MutableByteArray# RealWorld) + +newFastMutInt :: IO FastMutInt +newFastMutInt = IO $ \s -> + case newByteArray# size s of { (# s', arr #) -> + (# s', FastMutInt arr #) } + where I# size = SIZEOF_HSINT + +readFastMutInt :: FastMutInt -> IO Int +readFastMutInt (FastMutInt arr) = IO $ \s -> + case readIntArray# arr 0# s of { (# s', i #) -> + (# s', I# i #) } + +writeFastMutInt :: FastMutInt -> Int -> IO () +writeFastMutInt (FastMutInt arr) (I# i) = IO $ \s -> + case writeIntArray# arr 0# i s of { s' -> + (# s', () #) } diff --git a/Lib/Error.hs b/Lib/Error.hs new file mode 100644 --- /dev/null +++ b/Lib/Error.hs @@ -0,0 +1,82 @@ +-- +-- | Error utilities +-- +module Lib.Error where + +import Control.Monad (liftM) +import Control.Monad.Error (MonadError (..)) + +-- | 'catchErrorJust' is an error catcher for the Maybe type. As input is given +-- a deciding function, a monad and a handler. When an error is caught, the +-- decider is executed to decide if the error should be handled or not. +-- Then the handler is eventually called to handle the error. +catchErrorJust :: MonadError e m => (e -> Maybe b) -- ^ Decider function + -> m a -- ^ Monad + -> (b -> m a) -- ^ Handler function + -> m a -- ^ Result: A monadic operation on type a +catchErrorJust decide m handler + = catchError m (\e -> case decide e of + Just b -> handler b + Nothing -> throwError e) + +-- | 'handleError' is the flipped version of 'catchError'. +handleError :: MonadError e m => (e -> m a) -- ^ Error handler + -> m a -- ^ Monad + -> m a -- ^ Resulting monad +handleError = flip catchError + +-- | 'handleErrorJust' is the flipped version of 'catchErrorJust'. +handleErrorJust :: MonadError e m => (e -> Maybe b) -- ^ Decider + -> (b -> m a) -- ^ Handler + -> m a -- ^ Monad + -> m a -- ^ Resulting Monad +handleErrorJust = flip . catchErrorJust + +-- | 'tryError' uses Either to explicitly define the outcome of a +-- monadic operation. An error is caught and placed into Right, +-- whereas successful operation is placed into Left. +tryError :: MonadError e m => m a -- ^ Monad to operate on + -> m (Either e a) -- ^ Returns: Explicit Either type +tryError m = catchError (liftM Right m) (return . Left) + +-- | 'tryErrorJust' is the 'catchErrorJust' version of 'tryError' +-- given is a decider guarding whether or not the error should be +-- handled. The handler will always Right and no errors are Left'ed +-- through. If the decider returns Nothing, the error will be thrown +-- further up. +tryErrorJust :: MonadError e m => (e -> Maybe b) -- ^ Decider + -> m a -- ^ Monad + -> m (Either b a) -- ^ Returns: Explicit Either type +tryErrorJust decide m = catchErrorJust decide (liftM Right m) (return . Left) + +-- | 'finallyError' is a monadic version of the classic UNWIND-PROTECT of +-- lisp fame. Given parameters m and after (both monads) we proceed to +-- work on m. If an error is caught, we execute the out-guard, after, +-- before rethrowing the error. If m does not fail, after is executed +-- and the value of m is returned. +finallyError :: MonadError e m => m a -- ^ Monadic operation + -> m b -- ^ Guard + -> m a -- ^ Returns: A new monad. +finallyError m after = do a <- catchError m (\e -> after >> throwError e) + after + return a + +-- | 'bracketError' is the monadic version of DYNAMIC-WIND from Scheme +-- fame. Parameters are: before, after and m. before is the in-guard +-- being executed before m. after is the out-guard and protects fails +-- of the m. +-- In the Haskell world, this scheme is called a bracket and is often +-- seen employed to manage resources. +bracketError :: MonadError e m => m a -- ^ Before (in-guard) monad + -> (a -> m b) -- ^ After (out-guard) operation. Fed output of before + -> (a -> m c) -- ^ Monad to work on. Fed with output of before + -> m c -- ^ Resulting monad. +bracketError before after m = do v <- before; finallyError (m v) (after v) + +-- | 'bracketError_' is the non-bound version of 'bracketError'. The +-- naming scheme follows usual Haskell convention. +bracketError_ :: MonadError e m => m a -- ^ Before (in-guard) + -> m b -- ^ After (out-guard) + -> m c -- ^ Monad to work on + -> m c -- ^ Resulting monad +bracketError_ before after m = bracketError before (\_ -> after) (\_ -> m) diff --git a/Lib/MiniHTTP.hs b/Lib/MiniHTTP.hs new file mode 100644 --- /dev/null +++ b/Lib/MiniHTTP.hs @@ -0,0 +1,115 @@ +-- +-- | HTTP protocol binding. +-- +-- +-- + +module Lib.MiniHTTP ( + Proxy, + mkPost, + readPage, + readNBytes, + urlEncode, + urlDecode, + module Network.URI + ) where + +import Data.Maybe (fromMaybe) +import Data.Bits ((.&.)) +import Data.Char (ord, chr, digitToInt, intToDigit) + +import Control.Monad (liftM2) + +import System.IO + +import Network +import Network.URI hiding (authority) + +authority :: URI -> String +authority = uriRegName . maybe (error "authority") id . uriAuthority + +type Proxy = Maybe (String, Integer) + +-- HTTP specific stuff +mkPost :: URI -> String -> [String] +mkPost uri body = ["POST " ++ url ++ " HTTP/1.0", + "Host: " ++ host, + "Accept: */*", + "Content-Type: application/x-www-form-urlencoded", + "Content-Length: " ++ (show $ length body), + ""] + where + url = show uri + host = authority uri + +hGetLines :: Handle -> IO [String] +hGetLines h = do + eof <- hIsEOF h + if eof then return [] + else + liftM2 (:) (hGetLine h) (hGetLines h) + +readPage :: Proxy -> URI -> [String] -> String -> IO [String] +readPage proxy uri headers body = withSocketsDo $ do + h <- connectTo host (PortNumber (fromInteger port)) + mapM_ (\s -> hPutStr h (s ++ "\r\n")) headers + hPutStr h body + hFlush h + contents <- hGetLines h + hClose h + return contents + where + (host, port) = fromMaybe (authority uri, 80) proxy + +-- +-- read lines, up to limit of n bytes. Useful to ensure people don't +-- abuse the url plugin +-- +readNBytes :: Int -> Proxy -> URI -> [String] -> String -> IO [String] +readNBytes n proxy uri headers body = withSocketsDo $ do + h <- connectTo host (PortNumber (fromInteger port)) + mapM_ (\s -> hPutStr h (s ++ "\r\n")) headers + hPutStr h body + hFlush h + contents <- lines `fmap` hGetN n h + hClose h + return contents + where + (host, port) = fromMaybe (authority uri, 80) proxy + + hGetN :: Int -> Handle -> IO String + hGetN i h | i `seq` h `seq` False = undefined -- strictify + hGetN 0 _ = return [] + hGetN i h = do eof <- hIsEOF h + if eof then return [] + else liftM2 (:) (hGetChar h) (hGetN (i-1) h) + +-- from HTTP.hs +urlEncode, urlDecode :: String -> String + +urlDecode ('%':a:b:rest) = chr (16 * digitToInt a + digitToInt b) + : urlDecode rest +urlDecode (h:t) = h : urlDecode t +urlDecode [] = [] + +urlEncode (h:t) = + let str = if isReservedChar(ord h) then escape h else [h] + in str ++ urlEncode t + where + isReservedChar x + | x >= ord 'a' && x <= ord 'z' = False + | x >= ord 'A' && x <= ord 'Z' = False + | x >= ord '0' && x <= ord '9' = False + | x <= 0x20 || x >= 0x7F = True + | otherwise = x `elem` map ord [';','/','?',':','@','&' + ,'=','+',',','$','{','}' + ,'|','\\','^','[',']','`' + ,'<','>','#','%','"'] + -- wouldn't it be nice if the compiler + -- optimised the above for us? + + escape x = + let y = ord x + in [ '%', intToDigit ((y `div` 16) .&. 0xf), intToDigit (y .&. 0xf) ] + +urlEncode [] = [] diff --git a/Lib/Parser.hs b/Lib/Parser.hs new file mode 100644 --- /dev/null +++ b/Lib/Parser.hs @@ -0,0 +1,8443 @@ +{-# OPTIONS -fglasgow-exts -cpp #-} +{-# OPTIONS -w #-} +----------------------------------------------------------------------------- +-- | +-- Module : Lib.Haskell.Parser +-- Copyright : (c) Simon Marlow, Sven Panne 1997-2000 +-- License : BSD-style (see the file libraries/base/LICENSE) +-- +-- Maintainer : libraries@haskell.org +-- Stability : experimental +-- Portability : portable +-- +-- Haskell parser, modified to be provide an expression parser. +-- +----------------------------------------------------------------------------- +module Lib.Parser ( + parseExpr, + ParseMode(..), defaultParseMode, ParseResult(..)) where +import Language.Haskell.Syntax +import Language.Haskell.ParseMonad +import Language.Haskell.Lexer +import Language.Haskell.ParseUtils +#if __GLASGOW_HASKELL__ >= 503 +import GHC.Exts +#else +import GlaExts +#endif + +-- parser produced by Happy Version 1.15 + +newtype HappyAbsSyn = HappyAbsSyn (() -> ()) +happyIn4 :: (HsModule) -> (HappyAbsSyn ) +happyIn4 x = unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn ) -> (HsModule) +happyOut4 x = unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) +happyIn5 x = unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) +happyOut5 x = unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) +happyIn6 x = unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) +happyOut6 x = unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: (()) -> (HappyAbsSyn ) +happyIn7 x = unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn ) -> (()) +happyOut7 x = unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: (()) -> (HappyAbsSyn ) +happyIn8 x = unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn ) -> (()) +happyOut8 x = unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: (Maybe [HsExportSpec]) -> (HappyAbsSyn ) +happyIn9 x = unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (Maybe [HsExportSpec]) +happyOut9 x = unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: ([HsExportSpec]) -> (HappyAbsSyn ) +happyIn10 x = unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> ([HsExportSpec]) +happyOut10 x = unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: (()) -> (HappyAbsSyn ) +happyIn11 x = unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> (()) +happyOut11 x = unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: ([HsExportSpec]) -> (HappyAbsSyn ) +happyIn12 x = unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> ([HsExportSpec]) +happyOut12 x = unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (HsExportSpec) -> (HappyAbsSyn ) +happyIn13 x = unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (HsExportSpec) +happyOut13 x = unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: ([HsImportDecl]) -> (HappyAbsSyn ) +happyIn14 x = unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> ([HsImportDecl]) +happyOut14 x = unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: (HsImportDecl) -> (HappyAbsSyn ) +happyIn15 x = unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> (HsImportDecl) +happyOut15 x = unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: (Bool) -> (HappyAbsSyn ) +happyIn16 x = unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> (Bool) +happyOut16 x = unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (Maybe Module) -> (HappyAbsSyn ) +happyIn17 x = unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (Maybe Module) +happyOut17 x = unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: (Maybe (Bool, [HsImportSpec])) -> (HappyAbsSyn ) +happyIn18 x = unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> (Maybe (Bool, [HsImportSpec])) +happyOut18 x = unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: ((Bool, [HsImportSpec])) -> (HappyAbsSyn ) +happyIn19 x = unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> ((Bool, [HsImportSpec])) +happyOut19 x = unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (Bool) -> (HappyAbsSyn ) +happyIn20 x = unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (Bool) +happyOut20 x = unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: ([HsImportSpec]) -> (HappyAbsSyn ) +happyIn21 x = unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> ([HsImportSpec]) +happyOut21 x = unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: (HsImportSpec) -> (HappyAbsSyn ) +happyIn22 x = unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> (HsImportSpec) +happyOut22 x = unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: ([HsCName]) -> (HappyAbsSyn ) +happyIn23 x = unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> ([HsCName]) +happyOut23 x = unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: (HsCName) -> (HappyAbsSyn ) +happyIn24 x = unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> (HsCName) +happyOut24 x = unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: (HsDecl) -> (HappyAbsSyn ) +happyIn25 x = unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> (HsDecl) +happyOut25 x = unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: (Int) -> (HappyAbsSyn ) +happyIn26 x = unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> (Int) +happyOut26 x = unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (HsAssoc) -> (HappyAbsSyn ) +happyIn27 x = unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (HsAssoc) +happyOut27 x = unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: ([HsOp]) -> (HappyAbsSyn ) +happyIn28 x = unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> ([HsOp]) +happyOut28 x = unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn29 x = unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut29 x = unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn30 x = unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut30 x = unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: (HsDecl) -> (HappyAbsSyn ) +happyIn31 x = unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> (HsDecl) +happyOut31 x = unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: ([HsType]) -> (HappyAbsSyn ) +happyIn32 x = unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> ([HsType]) +happyOut32 x = unsafeCoerce# x +{-# INLINE happyOut32 #-} +happyIn33 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn33 x = unsafeCoerce# x +{-# INLINE happyIn33 #-} +happyOut33 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut33 x = unsafeCoerce# x +{-# INLINE happyOut33 #-} +happyIn34 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn34 x = unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut34 x = unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: (HsDecl) -> (HappyAbsSyn ) +happyIn35 x = unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> (HsDecl) +happyOut35 x = unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn36 x = unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut36 x = unsafeCoerce# x +{-# INLINE happyOut36 #-} +happyIn37 :: (HsDecl) -> (HappyAbsSyn ) +happyIn37 x = unsafeCoerce# x +{-# INLINE happyIn37 #-} +happyOut37 :: (HappyAbsSyn ) -> (HsDecl) +happyOut37 x = unsafeCoerce# x +{-# INLINE happyOut37 #-} +happyIn38 :: ([HsName]) -> (HappyAbsSyn ) +happyIn38 x = unsafeCoerce# x +{-# INLINE happyIn38 #-} +happyOut38 :: (HappyAbsSyn ) -> ([HsName]) +happyOut38 x = unsafeCoerce# x +{-# INLINE happyOut38 #-} +happyIn39 :: (HsType) -> (HappyAbsSyn ) +happyIn39 x = unsafeCoerce# x +{-# INLINE happyIn39 #-} +happyOut39 :: (HappyAbsSyn ) -> (HsType) +happyOut39 x = unsafeCoerce# x +{-# INLINE happyOut39 #-} +happyIn40 :: (HsType) -> (HappyAbsSyn ) +happyIn40 x = unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (HsType) +happyOut40 x = unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: (HsType) -> (HappyAbsSyn ) +happyIn41 x = unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> (HsType) +happyOut41 x = unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: (HsQName) -> (HappyAbsSyn ) +happyIn42 x = unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> (HsQName) +happyOut42 x = unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: (HsQualType) -> (HappyAbsSyn ) +happyIn43 x = unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> (HsQualType) +happyOut43 x = unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: (HsContext) -> (HappyAbsSyn ) +happyIn44 x = unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> (HsContext) +happyOut44 x = unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: ([HsType]) -> (HappyAbsSyn ) +happyIn45 x = unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> ([HsType]) +happyOut45 x = unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: ((HsName, [HsName])) -> (HappyAbsSyn ) +happyIn46 x = unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> ((HsName, [HsName])) +happyOut46 x = unsafeCoerce# x +{-# INLINE happyOut46 #-} +happyIn47 :: ([HsName]) -> (HappyAbsSyn ) +happyIn47 x = unsafeCoerce# x +{-# INLINE happyIn47 #-} +happyOut47 :: (HappyAbsSyn ) -> ([HsName]) +happyOut47 x = unsafeCoerce# x +{-# INLINE happyOut47 #-} +happyIn48 :: ([HsConDecl]) -> (HappyAbsSyn ) +happyIn48 x = unsafeCoerce# x +{-# INLINE happyIn48 #-} +happyOut48 :: (HappyAbsSyn ) -> ([HsConDecl]) +happyOut48 x = unsafeCoerce# x +{-# INLINE happyOut48 #-} +happyIn49 :: (HsConDecl) -> (HappyAbsSyn ) +happyIn49 x = unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> (HsConDecl) +happyOut49 x = unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) +happyIn50 x = unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) +happyOut50 x = unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) +happyIn51 x = unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) +happyOut51 x = unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (HsBangType) -> (HappyAbsSyn ) +happyIn52 x = unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (HsBangType) +happyOut52 x = unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: (HsBangType) -> (HappyAbsSyn ) +happyIn53 x = unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> (HsBangType) +happyOut53 x = unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: ([([HsName],HsBangType)]) -> (HappyAbsSyn ) +happyIn54 x = unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> ([([HsName],HsBangType)]) +happyOut54 x = unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: (([HsName],HsBangType)) -> (HappyAbsSyn ) +happyIn55 x = unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> (([HsName],HsBangType)) +happyOut55 x = unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: (HsBangType) -> (HappyAbsSyn ) +happyIn56 x = unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> (HsBangType) +happyOut56 x = unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: ([HsQName]) -> (HappyAbsSyn ) +happyIn57 x = unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> ([HsQName]) +happyOut57 x = unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: ([HsQName]) -> (HappyAbsSyn ) +happyIn58 x = unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> ([HsQName]) +happyOut58 x = unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn59 x = unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut59 x = unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn60 x = unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut60 x = unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn61 x = unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut61 x = unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn62 x = unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut62 x = unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: (HsDecl) -> (HappyAbsSyn ) +happyIn63 x = unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> (HsDecl) +happyOut63 x = unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn64 x = unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut64 x = unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: (HsRhs) -> (HappyAbsSyn ) +happyIn65 x = unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> (HsRhs) +happyOut65 x = unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: ([HsGuardedRhs]) -> (HappyAbsSyn ) +happyIn66 x = unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> ([HsGuardedRhs]) +happyOut66 x = unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: (HsGuardedRhs) -> (HappyAbsSyn ) +happyIn67 x = unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> (HsGuardedRhs) +happyOut67 x = unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: (HsExp) -> (HappyAbsSyn ) +happyIn68 x = unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> (HsExp) +happyOut68 x = unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: (HsExp) -> (HappyAbsSyn ) +happyIn69 x = unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> (HsExp) +happyOut69 x = unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: (HsExp) -> (HappyAbsSyn ) +happyIn70 x = unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> (HsExp) +happyOut70 x = unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: (HsExp) -> (HappyAbsSyn ) +happyIn71 x = unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> (HsExp) +happyOut71 x = unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: (HsExp) -> (HappyAbsSyn ) +happyIn72 x = unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> (HsExp) +happyOut72 x = unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: (HsExp) -> (HappyAbsSyn ) +happyIn73 x = unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> (HsExp) +happyOut73 x = unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (HsExp) -> (HappyAbsSyn ) +happyIn74 x = unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (HsExp) +happyOut74 x = unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: ([HsPat]) -> (HappyAbsSyn ) +happyIn75 x = unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> ([HsPat]) +happyOut75 x = unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: (HsPat) -> (HappyAbsSyn ) +happyIn76 x = unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> (HsPat) +happyOut76 x = unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: (HsExp) -> (HappyAbsSyn ) +happyIn77 x = unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> (HsExp) +happyOut77 x = unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: (HsExp) -> (HappyAbsSyn ) +happyIn78 x = unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> (HsExp) +happyOut78 x = unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: (HsExp) -> (HappyAbsSyn ) +happyIn79 x = unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> (HsExp) +happyOut79 x = unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: (Int) -> (HappyAbsSyn ) +happyIn80 x = unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> (Int) +happyOut80 x = unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn81 x = unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut81 x = unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (HsExp) -> (HappyAbsSyn ) +happyIn82 x = unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (HsExp) +happyOut82 x = unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn83 x = unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut83 x = unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn84 x = unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut84 x = unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: (HsStmt) -> (HappyAbsSyn ) +happyIn85 x = unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> (HsStmt) +happyOut85 x = unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn86 x = unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut86 x = unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn87 x = unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut87 x = unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn88 x = unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut88 x = unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: (HsAlt) -> (HappyAbsSyn ) +happyIn89 x = unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> (HsAlt) +happyOut89 x = unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: (HsGuardedAlts) -> (HappyAbsSyn ) +happyIn90 x = unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> (HsGuardedAlts) +happyOut90 x = unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: ([HsGuardedAlt]) -> (HappyAbsSyn ) +happyIn91 x = unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> ([HsGuardedAlt]) +happyOut91 x = unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: (HsGuardedAlt) -> (HappyAbsSyn ) +happyIn92 x = unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> (HsGuardedAlt) +happyOut92 x = unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: (HsPat) -> (HappyAbsSyn ) +happyIn93 x = unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> (HsPat) +happyOut93 x = unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn94 x = unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut94 x = unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn95 x = unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut95 x = unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: ([HsFieldUpdate]) -> (HappyAbsSyn ) +happyIn96 x = unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> ([HsFieldUpdate]) +happyOut96 x = unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: (HsFieldUpdate) -> (HappyAbsSyn ) +happyIn97 x = unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> (HsFieldUpdate) +happyOut97 x = unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: (HsExp) -> (HappyAbsSyn ) +happyIn98 x = unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> (HsExp) +happyOut98 x = unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (HsName) -> (HappyAbsSyn ) +happyIn99 x = unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (HsName) +happyOut99 x = unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: (HsQName) -> (HappyAbsSyn ) +happyIn100 x = unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> (HsQName) +happyOut100 x = unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (HsName) -> (HappyAbsSyn ) +happyIn101 x = unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (HsName) +happyOut101 x = unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: (HsQName) -> (HappyAbsSyn ) +happyIn102 x = unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> (HsQName) +happyOut102 x = unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: (HsName) -> (HappyAbsSyn ) +happyIn103 x = unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> (HsName) +happyOut103 x = unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (HsQName) -> (HappyAbsSyn ) +happyIn104 x = unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (HsQName) +happyOut104 x = unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (HsQName) -> (HappyAbsSyn ) +happyIn105 x = unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (HsQName) +happyOut105 x = unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: (HsName) -> (HappyAbsSyn ) +happyIn106 x = unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> (HsName) +happyOut106 x = unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: (HsQName) -> (HappyAbsSyn ) +happyIn107 x = unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> (HsQName) +happyOut107 x = unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (HsOp) -> (HappyAbsSyn ) +happyIn108 x = unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (HsOp) +happyOut108 x = unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: (HsQOp) -> (HappyAbsSyn ) +happyIn109 x = unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> (HsQOp) +happyOut109 x = unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyIn110 :: (HsQOp) -> (HappyAbsSyn ) +happyIn110 x = unsafeCoerce# x +{-# INLINE happyIn110 #-} +happyOut110 :: (HappyAbsSyn ) -> (HsQOp) +happyOut110 x = unsafeCoerce# x +{-# INLINE happyOut110 #-} +happyIn111 :: (HsQName) -> (HappyAbsSyn ) +happyIn111 x = unsafeCoerce# x +{-# INLINE happyIn111 #-} +happyOut111 :: (HappyAbsSyn ) -> (HsQName) +happyOut111 x = unsafeCoerce# x +{-# INLINE happyOut111 #-} +happyIn112 :: (HsQName) -> (HappyAbsSyn ) +happyIn112 x = unsafeCoerce# x +{-# INLINE happyIn112 #-} +happyOut112 :: (HappyAbsSyn ) -> (HsQName) +happyOut112 x = unsafeCoerce# x +{-# INLINE happyOut112 #-} +happyIn113 :: (HsName) -> (HappyAbsSyn ) +happyIn113 x = unsafeCoerce# x +{-# INLINE happyIn113 #-} +happyOut113 :: (HappyAbsSyn ) -> (HsName) +happyOut113 x = unsafeCoerce# x +{-# INLINE happyOut113 #-} +happyIn114 :: (HsQName) -> (HappyAbsSyn ) +happyIn114 x = unsafeCoerce# x +{-# INLINE happyIn114 #-} +happyOut114 :: (HappyAbsSyn ) -> (HsQName) +happyOut114 x = unsafeCoerce# x +{-# INLINE happyOut114 #-} +happyIn115 :: (HsName) -> (HappyAbsSyn ) +happyIn115 x = unsafeCoerce# x +{-# INLINE happyIn115 #-} +happyOut115 :: (HappyAbsSyn ) -> (HsName) +happyOut115 x = unsafeCoerce# x +{-# INLINE happyOut115 #-} +happyIn116 :: (HsQName) -> (HappyAbsSyn ) +happyIn116 x = unsafeCoerce# x +{-# INLINE happyIn116 #-} +happyOut116 :: (HappyAbsSyn ) -> (HsQName) +happyOut116 x = unsafeCoerce# x +{-# INLINE happyOut116 #-} +happyIn117 :: (HsName) -> (HappyAbsSyn ) +happyIn117 x = unsafeCoerce# x +{-# INLINE happyIn117 #-} +happyOut117 :: (HappyAbsSyn ) -> (HsName) +happyOut117 x = unsafeCoerce# x +{-# INLINE happyOut117 #-} +happyIn118 :: (HsQName) -> (HappyAbsSyn ) +happyIn118 x = unsafeCoerce# x +{-# INLINE happyIn118 #-} +happyOut118 :: (HappyAbsSyn ) -> (HsQName) +happyOut118 x = unsafeCoerce# x +{-# INLINE happyOut118 #-} +happyIn119 :: (HsQName) -> (HappyAbsSyn ) +happyIn119 x = unsafeCoerce# x +{-# INLINE happyIn119 #-} +happyOut119 :: (HappyAbsSyn ) -> (HsQName) +happyOut119 x = unsafeCoerce# x +{-# INLINE happyOut119 #-} +happyIn120 :: (HsName) -> (HappyAbsSyn ) +happyIn120 x = unsafeCoerce# x +{-# INLINE happyIn120 #-} +happyOut120 :: (HappyAbsSyn ) -> (HsName) +happyOut120 x = unsafeCoerce# x +{-# INLINE happyOut120 #-} +happyIn121 :: (HsName) -> (HappyAbsSyn ) +happyIn121 x = unsafeCoerce# x +{-# INLINE happyIn121 #-} +happyOut121 :: (HappyAbsSyn ) -> (HsName) +happyOut121 x = unsafeCoerce# x +{-# INLINE happyOut121 #-} +happyIn122 :: (HsQName) -> (HappyAbsSyn ) +happyIn122 x = unsafeCoerce# x +{-# INLINE happyIn122 #-} +happyOut122 :: (HappyAbsSyn ) -> (HsQName) +happyOut122 x = unsafeCoerce# x +{-# INLINE happyOut122 #-} +happyIn123 :: (HsLiteral) -> (HappyAbsSyn ) +happyIn123 x = unsafeCoerce# x +{-# INLINE happyIn123 #-} +happyOut123 :: (HappyAbsSyn ) -> (HsLiteral) +happyOut123 x = unsafeCoerce# x +{-# INLINE happyOut123 #-} +happyIn124 :: (SrcLoc) -> (HappyAbsSyn ) +happyIn124 x = unsafeCoerce# x +{-# INLINE happyIn124 #-} +happyOut124 :: (HappyAbsSyn ) -> (SrcLoc) +happyOut124 x = unsafeCoerce# x +{-# INLINE happyOut124 #-} +happyIn125 :: (()) -> (HappyAbsSyn ) +happyIn125 x = unsafeCoerce# x +{-# INLINE happyIn125 #-} +happyOut125 :: (HappyAbsSyn ) -> (()) +happyOut125 x = unsafeCoerce# x +{-# INLINE happyOut125 #-} +happyIn126 :: (()) -> (HappyAbsSyn ) +happyIn126 x = unsafeCoerce# x +{-# INLINE happyIn126 #-} +happyOut126 :: (HappyAbsSyn ) -> (()) +happyOut126 x = unsafeCoerce# x +{-# INLINE happyOut126 #-} +happyIn127 :: (Module) -> (HappyAbsSyn ) +happyIn127 x = unsafeCoerce# x +{-# INLINE happyIn127 #-} +happyOut127 :: (HappyAbsSyn ) -> (Module) +happyOut127 x = unsafeCoerce# x +{-# INLINE happyOut127 #-} +happyIn128 :: (HsName) -> (HappyAbsSyn ) +happyIn128 x = unsafeCoerce# x +{-# INLINE happyIn128 #-} +happyOut128 :: (HappyAbsSyn ) -> (HsName) +happyOut128 x = unsafeCoerce# x +{-# INLINE happyOut128 #-} +happyIn129 :: (HsName) -> (HappyAbsSyn ) +happyIn129 x = unsafeCoerce# x +{-# INLINE happyIn129 #-} +happyOut129 :: (HappyAbsSyn ) -> (HsName) +happyOut129 x = unsafeCoerce# x +{-# INLINE happyOut129 #-} +happyIn130 :: (HsQName) -> (HappyAbsSyn ) +happyIn130 x = unsafeCoerce# x +{-# INLINE happyIn130 #-} +happyOut130 :: (HappyAbsSyn ) -> (HsQName) +happyOut130 x = unsafeCoerce# x +{-# INLINE happyOut130 #-} +happyIn131 :: (HsQName) -> (HappyAbsSyn ) +happyIn131 x = unsafeCoerce# x +{-# INLINE happyIn131 #-} +happyOut131 :: (HappyAbsSyn ) -> (HsQName) +happyOut131 x = unsafeCoerce# x +{-# INLINE happyOut131 #-} +happyIn132 :: (HsName) -> (HappyAbsSyn ) +happyIn132 x = unsafeCoerce# x +{-# INLINE happyIn132 #-} +happyOut132 :: (HappyAbsSyn ) -> (HsName) +happyOut132 x = unsafeCoerce# x +{-# INLINE happyOut132 #-} +happyInTok :: Token -> (HappyAbsSyn ) +happyInTok x = unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> Token +happyOutTok x = unsafeCoerce# x +{-# INLINE happyOutTok #-} + +type HappyReduction m = + Int# + -> (Token) + -> HappyState (Token) (HappyStk HappyAbsSyn -> m HappyAbsSyn) + -> [HappyState (Token) (HappyStk HappyAbsSyn -> m HappyAbsSyn)] + -> HappyStk HappyAbsSyn + -> m HappyAbsSyn + +action_0, + action_1, + action_2, + action_3, + action_4, + action_5, + action_6, + action_7, + action_8, + action_9, + action_10, + action_11, + action_12, + action_13, + action_14, + action_15, + action_16, + action_17, + action_18, + action_19, + action_20, + action_21, + action_22, + action_23, + action_24, + action_25, + action_26, + action_27, + action_28, + action_29, + action_30, + action_31, + action_32, + action_33, + action_34, + action_35, + action_36, + action_37, + action_38, + action_39, + action_40, + action_41, + action_42, + action_43, + action_44, + action_45, + action_46, + action_47, + action_48, + action_49, + action_50, + action_51, + action_52, + action_53, + action_54, + action_55, + action_56, + action_57, + action_58, + action_59, + action_60, + action_61, + action_62, + action_63, + action_64, + action_65, + action_66, + action_67, + action_68, + action_69, + action_70, + action_71, + action_72, + action_73, + action_74, + action_75, + action_76, + action_77, + action_78, + action_79, + action_80, + action_81, + action_82, + action_83, + action_84, + action_85, + action_86, + action_87, + action_88, + action_89, + action_90, + action_91, + action_92, + action_93, + action_94, + action_95, + action_96, + action_97, + action_98, + action_99, + action_100, + action_101, + action_102, + action_103, + action_104, + action_105, + action_106, + action_107, + action_108, + action_109, + action_110, + action_111, + action_112, + action_113, + action_114, + action_115, + action_116, + action_117, + action_118, + action_119, + action_120, + action_121, + action_122, + action_123, + action_124, + action_125, + action_126, + action_127, + action_128, + action_129, + action_130, + action_131, + action_132, + action_133, + action_134, + action_135, + action_136, + action_137, + action_138, + action_139, + action_140, + action_141, + action_142, + action_143, + action_144, + action_145, + action_146, + action_147, + action_148, + action_149, + action_150, + action_151, + action_152, + action_153, + action_154, + action_155, + action_156, + action_157, + action_158, + action_159, + action_160, + action_161, + action_162, + action_163, + action_164, + action_165, + action_166, + action_167, + action_168, + action_169, + action_170, + action_171, + action_172, + action_173, + action_174, + action_175, + action_176, + action_177, + action_178, + action_179, + action_180, + action_181, + action_182, + action_183, + action_184, + action_185, + action_186, + action_187, + action_188, + action_189, + action_190, + action_191, + action_192, + action_193, + action_194, + action_195, + action_196, + action_197, + action_198, + action_199, + action_200, + action_201, + action_202, + action_203, + action_204, + action_205, + action_206, + action_207, + action_208, + action_209, + action_210, + action_211, + action_212, + action_213, + action_214, + action_215, + action_216, + action_217, + action_218, + action_219, + action_220, + action_221, + action_222, + action_223, + action_224, + action_225, + action_226, + action_227, + action_228, + action_229, + action_230, + action_231, + action_232, + action_233, + action_234, + action_235, + action_236, + action_237, + action_238, + action_239, + action_240, + action_241, + action_242, + action_243, + action_244, + action_245, + action_246, + action_247, + action_248, + action_249, + action_250, + action_251, + action_252, + action_253, + action_254, + action_255, + action_256, + action_257, + action_258, + action_259, + action_260, + action_261, + action_262, + action_263, + action_264, + action_265, + action_266, + action_267, + action_268, + action_269, + action_270, + action_271, + action_272, + action_273, + action_274, + action_275, + action_276, + action_277, + action_278, + action_279, + action_280, + action_281, + action_282, + action_283, + action_284, + action_285, + action_286, + action_287, + action_288, + action_289, + action_290, + action_291, + action_292, + action_293, + action_294, + action_295, + action_296, + action_297, + action_298, + action_299, + action_300, + action_301, + action_302, + action_303, + action_304, + action_305, + action_306, + action_307, + action_308, + action_309, + action_310, + action_311, + action_312, + action_313, + action_314, + action_315, + action_316, + action_317, + action_318, + action_319, + action_320, + action_321, + action_322, + action_323, + action_324, + action_325, + action_326, + action_327, + action_328, + action_329, + action_330, + action_331, + action_332, + action_333, + action_334, + action_335, + action_336, + action_337, + action_338, + action_339, + action_340, + action_341, + action_342, + action_343, + action_344, + action_345, + action_346, + action_347, + action_348, + action_349, + action_350, + action_351, + action_352, + action_353, + action_354, + action_355, + action_356, + action_357, + action_358, + action_359, + action_360, + action_361, + action_362, + action_363, + action_364, + action_365, + action_366, + action_367, + action_368, + action_369, + action_370, + action_371, + action_372, + action_373, + action_374, + action_375, + action_376, + action_377, + action_378, + action_379, + action_380, + action_381, + action_382, + action_383, + action_384, + action_385, + action_386, + action_387, + action_388, + action_389, + action_390, + action_391, + action_392, + action_393, + action_394, + action_395, + action_396, + action_397, + action_398, + action_399, + action_400, + action_401, + action_402, + action_403, + action_404, + action_405, + action_406, + action_407, + action_408, + action_409, + action_410, + action_411, + action_412, + action_413, + action_414, + action_415, + action_416, + action_417, + action_418, + action_419, + action_420, + action_421, + action_422, + action_423, + action_424, + action_425, + action_426, + action_427, + action_428, + action_429, + action_430, + action_431, + action_432, + action_433, + action_434, + action_435, + action_436, + action_437, + action_438, + action_439, + action_440, + action_441, + action_442, + action_443, + action_444, + action_445, + action_446, + action_447, + action_448, + action_449, + action_450, + action_451, + action_452, + action_453, + action_454, + action_455, + action_456, + action_457, + action_458, + action_459, + action_460, + action_461, + action_462, + action_463, + action_464, + action_465, + action_466, + action_467, + action_468, + action_469, + action_470, + action_471, + action_472, + action_473, + action_474, + action_475, + action_476, + action_477, + action_478, + action_479, + action_480, + action_481, + action_482, + action_483, + action_484, + action_485, + action_486, + action_487, + action_488, + action_489, + action_490 :: () => Int# -> HappyReduction (P) + +happyReduce_1, + happyReduce_2, + happyReduce_3, + happyReduce_4, + happyReduce_5, + happyReduce_6, + happyReduce_7, + happyReduce_8, + happyReduce_9, + happyReduce_10, + happyReduce_11, + happyReduce_12, + happyReduce_13, + happyReduce_14, + happyReduce_15, + happyReduce_16, + happyReduce_17, + happyReduce_18, + happyReduce_19, + happyReduce_20, + happyReduce_21, + happyReduce_22, + happyReduce_23, + happyReduce_24, + happyReduce_25, + happyReduce_26, + happyReduce_27, + happyReduce_28, + happyReduce_29, + happyReduce_30, + happyReduce_31, + happyReduce_32, + happyReduce_33, + happyReduce_34, + happyReduce_35, + happyReduce_36, + happyReduce_37, + happyReduce_38, + happyReduce_39, + happyReduce_40, + happyReduce_41, + happyReduce_42, + happyReduce_43, + happyReduce_44, + happyReduce_45, + happyReduce_46, + happyReduce_47, + happyReduce_48, + happyReduce_49, + happyReduce_50, + happyReduce_51, + happyReduce_52, + happyReduce_53, + happyReduce_54, + happyReduce_55, + happyReduce_56, + happyReduce_57, + happyReduce_58, + happyReduce_59, + happyReduce_60, + happyReduce_61, + happyReduce_62, + happyReduce_63, + happyReduce_64, + happyReduce_65, + happyReduce_66, + happyReduce_67, + happyReduce_68, + happyReduce_69, + happyReduce_70, + happyReduce_71, + happyReduce_72, + happyReduce_73, + happyReduce_74, + happyReduce_75, + happyReduce_76, + happyReduce_77, + happyReduce_78, + happyReduce_79, + happyReduce_80, + happyReduce_81, + happyReduce_82, + happyReduce_83, + happyReduce_84, + happyReduce_85, + happyReduce_86, + happyReduce_87, + happyReduce_88, + happyReduce_89, + happyReduce_90, + happyReduce_91, + happyReduce_92, + happyReduce_93, + happyReduce_94, + happyReduce_95, + happyReduce_96, + happyReduce_97, + happyReduce_98, + happyReduce_99, + happyReduce_100, + happyReduce_101, + happyReduce_102, + happyReduce_103, + happyReduce_104, + happyReduce_105, + happyReduce_106, + happyReduce_107, + happyReduce_108, + happyReduce_109, + happyReduce_110, + happyReduce_111, + happyReduce_112, + happyReduce_113, + happyReduce_114, + happyReduce_115, + happyReduce_116, + happyReduce_117, + happyReduce_118, + happyReduce_119, + happyReduce_120, + happyReduce_121, + happyReduce_122, + happyReduce_123, + happyReduce_124, + happyReduce_125, + happyReduce_126, + happyReduce_127, + happyReduce_128, + happyReduce_129, + happyReduce_130, + happyReduce_131, + happyReduce_132, + happyReduce_133, + happyReduce_134, + happyReduce_135, + happyReduce_136, + happyReduce_137, + happyReduce_138, + happyReduce_139, + happyReduce_140, + happyReduce_141, + happyReduce_142, + happyReduce_143, + happyReduce_144, + happyReduce_145, + happyReduce_146, + happyReduce_147, + happyReduce_148, + happyReduce_149, + happyReduce_150, + happyReduce_151, + happyReduce_152, + happyReduce_153, + happyReduce_154, + happyReduce_155, + happyReduce_156, + happyReduce_157, + happyReduce_158, + happyReduce_159, + happyReduce_160, + happyReduce_161, + happyReduce_162, + happyReduce_163, + happyReduce_164, + happyReduce_165, + happyReduce_166, + happyReduce_167, + happyReduce_168, + happyReduce_169, + happyReduce_170, + happyReduce_171, + happyReduce_172, + happyReduce_173, + happyReduce_174, + happyReduce_175, + happyReduce_176, + happyReduce_177, + happyReduce_178, + happyReduce_179, + happyReduce_180, + happyReduce_181, + happyReduce_182, + happyReduce_183, + happyReduce_184, + happyReduce_185, + happyReduce_186, + happyReduce_187, + happyReduce_188, + happyReduce_189, + happyReduce_190, + happyReduce_191, + happyReduce_192, + happyReduce_193, + happyReduce_194, + happyReduce_195, + happyReduce_196, + happyReduce_197, + happyReduce_198, + happyReduce_199, + happyReduce_200, + happyReduce_201, + happyReduce_202, + happyReduce_203, + happyReduce_204, + happyReduce_205, + happyReduce_206, + happyReduce_207, + happyReduce_208, + happyReduce_209, + happyReduce_210, + happyReduce_211, + happyReduce_212, + happyReduce_213, + happyReduce_214, + happyReduce_215, + happyReduce_216, + happyReduce_217, + happyReduce_218, + happyReduce_219, + happyReduce_220, + happyReduce_221, + happyReduce_222, + happyReduce_223, + happyReduce_224, + happyReduce_225, + happyReduce_226, + happyReduce_227, + happyReduce_228, + happyReduce_229, + happyReduce_230, + happyReduce_231, + happyReduce_232, + happyReduce_233, + happyReduce_234, + happyReduce_235, + happyReduce_236, + happyReduce_237, + happyReduce_238, + happyReduce_239, + happyReduce_240, + happyReduce_241, + happyReduce_242, + happyReduce_243, + happyReduce_244, + happyReduce_245, + happyReduce_246, + happyReduce_247, + happyReduce_248, + happyReduce_249, + happyReduce_250, + happyReduce_251, + happyReduce_252, + happyReduce_253, + happyReduce_254, + happyReduce_255, + happyReduce_256, + happyReduce_257, + happyReduce_258, + happyReduce_259, + happyReduce_260, + happyReduce_261, + happyReduce_262, + happyReduce_263, + happyReduce_264, + happyReduce_265, + happyReduce_266, + happyReduce_267, + happyReduce_268, + happyReduce_269, + happyReduce_270, + happyReduce_271, + happyReduce_272, + happyReduce_273, + happyReduce_274, + happyReduce_275, + happyReduce_276, + happyReduce_277, + happyReduce_278, + happyReduce_279, + happyReduce_280, + happyReduce_281, + happyReduce_282, + happyReduce_283, + happyReduce_284, + happyReduce_285, + happyReduce_286, + happyReduce_287, + happyReduce_288, + happyReduce_289 :: () => HappyReduction (P) + +action_0 (133#) = happyShift action_21 +action_0 (134#) = happyShift action_22 +action_0 (135#) = happyShift action_23 +action_0 (136#) = happyShift action_24 +action_0 (141#) = happyShift action_25 +action_0 (142#) = happyShift action_26 +action_0 (143#) = happyShift action_27 +action_0 (144#) = happyShift action_28 +action_0 (145#) = happyShift action_29 +action_0 (151#) = happyShift action_30 +action_0 (154#) = happyShift action_31 +action_0 (160#) = happyShift action_32 +action_0 (165#) = happyShift action_33 +action_0 (167#) = happyShift action_34 +action_0 (169#) = happyShift action_35 +action_0 (170#) = happyShift action_36 +action_0 (175#) = happyShift action_37 +action_0 (177#) = happyShift action_38 +action_0 (178#) = happyShift action_39 +action_0 (185#) = happyShift action_40 +action_0 (192#) = happyShift action_41 +action_0 (68#) = happyGoto action_3 +action_0 (69#) = happyGoto action_4 +action_0 (70#) = happyGoto action_5 +action_0 (71#) = happyGoto action_6 +action_0 (72#) = happyGoto action_7 +action_0 (73#) = happyGoto action_8 +action_0 (74#) = happyGoto action_9 +action_0 (77#) = happyGoto action_10 +action_0 (78#) = happyGoto action_11 +action_0 (79#) = happyGoto action_12 +action_0 (98#) = happyGoto action_13 +action_0 (100#) = happyGoto action_14 +action_0 (102#) = happyGoto action_15 +action_0 (112#) = happyGoto action_16 +action_0 (113#) = happyGoto action_17 +action_0 (114#) = happyGoto action_18 +action_0 (115#) = happyGoto action_19 +action_0 (123#) = happyGoto action_20 +action_0 x = happyTcHack x happyFail + +action_1 (124#) = happyGoto action_2 +action_1 x = happyTcHack x happyFail + +action_2 (186#) = happyShift action_96 +action_2 x = happyTcHack x happyFail + +action_3 (193#) = happyAccept +action_3 x = happyTcHack x happyFail + +action_4 x = happyTcHack x happyReduce_148 + +action_5 x = happyTcHack x happyReduce_149 + +action_6 (137#) = happyShift action_91 +action_6 (138#) = happyShift action_73 +action_6 (139#) = happyShift action_74 +action_6 (140#) = happyShift action_75 +action_6 (155#) = happyShift action_92 +action_6 (157#) = happyShift action_79 +action_6 (158#) = happyShift action_93 +action_6 (167#) = happyShift action_94 +action_6 (168#) = happyShift action_95 +action_6 (104#) = happyGoto action_85 +action_6 (107#) = happyGoto action_86 +action_6 (109#) = happyGoto action_87 +action_6 (111#) = happyGoto action_88 +action_6 (116#) = happyGoto action_65 +action_6 (117#) = happyGoto action_66 +action_6 (118#) = happyGoto action_89 +action_6 (120#) = happyGoto action_69 +action_6 (122#) = happyGoto action_90 +action_6 x = happyTcHack x happyReduce_150 + +action_7 x = happyTcHack x happyReduce_152 + +action_8 x = happyTcHack x happyReduce_154 + +action_9 (133#) = happyShift action_21 +action_9 (134#) = happyShift action_22 +action_9 (135#) = happyShift action_23 +action_9 (136#) = happyShift action_24 +action_9 (141#) = happyShift action_25 +action_9 (142#) = happyShift action_26 +action_9 (143#) = happyShift action_27 +action_9 (144#) = happyShift action_28 +action_9 (145#) = happyShift action_29 +action_9 (151#) = happyShift action_30 +action_9 (154#) = happyShift action_31 +action_9 (165#) = happyShift action_33 +action_9 (169#) = happyShift action_35 +action_9 (177#) = happyShift action_38 +action_9 (192#) = happyShift action_41 +action_9 (77#) = happyGoto action_84 +action_9 (78#) = happyGoto action_11 +action_9 (79#) = happyGoto action_12 +action_9 (98#) = happyGoto action_13 +action_9 (100#) = happyGoto action_14 +action_9 (102#) = happyGoto action_15 +action_9 (112#) = happyGoto action_16 +action_9 (113#) = happyGoto action_17 +action_9 (114#) = happyGoto action_18 +action_9 (115#) = happyGoto action_19 +action_9 (123#) = happyGoto action_20 +action_9 x = happyTcHack x happyReduce_161 + +action_10 x = happyTcHack x happyReduce_163 + +action_11 (148#) = happyShift action_83 +action_11 x = happyTcHack x happyReduce_169 + +action_12 x = happyTcHack x happyReduce_172 + +action_13 x = happyTcHack x happyReduce_174 + +action_14 (164#) = happyShift action_82 +action_14 x = happyTcHack x happyReduce_173 + +action_15 x = happyTcHack x happyReduce_226 + +action_16 x = happyTcHack x happyReduce_229 + +action_17 x = happyTcHack x happyReduce_253 + +action_18 x = happyTcHack x happyReduce_233 + +action_19 x = happyTcHack x happyReduce_259 + +action_20 x = happyTcHack x happyReduce_175 + +action_21 x = happyTcHack x happyReduce_255 + +action_22 x = happyTcHack x happyReduce_254 + +action_23 x = happyTcHack x happyReduce_261 + +action_24 x = happyTcHack x happyReduce_260 + +action_25 x = happyTcHack x happyReduce_275 + +action_26 x = happyTcHack x happyReduce_277 + +action_27 x = happyTcHack x happyReduce_276 + +action_28 x = happyTcHack x happyReduce_278 + +action_29 (133#) = happyShift action_21 +action_29 (134#) = happyShift action_22 +action_29 (135#) = happyShift action_23 +action_29 (136#) = happyShift action_24 +action_29 (137#) = happyShift action_72 +action_29 (138#) = happyShift action_73 +action_29 (139#) = happyShift action_74 +action_29 (140#) = happyShift action_75 +action_29 (141#) = happyShift action_25 +action_29 (142#) = happyShift action_26 +action_29 (143#) = happyShift action_27 +action_29 (144#) = happyShift action_28 +action_29 (145#) = happyShift action_29 +action_29 (146#) = happyShift action_76 +action_29 (151#) = happyShift action_30 +action_29 (153#) = happyShift action_77 +action_29 (154#) = happyShift action_31 +action_29 (155#) = happyShift action_78 +action_29 (157#) = happyShift action_79 +action_29 (160#) = happyShift action_32 +action_29 (165#) = happyShift action_33 +action_29 (167#) = happyShift action_80 +action_29 (168#) = happyShift action_81 +action_29 (169#) = happyShift action_35 +action_29 (170#) = happyShift action_36 +action_29 (175#) = happyShift action_37 +action_29 (177#) = happyShift action_38 +action_29 (178#) = happyShift action_39 +action_29 (185#) = happyShift action_40 +action_29 (192#) = happyShift action_41 +action_29 (68#) = happyGoto action_57 +action_29 (69#) = happyGoto action_4 +action_29 (70#) = happyGoto action_5 +action_29 (71#) = happyGoto action_58 +action_29 (72#) = happyGoto action_7 +action_29 (73#) = happyGoto action_8 +action_29 (74#) = happyGoto action_9 +action_29 (77#) = happyGoto action_10 +action_29 (78#) = happyGoto action_11 +action_29 (79#) = happyGoto action_12 +action_29 (80#) = happyGoto action_59 +action_29 (81#) = happyGoto action_60 +action_29 (98#) = happyGoto action_13 +action_29 (100#) = happyGoto action_14 +action_29 (102#) = happyGoto action_15 +action_29 (105#) = happyGoto action_61 +action_29 (107#) = happyGoto action_62 +action_29 (110#) = happyGoto action_63 +action_29 (111#) = happyGoto action_64 +action_29 (112#) = happyGoto action_16 +action_29 (113#) = happyGoto action_17 +action_29 (114#) = happyGoto action_18 +action_29 (115#) = happyGoto action_19 +action_29 (116#) = happyGoto action_65 +action_29 (117#) = happyGoto action_66 +action_29 (118#) = happyGoto action_67 +action_29 (119#) = happyGoto action_68 +action_29 (120#) = happyGoto action_69 +action_29 (121#) = happyGoto action_70 +action_29 (122#) = happyGoto action_71 +action_29 (123#) = happyGoto action_20 +action_29 x = happyTcHack x happyFail + +action_30 (133#) = happyShift action_21 +action_30 (134#) = happyShift action_22 +action_30 (135#) = happyShift action_23 +action_30 (136#) = happyShift action_24 +action_30 (141#) = happyShift action_25 +action_30 (142#) = happyShift action_26 +action_30 (143#) = happyShift action_27 +action_30 (144#) = happyShift action_28 +action_30 (145#) = happyShift action_29 +action_30 (151#) = happyShift action_30 +action_30 (152#) = happyShift action_56 +action_30 (154#) = happyShift action_31 +action_30 (160#) = happyShift action_32 +action_30 (165#) = happyShift action_33 +action_30 (167#) = happyShift action_34 +action_30 (169#) = happyShift action_35 +action_30 (170#) = happyShift action_36 +action_30 (175#) = happyShift action_37 +action_30 (177#) = happyShift action_38 +action_30 (178#) = happyShift action_39 +action_30 (185#) = happyShift action_40 +action_30 (192#) = happyShift action_41 +action_30 (68#) = happyGoto action_53 +action_30 (69#) = happyGoto action_4 +action_30 (70#) = happyGoto action_5 +action_30 (71#) = happyGoto action_6 +action_30 (72#) = happyGoto action_7 +action_30 (73#) = happyGoto action_8 +action_30 (74#) = happyGoto action_9 +action_30 (77#) = happyGoto action_10 +action_30 (78#) = happyGoto action_11 +action_30 (79#) = happyGoto action_12 +action_30 (82#) = happyGoto action_54 +action_30 (83#) = happyGoto action_55 +action_30 (98#) = happyGoto action_13 +action_30 (100#) = happyGoto action_14 +action_30 (102#) = happyGoto action_15 +action_30 (112#) = happyGoto action_16 +action_30 (113#) = happyGoto action_17 +action_30 (114#) = happyGoto action_18 +action_30 (115#) = happyGoto action_19 +action_30 (123#) = happyGoto action_20 +action_30 x = happyTcHack x happyFail + +action_31 x = happyTcHack x happyReduce_181 + +action_32 (124#) = happyGoto action_52 +action_32 x = happyTcHack x happyReduce_279 + +action_33 (133#) = happyShift action_21 +action_33 (134#) = happyShift action_22 +action_33 (135#) = happyShift action_23 +action_33 (136#) = happyShift action_24 +action_33 (141#) = happyShift action_25 +action_33 (142#) = happyShift action_26 +action_33 (143#) = happyShift action_27 +action_33 (144#) = happyShift action_28 +action_33 (145#) = happyShift action_29 +action_33 (151#) = happyShift action_30 +action_33 (154#) = happyShift action_31 +action_33 (165#) = happyShift action_33 +action_33 (169#) = happyShift action_35 +action_33 (177#) = happyShift action_38 +action_33 (192#) = happyShift action_41 +action_33 (77#) = happyGoto action_51 +action_33 (78#) = happyGoto action_11 +action_33 (79#) = happyGoto action_12 +action_33 (98#) = happyGoto action_13 +action_33 (100#) = happyGoto action_14 +action_33 (102#) = happyGoto action_15 +action_33 (112#) = happyGoto action_16 +action_33 (113#) = happyGoto action_17 +action_33 (114#) = happyGoto action_18 +action_33 (115#) = happyGoto action_19 +action_33 (123#) = happyGoto action_20 +action_33 x = happyTcHack x happyFail + +action_34 (133#) = happyShift action_21 +action_34 (134#) = happyShift action_22 +action_34 (135#) = happyShift action_23 +action_34 (136#) = happyShift action_24 +action_34 (141#) = happyShift action_25 +action_34 (142#) = happyShift action_26 +action_34 (143#) = happyShift action_27 +action_34 (144#) = happyShift action_28 +action_34 (145#) = happyShift action_29 +action_34 (151#) = happyShift action_30 +action_34 (154#) = happyShift action_31 +action_34 (165#) = happyShift action_33 +action_34 (169#) = happyShift action_35 +action_34 (177#) = happyShift action_38 +action_34 (192#) = happyShift action_41 +action_34 (74#) = happyGoto action_50 +action_34 (77#) = happyGoto action_10 +action_34 (78#) = happyGoto action_11 +action_34 (79#) = happyGoto action_12 +action_34 (98#) = happyGoto action_13 +action_34 (100#) = happyGoto action_14 +action_34 (102#) = happyGoto action_15 +action_34 (112#) = happyGoto action_16 +action_34 (113#) = happyGoto action_17 +action_34 (114#) = happyGoto action_18 +action_34 (115#) = happyGoto action_19 +action_34 (123#) = happyGoto action_20 +action_34 x = happyTcHack x happyFail + +action_35 x = happyTcHack x happyReduce_256 + +action_36 (133#) = happyShift action_21 +action_36 (134#) = happyShift action_22 +action_36 (135#) = happyShift action_23 +action_36 (136#) = happyShift action_24 +action_36 (141#) = happyShift action_25 +action_36 (142#) = happyShift action_26 +action_36 (143#) = happyShift action_27 +action_36 (144#) = happyShift action_28 +action_36 (145#) = happyShift action_29 +action_36 (151#) = happyShift action_30 +action_36 (154#) = happyShift action_31 +action_36 (160#) = happyShift action_32 +action_36 (165#) = happyShift action_33 +action_36 (167#) = happyShift action_34 +action_36 (169#) = happyShift action_35 +action_36 (170#) = happyShift action_36 +action_36 (175#) = happyShift action_37 +action_36 (177#) = happyShift action_38 +action_36 (178#) = happyShift action_39 +action_36 (185#) = happyShift action_40 +action_36 (192#) = happyShift action_41 +action_36 (68#) = happyGoto action_49 +action_36 (69#) = happyGoto action_4 +action_36 (70#) = happyGoto action_5 +action_36 (71#) = happyGoto action_6 +action_36 (72#) = happyGoto action_7 +action_36 (73#) = happyGoto action_8 +action_36 (74#) = happyGoto action_9 +action_36 (77#) = happyGoto action_10 +action_36 (78#) = happyGoto action_11 +action_36 (79#) = happyGoto action_12 +action_36 (98#) = happyGoto action_13 +action_36 (100#) = happyGoto action_14 +action_36 (102#) = happyGoto action_15 +action_36 (112#) = happyGoto action_16 +action_36 (113#) = happyGoto action_17 +action_36 (114#) = happyGoto action_18 +action_36 (115#) = happyGoto action_19 +action_36 (123#) = happyGoto action_20 +action_36 x = happyTcHack x happyFail + +action_37 (148#) = happyShift action_48 +action_37 (94#) = happyGoto action_46 +action_37 (125#) = happyGoto action_47 +action_37 x = happyTcHack x happyReduce_280 + +action_38 x = happyTcHack x happyReduce_258 + +action_39 (133#) = happyShift action_21 +action_39 (134#) = happyShift action_22 +action_39 (135#) = happyShift action_23 +action_39 (136#) = happyShift action_24 +action_39 (141#) = happyShift action_25 +action_39 (142#) = happyShift action_26 +action_39 (143#) = happyShift action_27 +action_39 (144#) = happyShift action_28 +action_39 (145#) = happyShift action_29 +action_39 (151#) = happyShift action_30 +action_39 (154#) = happyShift action_31 +action_39 (160#) = happyShift action_32 +action_39 (165#) = happyShift action_33 +action_39 (167#) = happyShift action_34 +action_39 (169#) = happyShift action_35 +action_39 (170#) = happyShift action_36 +action_39 (175#) = happyShift action_37 +action_39 (177#) = happyShift action_38 +action_39 (178#) = happyShift action_39 +action_39 (185#) = happyShift action_40 +action_39 (192#) = happyShift action_41 +action_39 (68#) = happyGoto action_45 +action_39 (69#) = happyGoto action_4 +action_39 (70#) = happyGoto action_5 +action_39 (71#) = happyGoto action_6 +action_39 (72#) = happyGoto action_7 +action_39 (73#) = happyGoto action_8 +action_39 (74#) = happyGoto action_9 +action_39 (77#) = happyGoto action_10 +action_39 (78#) = happyGoto action_11 +action_39 (79#) = happyGoto action_12 +action_39 (98#) = happyGoto action_13 +action_39 (100#) = happyGoto action_14 +action_39 (102#) = happyGoto action_15 +action_39 (112#) = happyGoto action_16 +action_39 (113#) = happyGoto action_17 +action_39 (114#) = happyGoto action_18 +action_39 (115#) = happyGoto action_19 +action_39 (123#) = happyGoto action_20 +action_39 x = happyTcHack x happyFail + +action_40 (148#) = happyShift action_44 +action_40 (36#) = happyGoto action_42 +action_40 (125#) = happyGoto action_43 +action_40 x = happyTcHack x happyReduce_280 + +action_41 x = happyTcHack x happyReduce_257 + +action_42 (180#) = happyShift action_144 +action_42 x = happyTcHack x happyFail + +action_43 (7#) = happyGoto action_140 +action_43 (8#) = happyGoto action_141 +action_43 (33#) = happyGoto action_143 +action_43 x = happyTcHack x happyReduce_11 + +action_44 (7#) = happyGoto action_140 +action_44 (8#) = happyGoto action_141 +action_44 (33#) = happyGoto action_142 +action_44 x = happyTcHack x happyReduce_11 + +action_45 (189#) = happyShift action_139 +action_45 x = happyTcHack x happyFail + +action_46 x = happyTcHack x happyReduce_160 + +action_47 (133#) = happyShift action_21 +action_47 (134#) = happyShift action_22 +action_47 (135#) = happyShift action_23 +action_47 (136#) = happyShift action_24 +action_47 (141#) = happyShift action_25 +action_47 (142#) = happyShift action_26 +action_47 (143#) = happyShift action_27 +action_47 (144#) = happyShift action_28 +action_47 (145#) = happyShift action_29 +action_47 (147#) = happyShift action_136 +action_47 (151#) = happyShift action_30 +action_47 (154#) = happyShift action_31 +action_47 (160#) = happyShift action_32 +action_47 (165#) = happyShift action_33 +action_47 (167#) = happyShift action_34 +action_47 (169#) = happyShift action_35 +action_47 (170#) = happyShift action_36 +action_47 (175#) = happyShift action_37 +action_47 (177#) = happyShift action_38 +action_47 (178#) = happyShift action_39 +action_47 (185#) = happyShift action_137 +action_47 (192#) = happyShift action_41 +action_47 (68#) = happyGoto action_132 +action_47 (69#) = happyGoto action_4 +action_47 (70#) = happyGoto action_5 +action_47 (71#) = happyGoto action_133 +action_47 (72#) = happyGoto action_7 +action_47 (73#) = happyGoto action_8 +action_47 (74#) = happyGoto action_9 +action_47 (77#) = happyGoto action_10 +action_47 (78#) = happyGoto action_11 +action_47 (79#) = happyGoto action_12 +action_47 (93#) = happyGoto action_134 +action_47 (95#) = happyGoto action_138 +action_47 (98#) = happyGoto action_13 +action_47 (100#) = happyGoto action_14 +action_47 (102#) = happyGoto action_15 +action_47 (112#) = happyGoto action_16 +action_47 (113#) = happyGoto action_17 +action_47 (114#) = happyGoto action_18 +action_47 (115#) = happyGoto action_19 +action_47 (123#) = happyGoto action_20 +action_47 x = happyTcHack x happyFail + +action_48 (133#) = happyShift action_21 +action_48 (134#) = happyShift action_22 +action_48 (135#) = happyShift action_23 +action_48 (136#) = happyShift action_24 +action_48 (141#) = happyShift action_25 +action_48 (142#) = happyShift action_26 +action_48 (143#) = happyShift action_27 +action_48 (144#) = happyShift action_28 +action_48 (145#) = happyShift action_29 +action_48 (147#) = happyShift action_136 +action_48 (151#) = happyShift action_30 +action_48 (154#) = happyShift action_31 +action_48 (160#) = happyShift action_32 +action_48 (165#) = happyShift action_33 +action_48 (167#) = happyShift action_34 +action_48 (169#) = happyShift action_35 +action_48 (170#) = happyShift action_36 +action_48 (175#) = happyShift action_37 +action_48 (177#) = happyShift action_38 +action_48 (178#) = happyShift action_39 +action_48 (185#) = happyShift action_137 +action_48 (192#) = happyShift action_41 +action_48 (68#) = happyGoto action_132 +action_48 (69#) = happyGoto action_4 +action_48 (70#) = happyGoto action_5 +action_48 (71#) = happyGoto action_133 +action_48 (72#) = happyGoto action_7 +action_48 (73#) = happyGoto action_8 +action_48 (74#) = happyGoto action_9 +action_48 (77#) = happyGoto action_10 +action_48 (78#) = happyGoto action_11 +action_48 (79#) = happyGoto action_12 +action_48 (93#) = happyGoto action_134 +action_48 (95#) = happyGoto action_135 +action_48 (98#) = happyGoto action_13 +action_48 (100#) = happyGoto action_14 +action_48 (102#) = happyGoto action_15 +action_48 (112#) = happyGoto action_16 +action_48 (113#) = happyGoto action_17 +action_48 (114#) = happyGoto action_18 +action_48 (115#) = happyGoto action_19 +action_48 (123#) = happyGoto action_20 +action_48 x = happyTcHack x happyFail + +action_49 (188#) = happyShift action_131 +action_49 x = happyTcHack x happyFail + +action_50 (133#) = happyShift action_21 +action_50 (134#) = happyShift action_22 +action_50 (135#) = happyShift action_23 +action_50 (136#) = happyShift action_24 +action_50 (141#) = happyShift action_25 +action_50 (142#) = happyShift action_26 +action_50 (143#) = happyShift action_27 +action_50 (144#) = happyShift action_28 +action_50 (145#) = happyShift action_29 +action_50 (151#) = happyShift action_30 +action_50 (154#) = happyShift action_31 +action_50 (165#) = happyShift action_33 +action_50 (169#) = happyShift action_35 +action_50 (177#) = happyShift action_38 +action_50 (192#) = happyShift action_41 +action_50 (77#) = happyGoto action_84 +action_50 (78#) = happyGoto action_11 +action_50 (79#) = happyGoto action_12 +action_50 (98#) = happyGoto action_13 +action_50 (100#) = happyGoto action_14 +action_50 (102#) = happyGoto action_15 +action_50 (112#) = happyGoto action_16 +action_50 (113#) = happyGoto action_17 +action_50 (114#) = happyGoto action_18 +action_50 (115#) = happyGoto action_19 +action_50 (123#) = happyGoto action_20 +action_50 x = happyTcHack x happyReduce_159 + +action_51 x = happyTcHack x happyReduce_168 + +action_52 (133#) = happyShift action_21 +action_52 (134#) = happyShift action_22 +action_52 (135#) = happyShift action_23 +action_52 (136#) = happyShift action_24 +action_52 (141#) = happyShift action_25 +action_52 (142#) = happyShift action_26 +action_52 (143#) = happyShift action_27 +action_52 (144#) = happyShift action_28 +action_52 (145#) = happyShift action_29 +action_52 (151#) = happyShift action_30 +action_52 (154#) = happyShift action_31 +action_52 (165#) = happyShift action_33 +action_52 (169#) = happyShift action_35 +action_52 (177#) = happyShift action_38 +action_52 (192#) = happyShift action_41 +action_52 (75#) = happyGoto action_128 +action_52 (76#) = happyGoto action_129 +action_52 (77#) = happyGoto action_130 +action_52 (78#) = happyGoto action_11 +action_52 (79#) = happyGoto action_12 +action_52 (98#) = happyGoto action_13 +action_52 (100#) = happyGoto action_14 +action_52 (102#) = happyGoto action_15 +action_52 (112#) = happyGoto action_16 +action_52 (113#) = happyGoto action_17 +action_52 (114#) = happyGoto action_18 +action_52 (115#) = happyGoto action_19 +action_52 (123#) = happyGoto action_20 +action_52 x = happyTcHack x happyFail + +action_53 (153#) = happyShift action_125 +action_53 (156#) = happyShift action_126 +action_53 (161#) = happyShift action_127 +action_53 x = happyTcHack x happyReduce_186 + +action_54 (152#) = happyShift action_124 +action_54 x = happyTcHack x happyFail + +action_55 (153#) = happyShift action_123 +action_55 x = happyTcHack x happyReduce_187 + +action_56 x = happyTcHack x happyReduce_224 + +action_57 (146#) = happyShift action_121 +action_57 (153#) = happyShift action_122 +action_57 x = happyTcHack x happyFail + +action_58 (137#) = happyShift action_91 +action_58 (138#) = happyShift action_73 +action_58 (139#) = happyShift action_74 +action_58 (140#) = happyShift action_75 +action_58 (155#) = happyShift action_92 +action_58 (157#) = happyShift action_79 +action_58 (158#) = happyShift action_93 +action_58 (167#) = happyShift action_94 +action_58 (168#) = happyShift action_95 +action_58 (104#) = happyGoto action_85 +action_58 (107#) = happyGoto action_86 +action_58 (109#) = happyGoto action_120 +action_58 (111#) = happyGoto action_88 +action_58 (116#) = happyGoto action_65 +action_58 (117#) = happyGoto action_66 +action_58 (118#) = happyGoto action_89 +action_58 (120#) = happyGoto action_69 +action_58 (122#) = happyGoto action_90 +action_58 x = happyTcHack x happyReduce_150 + +action_59 (146#) = happyShift action_118 +action_59 (153#) = happyShift action_119 +action_59 x = happyTcHack x happyFail + +action_60 (146#) = happyShift action_116 +action_60 (153#) = happyShift action_117 +action_60 x = happyTcHack x happyFail + +action_61 x = happyTcHack x happyReduce_249 + +action_62 x = happyTcHack x happyReduce_250 + +action_63 (133#) = happyShift action_21 +action_63 (134#) = happyShift action_22 +action_63 (135#) = happyShift action_23 +action_63 (136#) = happyShift action_24 +action_63 (141#) = happyShift action_25 +action_63 (142#) = happyShift action_26 +action_63 (143#) = happyShift action_27 +action_63 (144#) = happyShift action_28 +action_63 (145#) = happyShift action_29 +action_63 (151#) = happyShift action_30 +action_63 (154#) = happyShift action_31 +action_63 (160#) = happyShift action_32 +action_63 (165#) = happyShift action_33 +action_63 (167#) = happyShift action_34 +action_63 (169#) = happyShift action_35 +action_63 (170#) = happyShift action_36 +action_63 (175#) = happyShift action_37 +action_63 (177#) = happyShift action_38 +action_63 (178#) = happyShift action_39 +action_63 (185#) = happyShift action_40 +action_63 (192#) = happyShift action_41 +action_63 (69#) = happyGoto action_114 +action_63 (70#) = happyGoto action_5 +action_63 (71#) = happyGoto action_115 +action_63 (72#) = happyGoto action_7 +action_63 (73#) = happyGoto action_8 +action_63 (74#) = happyGoto action_9 +action_63 (77#) = happyGoto action_10 +action_63 (78#) = happyGoto action_11 +action_63 (79#) = happyGoto action_12 +action_63 (98#) = happyGoto action_13 +action_63 (100#) = happyGoto action_14 +action_63 (102#) = happyGoto action_15 +action_63 (112#) = happyGoto action_16 +action_63 (113#) = happyGoto action_17 +action_63 (114#) = happyGoto action_18 +action_63 (115#) = happyGoto action_19 +action_63 (123#) = happyGoto action_20 +action_63 x = happyTcHack x happyFail + +action_64 (146#) = happyShift action_113 +action_64 x = happyTcHack x happyReduce_243 + +action_65 x = happyTcHack x happyReduce_252 + +action_66 x = happyTcHack x happyReduce_262 + +action_67 (146#) = happyShift action_112 +action_67 x = happyTcHack x happyFail + +action_68 x = happyTcHack x happyReduce_239 + +action_69 x = happyTcHack x happyReduce_265 + +action_70 x = happyTcHack x happyReduce_267 + +action_71 (146#) = happyReduce_266 +action_71 x = happyTcHack x happyReduce_268 + +action_72 (146#) = happyReduce_269 +action_72 x = happyTcHack x happyReduce_272 + +action_73 x = happyTcHack x happyReduce_264 + +action_74 x = happyTcHack x happyReduce_274 + +action_75 x = happyTcHack x happyReduce_263 + +action_76 x = happyTcHack x happyReduce_223 + +action_77 x = happyTcHack x happyReduce_183 + +action_78 (133#) = happyShift action_21 +action_78 (134#) = happyShift action_22 +action_78 (135#) = happyShift action_23 +action_78 (136#) = happyShift action_24 +action_78 (169#) = happyShift action_35 +action_78 (177#) = happyShift action_38 +action_78 (192#) = happyShift action_41 +action_78 (112#) = happyGoto action_111 +action_78 (113#) = happyGoto action_17 +action_78 (114#) = happyGoto action_102 +action_78 (115#) = happyGoto action_19 +action_78 x = happyTcHack x happyFail + +action_79 x = happyTcHack x happyReduce_251 + +action_80 (133#) = happyShift action_21 +action_80 (134#) = happyShift action_22 +action_80 (135#) = happyShift action_23 +action_80 (136#) = happyShift action_24 +action_80 (141#) = happyShift action_25 +action_80 (142#) = happyShift action_26 +action_80 (143#) = happyShift action_27 +action_80 (144#) = happyShift action_28 +action_80 (145#) = happyShift action_29 +action_80 (151#) = happyShift action_30 +action_80 (154#) = happyShift action_31 +action_80 (165#) = happyShift action_33 +action_80 (169#) = happyShift action_35 +action_80 (177#) = happyShift action_38 +action_80 (192#) = happyShift action_41 +action_80 (74#) = happyGoto action_50 +action_80 (77#) = happyGoto action_10 +action_80 (78#) = happyGoto action_11 +action_80 (79#) = happyGoto action_12 +action_80 (98#) = happyGoto action_13 +action_80 (100#) = happyGoto action_14 +action_80 (102#) = happyGoto action_15 +action_80 (112#) = happyGoto action_16 +action_80 (113#) = happyGoto action_17 +action_80 (114#) = happyGoto action_18 +action_80 (115#) = happyGoto action_19 +action_80 (123#) = happyGoto action_20 +action_80 x = happyTcHack x happyReduce_270 + +action_81 (146#) = happyReduce_271 +action_81 x = happyTcHack x happyReduce_273 + +action_82 (133#) = happyShift action_21 +action_82 (134#) = happyShift action_22 +action_82 (135#) = happyShift action_23 +action_82 (136#) = happyShift action_24 +action_82 (141#) = happyShift action_25 +action_82 (142#) = happyShift action_26 +action_82 (143#) = happyShift action_27 +action_82 (144#) = happyShift action_28 +action_82 (145#) = happyShift action_29 +action_82 (151#) = happyShift action_30 +action_82 (154#) = happyShift action_31 +action_82 (165#) = happyShift action_33 +action_82 (169#) = happyShift action_35 +action_82 (177#) = happyShift action_38 +action_82 (192#) = happyShift action_41 +action_82 (77#) = happyGoto action_110 +action_82 (78#) = happyGoto action_11 +action_82 (79#) = happyGoto action_12 +action_82 (98#) = happyGoto action_13 +action_82 (100#) = happyGoto action_14 +action_82 (102#) = happyGoto action_15 +action_82 (112#) = happyGoto action_16 +action_82 (113#) = happyGoto action_17 +action_82 (114#) = happyGoto action_18 +action_82 (115#) = happyGoto action_19 +action_82 (123#) = happyGoto action_20 +action_82 x = happyTcHack x happyFail + +action_83 (133#) = happyShift action_21 +action_83 (134#) = happyShift action_22 +action_83 (145#) = happyShift action_108 +action_83 (149#) = happyShift action_109 +action_83 (169#) = happyShift action_35 +action_83 (177#) = happyShift action_38 +action_83 (192#) = happyShift action_41 +action_83 (96#) = happyGoto action_105 +action_83 (97#) = happyGoto action_106 +action_83 (100#) = happyGoto action_107 +action_83 (112#) = happyGoto action_16 +action_83 (113#) = happyGoto action_17 +action_83 x = happyTcHack x happyFail + +action_84 x = happyTcHack x happyReduce_162 + +action_85 x = happyTcHack x happyReduce_247 + +action_86 x = happyTcHack x happyReduce_248 + +action_87 (133#) = happyShift action_21 +action_87 (134#) = happyShift action_22 +action_87 (135#) = happyShift action_23 +action_87 (136#) = happyShift action_24 +action_87 (141#) = happyShift action_25 +action_87 (142#) = happyShift action_26 +action_87 (143#) = happyShift action_27 +action_87 (144#) = happyShift action_28 +action_87 (145#) = happyShift action_29 +action_87 (151#) = happyShift action_30 +action_87 (154#) = happyShift action_31 +action_87 (160#) = happyShift action_32 +action_87 (165#) = happyShift action_33 +action_87 (167#) = happyShift action_34 +action_87 (169#) = happyShift action_35 +action_87 (170#) = happyShift action_36 +action_87 (175#) = happyShift action_37 +action_87 (177#) = happyShift action_38 +action_87 (178#) = happyShift action_39 +action_87 (185#) = happyShift action_40 +action_87 (192#) = happyShift action_41 +action_87 (72#) = happyGoto action_103 +action_87 (73#) = happyGoto action_104 +action_87 (74#) = happyGoto action_9 +action_87 (77#) = happyGoto action_10 +action_87 (78#) = happyGoto action_11 +action_87 (79#) = happyGoto action_12 +action_87 (98#) = happyGoto action_13 +action_87 (100#) = happyGoto action_14 +action_87 (102#) = happyGoto action_15 +action_87 (112#) = happyGoto action_16 +action_87 (113#) = happyGoto action_17 +action_87 (114#) = happyGoto action_18 +action_87 (115#) = happyGoto action_19 +action_87 (123#) = happyGoto action_20 +action_87 x = happyTcHack x happyFail + +action_88 x = happyTcHack x happyReduce_243 + +action_89 x = happyTcHack x happyReduce_237 + +action_90 x = happyTcHack x happyReduce_266 + +action_91 x = happyTcHack x happyReduce_269 + +action_92 (133#) = happyShift action_21 +action_92 (134#) = happyShift action_22 +action_92 (135#) = happyShift action_23 +action_92 (136#) = happyShift action_24 +action_92 (169#) = happyShift action_35 +action_92 (177#) = happyShift action_38 +action_92 (192#) = happyShift action_41 +action_92 (112#) = happyGoto action_101 +action_92 (113#) = happyGoto action_17 +action_92 (114#) = happyGoto action_102 +action_92 (115#) = happyGoto action_19 +action_92 x = happyTcHack x happyFail + +action_93 (124#) = happyGoto action_100 +action_93 x = happyTcHack x happyReduce_279 + +action_94 x = happyTcHack x happyReduce_270 + +action_95 x = happyTcHack x happyReduce_271 + +action_96 (135#) = happyShift action_98 +action_96 (136#) = happyShift action_99 +action_96 (127#) = happyGoto action_97 +action_96 x = happyTcHack x happyFail + +action_97 (145#) = happyShift action_200 +action_97 (9#) = happyGoto action_198 +action_97 (10#) = happyGoto action_199 +action_97 x = happyTcHack x happyFail + +action_98 x = happyTcHack x happyReduce_283 + +action_99 x = happyTcHack x happyReduce_284 + +action_100 (133#) = happyShift action_21 +action_100 (135#) = happyShift action_23 +action_100 (136#) = happyShift action_24 +action_100 (145#) = happyShift action_196 +action_100 (151#) = happyShift action_197 +action_100 (169#) = happyShift action_35 +action_100 (177#) = happyShift action_38 +action_100 (192#) = happyShift action_41 +action_100 (39#) = happyGoto action_187 +action_100 (40#) = happyGoto action_188 +action_100 (41#) = happyGoto action_189 +action_100 (42#) = happyGoto action_190 +action_100 (43#) = happyGoto action_191 +action_100 (44#) = happyGoto action_192 +action_100 (113#) = happyGoto action_193 +action_100 (114#) = happyGoto action_194 +action_100 (115#) = happyGoto action_19 +action_100 (132#) = happyGoto action_195 +action_100 x = happyTcHack x happyFail + +action_101 (155#) = happyShift action_186 +action_101 x = happyTcHack x happyFail + +action_102 (155#) = happyShift action_185 +action_102 x = happyTcHack x happyFail + +action_103 x = happyTcHack x happyReduce_151 + +action_104 x = happyTcHack x happyReduce_153 + +action_105 (149#) = happyShift action_183 +action_105 (153#) = happyShift action_184 +action_105 x = happyTcHack x happyFail + +action_106 x = happyTcHack x happyReduce_221 + +action_107 (159#) = happyShift action_182 +action_107 x = happyTcHack x happyFail + +action_108 (137#) = happyShift action_91 +action_108 (139#) = happyShift action_74 +action_108 (167#) = happyShift action_94 +action_108 (168#) = happyShift action_95 +action_108 (118#) = happyGoto action_67 +action_108 (120#) = happyGoto action_69 +action_108 (122#) = happyGoto action_90 +action_108 x = happyTcHack x happyFail + +action_109 x = happyTcHack x happyReduce_170 + +action_110 x = happyTcHack x happyReduce_167 + +action_111 (155#) = happyShift action_181 +action_111 x = happyTcHack x happyFail + +action_112 x = happyTcHack x happyReduce_230 + +action_113 x = happyTcHack x happyReduce_234 + +action_114 (146#) = happyShift action_180 +action_114 x = happyTcHack x happyFail + +action_115 (137#) = happyShift action_91 +action_115 (138#) = happyShift action_73 +action_115 (139#) = happyShift action_74 +action_115 (140#) = happyShift action_75 +action_115 (155#) = happyShift action_92 +action_115 (157#) = happyShift action_79 +action_115 (167#) = happyShift action_94 +action_115 (168#) = happyShift action_95 +action_115 (104#) = happyGoto action_85 +action_115 (107#) = happyGoto action_86 +action_115 (109#) = happyGoto action_87 +action_115 (111#) = happyGoto action_88 +action_115 (116#) = happyGoto action_65 +action_115 (117#) = happyGoto action_66 +action_115 (118#) = happyGoto action_89 +action_115 (120#) = happyGoto action_69 +action_115 (122#) = happyGoto action_90 +action_115 x = happyTcHack x happyReduce_150 + +action_116 x = happyTcHack x happyReduce_177 + +action_117 (133#) = happyShift action_21 +action_117 (134#) = happyShift action_22 +action_117 (135#) = happyShift action_23 +action_117 (136#) = happyShift action_24 +action_117 (141#) = happyShift action_25 +action_117 (142#) = happyShift action_26 +action_117 (143#) = happyShift action_27 +action_117 (144#) = happyShift action_28 +action_117 (145#) = happyShift action_29 +action_117 (151#) = happyShift action_30 +action_117 (154#) = happyShift action_31 +action_117 (160#) = happyShift action_32 +action_117 (165#) = happyShift action_33 +action_117 (167#) = happyShift action_34 +action_117 (169#) = happyShift action_35 +action_117 (170#) = happyShift action_36 +action_117 (175#) = happyShift action_37 +action_117 (177#) = happyShift action_38 +action_117 (178#) = happyShift action_39 +action_117 (185#) = happyShift action_40 +action_117 (192#) = happyShift action_41 +action_117 (68#) = happyGoto action_179 +action_117 (69#) = happyGoto action_4 +action_117 (70#) = happyGoto action_5 +action_117 (71#) = happyGoto action_6 +action_117 (72#) = happyGoto action_7 +action_117 (73#) = happyGoto action_8 +action_117 (74#) = happyGoto action_9 +action_117 (77#) = happyGoto action_10 +action_117 (78#) = happyGoto action_11 +action_117 (79#) = happyGoto action_12 +action_117 (98#) = happyGoto action_13 +action_117 (100#) = happyGoto action_14 +action_117 (102#) = happyGoto action_15 +action_117 (112#) = happyGoto action_16 +action_117 (113#) = happyGoto action_17 +action_117 (114#) = happyGoto action_18 +action_117 (115#) = happyGoto action_19 +action_117 (123#) = happyGoto action_20 +action_117 x = happyTcHack x happyFail + +action_118 x = happyTcHack x happyReduce_225 + +action_119 x = happyTcHack x happyReduce_182 + +action_120 (133#) = happyShift action_21 +action_120 (134#) = happyShift action_22 +action_120 (135#) = happyShift action_23 +action_120 (136#) = happyShift action_24 +action_120 (141#) = happyShift action_25 +action_120 (142#) = happyShift action_26 +action_120 (143#) = happyShift action_27 +action_120 (144#) = happyShift action_28 +action_120 (145#) = happyShift action_29 +action_120 (146#) = happyShift action_178 +action_120 (151#) = happyShift action_30 +action_120 (154#) = happyShift action_31 +action_120 (160#) = happyShift action_32 +action_120 (165#) = happyShift action_33 +action_120 (167#) = happyShift action_34 +action_120 (169#) = happyShift action_35 +action_120 (170#) = happyShift action_36 +action_120 (175#) = happyShift action_37 +action_120 (177#) = happyShift action_38 +action_120 (178#) = happyShift action_39 +action_120 (185#) = happyShift action_40 +action_120 (192#) = happyShift action_41 +action_120 (72#) = happyGoto action_103 +action_120 (73#) = happyGoto action_104 +action_120 (74#) = happyGoto action_9 +action_120 (77#) = happyGoto action_10 +action_120 (78#) = happyGoto action_11 +action_120 (79#) = happyGoto action_12 +action_120 (98#) = happyGoto action_13 +action_120 (100#) = happyGoto action_14 +action_120 (102#) = happyGoto action_15 +action_120 (112#) = happyGoto action_16 +action_120 (113#) = happyGoto action_17 +action_120 (114#) = happyGoto action_18 +action_120 (115#) = happyGoto action_19 +action_120 (123#) = happyGoto action_20 +action_120 x = happyTcHack x happyFail + +action_121 x = happyTcHack x happyReduce_176 + +action_122 (133#) = happyShift action_21 +action_122 (134#) = happyShift action_22 +action_122 (135#) = happyShift action_23 +action_122 (136#) = happyShift action_24 +action_122 (141#) = happyShift action_25 +action_122 (142#) = happyShift action_26 +action_122 (143#) = happyShift action_27 +action_122 (144#) = happyShift action_28 +action_122 (145#) = happyShift action_29 +action_122 (151#) = happyShift action_30 +action_122 (154#) = happyShift action_31 +action_122 (160#) = happyShift action_32 +action_122 (165#) = happyShift action_33 +action_122 (167#) = happyShift action_34 +action_122 (169#) = happyShift action_35 +action_122 (170#) = happyShift action_36 +action_122 (175#) = happyShift action_37 +action_122 (177#) = happyShift action_38 +action_122 (178#) = happyShift action_39 +action_122 (185#) = happyShift action_40 +action_122 (192#) = happyShift action_41 +action_122 (68#) = happyGoto action_177 +action_122 (69#) = happyGoto action_4 +action_122 (70#) = happyGoto action_5 +action_122 (71#) = happyGoto action_6 +action_122 (72#) = happyGoto action_7 +action_122 (73#) = happyGoto action_8 +action_122 (74#) = happyGoto action_9 +action_122 (77#) = happyGoto action_10 +action_122 (78#) = happyGoto action_11 +action_122 (79#) = happyGoto action_12 +action_122 (98#) = happyGoto action_13 +action_122 (100#) = happyGoto action_14 +action_122 (102#) = happyGoto action_15 +action_122 (112#) = happyGoto action_16 +action_122 (113#) = happyGoto action_17 +action_122 (114#) = happyGoto action_18 +action_122 (115#) = happyGoto action_19 +action_122 (123#) = happyGoto action_20 +action_122 x = happyTcHack x happyFail + +action_123 (133#) = happyShift action_21 +action_123 (134#) = happyShift action_22 +action_123 (135#) = happyShift action_23 +action_123 (136#) = happyShift action_24 +action_123 (141#) = happyShift action_25 +action_123 (142#) = happyShift action_26 +action_123 (143#) = happyShift action_27 +action_123 (144#) = happyShift action_28 +action_123 (145#) = happyShift action_29 +action_123 (151#) = happyShift action_30 +action_123 (154#) = happyShift action_31 +action_123 (160#) = happyShift action_32 +action_123 (165#) = happyShift action_33 +action_123 (167#) = happyShift action_34 +action_123 (169#) = happyShift action_35 +action_123 (170#) = happyShift action_36 +action_123 (175#) = happyShift action_37 +action_123 (177#) = happyShift action_38 +action_123 (178#) = happyShift action_39 +action_123 (185#) = happyShift action_40 +action_123 (192#) = happyShift action_41 +action_123 (68#) = happyGoto action_176 +action_123 (69#) = happyGoto action_4 +action_123 (70#) = happyGoto action_5 +action_123 (71#) = happyGoto action_6 +action_123 (72#) = happyGoto action_7 +action_123 (73#) = happyGoto action_8 +action_123 (74#) = happyGoto action_9 +action_123 (77#) = happyGoto action_10 +action_123 (78#) = happyGoto action_11 +action_123 (79#) = happyGoto action_12 +action_123 (98#) = happyGoto action_13 +action_123 (100#) = happyGoto action_14 +action_123 (102#) = happyGoto action_15 +action_123 (112#) = happyGoto action_16 +action_123 (113#) = happyGoto action_17 +action_123 (114#) = happyGoto action_18 +action_123 (115#) = happyGoto action_19 +action_123 (123#) = happyGoto action_20 +action_123 x = happyTcHack x happyFail + +action_124 x = happyTcHack x happyReduce_178 + +action_125 (133#) = happyShift action_21 +action_125 (134#) = happyShift action_22 +action_125 (135#) = happyShift action_23 +action_125 (136#) = happyShift action_24 +action_125 (141#) = happyShift action_25 +action_125 (142#) = happyShift action_26 +action_125 (143#) = happyShift action_27 +action_125 (144#) = happyShift action_28 +action_125 (145#) = happyShift action_29 +action_125 (151#) = happyShift action_30 +action_125 (154#) = happyShift action_31 +action_125 (160#) = happyShift action_32 +action_125 (165#) = happyShift action_33 +action_125 (167#) = happyShift action_34 +action_125 (169#) = happyShift action_35 +action_125 (170#) = happyShift action_36 +action_125 (175#) = happyShift action_37 +action_125 (177#) = happyShift action_38 +action_125 (178#) = happyShift action_39 +action_125 (185#) = happyShift action_40 +action_125 (192#) = happyShift action_41 +action_125 (68#) = happyGoto action_175 +action_125 (69#) = happyGoto action_4 +action_125 (70#) = happyGoto action_5 +action_125 (71#) = happyGoto action_6 +action_125 (72#) = happyGoto action_7 +action_125 (73#) = happyGoto action_8 +action_125 (74#) = happyGoto action_9 +action_125 (77#) = happyGoto action_10 +action_125 (78#) = happyGoto action_11 +action_125 (79#) = happyGoto action_12 +action_125 (98#) = happyGoto action_13 +action_125 (100#) = happyGoto action_14 +action_125 (102#) = happyGoto action_15 +action_125 (112#) = happyGoto action_16 +action_125 (113#) = happyGoto action_17 +action_125 (114#) = happyGoto action_18 +action_125 (115#) = happyGoto action_19 +action_125 (123#) = happyGoto action_20 +action_125 x = happyTcHack x happyFail + +action_126 (133#) = happyShift action_21 +action_126 (134#) = happyShift action_22 +action_126 (135#) = happyShift action_23 +action_126 (136#) = happyShift action_24 +action_126 (141#) = happyShift action_25 +action_126 (142#) = happyShift action_26 +action_126 (143#) = happyShift action_27 +action_126 (144#) = happyShift action_28 +action_126 (145#) = happyShift action_29 +action_126 (151#) = happyShift action_30 +action_126 (154#) = happyShift action_31 +action_126 (160#) = happyShift action_32 +action_126 (165#) = happyShift action_33 +action_126 (167#) = happyShift action_34 +action_126 (169#) = happyShift action_35 +action_126 (170#) = happyShift action_36 +action_126 (175#) = happyShift action_37 +action_126 (177#) = happyShift action_38 +action_126 (178#) = happyShift action_39 +action_126 (185#) = happyShift action_40 +action_126 (192#) = happyShift action_41 +action_126 (68#) = happyGoto action_174 +action_126 (69#) = happyGoto action_4 +action_126 (70#) = happyGoto action_5 +action_126 (71#) = happyGoto action_6 +action_126 (72#) = happyGoto action_7 +action_126 (73#) = happyGoto action_8 +action_126 (74#) = happyGoto action_9 +action_126 (77#) = happyGoto action_10 +action_126 (78#) = happyGoto action_11 +action_126 (79#) = happyGoto action_12 +action_126 (98#) = happyGoto action_13 +action_126 (100#) = happyGoto action_14 +action_126 (102#) = happyGoto action_15 +action_126 (112#) = happyGoto action_16 +action_126 (113#) = happyGoto action_17 +action_126 (114#) = happyGoto action_18 +action_126 (115#) = happyGoto action_19 +action_126 (123#) = happyGoto action_20 +action_126 x = happyTcHack x happyReduce_188 + +action_127 (133#) = happyShift action_21 +action_127 (134#) = happyShift action_22 +action_127 (135#) = happyShift action_23 +action_127 (136#) = happyShift action_24 +action_127 (141#) = happyShift action_25 +action_127 (142#) = happyShift action_26 +action_127 (143#) = happyShift action_27 +action_127 (144#) = happyShift action_28 +action_127 (145#) = happyShift action_29 +action_127 (151#) = happyShift action_30 +action_127 (154#) = happyShift action_31 +action_127 (160#) = happyShift action_32 +action_127 (165#) = happyShift action_33 +action_127 (167#) = happyShift action_34 +action_127 (169#) = happyShift action_35 +action_127 (170#) = happyShift action_36 +action_127 (175#) = happyShift action_37 +action_127 (177#) = happyShift action_38 +action_127 (178#) = happyShift action_39 +action_127 (185#) = happyShift action_173 +action_127 (192#) = happyShift action_41 +action_127 (68#) = happyGoto action_169 +action_127 (69#) = happyGoto action_4 +action_127 (70#) = happyGoto action_5 +action_127 (71#) = happyGoto action_133 +action_127 (72#) = happyGoto action_7 +action_127 (73#) = happyGoto action_8 +action_127 (74#) = happyGoto action_9 +action_127 (77#) = happyGoto action_10 +action_127 (78#) = happyGoto action_11 +action_127 (79#) = happyGoto action_12 +action_127 (84#) = happyGoto action_170 +action_127 (85#) = happyGoto action_171 +action_127 (93#) = happyGoto action_172 +action_127 (98#) = happyGoto action_13 +action_127 (100#) = happyGoto action_14 +action_127 (102#) = happyGoto action_15 +action_127 (112#) = happyGoto action_16 +action_127 (113#) = happyGoto action_17 +action_127 (114#) = happyGoto action_18 +action_127 (115#) = happyGoto action_19 +action_127 (123#) = happyGoto action_20 +action_127 x = happyTcHack x happyFail + +action_128 (133#) = happyShift action_21 +action_128 (134#) = happyShift action_22 +action_128 (135#) = happyShift action_23 +action_128 (136#) = happyShift action_24 +action_128 (141#) = happyShift action_25 +action_128 (142#) = happyShift action_26 +action_128 (143#) = happyShift action_27 +action_128 (144#) = happyShift action_28 +action_128 (145#) = happyShift action_29 +action_128 (151#) = happyShift action_30 +action_128 (154#) = happyShift action_31 +action_128 (163#) = happyShift action_168 +action_128 (165#) = happyShift action_33 +action_128 (169#) = happyShift action_35 +action_128 (177#) = happyShift action_38 +action_128 (192#) = happyShift action_41 +action_128 (76#) = happyGoto action_167 +action_128 (77#) = happyGoto action_130 +action_128 (78#) = happyGoto action_11 +action_128 (79#) = happyGoto action_12 +action_128 (98#) = happyGoto action_13 +action_128 (100#) = happyGoto action_14 +action_128 (102#) = happyGoto action_15 +action_128 (112#) = happyGoto action_16 +action_128 (113#) = happyGoto action_17 +action_128 (114#) = happyGoto action_18 +action_128 (115#) = happyGoto action_19 +action_128 (123#) = happyGoto action_20 +action_128 x = happyTcHack x happyFail + +action_129 x = happyTcHack x happyReduce_165 + +action_130 x = happyTcHack x happyReduce_166 + +action_131 (148#) = happyShift action_166 +action_131 (86#) = happyGoto action_164 +action_131 (125#) = happyGoto action_165 +action_131 x = happyTcHack x happyReduce_280 + +action_132 (147#) = happyShift action_163 +action_132 x = happyTcHack x happyReduce_219 + +action_133 (137#) = happyShift action_91 +action_133 (138#) = happyShift action_73 +action_133 (139#) = happyShift action_74 +action_133 (140#) = happyShift action_75 +action_133 (155#) = happyShift action_92 +action_133 (157#) = happyShift action_79 +action_133 (158#) = happyShift action_93 +action_133 (162#) = happyReduce_211 +action_133 (167#) = happyShift action_94 +action_133 (168#) = happyShift action_95 +action_133 (104#) = happyGoto action_85 +action_133 (107#) = happyGoto action_86 +action_133 (109#) = happyGoto action_87 +action_133 (111#) = happyGoto action_88 +action_133 (116#) = happyGoto action_65 +action_133 (117#) = happyGoto action_66 +action_133 (118#) = happyGoto action_89 +action_133 (120#) = happyGoto action_69 +action_133 (122#) = happyGoto action_90 +action_133 x = happyTcHack x happyReduce_150 + +action_134 (124#) = happyGoto action_162 +action_134 x = happyTcHack x happyReduce_279 + +action_135 (149#) = happyShift action_161 +action_135 x = happyTcHack x happyFail + +action_136 (133#) = happyShift action_21 +action_136 (134#) = happyShift action_22 +action_136 (135#) = happyShift action_23 +action_136 (136#) = happyShift action_24 +action_136 (141#) = happyShift action_25 +action_136 (142#) = happyShift action_26 +action_136 (143#) = happyShift action_27 +action_136 (144#) = happyShift action_28 +action_136 (145#) = happyShift action_29 +action_136 (147#) = happyShift action_136 +action_136 (151#) = happyShift action_30 +action_136 (154#) = happyShift action_31 +action_136 (160#) = happyShift action_32 +action_136 (165#) = happyShift action_33 +action_136 (167#) = happyShift action_34 +action_136 (169#) = happyShift action_35 +action_136 (170#) = happyShift action_36 +action_136 (175#) = happyShift action_37 +action_136 (177#) = happyShift action_38 +action_136 (178#) = happyShift action_39 +action_136 (185#) = happyShift action_137 +action_136 (192#) = happyShift action_41 +action_136 (68#) = happyGoto action_132 +action_136 (69#) = happyGoto action_4 +action_136 (70#) = happyGoto action_5 +action_136 (71#) = happyGoto action_133 +action_136 (72#) = happyGoto action_7 +action_136 (73#) = happyGoto action_8 +action_136 (74#) = happyGoto action_9 +action_136 (77#) = happyGoto action_10 +action_136 (78#) = happyGoto action_11 +action_136 (79#) = happyGoto action_12 +action_136 (93#) = happyGoto action_134 +action_136 (95#) = happyGoto action_160 +action_136 (98#) = happyGoto action_13 +action_136 (100#) = happyGoto action_14 +action_136 (102#) = happyGoto action_15 +action_136 (112#) = happyGoto action_16 +action_136 (113#) = happyGoto action_17 +action_136 (114#) = happyGoto action_18 +action_136 (115#) = happyGoto action_19 +action_136 (123#) = happyGoto action_20 +action_136 x = happyTcHack x happyFail + +action_137 (148#) = happyShift action_44 +action_137 (36#) = happyGoto action_159 +action_137 (125#) = happyGoto action_43 +action_137 x = happyTcHack x happyReduce_280 + +action_138 (1#) = happyShift action_147 +action_138 (150#) = happyShift action_148 +action_138 (126#) = happyGoto action_158 +action_138 x = happyTcHack x happyFail + +action_139 (133#) = happyShift action_21 +action_139 (134#) = happyShift action_22 +action_139 (135#) = happyShift action_23 +action_139 (136#) = happyShift action_24 +action_139 (141#) = happyShift action_25 +action_139 (142#) = happyShift action_26 +action_139 (143#) = happyShift action_27 +action_139 (144#) = happyShift action_28 +action_139 (145#) = happyShift action_29 +action_139 (151#) = happyShift action_30 +action_139 (154#) = happyShift action_31 +action_139 (160#) = happyShift action_32 +action_139 (165#) = happyShift action_33 +action_139 (167#) = happyShift action_34 +action_139 (169#) = happyShift action_35 +action_139 (170#) = happyShift action_36 +action_139 (175#) = happyShift action_37 +action_139 (177#) = happyShift action_38 +action_139 (178#) = happyShift action_39 +action_139 (185#) = happyShift action_40 +action_139 (192#) = happyShift action_41 +action_139 (68#) = happyGoto action_157 +action_139 (69#) = happyGoto action_4 +action_139 (70#) = happyGoto action_5 +action_139 (71#) = happyGoto action_6 +action_139 (72#) = happyGoto action_7 +action_139 (73#) = happyGoto action_8 +action_139 (74#) = happyGoto action_9 +action_139 (77#) = happyGoto action_10 +action_139 (78#) = happyGoto action_11 +action_139 (79#) = happyGoto action_12 +action_139 (98#) = happyGoto action_13 +action_139 (100#) = happyGoto action_14 +action_139 (102#) = happyGoto action_15 +action_139 (112#) = happyGoto action_16 +action_139 (113#) = happyGoto action_17 +action_139 (114#) = happyGoto action_18 +action_139 (115#) = happyGoto action_19 +action_139 (123#) = happyGoto action_20 +action_139 x = happyTcHack x happyFail + +action_140 x = happyTcHack x happyReduce_10 + +action_141 (133#) = happyReduce_279 +action_141 (134#) = happyReduce_279 +action_141 (135#) = happyReduce_279 +action_141 (136#) = happyReduce_279 +action_141 (141#) = happyReduce_279 +action_141 (142#) = happyReduce_279 +action_141 (143#) = happyReduce_279 +action_141 (144#) = happyReduce_279 +action_141 (145#) = happyReduce_279 +action_141 (147#) = happyShift action_156 +action_141 (151#) = happyReduce_279 +action_141 (154#) = happyReduce_279 +action_141 (165#) = happyReduce_279 +action_141 (167#) = happyReduce_279 +action_141 (169#) = happyReduce_279 +action_141 (170#) = happyReduce_279 +action_141 (175#) = happyReduce_279 +action_141 (177#) = happyReduce_279 +action_141 (181#) = happyReduce_279 +action_141 (182#) = happyReduce_279 +action_141 (183#) = happyReduce_279 +action_141 (192#) = happyReduce_279 +action_141 (25#) = happyGoto action_150 +action_141 (34#) = happyGoto action_151 +action_141 (35#) = happyGoto action_152 +action_141 (37#) = happyGoto action_153 +action_141 (63#) = happyGoto action_154 +action_141 (124#) = happyGoto action_155 +action_141 x = happyTcHack x happyReduce_72 + +action_142 (149#) = happyShift action_149 +action_142 x = happyTcHack x happyFail + +action_143 (1#) = happyShift action_147 +action_143 (150#) = happyShift action_148 +action_143 (126#) = happyGoto action_146 +action_143 x = happyTcHack x happyFail + +action_144 (133#) = happyShift action_21 +action_144 (134#) = happyShift action_22 +action_144 (135#) = happyShift action_23 +action_144 (136#) = happyShift action_24 +action_144 (141#) = happyShift action_25 +action_144 (142#) = happyShift action_26 +action_144 (143#) = happyShift action_27 +action_144 (144#) = happyShift action_28 +action_144 (145#) = happyShift action_29 +action_144 (151#) = happyShift action_30 +action_144 (154#) = happyShift action_31 +action_144 (160#) = happyShift action_32 +action_144 (165#) = happyShift action_33 +action_144 (167#) = happyShift action_34 +action_144 (169#) = happyShift action_35 +action_144 (170#) = happyShift action_36 +action_144 (175#) = happyShift action_37 +action_144 (177#) = happyShift action_38 +action_144 (178#) = happyShift action_39 +action_144 (185#) = happyShift action_40 +action_144 (192#) = happyShift action_41 +action_144 (68#) = happyGoto action_145 +action_144 (69#) = happyGoto action_4 +action_144 (70#) = happyGoto action_5 +action_144 (71#) = happyGoto action_6 +action_144 (72#) = happyGoto action_7 +action_144 (73#) = happyGoto action_8 +action_144 (74#) = happyGoto action_9 +action_144 (77#) = happyGoto action_10 +action_144 (78#) = happyGoto action_11 +action_144 (79#) = happyGoto action_12 +action_144 (98#) = happyGoto action_13 +action_144 (100#) = happyGoto action_14 +action_144 (102#) = happyGoto action_15 +action_144 (112#) = happyGoto action_16 +action_144 (113#) = happyGoto action_17 +action_144 (114#) = happyGoto action_18 +action_144 (115#) = happyGoto action_19 +action_144 (123#) = happyGoto action_20 +action_144 x = happyTcHack x happyFail + +action_145 x = happyTcHack x happyReduce_156 + +action_146 x = happyTcHack x happyReduce_79 + +action_147 x = happyTcHack x happyReduce_282 + +action_148 x = happyTcHack x happyReduce_281 + +action_149 x = happyTcHack x happyReduce_78 + +action_150 x = happyTcHack x happyReduce_76 + +action_151 (7#) = happyGoto action_242 +action_151 (8#) = happyGoto action_243 +action_151 x = happyTcHack x happyReduce_11 + +action_152 x = happyTcHack x happyReduce_74 + +action_153 x = happyTcHack x happyReduce_75 + +action_154 x = happyTcHack x happyReduce_77 + +action_155 (133#) = happyShift action_21 +action_155 (134#) = happyShift action_22 +action_155 (135#) = happyShift action_23 +action_155 (136#) = happyShift action_24 +action_155 (141#) = happyShift action_25 +action_155 (142#) = happyShift action_26 +action_155 (143#) = happyShift action_27 +action_155 (144#) = happyShift action_28 +action_155 (145#) = happyShift action_29 +action_155 (151#) = happyShift action_30 +action_155 (154#) = happyShift action_31 +action_155 (165#) = happyShift action_33 +action_155 (167#) = happyShift action_34 +action_155 (169#) = happyShift action_35 +action_155 (170#) = happyShift action_36 +action_155 (175#) = happyShift action_37 +action_155 (177#) = happyShift action_38 +action_155 (181#) = happyShift action_239 +action_155 (182#) = happyShift action_240 +action_155 (183#) = happyShift action_241 +action_155 (192#) = happyShift action_41 +action_155 (27#) = happyGoto action_235 +action_155 (38#) = happyGoto action_236 +action_155 (71#) = happyGoto action_237 +action_155 (73#) = happyGoto action_8 +action_155 (74#) = happyGoto action_9 +action_155 (77#) = happyGoto action_10 +action_155 (78#) = happyGoto action_11 +action_155 (79#) = happyGoto action_12 +action_155 (98#) = happyGoto action_13 +action_155 (100#) = happyGoto action_238 +action_155 (102#) = happyGoto action_15 +action_155 (112#) = happyGoto action_16 +action_155 (113#) = happyGoto action_17 +action_155 (114#) = happyGoto action_18 +action_155 (115#) = happyGoto action_19 +action_155 (123#) = happyGoto action_20 +action_155 x = happyTcHack x happyFail + +action_156 x = happyTcHack x happyReduce_9 + +action_157 (176#) = happyShift action_234 +action_157 x = happyTcHack x happyFail + +action_158 x = happyTcHack x happyReduce_213 + +action_159 (147#) = happyShift action_233 +action_159 (180#) = happyShift action_144 +action_159 x = happyTcHack x happyFail + +action_160 x = happyTcHack x happyReduce_217 + +action_161 x = happyTcHack x happyReduce_212 + +action_162 (162#) = happyShift action_232 +action_162 x = happyTcHack x happyFail + +action_163 (133#) = happyShift action_21 +action_163 (134#) = happyShift action_22 +action_163 (135#) = happyShift action_23 +action_163 (136#) = happyShift action_24 +action_163 (141#) = happyShift action_25 +action_163 (142#) = happyShift action_26 +action_163 (143#) = happyShift action_27 +action_163 (144#) = happyShift action_28 +action_163 (145#) = happyShift action_29 +action_163 (147#) = happyShift action_136 +action_163 (151#) = happyShift action_30 +action_163 (154#) = happyShift action_31 +action_163 (160#) = happyShift action_32 +action_163 (165#) = happyShift action_33 +action_163 (167#) = happyShift action_34 +action_163 (169#) = happyShift action_35 +action_163 (170#) = happyShift action_36 +action_163 (175#) = happyShift action_37 +action_163 (177#) = happyShift action_38 +action_163 (178#) = happyShift action_39 +action_163 (185#) = happyShift action_137 +action_163 (192#) = happyShift action_41 +action_163 (68#) = happyGoto action_132 +action_163 (69#) = happyGoto action_4 +action_163 (70#) = happyGoto action_5 +action_163 (71#) = happyGoto action_133 +action_163 (72#) = happyGoto action_7 +action_163 (73#) = happyGoto action_8 +action_163 (74#) = happyGoto action_9 +action_163 (77#) = happyGoto action_10 +action_163 (78#) = happyGoto action_11 +action_163 (79#) = happyGoto action_12 +action_163 (93#) = happyGoto action_134 +action_163 (95#) = happyGoto action_231 +action_163 (98#) = happyGoto action_13 +action_163 (100#) = happyGoto action_14 +action_163 (102#) = happyGoto action_15 +action_163 (112#) = happyGoto action_16 +action_163 (113#) = happyGoto action_17 +action_163 (114#) = happyGoto action_18 +action_163 (115#) = happyGoto action_19 +action_163 (123#) = happyGoto action_20 +action_163 x = happyTcHack x happyReduce_218 + +action_164 x = happyTcHack x happyReduce_158 + +action_165 (7#) = happyGoto action_140 +action_165 (8#) = happyGoto action_228 +action_165 (87#) = happyGoto action_230 +action_165 x = happyTcHack x happyReduce_11 + +action_166 (7#) = happyGoto action_140 +action_166 (8#) = happyGoto action_228 +action_166 (87#) = happyGoto action_229 +action_166 x = happyTcHack x happyReduce_11 + +action_167 x = happyTcHack x happyReduce_164 + +action_168 (133#) = happyShift action_21 +action_168 (134#) = happyShift action_22 +action_168 (135#) = happyShift action_23 +action_168 (136#) = happyShift action_24 +action_168 (141#) = happyShift action_25 +action_168 (142#) = happyShift action_26 +action_168 (143#) = happyShift action_27 +action_168 (144#) = happyShift action_28 +action_168 (145#) = happyShift action_29 +action_168 (151#) = happyShift action_30 +action_168 (154#) = happyShift action_31 +action_168 (160#) = happyShift action_32 +action_168 (165#) = happyShift action_33 +action_168 (167#) = happyShift action_34 +action_168 (169#) = happyShift action_35 +action_168 (170#) = happyShift action_36 +action_168 (175#) = happyShift action_37 +action_168 (177#) = happyShift action_38 +action_168 (178#) = happyShift action_39 +action_168 (185#) = happyShift action_40 +action_168 (192#) = happyShift action_41 +action_168 (68#) = happyGoto action_227 +action_168 (69#) = happyGoto action_4 +action_168 (70#) = happyGoto action_5 +action_168 (71#) = happyGoto action_6 +action_168 (72#) = happyGoto action_7 +action_168 (73#) = happyGoto action_8 +action_168 (74#) = happyGoto action_9 +action_168 (77#) = happyGoto action_10 +action_168 (78#) = happyGoto action_11 +action_168 (79#) = happyGoto action_12 +action_168 (98#) = happyGoto action_13 +action_168 (100#) = happyGoto action_14 +action_168 (102#) = happyGoto action_15 +action_168 (112#) = happyGoto action_16 +action_168 (113#) = happyGoto action_17 +action_168 (114#) = happyGoto action_18 +action_168 (115#) = happyGoto action_19 +action_168 (123#) = happyGoto action_20 +action_168 x = happyTcHack x happyFail + +action_169 x = happyTcHack x happyReduce_198 + +action_170 (153#) = happyShift action_226 +action_170 x = happyTcHack x happyReduce_192 + +action_171 x = happyTcHack x happyReduce_196 + +action_172 (124#) = happyGoto action_225 +action_172 x = happyTcHack x happyReduce_279 + +action_173 (148#) = happyShift action_44 +action_173 (36#) = happyGoto action_224 +action_173 (125#) = happyGoto action_43 +action_173 x = happyTcHack x happyReduce_280 + +action_174 x = happyTcHack x happyReduce_190 + +action_175 (156#) = happyShift action_223 +action_175 x = happyTcHack x happyReduce_194 + +action_176 x = happyTcHack x happyReduce_193 + +action_177 x = happyTcHack x happyReduce_185 + +action_178 x = happyTcHack x happyReduce_179 + +action_179 x = happyTcHack x happyReduce_184 + +action_180 x = happyTcHack x happyReduce_180 + +action_181 x = happyTcHack x happyReduce_240 + +action_182 (133#) = happyShift action_21 +action_182 (134#) = happyShift action_22 +action_182 (135#) = happyShift action_23 +action_182 (136#) = happyShift action_24 +action_182 (141#) = happyShift action_25 +action_182 (142#) = happyShift action_26 +action_182 (143#) = happyShift action_27 +action_182 (144#) = happyShift action_28 +action_182 (145#) = happyShift action_29 +action_182 (151#) = happyShift action_30 +action_182 (154#) = happyShift action_31 +action_182 (160#) = happyShift action_32 +action_182 (165#) = happyShift action_33 +action_182 (167#) = happyShift action_34 +action_182 (169#) = happyShift action_35 +action_182 (170#) = happyShift action_36 +action_182 (175#) = happyShift action_37 +action_182 (177#) = happyShift action_38 +action_182 (178#) = happyShift action_39 +action_182 (185#) = happyShift action_40 +action_182 (192#) = happyShift action_41 +action_182 (68#) = happyGoto action_222 +action_182 (69#) = happyGoto action_4 +action_182 (70#) = happyGoto action_5 +action_182 (71#) = happyGoto action_6 +action_182 (72#) = happyGoto action_7 +action_182 (73#) = happyGoto action_8 +action_182 (74#) = happyGoto action_9 +action_182 (77#) = happyGoto action_10 +action_182 (78#) = happyGoto action_11 +action_182 (79#) = happyGoto action_12 +action_182 (98#) = happyGoto action_13 +action_182 (100#) = happyGoto action_14 +action_182 (102#) = happyGoto action_15 +action_182 (112#) = happyGoto action_16 +action_182 (113#) = happyGoto action_17 +action_182 (114#) = happyGoto action_18 +action_182 (115#) = happyGoto action_19 +action_182 (123#) = happyGoto action_20 +action_182 x = happyTcHack x happyFail + +action_183 x = happyTcHack x happyReduce_171 + +action_184 (133#) = happyShift action_21 +action_184 (134#) = happyShift action_22 +action_184 (145#) = happyShift action_108 +action_184 (169#) = happyShift action_35 +action_184 (177#) = happyShift action_38 +action_184 (192#) = happyShift action_41 +action_184 (97#) = happyGoto action_221 +action_184 (100#) = happyGoto action_107 +action_184 (112#) = happyGoto action_16 +action_184 (113#) = happyGoto action_17 +action_184 x = happyTcHack x happyFail + +action_185 x = happyTcHack x happyReduce_244 + +action_186 x = happyTcHack x happyReduce_238 + +action_187 x = happyTcHack x happyReduce_98 + +action_188 (133#) = happyShift action_21 +action_188 (135#) = happyShift action_23 +action_188 (136#) = happyShift action_24 +action_188 (145#) = happyShift action_196 +action_188 (151#) = happyShift action_197 +action_188 (163#) = happyShift action_220 +action_188 (166#) = happyReduce_99 +action_188 (169#) = happyShift action_35 +action_188 (177#) = happyShift action_38 +action_188 (192#) = happyShift action_41 +action_188 (41#) = happyGoto action_219 +action_188 (42#) = happyGoto action_190 +action_188 (113#) = happyGoto action_193 +action_188 (114#) = happyGoto action_194 +action_188 (115#) = happyGoto action_19 +action_188 (132#) = happyGoto action_195 +action_188 x = happyTcHack x happyReduce_84 + +action_189 x = happyTcHack x happyReduce_86 + +action_190 x = happyTcHack x happyReduce_87 + +action_191 x = happyTcHack x happyReduce_147 + +action_192 (166#) = happyShift action_218 +action_192 x = happyTcHack x happyFail + +action_193 x = happyTcHack x happyReduce_289 + +action_194 x = happyTcHack x happyReduce_92 + +action_195 x = happyTcHack x happyReduce_88 + +action_196 (133#) = happyShift action_21 +action_196 (135#) = happyShift action_23 +action_196 (136#) = happyShift action_24 +action_196 (145#) = happyShift action_196 +action_196 (146#) = happyShift action_216 +action_196 (151#) = happyShift action_197 +action_196 (153#) = happyShift action_77 +action_196 (163#) = happyShift action_217 +action_196 (169#) = happyShift action_35 +action_196 (177#) = happyShift action_38 +action_196 (192#) = happyShift action_41 +action_196 (39#) = happyGoto action_213 +action_196 (40#) = happyGoto action_211 +action_196 (41#) = happyGoto action_189 +action_196 (42#) = happyGoto action_190 +action_196 (45#) = happyGoto action_214 +action_196 (80#) = happyGoto action_215 +action_196 (113#) = happyGoto action_193 +action_196 (114#) = happyGoto action_194 +action_196 (115#) = happyGoto action_19 +action_196 (132#) = happyGoto action_195 +action_196 x = happyTcHack x happyFail + +action_197 (133#) = happyShift action_21 +action_197 (135#) = happyShift action_23 +action_197 (136#) = happyShift action_24 +action_197 (145#) = happyShift action_196 +action_197 (151#) = happyShift action_197 +action_197 (152#) = happyShift action_212 +action_197 (169#) = happyShift action_35 +action_197 (177#) = happyShift action_38 +action_197 (192#) = happyShift action_41 +action_197 (39#) = happyGoto action_210 +action_197 (40#) = happyGoto action_211 +action_197 (41#) = happyGoto action_189 +action_197 (42#) = happyGoto action_190 +action_197 (113#) = happyGoto action_193 +action_197 (114#) = happyGoto action_194 +action_197 (115#) = happyGoto action_19 +action_197 (132#) = happyGoto action_195 +action_197 x = happyTcHack x happyFail + +action_198 (191#) = happyShift action_209 +action_198 x = happyTcHack x happyFail + +action_199 x = happyTcHack x happyReduce_12 + +action_200 (133#) = happyShift action_21 +action_200 (134#) = happyShift action_22 +action_200 (135#) = happyShift action_23 +action_200 (136#) = happyShift action_24 +action_200 (145#) = happyShift action_108 +action_200 (153#) = happyShift action_207 +action_200 (169#) = happyShift action_35 +action_200 (177#) = happyShift action_38 +action_200 (186#) = happyShift action_208 +action_200 (192#) = happyShift action_41 +action_200 (11#) = happyGoto action_201 +action_200 (12#) = happyGoto action_202 +action_200 (13#) = happyGoto action_203 +action_200 (100#) = happyGoto action_204 +action_200 (112#) = happyGoto action_16 +action_200 (113#) = happyGoto action_17 +action_200 (114#) = happyGoto action_205 +action_200 (115#) = happyGoto action_19 +action_200 (130#) = happyGoto action_206 +action_200 x = happyTcHack x happyReduce_17 + +action_201 (146#) = happyShift action_282 +action_201 x = happyTcHack x happyFail + +action_202 (153#) = happyShift action_281 +action_202 (11#) = happyGoto action_280 +action_202 x = happyTcHack x happyReduce_17 + +action_203 x = happyTcHack x happyReduce_19 + +action_204 x = happyTcHack x happyReduce_20 + +action_205 x = happyTcHack x happyReduce_287 + +action_206 (145#) = happyShift action_279 +action_206 x = happyTcHack x happyReduce_21 + +action_207 x = happyTcHack x happyReduce_16 + +action_208 (135#) = happyShift action_98 +action_208 (136#) = happyShift action_99 +action_208 (127#) = happyGoto action_278 +action_208 x = happyTcHack x happyFail + +action_209 (148#) = happyShift action_277 +action_209 (5#) = happyGoto action_275 +action_209 (125#) = happyGoto action_276 +action_209 x = happyTcHack x happyFail + +action_210 (152#) = happyShift action_274 +action_210 x = happyTcHack x happyFail + +action_211 (133#) = happyShift action_21 +action_211 (135#) = happyShift action_23 +action_211 (136#) = happyShift action_24 +action_211 (145#) = happyShift action_196 +action_211 (151#) = happyShift action_197 +action_211 (163#) = happyShift action_220 +action_211 (169#) = happyShift action_35 +action_211 (177#) = happyShift action_38 +action_211 (192#) = happyShift action_41 +action_211 (41#) = happyGoto action_219 +action_211 (42#) = happyGoto action_190 +action_211 (113#) = happyGoto action_193 +action_211 (114#) = happyGoto action_194 +action_211 (115#) = happyGoto action_19 +action_211 (132#) = happyGoto action_195 +action_211 x = happyTcHack x happyReduce_84 + +action_212 x = happyTcHack x happyReduce_95 + +action_213 (146#) = happyShift action_272 +action_213 (153#) = happyShift action_273 +action_213 x = happyTcHack x happyFail + +action_214 (146#) = happyShift action_270 +action_214 (153#) = happyShift action_271 +action_214 x = happyTcHack x happyFail + +action_215 (146#) = happyShift action_269 +action_215 (153#) = happyShift action_119 +action_215 x = happyTcHack x happyFail + +action_216 x = happyTcHack x happyReduce_93 + +action_217 (146#) = happyShift action_268 +action_217 x = happyTcHack x happyFail + +action_218 (133#) = happyShift action_21 +action_218 (135#) = happyShift action_23 +action_218 (136#) = happyShift action_24 +action_218 (145#) = happyShift action_196 +action_218 (151#) = happyShift action_197 +action_218 (169#) = happyShift action_35 +action_218 (177#) = happyShift action_38 +action_218 (192#) = happyShift action_41 +action_218 (39#) = happyGoto action_267 +action_218 (40#) = happyGoto action_211 +action_218 (41#) = happyGoto action_189 +action_218 (42#) = happyGoto action_190 +action_218 (113#) = happyGoto action_193 +action_218 (114#) = happyGoto action_194 +action_218 (115#) = happyGoto action_19 +action_218 (132#) = happyGoto action_195 +action_218 x = happyTcHack x happyFail + +action_219 x = happyTcHack x happyReduce_85 + +action_220 (133#) = happyShift action_21 +action_220 (135#) = happyShift action_23 +action_220 (136#) = happyShift action_24 +action_220 (145#) = happyShift action_196 +action_220 (151#) = happyShift action_197 +action_220 (169#) = happyShift action_35 +action_220 (177#) = happyShift action_38 +action_220 (192#) = happyShift action_41 +action_220 (39#) = happyGoto action_266 +action_220 (40#) = happyGoto action_211 +action_220 (41#) = happyGoto action_189 +action_220 (42#) = happyGoto action_190 +action_220 (113#) = happyGoto action_193 +action_220 (114#) = happyGoto action_194 +action_220 (115#) = happyGoto action_19 +action_220 (132#) = happyGoto action_195 +action_220 x = happyTcHack x happyFail + +action_221 x = happyTcHack x happyReduce_220 + +action_222 x = happyTcHack x happyReduce_222 + +action_223 (133#) = happyShift action_21 +action_223 (134#) = happyShift action_22 +action_223 (135#) = happyShift action_23 +action_223 (136#) = happyShift action_24 +action_223 (141#) = happyShift action_25 +action_223 (142#) = happyShift action_26 +action_223 (143#) = happyShift action_27 +action_223 (144#) = happyShift action_28 +action_223 (145#) = happyShift action_29 +action_223 (151#) = happyShift action_30 +action_223 (154#) = happyShift action_31 +action_223 (160#) = happyShift action_32 +action_223 (165#) = happyShift action_33 +action_223 (167#) = happyShift action_34 +action_223 (169#) = happyShift action_35 +action_223 (170#) = happyShift action_36 +action_223 (175#) = happyShift action_37 +action_223 (177#) = happyShift action_38 +action_223 (178#) = happyShift action_39 +action_223 (185#) = happyShift action_40 +action_223 (192#) = happyShift action_41 +action_223 (68#) = happyGoto action_265 +action_223 (69#) = happyGoto action_4 +action_223 (70#) = happyGoto action_5 +action_223 (71#) = happyGoto action_6 +action_223 (72#) = happyGoto action_7 +action_223 (73#) = happyGoto action_8 +action_223 (74#) = happyGoto action_9 +action_223 (77#) = happyGoto action_10 +action_223 (78#) = happyGoto action_11 +action_223 (79#) = happyGoto action_12 +action_223 (98#) = happyGoto action_13 +action_223 (100#) = happyGoto action_14 +action_223 (102#) = happyGoto action_15 +action_223 (112#) = happyGoto action_16 +action_223 (113#) = happyGoto action_17 +action_223 (114#) = happyGoto action_18 +action_223 (115#) = happyGoto action_19 +action_223 (123#) = happyGoto action_20 +action_223 x = happyTcHack x happyReduce_189 + +action_224 (180#) = happyShift action_144 +action_224 x = happyTcHack x happyReduce_199 + +action_225 (162#) = happyShift action_264 +action_225 x = happyTcHack x happyFail + +action_226 (133#) = happyShift action_21 +action_226 (134#) = happyShift action_22 +action_226 (135#) = happyShift action_23 +action_226 (136#) = happyShift action_24 +action_226 (141#) = happyShift action_25 +action_226 (142#) = happyShift action_26 +action_226 (143#) = happyShift action_27 +action_226 (144#) = happyShift action_28 +action_226 (145#) = happyShift action_29 +action_226 (151#) = happyShift action_30 +action_226 (154#) = happyShift action_31 +action_226 (160#) = happyShift action_32 +action_226 (165#) = happyShift action_33 +action_226 (167#) = happyShift action_34 +action_226 (169#) = happyShift action_35 +action_226 (170#) = happyShift action_36 +action_226 (175#) = happyShift action_37 +action_226 (177#) = happyShift action_38 +action_226 (178#) = happyShift action_39 +action_226 (185#) = happyShift action_173 +action_226 (192#) = happyShift action_41 +action_226 (68#) = happyGoto action_169 +action_226 (69#) = happyGoto action_4 +action_226 (70#) = happyGoto action_5 +action_226 (71#) = happyGoto action_133 +action_226 (72#) = happyGoto action_7 +action_226 (73#) = happyGoto action_8 +action_226 (74#) = happyGoto action_9 +action_226 (77#) = happyGoto action_10 +action_226 (78#) = happyGoto action_11 +action_226 (79#) = happyGoto action_12 +action_226 (85#) = happyGoto action_263 +action_226 (93#) = happyGoto action_172 +action_226 (98#) = happyGoto action_13 +action_226 (100#) = happyGoto action_14 +action_226 (102#) = happyGoto action_15 +action_226 (112#) = happyGoto action_16 +action_226 (113#) = happyGoto action_17 +action_226 (114#) = happyGoto action_18 +action_226 (115#) = happyGoto action_19 +action_226 (123#) = happyGoto action_20 +action_226 x = happyTcHack x happyFail + +action_227 x = happyTcHack x happyReduce_155 + +action_228 (147#) = happyShift action_156 +action_228 (88#) = happyGoto action_260 +action_228 (89#) = happyGoto action_261 +action_228 (124#) = happyGoto action_262 +action_228 x = happyTcHack x happyReduce_279 + +action_229 (149#) = happyShift action_259 +action_229 x = happyTcHack x happyFail + +action_230 (1#) = happyShift action_147 +action_230 (150#) = happyShift action_148 +action_230 (126#) = happyGoto action_258 +action_230 x = happyTcHack x happyFail + +action_231 x = happyTcHack x happyReduce_216 + +action_232 (133#) = happyShift action_21 +action_232 (134#) = happyShift action_22 +action_232 (135#) = happyShift action_23 +action_232 (136#) = happyShift action_24 +action_232 (141#) = happyShift action_25 +action_232 (142#) = happyShift action_26 +action_232 (143#) = happyShift action_27 +action_232 (144#) = happyShift action_28 +action_232 (145#) = happyShift action_29 +action_232 (151#) = happyShift action_30 +action_232 (154#) = happyShift action_31 +action_232 (160#) = happyShift action_32 +action_232 (165#) = happyShift action_33 +action_232 (167#) = happyShift action_34 +action_232 (169#) = happyShift action_35 +action_232 (170#) = happyShift action_36 +action_232 (175#) = happyShift action_37 +action_232 (177#) = happyShift action_38 +action_232 (178#) = happyShift action_39 +action_232 (185#) = happyShift action_40 +action_232 (192#) = happyShift action_41 +action_232 (68#) = happyGoto action_257 +action_232 (69#) = happyGoto action_4 +action_232 (70#) = happyGoto action_5 +action_232 (71#) = happyGoto action_6 +action_232 (72#) = happyGoto action_7 +action_232 (73#) = happyGoto action_8 +action_232 (74#) = happyGoto action_9 +action_232 (77#) = happyGoto action_10 +action_232 (78#) = happyGoto action_11 +action_232 (79#) = happyGoto action_12 +action_232 (98#) = happyGoto action_13 +action_232 (100#) = happyGoto action_14 +action_232 (102#) = happyGoto action_15 +action_232 (112#) = happyGoto action_16 +action_232 (113#) = happyGoto action_17 +action_232 (114#) = happyGoto action_18 +action_232 (115#) = happyGoto action_19 +action_232 (123#) = happyGoto action_20 +action_232 x = happyTcHack x happyFail + +action_233 (133#) = happyShift action_21 +action_233 (134#) = happyShift action_22 +action_233 (135#) = happyShift action_23 +action_233 (136#) = happyShift action_24 +action_233 (141#) = happyShift action_25 +action_233 (142#) = happyShift action_26 +action_233 (143#) = happyShift action_27 +action_233 (144#) = happyShift action_28 +action_233 (145#) = happyShift action_29 +action_233 (147#) = happyShift action_136 +action_233 (151#) = happyShift action_30 +action_233 (154#) = happyShift action_31 +action_233 (160#) = happyShift action_32 +action_233 (165#) = happyShift action_33 +action_233 (167#) = happyShift action_34 +action_233 (169#) = happyShift action_35 +action_233 (170#) = happyShift action_36 +action_233 (175#) = happyShift action_37 +action_233 (177#) = happyShift action_38 +action_233 (178#) = happyShift action_39 +action_233 (185#) = happyShift action_137 +action_233 (192#) = happyShift action_41 +action_233 (68#) = happyGoto action_132 +action_233 (69#) = happyGoto action_4 +action_233 (70#) = happyGoto action_5 +action_233 (71#) = happyGoto action_133 +action_233 (72#) = happyGoto action_7 +action_233 (73#) = happyGoto action_8 +action_233 (74#) = happyGoto action_9 +action_233 (77#) = happyGoto action_10 +action_233 (78#) = happyGoto action_11 +action_233 (79#) = happyGoto action_12 +action_233 (93#) = happyGoto action_134 +action_233 (95#) = happyGoto action_256 +action_233 (98#) = happyGoto action_13 +action_233 (100#) = happyGoto action_14 +action_233 (102#) = happyGoto action_15 +action_233 (112#) = happyGoto action_16 +action_233 (113#) = happyGoto action_17 +action_233 (114#) = happyGoto action_18 +action_233 (115#) = happyGoto action_19 +action_233 (123#) = happyGoto action_20 +action_233 x = happyTcHack x happyFail + +action_234 (133#) = happyShift action_21 +action_234 (134#) = happyShift action_22 +action_234 (135#) = happyShift action_23 +action_234 (136#) = happyShift action_24 +action_234 (141#) = happyShift action_25 +action_234 (142#) = happyShift action_26 +action_234 (143#) = happyShift action_27 +action_234 (144#) = happyShift action_28 +action_234 (145#) = happyShift action_29 +action_234 (151#) = happyShift action_30 +action_234 (154#) = happyShift action_31 +action_234 (160#) = happyShift action_32 +action_234 (165#) = happyShift action_33 +action_234 (167#) = happyShift action_34 +action_234 (169#) = happyShift action_35 +action_234 (170#) = happyShift action_36 +action_234 (175#) = happyShift action_37 +action_234 (177#) = happyShift action_38 +action_234 (178#) = happyShift action_39 +action_234 (185#) = happyShift action_40 +action_234 (192#) = happyShift action_41 +action_234 (68#) = happyGoto action_255 +action_234 (69#) = happyGoto action_4 +action_234 (70#) = happyGoto action_5 +action_234 (71#) = happyGoto action_6 +action_234 (72#) = happyGoto action_7 +action_234 (73#) = happyGoto action_8 +action_234 (74#) = happyGoto action_9 +action_234 (77#) = happyGoto action_10 +action_234 (78#) = happyGoto action_11 +action_234 (79#) = happyGoto action_12 +action_234 (98#) = happyGoto action_13 +action_234 (100#) = happyGoto action_14 +action_234 (102#) = happyGoto action_15 +action_234 (112#) = happyGoto action_16 +action_234 (113#) = happyGoto action_17 +action_234 (114#) = happyGoto action_18 +action_234 (115#) = happyGoto action_19 +action_234 (123#) = happyGoto action_20 +action_234 x = happyTcHack x happyFail + +action_235 (141#) = happyShift action_254 +action_235 (26#) = happyGoto action_253 +action_235 x = happyTcHack x happyReduce_51 + +action_236 (153#) = happyShift action_251 +action_236 (158#) = happyShift action_252 +action_236 x = happyTcHack x happyFail + +action_237 (137#) = happyShift action_91 +action_237 (138#) = happyShift action_73 +action_237 (139#) = happyShift action_74 +action_237 (140#) = happyShift action_75 +action_237 (155#) = happyShift action_92 +action_237 (157#) = happyShift action_79 +action_237 (159#) = happyShift action_250 +action_237 (167#) = happyShift action_94 +action_237 (168#) = happyShift action_95 +action_237 (65#) = happyGoto action_245 +action_237 (66#) = happyGoto action_246 +action_237 (67#) = happyGoto action_247 +action_237 (104#) = happyGoto action_85 +action_237 (107#) = happyGoto action_86 +action_237 (109#) = happyGoto action_248 +action_237 (111#) = happyGoto action_88 +action_237 (116#) = happyGoto action_65 +action_237 (117#) = happyGoto action_66 +action_237 (118#) = happyGoto action_89 +action_237 (120#) = happyGoto action_69 +action_237 (122#) = happyGoto action_90 +action_237 (124#) = happyGoto action_249 +action_237 x = happyTcHack x happyReduce_279 + +action_238 (153#) = happyReduce_82 +action_238 (158#) = happyReduce_82 +action_238 (164#) = happyShift action_82 +action_238 x = happyTcHack x happyReduce_173 + +action_239 x = happyTcHack x happyReduce_53 + +action_240 x = happyTcHack x happyReduce_54 + +action_241 x = happyTcHack x happyReduce_55 + +action_242 (133#) = happyReduce_279 +action_242 (134#) = happyReduce_279 +action_242 (135#) = happyReduce_279 +action_242 (136#) = happyReduce_279 +action_242 (141#) = happyReduce_279 +action_242 (142#) = happyReduce_279 +action_242 (143#) = happyReduce_279 +action_242 (144#) = happyReduce_279 +action_242 (145#) = happyReduce_279 +action_242 (151#) = happyReduce_279 +action_242 (154#) = happyReduce_279 +action_242 (165#) = happyReduce_279 +action_242 (167#) = happyReduce_279 +action_242 (169#) = happyReduce_279 +action_242 (170#) = happyReduce_279 +action_242 (175#) = happyReduce_279 +action_242 (177#) = happyReduce_279 +action_242 (181#) = happyReduce_279 +action_242 (182#) = happyReduce_279 +action_242 (183#) = happyReduce_279 +action_242 (192#) = happyReduce_279 +action_242 (25#) = happyGoto action_150 +action_242 (35#) = happyGoto action_244 +action_242 (37#) = happyGoto action_153 +action_242 (63#) = happyGoto action_154 +action_242 (124#) = happyGoto action_155 +action_242 x = happyTcHack x happyReduce_10 + +action_243 (147#) = happyShift action_156 +action_243 x = happyTcHack x happyReduce_71 + +action_244 x = happyTcHack x happyReduce_73 + +action_245 (191#) = happyShift action_319 +action_245 (64#) = happyGoto action_318 +action_245 x = happyTcHack x happyReduce_141 + +action_246 (161#) = happyReduce_279 +action_246 (67#) = happyGoto action_317 +action_246 (124#) = happyGoto action_249 +action_246 x = happyTcHack x happyReduce_143 + +action_247 x = happyTcHack x happyReduce_145 + +action_248 (133#) = happyShift action_21 +action_248 (134#) = happyShift action_22 +action_248 (135#) = happyShift action_23 +action_248 (136#) = happyShift action_24 +action_248 (141#) = happyShift action_25 +action_248 (142#) = happyShift action_26 +action_248 (143#) = happyShift action_27 +action_248 (144#) = happyShift action_28 +action_248 (145#) = happyShift action_29 +action_248 (151#) = happyShift action_30 +action_248 (154#) = happyShift action_31 +action_248 (165#) = happyShift action_33 +action_248 (167#) = happyShift action_34 +action_248 (169#) = happyShift action_35 +action_248 (170#) = happyShift action_36 +action_248 (175#) = happyShift action_37 +action_248 (177#) = happyShift action_38 +action_248 (192#) = happyShift action_41 +action_248 (73#) = happyGoto action_104 +action_248 (74#) = happyGoto action_9 +action_248 (77#) = happyGoto action_10 +action_248 (78#) = happyGoto action_11 +action_248 (79#) = happyGoto action_12 +action_248 (98#) = happyGoto action_13 +action_248 (100#) = happyGoto action_14 +action_248 (102#) = happyGoto action_15 +action_248 (112#) = happyGoto action_16 +action_248 (113#) = happyGoto action_17 +action_248 (114#) = happyGoto action_18 +action_248 (115#) = happyGoto action_19 +action_248 (123#) = happyGoto action_20 +action_248 x = happyTcHack x happyFail + +action_249 (161#) = happyShift action_316 +action_249 x = happyTcHack x happyFail + +action_250 (133#) = happyShift action_21 +action_250 (134#) = happyShift action_22 +action_250 (135#) = happyShift action_23 +action_250 (136#) = happyShift action_24 +action_250 (141#) = happyShift action_25 +action_250 (142#) = happyShift action_26 +action_250 (143#) = happyShift action_27 +action_250 (144#) = happyShift action_28 +action_250 (145#) = happyShift action_29 +action_250 (151#) = happyShift action_30 +action_250 (154#) = happyShift action_31 +action_250 (160#) = happyShift action_32 +action_250 (165#) = happyShift action_33 +action_250 (167#) = happyShift action_34 +action_250 (169#) = happyShift action_35 +action_250 (170#) = happyShift action_36 +action_250 (175#) = happyShift action_37 +action_250 (177#) = happyShift action_38 +action_250 (178#) = happyShift action_39 +action_250 (185#) = happyShift action_40 +action_250 (192#) = happyShift action_41 +action_250 (68#) = happyGoto action_315 +action_250 (69#) = happyGoto action_4 +action_250 (70#) = happyGoto action_5 +action_250 (71#) = happyGoto action_6 +action_250 (72#) = happyGoto action_7 +action_250 (73#) = happyGoto action_8 +action_250 (74#) = happyGoto action_9 +action_250 (77#) = happyGoto action_10 +action_250 (78#) = happyGoto action_11 +action_250 (79#) = happyGoto action_12 +action_250 (98#) = happyGoto action_13 +action_250 (100#) = happyGoto action_14 +action_250 (102#) = happyGoto action_15 +action_250 (112#) = happyGoto action_16 +action_250 (113#) = happyGoto action_17 +action_250 (114#) = happyGoto action_18 +action_250 (115#) = happyGoto action_19 +action_250 (123#) = happyGoto action_20 +action_250 x = happyTcHack x happyFail + +action_251 (133#) = happyShift action_21 +action_251 (145#) = happyShift action_314 +action_251 (169#) = happyShift action_35 +action_251 (177#) = happyShift action_38 +action_251 (192#) = happyShift action_41 +action_251 (99#) = happyGoto action_313 +action_251 (113#) = happyGoto action_289 +action_251 x = happyTcHack x happyFail + +action_252 (133#) = happyShift action_21 +action_252 (135#) = happyShift action_23 +action_252 (136#) = happyShift action_24 +action_252 (145#) = happyShift action_196 +action_252 (151#) = happyShift action_197 +action_252 (169#) = happyShift action_35 +action_252 (177#) = happyShift action_38 +action_252 (192#) = happyShift action_41 +action_252 (39#) = happyGoto action_187 +action_252 (40#) = happyGoto action_188 +action_252 (41#) = happyGoto action_189 +action_252 (42#) = happyGoto action_190 +action_252 (43#) = happyGoto action_312 +action_252 (44#) = happyGoto action_192 +action_252 (113#) = happyGoto action_193 +action_252 (114#) = happyGoto action_194 +action_252 (115#) = happyGoto action_19 +action_252 (132#) = happyGoto action_195 +action_252 x = happyTcHack x happyFail + +action_253 (137#) = happyShift action_91 +action_253 (138#) = happyShift action_73 +action_253 (155#) = happyShift action_311 +action_253 (167#) = happyShift action_94 +action_253 (168#) = happyShift action_95 +action_253 (28#) = happyGoto action_305 +action_253 (103#) = happyGoto action_306 +action_253 (106#) = happyGoto action_307 +action_253 (108#) = happyGoto action_308 +action_253 (117#) = happyGoto action_309 +action_253 (120#) = happyGoto action_310 +action_253 x = happyTcHack x happyFail + +action_254 x = happyTcHack x happyReduce_52 + +action_255 x = happyTcHack x happyReduce_157 + +action_256 x = happyTcHack x happyReduce_214 + +action_257 (147#) = happyShift action_304 +action_257 x = happyTcHack x happyFail + +action_258 x = happyTcHack x happyReduce_201 + +action_259 x = happyTcHack x happyReduce_200 + +action_260 (7#) = happyGoto action_302 +action_260 (8#) = happyGoto action_303 +action_260 x = happyTcHack x happyReduce_11 + +action_261 x = happyTcHack x happyReduce_204 + +action_262 (133#) = happyShift action_21 +action_262 (134#) = happyShift action_22 +action_262 (135#) = happyShift action_23 +action_262 (136#) = happyShift action_24 +action_262 (141#) = happyShift action_25 +action_262 (142#) = happyShift action_26 +action_262 (143#) = happyShift action_27 +action_262 (144#) = happyShift action_28 +action_262 (145#) = happyShift action_29 +action_262 (151#) = happyShift action_30 +action_262 (154#) = happyShift action_31 +action_262 (165#) = happyShift action_33 +action_262 (167#) = happyShift action_34 +action_262 (169#) = happyShift action_35 +action_262 (170#) = happyShift action_36 +action_262 (175#) = happyShift action_37 +action_262 (177#) = happyShift action_38 +action_262 (192#) = happyShift action_41 +action_262 (71#) = happyGoto action_300 +action_262 (73#) = happyGoto action_8 +action_262 (74#) = happyGoto action_9 +action_262 (77#) = happyGoto action_10 +action_262 (78#) = happyGoto action_11 +action_262 (79#) = happyGoto action_12 +action_262 (93#) = happyGoto action_301 +action_262 (98#) = happyGoto action_13 +action_262 (100#) = happyGoto action_14 +action_262 (102#) = happyGoto action_15 +action_262 (112#) = happyGoto action_16 +action_262 (113#) = happyGoto action_17 +action_262 (114#) = happyGoto action_18 +action_262 (115#) = happyGoto action_19 +action_262 (123#) = happyGoto action_20 +action_262 x = happyTcHack x happyFail + +action_263 x = happyTcHack x happyReduce_195 + +action_264 (133#) = happyShift action_21 +action_264 (134#) = happyShift action_22 +action_264 (135#) = happyShift action_23 +action_264 (136#) = happyShift action_24 +action_264 (141#) = happyShift action_25 +action_264 (142#) = happyShift action_26 +action_264 (143#) = happyShift action_27 +action_264 (144#) = happyShift action_28 +action_264 (145#) = happyShift action_29 +action_264 (151#) = happyShift action_30 +action_264 (154#) = happyShift action_31 +action_264 (160#) = happyShift action_32 +action_264 (165#) = happyShift action_33 +action_264 (167#) = happyShift action_34 +action_264 (169#) = happyShift action_35 +action_264 (170#) = happyShift action_36 +action_264 (175#) = happyShift action_37 +action_264 (177#) = happyShift action_38 +action_264 (178#) = happyShift action_39 +action_264 (185#) = happyShift action_40 +action_264 (192#) = happyShift action_41 +action_264 (68#) = happyGoto action_299 +action_264 (69#) = happyGoto action_4 +action_264 (70#) = happyGoto action_5 +action_264 (71#) = happyGoto action_6 +action_264 (72#) = happyGoto action_7 +action_264 (73#) = happyGoto action_8 +action_264 (74#) = happyGoto action_9 +action_264 (77#) = happyGoto action_10 +action_264 (78#) = happyGoto action_11 +action_264 (79#) = happyGoto action_12 +action_264 (98#) = happyGoto action_13 +action_264 (100#) = happyGoto action_14 +action_264 (102#) = happyGoto action_15 +action_264 (112#) = happyGoto action_16 +action_264 (113#) = happyGoto action_17 +action_264 (114#) = happyGoto action_18 +action_264 (115#) = happyGoto action_19 +action_264 (123#) = happyGoto action_20 +action_264 x = happyTcHack x happyFail + +action_265 x = happyTcHack x happyReduce_191 + +action_266 x = happyTcHack x happyReduce_83 + +action_267 x = happyTcHack x happyReduce_97 + +action_268 x = happyTcHack x happyReduce_94 + +action_269 x = happyTcHack x happyReduce_96 + +action_270 x = happyTcHack x happyReduce_89 + +action_271 (133#) = happyShift action_21 +action_271 (135#) = happyShift action_23 +action_271 (136#) = happyShift action_24 +action_271 (145#) = happyShift action_196 +action_271 (151#) = happyShift action_197 +action_271 (169#) = happyShift action_35 +action_271 (177#) = happyShift action_38 +action_271 (192#) = happyShift action_41 +action_271 (39#) = happyGoto action_298 +action_271 (40#) = happyGoto action_211 +action_271 (41#) = happyGoto action_189 +action_271 (42#) = happyGoto action_190 +action_271 (113#) = happyGoto action_193 +action_271 (114#) = happyGoto action_194 +action_271 (115#) = happyGoto action_19 +action_271 (132#) = happyGoto action_195 +action_271 x = happyTcHack x happyFail + +action_272 x = happyTcHack x happyReduce_91 + +action_273 (133#) = happyShift action_21 +action_273 (135#) = happyShift action_23 +action_273 (136#) = happyShift action_24 +action_273 (145#) = happyShift action_196 +action_273 (151#) = happyShift action_197 +action_273 (169#) = happyShift action_35 +action_273 (177#) = happyShift action_38 +action_273 (192#) = happyShift action_41 +action_273 (39#) = happyGoto action_297 +action_273 (40#) = happyGoto action_211 +action_273 (41#) = happyGoto action_189 +action_273 (42#) = happyGoto action_190 +action_273 (113#) = happyGoto action_193 +action_273 (114#) = happyGoto action_194 +action_273 (115#) = happyGoto action_19 +action_273 (132#) = happyGoto action_195 +action_273 x = happyTcHack x happyFail + +action_274 x = happyTcHack x happyReduce_90 + +action_275 x = happyTcHack x happyFail + +action_276 (6#) = happyGoto action_296 +action_276 (7#) = happyGoto action_140 +action_276 (8#) = happyGoto action_295 +action_276 x = happyTcHack x happyFail + +action_277 (6#) = happyGoto action_294 +action_277 (7#) = happyGoto action_140 +action_277 (8#) = happyGoto action_295 +action_277 x = happyTcHack x happyFail + +action_278 x = happyTcHack x happyReduce_25 + +action_279 (133#) = happyShift action_21 +action_279 (135#) = happyShift action_23 +action_279 (145#) = happyShift action_291 +action_279 (146#) = happyShift action_292 +action_279 (156#) = happyShift action_293 +action_279 (169#) = happyShift action_35 +action_279 (177#) = happyShift action_38 +action_279 (192#) = happyShift action_41 +action_279 (23#) = happyGoto action_285 +action_279 (24#) = happyGoto action_286 +action_279 (99#) = happyGoto action_287 +action_279 (101#) = happyGoto action_288 +action_279 (113#) = happyGoto action_289 +action_279 (115#) = happyGoto action_290 +action_279 x = happyTcHack x happyFail + +action_280 (146#) = happyShift action_284 +action_280 x = happyTcHack x happyFail + +action_281 (133#) = happyShift action_21 +action_281 (134#) = happyShift action_22 +action_281 (135#) = happyShift action_23 +action_281 (136#) = happyShift action_24 +action_281 (145#) = happyShift action_108 +action_281 (169#) = happyShift action_35 +action_281 (177#) = happyShift action_38 +action_281 (186#) = happyShift action_208 +action_281 (192#) = happyShift action_41 +action_281 (13#) = happyGoto action_283 +action_281 (100#) = happyGoto action_204 +action_281 (112#) = happyGoto action_16 +action_281 (113#) = happyGoto action_17 +action_281 (114#) = happyGoto action_205 +action_281 (115#) = happyGoto action_19 +action_281 (130#) = happyGoto action_206 +action_281 x = happyTcHack x happyReduce_16 + +action_282 x = happyTcHack x happyReduce_15 + +action_283 x = happyTcHack x happyReduce_18 + +action_284 x = happyTcHack x happyReduce_14 + +action_285 (146#) = happyShift action_344 +action_285 (153#) = happyShift action_345 +action_285 x = happyTcHack x happyFail + +action_286 x = happyTcHack x happyReduce_47 + +action_287 x = happyTcHack x happyReduce_48 + +action_288 x = happyTcHack x happyReduce_49 + +action_289 x = happyTcHack x happyReduce_227 + +action_290 x = happyTcHack x happyReduce_231 + +action_291 (137#) = happyShift action_91 +action_291 (138#) = happyShift action_73 +action_291 (167#) = happyShift action_94 +action_291 (168#) = happyShift action_95 +action_291 (117#) = happyGoto action_343 +action_291 (120#) = happyGoto action_322 +action_291 x = happyTcHack x happyFail + +action_292 x = happyTcHack x happyReduce_23 + +action_293 (146#) = happyShift action_342 +action_293 x = happyTcHack x happyFail + +action_294 (149#) = happyShift action_341 +action_294 x = happyTcHack x happyFail + +action_295 (133#) = happyReduce_279 +action_295 (134#) = happyReduce_279 +action_295 (135#) = happyReduce_279 +action_295 (136#) = happyReduce_279 +action_295 (141#) = happyReduce_279 +action_295 (142#) = happyReduce_279 +action_295 (143#) = happyReduce_279 +action_295 (144#) = happyReduce_279 +action_295 (145#) = happyReduce_279 +action_295 (147#) = happyShift action_156 +action_295 (151#) = happyReduce_279 +action_295 (154#) = happyReduce_279 +action_295 (165#) = happyReduce_279 +action_295 (167#) = happyReduce_279 +action_295 (169#) = happyReduce_279 +action_295 (170#) = happyReduce_279 +action_295 (171#) = happyReduce_279 +action_295 (172#) = happyReduce_279 +action_295 (173#) = happyReduce_279 +action_295 (175#) = happyReduce_279 +action_295 (177#) = happyReduce_279 +action_295 (179#) = happyReduce_279 +action_295 (181#) = happyReduce_279 +action_295 (182#) = happyReduce_279 +action_295 (183#) = happyReduce_279 +action_295 (184#) = happyReduce_279 +action_295 (187#) = happyReduce_279 +action_295 (190#) = happyReduce_279 +action_295 (192#) = happyReduce_279 +action_295 (14#) = happyGoto action_334 +action_295 (15#) = happyGoto action_335 +action_295 (25#) = happyGoto action_150 +action_295 (29#) = happyGoto action_336 +action_295 (30#) = happyGoto action_337 +action_295 (31#) = happyGoto action_338 +action_295 (35#) = happyGoto action_339 +action_295 (37#) = happyGoto action_153 +action_295 (63#) = happyGoto action_154 +action_295 (124#) = happyGoto action_340 +action_295 x = happyTcHack x happyReduce_8 + +action_296 (1#) = happyShift action_147 +action_296 (150#) = happyShift action_148 +action_296 (126#) = happyGoto action_333 +action_296 x = happyTcHack x happyFail + +action_297 x = happyTcHack x happyReduce_101 + +action_298 x = happyTcHack x happyReduce_100 + +action_299 x = happyTcHack x happyReduce_197 + +action_300 (137#) = happyShift action_91 +action_300 (138#) = happyShift action_73 +action_300 (139#) = happyShift action_74 +action_300 (140#) = happyShift action_75 +action_300 (155#) = happyShift action_92 +action_300 (157#) = happyShift action_79 +action_300 (167#) = happyShift action_94 +action_300 (168#) = happyShift action_95 +action_300 (104#) = happyGoto action_85 +action_300 (107#) = happyGoto action_86 +action_300 (109#) = happyGoto action_248 +action_300 (111#) = happyGoto action_88 +action_300 (116#) = happyGoto action_65 +action_300 (117#) = happyGoto action_66 +action_300 (118#) = happyGoto action_89 +action_300 (120#) = happyGoto action_69 +action_300 (122#) = happyGoto action_90 +action_300 x = happyTcHack x happyReduce_211 + +action_301 (163#) = happyShift action_332 +action_301 (90#) = happyGoto action_328 +action_301 (91#) = happyGoto action_329 +action_301 (92#) = happyGoto action_330 +action_301 (124#) = happyGoto action_331 +action_301 x = happyTcHack x happyReduce_279 + +action_302 (133#) = happyReduce_279 +action_302 (134#) = happyReduce_279 +action_302 (135#) = happyReduce_279 +action_302 (136#) = happyReduce_279 +action_302 (141#) = happyReduce_279 +action_302 (142#) = happyReduce_279 +action_302 (143#) = happyReduce_279 +action_302 (144#) = happyReduce_279 +action_302 (145#) = happyReduce_279 +action_302 (151#) = happyReduce_279 +action_302 (154#) = happyReduce_279 +action_302 (165#) = happyReduce_279 +action_302 (167#) = happyReduce_279 +action_302 (169#) = happyReduce_279 +action_302 (170#) = happyReduce_279 +action_302 (175#) = happyReduce_279 +action_302 (177#) = happyReduce_279 +action_302 (192#) = happyReduce_279 +action_302 (89#) = happyGoto action_327 +action_302 (124#) = happyGoto action_262 +action_302 x = happyTcHack x happyReduce_10 + +action_303 (147#) = happyShift action_156 +action_303 x = happyTcHack x happyReduce_202 + +action_304 (133#) = happyShift action_21 +action_304 (134#) = happyShift action_22 +action_304 (135#) = happyShift action_23 +action_304 (136#) = happyShift action_24 +action_304 (141#) = happyShift action_25 +action_304 (142#) = happyShift action_26 +action_304 (143#) = happyShift action_27 +action_304 (144#) = happyShift action_28 +action_304 (145#) = happyShift action_29 +action_304 (147#) = happyShift action_136 +action_304 (151#) = happyShift action_30 +action_304 (154#) = happyShift action_31 +action_304 (160#) = happyShift action_32 +action_304 (165#) = happyShift action_33 +action_304 (167#) = happyShift action_34 +action_304 (169#) = happyShift action_35 +action_304 (170#) = happyShift action_36 +action_304 (175#) = happyShift action_37 +action_304 (177#) = happyShift action_38 +action_304 (178#) = happyShift action_39 +action_304 (185#) = happyShift action_137 +action_304 (192#) = happyShift action_41 +action_304 (68#) = happyGoto action_132 +action_304 (69#) = happyGoto action_4 +action_304 (70#) = happyGoto action_5 +action_304 (71#) = happyGoto action_133 +action_304 (72#) = happyGoto action_7 +action_304 (73#) = happyGoto action_8 +action_304 (74#) = happyGoto action_9 +action_304 (77#) = happyGoto action_10 +action_304 (78#) = happyGoto action_11 +action_304 (79#) = happyGoto action_12 +action_304 (93#) = happyGoto action_134 +action_304 (95#) = happyGoto action_326 +action_304 (98#) = happyGoto action_13 +action_304 (100#) = happyGoto action_14 +action_304 (102#) = happyGoto action_15 +action_304 (112#) = happyGoto action_16 +action_304 (113#) = happyGoto action_17 +action_304 (114#) = happyGoto action_18 +action_304 (115#) = happyGoto action_19 +action_304 (123#) = happyGoto action_20 +action_304 x = happyTcHack x happyFail + +action_305 (153#) = happyShift action_325 +action_305 x = happyTcHack x happyReduce_50 + +action_306 x = happyTcHack x happyReduce_245 + +action_307 x = happyTcHack x happyReduce_246 + +action_308 x = happyTcHack x happyReduce_57 + +action_309 x = happyTcHack x happyReduce_241 + +action_310 x = happyTcHack x happyReduce_235 + +action_311 (133#) = happyShift action_21 +action_311 (135#) = happyShift action_23 +action_311 (169#) = happyShift action_35 +action_311 (177#) = happyShift action_38 +action_311 (192#) = happyShift action_41 +action_311 (113#) = happyGoto action_323 +action_311 (115#) = happyGoto action_324 +action_311 x = happyTcHack x happyFail + +action_312 x = happyTcHack x happyReduce_80 + +action_313 x = happyTcHack x happyReduce_81 + +action_314 (137#) = happyShift action_91 +action_314 (167#) = happyShift action_94 +action_314 (168#) = happyShift action_95 +action_314 (120#) = happyGoto action_322 +action_314 x = happyTcHack x happyFail + +action_315 x = happyTcHack x happyReduce_142 + +action_316 (133#) = happyShift action_21 +action_316 (134#) = happyShift action_22 +action_316 (135#) = happyShift action_23 +action_316 (136#) = happyShift action_24 +action_316 (141#) = happyShift action_25 +action_316 (142#) = happyShift action_26 +action_316 (143#) = happyShift action_27 +action_316 (144#) = happyShift action_28 +action_316 (145#) = happyShift action_29 +action_316 (151#) = happyShift action_30 +action_316 (154#) = happyShift action_31 +action_316 (160#) = happyShift action_32 +action_316 (165#) = happyShift action_33 +action_316 (167#) = happyShift action_34 +action_316 (169#) = happyShift action_35 +action_316 (170#) = happyShift action_36 +action_316 (175#) = happyShift action_37 +action_316 (177#) = happyShift action_38 +action_316 (178#) = happyShift action_39 +action_316 (185#) = happyShift action_40 +action_316 (192#) = happyShift action_41 +action_316 (69#) = happyGoto action_321 +action_316 (70#) = happyGoto action_5 +action_316 (71#) = happyGoto action_115 +action_316 (72#) = happyGoto action_7 +action_316 (73#) = happyGoto action_8 +action_316 (74#) = happyGoto action_9 +action_316 (77#) = happyGoto action_10 +action_316 (78#) = happyGoto action_11 +action_316 (79#) = happyGoto action_12 +action_316 (98#) = happyGoto action_13 +action_316 (100#) = happyGoto action_14 +action_316 (102#) = happyGoto action_15 +action_316 (112#) = happyGoto action_16 +action_316 (113#) = happyGoto action_17 +action_316 (114#) = happyGoto action_18 +action_316 (115#) = happyGoto action_19 +action_316 (123#) = happyGoto action_20 +action_316 x = happyTcHack x happyFail + +action_317 x = happyTcHack x happyReduce_144 + +action_318 x = happyTcHack x happyReduce_139 + +action_319 (148#) = happyShift action_44 +action_319 (36#) = happyGoto action_320 +action_319 (125#) = happyGoto action_43 +action_319 x = happyTcHack x happyReduce_280 + +action_320 x = happyTcHack x happyReduce_140 + +action_321 (159#) = happyShift action_367 +action_321 x = happyTcHack x happyFail + +action_322 (146#) = happyShift action_366 +action_322 x = happyTcHack x happyFail + +action_323 (155#) = happyShift action_365 +action_323 x = happyTcHack x happyFail + +action_324 (155#) = happyShift action_364 +action_324 x = happyTcHack x happyFail + +action_325 (137#) = happyShift action_91 +action_325 (138#) = happyShift action_73 +action_325 (155#) = happyShift action_311 +action_325 (167#) = happyShift action_94 +action_325 (168#) = happyShift action_95 +action_325 (103#) = happyGoto action_306 +action_325 (106#) = happyGoto action_307 +action_325 (108#) = happyGoto action_363 +action_325 (117#) = happyGoto action_309 +action_325 (120#) = happyGoto action_310 +action_325 x = happyTcHack x happyFail + +action_326 x = happyTcHack x happyReduce_215 + +action_327 x = happyTcHack x happyReduce_203 + +action_328 (191#) = happyShift action_319 +action_328 (64#) = happyGoto action_362 +action_328 x = happyTcHack x happyReduce_141 + +action_329 (161#) = happyReduce_279 +action_329 (92#) = happyGoto action_361 +action_329 (124#) = happyGoto action_331 +action_329 x = happyTcHack x happyReduce_207 + +action_330 x = happyTcHack x happyReduce_209 + +action_331 (161#) = happyShift action_360 +action_331 x = happyTcHack x happyFail + +action_332 (133#) = happyShift action_21 +action_332 (134#) = happyShift action_22 +action_332 (135#) = happyShift action_23 +action_332 (136#) = happyShift action_24 +action_332 (141#) = happyShift action_25 +action_332 (142#) = happyShift action_26 +action_332 (143#) = happyShift action_27 +action_332 (144#) = happyShift action_28 +action_332 (145#) = happyShift action_29 +action_332 (151#) = happyShift action_30 +action_332 (154#) = happyShift action_31 +action_332 (160#) = happyShift action_32 +action_332 (165#) = happyShift action_33 +action_332 (167#) = happyShift action_34 +action_332 (169#) = happyShift action_35 +action_332 (170#) = happyShift action_36 +action_332 (175#) = happyShift action_37 +action_332 (177#) = happyShift action_38 +action_332 (178#) = happyShift action_39 +action_332 (185#) = happyShift action_40 +action_332 (192#) = happyShift action_41 +action_332 (68#) = happyGoto action_359 +action_332 (69#) = happyGoto action_4 +action_332 (70#) = happyGoto action_5 +action_332 (71#) = happyGoto action_6 +action_332 (72#) = happyGoto action_7 +action_332 (73#) = happyGoto action_8 +action_332 (74#) = happyGoto action_9 +action_332 (77#) = happyGoto action_10 +action_332 (78#) = happyGoto action_11 +action_332 (79#) = happyGoto action_12 +action_332 (98#) = happyGoto action_13 +action_332 (100#) = happyGoto action_14 +action_332 (102#) = happyGoto action_15 +action_332 (112#) = happyGoto action_16 +action_332 (113#) = happyGoto action_17 +action_332 (114#) = happyGoto action_18 +action_332 (115#) = happyGoto action_19 +action_332 (123#) = happyGoto action_20 +action_332 x = happyTcHack x happyFail + +action_333 x = happyTcHack x happyFail + +action_334 (7#) = happyGoto action_357 +action_334 (8#) = happyGoto action_358 +action_334 x = happyTcHack x happyReduce_11 + +action_335 x = happyTcHack x happyReduce_27 + +action_336 x = happyTcHack x happyReduce_6 + +action_337 (7#) = happyGoto action_355 +action_337 (8#) = happyGoto action_356 +action_337 x = happyTcHack x happyReduce_11 + +action_338 x = happyTcHack x happyReduce_60 + +action_339 x = happyTcHack x happyReduce_67 + +action_340 (133#) = happyShift action_21 +action_340 (134#) = happyShift action_22 +action_340 (135#) = happyShift action_23 +action_340 (136#) = happyShift action_24 +action_340 (141#) = happyShift action_25 +action_340 (142#) = happyShift action_26 +action_340 (143#) = happyShift action_27 +action_340 (144#) = happyShift action_28 +action_340 (145#) = happyShift action_29 +action_340 (151#) = happyShift action_30 +action_340 (154#) = happyShift action_31 +action_340 (165#) = happyShift action_33 +action_340 (167#) = happyShift action_34 +action_340 (169#) = happyShift action_35 +action_340 (170#) = happyShift action_36 +action_340 (171#) = happyShift action_348 +action_340 (172#) = happyShift action_349 +action_340 (173#) = happyShift action_350 +action_340 (175#) = happyShift action_37 +action_340 (177#) = happyShift action_38 +action_340 (179#) = happyShift action_351 +action_340 (181#) = happyShift action_239 +action_340 (182#) = happyShift action_240 +action_340 (183#) = happyShift action_241 +action_340 (184#) = happyShift action_352 +action_340 (187#) = happyShift action_353 +action_340 (190#) = happyShift action_354 +action_340 (192#) = happyShift action_41 +action_340 (27#) = happyGoto action_235 +action_340 (38#) = happyGoto action_236 +action_340 (71#) = happyGoto action_237 +action_340 (73#) = happyGoto action_8 +action_340 (74#) = happyGoto action_9 +action_340 (77#) = happyGoto action_10 +action_340 (78#) = happyGoto action_11 +action_340 (79#) = happyGoto action_12 +action_340 (98#) = happyGoto action_13 +action_340 (100#) = happyGoto action_238 +action_340 (102#) = happyGoto action_15 +action_340 (112#) = happyGoto action_16 +action_340 (113#) = happyGoto action_17 +action_340 (114#) = happyGoto action_18 +action_340 (115#) = happyGoto action_19 +action_340 (123#) = happyGoto action_20 +action_340 x = happyTcHack x happyFail + +action_341 x = happyTcHack x happyFail + +action_342 x = happyTcHack x happyReduce_22 + +action_343 (146#) = happyShift action_347 +action_343 x = happyTcHack x happyFail + +action_344 x = happyTcHack x happyReduce_24 + +action_345 (133#) = happyShift action_21 +action_345 (135#) = happyShift action_23 +action_345 (145#) = happyShift action_291 +action_345 (169#) = happyShift action_35 +action_345 (177#) = happyShift action_38 +action_345 (192#) = happyShift action_41 +action_345 (24#) = happyGoto action_346 +action_345 (99#) = happyGoto action_287 +action_345 (101#) = happyGoto action_288 +action_345 (113#) = happyGoto action_289 +action_345 (115#) = happyGoto action_290 +action_345 x = happyTcHack x happyFail + +action_346 x = happyTcHack x happyReduce_46 + +action_347 x = happyTcHack x happyReduce_232 + +action_348 (133#) = happyShift action_21 +action_348 (135#) = happyShift action_23 +action_348 (136#) = happyShift action_24 +action_348 (145#) = happyShift action_196 +action_348 (151#) = happyShift action_197 +action_348 (169#) = happyShift action_35 +action_348 (177#) = happyShift action_38 +action_348 (192#) = happyShift action_41 +action_348 (39#) = happyGoto action_187 +action_348 (40#) = happyGoto action_188 +action_348 (41#) = happyGoto action_189 +action_348 (42#) = happyGoto action_190 +action_348 (43#) = happyGoto action_383 +action_348 (44#) = happyGoto action_192 +action_348 (113#) = happyGoto action_193 +action_348 (114#) = happyGoto action_194 +action_348 (115#) = happyGoto action_19 +action_348 (132#) = happyGoto action_195 +action_348 x = happyTcHack x happyFail + +action_349 (133#) = happyShift action_21 +action_349 (135#) = happyShift action_23 +action_349 (136#) = happyShift action_24 +action_349 (145#) = happyShift action_196 +action_349 (151#) = happyShift action_197 +action_349 (169#) = happyShift action_35 +action_349 (177#) = happyShift action_38 +action_349 (192#) = happyShift action_41 +action_349 (39#) = happyGoto action_187 +action_349 (40#) = happyGoto action_188 +action_349 (41#) = happyGoto action_189 +action_349 (42#) = happyGoto action_190 +action_349 (43#) = happyGoto action_382 +action_349 (44#) = happyGoto action_192 +action_349 (113#) = happyGoto action_193 +action_349 (114#) = happyGoto action_194 +action_349 (115#) = happyGoto action_19 +action_349 (132#) = happyGoto action_195 +action_349 x = happyTcHack x happyFail + +action_350 (145#) = happyShift action_381 +action_350 x = happyTcHack x happyFail + +action_351 (192#) = happyShift action_380 +action_351 (16#) = happyGoto action_379 +action_351 x = happyTcHack x happyReduce_30 + +action_352 (133#) = happyShift action_21 +action_352 (135#) = happyShift action_23 +action_352 (136#) = happyShift action_24 +action_352 (145#) = happyShift action_196 +action_352 (151#) = happyShift action_197 +action_352 (169#) = happyShift action_35 +action_352 (177#) = happyShift action_38 +action_352 (192#) = happyShift action_41 +action_352 (39#) = happyGoto action_187 +action_352 (40#) = happyGoto action_188 +action_352 (41#) = happyGoto action_189 +action_352 (42#) = happyGoto action_190 +action_352 (43#) = happyGoto action_378 +action_352 (44#) = happyGoto action_192 +action_352 (113#) = happyGoto action_193 +action_352 (114#) = happyGoto action_194 +action_352 (115#) = happyGoto action_19 +action_352 (132#) = happyGoto action_195 +action_352 x = happyTcHack x happyFail + +action_353 (133#) = happyShift action_21 +action_353 (135#) = happyShift action_23 +action_353 (136#) = happyShift action_24 +action_353 (145#) = happyShift action_196 +action_353 (151#) = happyShift action_197 +action_353 (169#) = happyShift action_35 +action_353 (177#) = happyShift action_38 +action_353 (192#) = happyShift action_41 +action_353 (39#) = happyGoto action_187 +action_353 (40#) = happyGoto action_188 +action_353 (41#) = happyGoto action_189 +action_353 (42#) = happyGoto action_190 +action_353 (43#) = happyGoto action_377 +action_353 (44#) = happyGoto action_192 +action_353 (113#) = happyGoto action_193 +action_353 (114#) = happyGoto action_194 +action_353 (115#) = happyGoto action_19 +action_353 (132#) = happyGoto action_195 +action_353 x = happyTcHack x happyFail + +action_354 (135#) = happyShift action_23 +action_354 (46#) = happyGoto action_374 +action_354 (115#) = happyGoto action_375 +action_354 (129#) = happyGoto action_376 +action_354 x = happyTcHack x happyFail + +action_355 (133#) = happyReduce_279 +action_355 (134#) = happyReduce_279 +action_355 (135#) = happyReduce_279 +action_355 (136#) = happyReduce_279 +action_355 (141#) = happyReduce_279 +action_355 (142#) = happyReduce_279 +action_355 (143#) = happyReduce_279 +action_355 (144#) = happyReduce_279 +action_355 (145#) = happyReduce_279 +action_355 (151#) = happyReduce_279 +action_355 (154#) = happyReduce_279 +action_355 (165#) = happyReduce_279 +action_355 (167#) = happyReduce_279 +action_355 (169#) = happyReduce_279 +action_355 (170#) = happyReduce_279 +action_355 (171#) = happyReduce_279 +action_355 (172#) = happyReduce_279 +action_355 (173#) = happyReduce_279 +action_355 (175#) = happyReduce_279 +action_355 (177#) = happyReduce_279 +action_355 (181#) = happyReduce_279 +action_355 (182#) = happyReduce_279 +action_355 (183#) = happyReduce_279 +action_355 (184#) = happyReduce_279 +action_355 (187#) = happyReduce_279 +action_355 (190#) = happyReduce_279 +action_355 (192#) = happyReduce_279 +action_355 (25#) = happyGoto action_150 +action_355 (31#) = happyGoto action_372 +action_355 (35#) = happyGoto action_339 +action_355 (37#) = happyGoto action_153 +action_355 (63#) = happyGoto action_154 +action_355 (124#) = happyGoto action_373 +action_355 x = happyTcHack x happyReduce_10 + +action_356 (147#) = happyShift action_156 +action_356 x = happyTcHack x happyReduce_58 + +action_357 (133#) = happyReduce_279 +action_357 (134#) = happyReduce_279 +action_357 (135#) = happyReduce_279 +action_357 (136#) = happyReduce_279 +action_357 (141#) = happyReduce_279 +action_357 (142#) = happyReduce_279 +action_357 (143#) = happyReduce_279 +action_357 (144#) = happyReduce_279 +action_357 (145#) = happyReduce_279 +action_357 (151#) = happyReduce_279 +action_357 (154#) = happyReduce_279 +action_357 (165#) = happyReduce_279 +action_357 (167#) = happyReduce_279 +action_357 (169#) = happyReduce_279 +action_357 (170#) = happyReduce_279 +action_357 (171#) = happyReduce_279 +action_357 (172#) = happyReduce_279 +action_357 (173#) = happyReduce_279 +action_357 (175#) = happyReduce_279 +action_357 (177#) = happyReduce_279 +action_357 (179#) = happyReduce_279 +action_357 (181#) = happyReduce_279 +action_357 (182#) = happyReduce_279 +action_357 (183#) = happyReduce_279 +action_357 (184#) = happyReduce_279 +action_357 (187#) = happyReduce_279 +action_357 (190#) = happyReduce_279 +action_357 (192#) = happyReduce_279 +action_357 (15#) = happyGoto action_370 +action_357 (25#) = happyGoto action_150 +action_357 (29#) = happyGoto action_371 +action_357 (30#) = happyGoto action_337 +action_357 (31#) = happyGoto action_338 +action_357 (35#) = happyGoto action_339 +action_357 (37#) = happyGoto action_153 +action_357 (63#) = happyGoto action_154 +action_357 (124#) = happyGoto action_340 +action_357 x = happyTcHack x happyReduce_10 + +action_358 (147#) = happyShift action_156 +action_358 x = happyTcHack x happyReduce_7 + +action_359 x = happyTcHack x happyReduce_206 + +action_360 (133#) = happyShift action_21 +action_360 (134#) = happyShift action_22 +action_360 (135#) = happyShift action_23 +action_360 (136#) = happyShift action_24 +action_360 (141#) = happyShift action_25 +action_360 (142#) = happyShift action_26 +action_360 (143#) = happyShift action_27 +action_360 (144#) = happyShift action_28 +action_360 (145#) = happyShift action_29 +action_360 (151#) = happyShift action_30 +action_360 (154#) = happyShift action_31 +action_360 (160#) = happyShift action_32 +action_360 (165#) = happyShift action_33 +action_360 (167#) = happyShift action_34 +action_360 (169#) = happyShift action_35 +action_360 (170#) = happyShift action_36 +action_360 (175#) = happyShift action_37 +action_360 (177#) = happyShift action_38 +action_360 (178#) = happyShift action_39 +action_360 (185#) = happyShift action_40 +action_360 (192#) = happyShift action_41 +action_360 (69#) = happyGoto action_369 +action_360 (70#) = happyGoto action_5 +action_360 (71#) = happyGoto action_115 +action_360 (72#) = happyGoto action_7 +action_360 (73#) = happyGoto action_8 +action_360 (74#) = happyGoto action_9 +action_360 (77#) = happyGoto action_10 +action_360 (78#) = happyGoto action_11 +action_360 (79#) = happyGoto action_12 +action_360 (98#) = happyGoto action_13 +action_360 (100#) = happyGoto action_14 +action_360 (102#) = happyGoto action_15 +action_360 (112#) = happyGoto action_16 +action_360 (113#) = happyGoto action_17 +action_360 (114#) = happyGoto action_18 +action_360 (115#) = happyGoto action_19 +action_360 (123#) = happyGoto action_20 +action_360 x = happyTcHack x happyFail + +action_361 x = happyTcHack x happyReduce_208 + +action_362 x = happyTcHack x happyReduce_205 + +action_363 x = happyTcHack x happyReduce_56 + +action_364 x = happyTcHack x happyReduce_242 + +action_365 x = happyTcHack x happyReduce_236 + +action_366 x = happyTcHack x happyReduce_228 + +action_367 (133#) = happyShift action_21 +action_367 (134#) = happyShift action_22 +action_367 (135#) = happyShift action_23 +action_367 (136#) = happyShift action_24 +action_367 (141#) = happyShift action_25 +action_367 (142#) = happyShift action_26 +action_367 (143#) = happyShift action_27 +action_367 (144#) = happyShift action_28 +action_367 (145#) = happyShift action_29 +action_367 (151#) = happyShift action_30 +action_367 (154#) = happyShift action_31 +action_367 (160#) = happyShift action_32 +action_367 (165#) = happyShift action_33 +action_367 (167#) = happyShift action_34 +action_367 (169#) = happyShift action_35 +action_367 (170#) = happyShift action_36 +action_367 (175#) = happyShift action_37 +action_367 (177#) = happyShift action_38 +action_367 (178#) = happyShift action_39 +action_367 (185#) = happyShift action_40 +action_367 (192#) = happyShift action_41 +action_367 (68#) = happyGoto action_368 +action_367 (69#) = happyGoto action_4 +action_367 (70#) = happyGoto action_5 +action_367 (71#) = happyGoto action_6 +action_367 (72#) = happyGoto action_7 +action_367 (73#) = happyGoto action_8 +action_367 (74#) = happyGoto action_9 +action_367 (77#) = happyGoto action_10 +action_367 (78#) = happyGoto action_11 +action_367 (79#) = happyGoto action_12 +action_367 (98#) = happyGoto action_13 +action_367 (100#) = happyGoto action_14 +action_367 (102#) = happyGoto action_15 +action_367 (112#) = happyGoto action_16 +action_367 (113#) = happyGoto action_17 +action_367 (114#) = happyGoto action_18 +action_367 (115#) = happyGoto action_19 +action_367 (123#) = happyGoto action_20 +action_367 x = happyTcHack x happyFail + +action_368 x = happyTcHack x happyReduce_146 + +action_369 (163#) = happyShift action_396 +action_369 x = happyTcHack x happyFail + +action_370 x = happyTcHack x happyReduce_26 + +action_371 x = happyTcHack x happyReduce_5 + +action_372 x = happyTcHack x happyReduce_59 + +action_373 (133#) = happyShift action_21 +action_373 (134#) = happyShift action_22 +action_373 (135#) = happyShift action_23 +action_373 (136#) = happyShift action_24 +action_373 (141#) = happyShift action_25 +action_373 (142#) = happyShift action_26 +action_373 (143#) = happyShift action_27 +action_373 (144#) = happyShift action_28 +action_373 (145#) = happyShift action_29 +action_373 (151#) = happyShift action_30 +action_373 (154#) = happyShift action_31 +action_373 (165#) = happyShift action_33 +action_373 (167#) = happyShift action_34 +action_373 (169#) = happyShift action_35 +action_373 (170#) = happyShift action_36 +action_373 (171#) = happyShift action_348 +action_373 (172#) = happyShift action_349 +action_373 (173#) = happyShift action_350 +action_373 (175#) = happyShift action_37 +action_373 (177#) = happyShift action_38 +action_373 (181#) = happyShift action_239 +action_373 (182#) = happyShift action_240 +action_373 (183#) = happyShift action_241 +action_373 (184#) = happyShift action_352 +action_373 (187#) = happyShift action_353 +action_373 (190#) = happyShift action_354 +action_373 (192#) = happyShift action_41 +action_373 (27#) = happyGoto action_235 +action_373 (38#) = happyGoto action_236 +action_373 (71#) = happyGoto action_237 +action_373 (73#) = happyGoto action_8 +action_373 (74#) = happyGoto action_9 +action_373 (77#) = happyGoto action_10 +action_373 (78#) = happyGoto action_11 +action_373 (79#) = happyGoto action_12 +action_373 (98#) = happyGoto action_13 +action_373 (100#) = happyGoto action_238 +action_373 (102#) = happyGoto action_15 +action_373 (112#) = happyGoto action_16 +action_373 (113#) = happyGoto action_17 +action_373 (114#) = happyGoto action_18 +action_373 (115#) = happyGoto action_19 +action_373 (123#) = happyGoto action_20 +action_373 x = happyTcHack x happyFail + +action_374 (159#) = happyShift action_395 +action_374 x = happyTcHack x happyFail + +action_375 x = happyTcHack x happyReduce_286 + +action_376 (47#) = happyGoto action_394 +action_376 x = happyTcHack x happyReduce_104 + +action_377 (159#) = happyShift action_393 +action_377 x = happyTcHack x happyFail + +action_378 (191#) = happyShift action_392 +action_378 (60#) = happyGoto action_391 +action_378 x = happyTcHack x happyReduce_134 + +action_379 (135#) = happyShift action_98 +action_379 (136#) = happyShift action_99 +action_379 (127#) = happyGoto action_390 +action_379 x = happyTcHack x happyFail + +action_380 x = happyTcHack x happyReduce_29 + +action_381 (133#) = happyShift action_21 +action_381 (135#) = happyShift action_23 +action_381 (136#) = happyShift action_24 +action_381 (145#) = happyShift action_196 +action_381 (151#) = happyShift action_197 +action_381 (169#) = happyShift action_35 +action_381 (177#) = happyShift action_38 +action_381 (192#) = happyShift action_41 +action_381 (32#) = happyGoto action_387 +action_381 (39#) = happyGoto action_388 +action_381 (40#) = happyGoto action_211 +action_381 (41#) = happyGoto action_189 +action_381 (42#) = happyGoto action_190 +action_381 (45#) = happyGoto action_389 +action_381 (113#) = happyGoto action_193 +action_381 (114#) = happyGoto action_194 +action_381 (115#) = happyGoto action_19 +action_381 (132#) = happyGoto action_195 +action_381 x = happyTcHack x happyReduce_70 + +action_382 (159#) = happyShift action_386 +action_382 x = happyTcHack x happyFail + +action_383 (191#) = happyShift action_385 +action_383 (59#) = happyGoto action_384 +action_383 x = happyTcHack x happyReduce_131 + +action_384 x = happyTcHack x happyReduce_64 + +action_385 (148#) = happyShift action_44 +action_385 (36#) = happyGoto action_409 +action_385 (125#) = happyGoto action_43 +action_385 x = happyTcHack x happyReduce_280 + +action_386 (48#) = happyGoto action_407 +action_386 (49#) = happyGoto action_408 +action_386 (124#) = happyGoto action_401 +action_386 x = happyTcHack x happyReduce_279 + +action_387 (146#) = happyShift action_406 +action_387 x = happyTcHack x happyFail + +action_388 (153#) = happyShift action_273 +action_388 x = happyTcHack x happyReduce_69 + +action_389 (153#) = happyShift action_271 +action_389 x = happyTcHack x happyReduce_68 + +action_390 (169#) = happyShift action_405 +action_390 (17#) = happyGoto action_404 +action_390 x = happyTcHack x happyReduce_32 + +action_391 x = happyTcHack x happyReduce_65 + +action_392 (148#) = happyShift action_403 +action_392 (125#) = happyGoto action_402 +action_392 x = happyTcHack x happyReduce_280 + +action_393 (49#) = happyGoto action_400 +action_393 (124#) = happyGoto action_401 +action_393 x = happyTcHack x happyReduce_279 + +action_394 (133#) = happyShift action_21 +action_394 (169#) = happyShift action_35 +action_394 (177#) = happyShift action_38 +action_394 (192#) = happyShift action_41 +action_394 (113#) = happyGoto action_193 +action_394 (132#) = happyGoto action_399 +action_394 x = happyTcHack x happyReduce_102 + +action_395 (133#) = happyShift action_21 +action_395 (135#) = happyShift action_23 +action_395 (136#) = happyShift action_24 +action_395 (145#) = happyShift action_196 +action_395 (151#) = happyShift action_197 +action_395 (169#) = happyShift action_35 +action_395 (177#) = happyShift action_38 +action_395 (192#) = happyShift action_41 +action_395 (39#) = happyGoto action_398 +action_395 (40#) = happyGoto action_211 +action_395 (41#) = happyGoto action_189 +action_395 (42#) = happyGoto action_190 +action_395 (113#) = happyGoto action_193 +action_395 (114#) = happyGoto action_194 +action_395 (115#) = happyGoto action_19 +action_395 (132#) = happyGoto action_195 +action_395 x = happyTcHack x happyFail + +action_396 (133#) = happyShift action_21 +action_396 (134#) = happyShift action_22 +action_396 (135#) = happyShift action_23 +action_396 (136#) = happyShift action_24 +action_396 (141#) = happyShift action_25 +action_396 (142#) = happyShift action_26 +action_396 (143#) = happyShift action_27 +action_396 (144#) = happyShift action_28 +action_396 (145#) = happyShift action_29 +action_396 (151#) = happyShift action_30 +action_396 (154#) = happyShift action_31 +action_396 (160#) = happyShift action_32 +action_396 (165#) = happyShift action_33 +action_396 (167#) = happyShift action_34 +action_396 (169#) = happyShift action_35 +action_396 (170#) = happyShift action_36 +action_396 (175#) = happyShift action_37 +action_396 (177#) = happyShift action_38 +action_396 (178#) = happyShift action_39 +action_396 (185#) = happyShift action_40 +action_396 (192#) = happyShift action_41 +action_396 (68#) = happyGoto action_397 +action_396 (69#) = happyGoto action_4 +action_396 (70#) = happyGoto action_5 +action_396 (71#) = happyGoto action_6 +action_396 (72#) = happyGoto action_7 +action_396 (73#) = happyGoto action_8 +action_396 (74#) = happyGoto action_9 +action_396 (77#) = happyGoto action_10 +action_396 (78#) = happyGoto action_11 +action_396 (79#) = happyGoto action_12 +action_396 (98#) = happyGoto action_13 +action_396 (100#) = happyGoto action_14 +action_396 (102#) = happyGoto action_15 +action_396 (112#) = happyGoto action_16 +action_396 (113#) = happyGoto action_17 +action_396 (114#) = happyGoto action_18 +action_396 (115#) = happyGoto action_19 +action_396 (123#) = happyGoto action_20 +action_396 x = happyTcHack x happyFail + +action_397 x = happyTcHack x happyReduce_210 + +action_398 x = happyTcHack x happyReduce_61 + +action_399 x = happyTcHack x happyReduce_103 + +action_400 (174#) = happyShift action_412 +action_400 (57#) = happyGoto action_429 +action_400 x = happyTcHack x happyReduce_124 + +action_401 (133#) = happyShift action_21 +action_401 (135#) = happyShift action_23 +action_401 (136#) = happyShift action_24 +action_401 (145#) = happyShift action_427 +action_401 (151#) = happyShift action_197 +action_401 (168#) = happyShift action_428 +action_401 (169#) = happyShift action_35 +action_401 (177#) = happyShift action_38 +action_401 (192#) = happyShift action_41 +action_401 (40#) = happyGoto action_421 +action_401 (41#) = happyGoto action_189 +action_401 (42#) = happyGoto action_190 +action_401 (50#) = happyGoto action_422 +action_401 (51#) = happyGoto action_423 +action_401 (53#) = happyGoto action_424 +action_401 (101#) = happyGoto action_425 +action_401 (113#) = happyGoto action_193 +action_401 (114#) = happyGoto action_194 +action_401 (115#) = happyGoto action_426 +action_401 (132#) = happyGoto action_195 +action_401 x = happyTcHack x happyFail + +action_402 (7#) = happyGoto action_140 +action_402 (8#) = happyGoto action_418 +action_402 (61#) = happyGoto action_420 +action_402 x = happyTcHack x happyReduce_11 + +action_403 (7#) = happyGoto action_140 +action_403 (8#) = happyGoto action_418 +action_403 (61#) = happyGoto action_419 +action_403 x = happyTcHack x happyReduce_11 + +action_404 (145#) = happyReduce_38 +action_404 (177#) = happyShift action_417 +action_404 (18#) = happyGoto action_414 +action_404 (19#) = happyGoto action_415 +action_404 (20#) = happyGoto action_416 +action_404 x = happyTcHack x happyReduce_34 + +action_405 (135#) = happyShift action_98 +action_405 (136#) = happyShift action_99 +action_405 (127#) = happyGoto action_413 +action_405 x = happyTcHack x happyFail + +action_406 x = happyTcHack x happyReduce_66 + +action_407 (161#) = happyShift action_411 +action_407 (174#) = happyShift action_412 +action_407 (57#) = happyGoto action_410 +action_407 x = happyTcHack x happyReduce_124 + +action_408 x = happyTcHack x happyReduce_106 + +action_409 x = happyTcHack x happyReduce_130 + +action_410 x = happyTcHack x happyReduce_62 + +action_411 (49#) = happyGoto action_447 +action_411 (124#) = happyGoto action_401 +action_411 x = happyTcHack x happyReduce_279 + +action_412 (135#) = happyShift action_23 +action_412 (136#) = happyShift action_24 +action_412 (145#) = happyShift action_446 +action_412 (114#) = happyGoto action_444 +action_412 (115#) = happyGoto action_19 +action_412 (131#) = happyGoto action_445 +action_412 x = happyTcHack x happyFail + +action_413 x = happyTcHack x happyReduce_31 + +action_414 x = happyTcHack x happyReduce_28 + +action_415 x = happyTcHack x happyReduce_33 + +action_416 (145#) = happyShift action_443 +action_416 x = happyTcHack x happyFail + +action_417 x = happyTcHack x happyReduce_37 + +action_418 (133#) = happyReduce_279 +action_418 (134#) = happyReduce_279 +action_418 (135#) = happyReduce_279 +action_418 (136#) = happyReduce_279 +action_418 (141#) = happyReduce_279 +action_418 (142#) = happyReduce_279 +action_418 (143#) = happyReduce_279 +action_418 (144#) = happyReduce_279 +action_418 (145#) = happyReduce_279 +action_418 (147#) = happyShift action_156 +action_418 (151#) = happyReduce_279 +action_418 (154#) = happyReduce_279 +action_418 (165#) = happyReduce_279 +action_418 (167#) = happyReduce_279 +action_418 (169#) = happyReduce_279 +action_418 (170#) = happyReduce_279 +action_418 (175#) = happyReduce_279 +action_418 (177#) = happyReduce_279 +action_418 (192#) = happyReduce_279 +action_418 (62#) = happyGoto action_440 +action_418 (63#) = happyGoto action_441 +action_418 (124#) = happyGoto action_442 +action_418 x = happyTcHack x happyReduce_136 + +action_419 (149#) = happyShift action_439 +action_419 x = happyTcHack x happyFail + +action_420 (1#) = happyShift action_147 +action_420 (150#) = happyShift action_148 +action_420 (126#) = happyGoto action_438 +action_420 x = happyTcHack x happyFail + +action_421 (133#) = happyShift action_21 +action_421 (135#) = happyShift action_23 +action_421 (136#) = happyShift action_24 +action_421 (138#) = happyReduce_117 +action_421 (145#) = happyShift action_196 +action_421 (151#) = happyShift action_197 +action_421 (155#) = happyReduce_117 +action_421 (168#) = happyShift action_437 +action_421 (169#) = happyShift action_35 +action_421 (177#) = happyShift action_38 +action_421 (192#) = happyShift action_41 +action_421 (41#) = happyGoto action_219 +action_421 (42#) = happyGoto action_190 +action_421 (113#) = happyGoto action_193 +action_421 (114#) = happyGoto action_194 +action_421 (115#) = happyGoto action_19 +action_421 (132#) = happyGoto action_195 +action_421 x = happyTcHack x happyReduce_111 + +action_422 x = happyTcHack x happyReduce_107 + +action_423 (133#) = happyShift action_21 +action_423 (135#) = happyShift action_23 +action_423 (136#) = happyShift action_24 +action_423 (145#) = happyShift action_196 +action_423 (151#) = happyShift action_197 +action_423 (168#) = happyShift action_436 +action_423 (169#) = happyShift action_35 +action_423 (177#) = happyShift action_38 +action_423 (192#) = happyShift action_41 +action_423 (41#) = happyGoto action_434 +action_423 (42#) = happyGoto action_190 +action_423 (52#) = happyGoto action_435 +action_423 (113#) = happyGoto action_193 +action_423 (114#) = happyGoto action_194 +action_423 (115#) = happyGoto action_19 +action_423 (132#) = happyGoto action_195 +action_423 x = happyTcHack x happyReduce_112 + +action_424 (138#) = happyShift action_73 +action_424 (155#) = happyShift action_433 +action_424 (106#) = happyGoto action_432 +action_424 (117#) = happyGoto action_309 +action_424 x = happyTcHack x happyFail + +action_425 (148#) = happyShift action_431 +action_425 x = happyTcHack x happyFail + +action_426 (148#) = happyReduce_231 +action_426 x = happyTcHack x happyReduce_259 + +action_427 (133#) = happyShift action_21 +action_427 (135#) = happyShift action_23 +action_427 (136#) = happyShift action_24 +action_427 (138#) = happyShift action_73 +action_427 (145#) = happyShift action_196 +action_427 (146#) = happyShift action_216 +action_427 (151#) = happyShift action_197 +action_427 (153#) = happyShift action_77 +action_427 (163#) = happyShift action_217 +action_427 (169#) = happyShift action_35 +action_427 (177#) = happyShift action_38 +action_427 (192#) = happyShift action_41 +action_427 (39#) = happyGoto action_213 +action_427 (40#) = happyGoto action_211 +action_427 (41#) = happyGoto action_189 +action_427 (42#) = happyGoto action_190 +action_427 (45#) = happyGoto action_214 +action_427 (80#) = happyGoto action_215 +action_427 (113#) = happyGoto action_193 +action_427 (114#) = happyGoto action_194 +action_427 (115#) = happyGoto action_19 +action_427 (117#) = happyGoto action_343 +action_427 (132#) = happyGoto action_195 +action_427 x = happyTcHack x happyFail + +action_428 (133#) = happyShift action_21 +action_428 (135#) = happyShift action_23 +action_428 (136#) = happyShift action_24 +action_428 (145#) = happyShift action_196 +action_428 (151#) = happyShift action_197 +action_428 (169#) = happyShift action_35 +action_428 (177#) = happyShift action_38 +action_428 (192#) = happyShift action_41 +action_428 (41#) = happyGoto action_430 +action_428 (42#) = happyGoto action_190 +action_428 (113#) = happyGoto action_193 +action_428 (114#) = happyGoto action_194 +action_428 (115#) = happyGoto action_19 +action_428 (132#) = happyGoto action_195 +action_428 x = happyTcHack x happyFail + +action_429 x = happyTcHack x happyReduce_63 + +action_430 x = happyTcHack x happyReduce_118 + +action_431 (133#) = happyShift action_21 +action_431 (134#) = happyShift action_22 +action_431 (145#) = happyShift action_108 +action_431 (149#) = happyShift action_467 +action_431 (169#) = happyShift action_35 +action_431 (177#) = happyShift action_38 +action_431 (192#) = happyShift action_41 +action_431 (38#) = happyGoto action_463 +action_431 (54#) = happyGoto action_464 +action_431 (55#) = happyGoto action_465 +action_431 (100#) = happyGoto action_466 +action_431 (112#) = happyGoto action_16 +action_431 (113#) = happyGoto action_17 +action_431 x = happyTcHack x happyFail + +action_432 (133#) = happyShift action_21 +action_432 (135#) = happyShift action_23 +action_432 (136#) = happyShift action_24 +action_432 (145#) = happyShift action_196 +action_432 (151#) = happyShift action_197 +action_432 (168#) = happyShift action_428 +action_432 (169#) = happyShift action_35 +action_432 (177#) = happyShift action_38 +action_432 (192#) = happyShift action_41 +action_432 (40#) = happyGoto action_461 +action_432 (41#) = happyGoto action_189 +action_432 (42#) = happyGoto action_190 +action_432 (53#) = happyGoto action_462 +action_432 (113#) = happyGoto action_193 +action_432 (114#) = happyGoto action_194 +action_432 (115#) = happyGoto action_19 +action_432 (132#) = happyGoto action_195 +action_432 x = happyTcHack x happyFail + +action_433 (135#) = happyShift action_23 +action_433 (115#) = happyGoto action_324 +action_433 x = happyTcHack x happyFail + +action_434 x = happyTcHack x happyReduce_115 + +action_435 x = happyTcHack x happyReduce_114 + +action_436 (133#) = happyShift action_21 +action_436 (135#) = happyShift action_23 +action_436 (136#) = happyShift action_24 +action_436 (145#) = happyShift action_196 +action_436 (151#) = happyShift action_197 +action_436 (169#) = happyShift action_35 +action_436 (177#) = happyShift action_38 +action_436 (192#) = happyShift action_41 +action_436 (41#) = happyGoto action_460 +action_436 (42#) = happyGoto action_190 +action_436 (113#) = happyGoto action_193 +action_436 (114#) = happyGoto action_194 +action_436 (115#) = happyGoto action_19 +action_436 (132#) = happyGoto action_195 +action_436 x = happyTcHack x happyFail + +action_437 (133#) = happyShift action_21 +action_437 (135#) = happyShift action_23 +action_437 (136#) = happyShift action_24 +action_437 (145#) = happyShift action_196 +action_437 (151#) = happyShift action_197 +action_437 (169#) = happyShift action_35 +action_437 (177#) = happyShift action_38 +action_437 (192#) = happyShift action_41 +action_437 (41#) = happyGoto action_459 +action_437 (42#) = happyGoto action_190 +action_437 (113#) = happyGoto action_193 +action_437 (114#) = happyGoto action_194 +action_437 (115#) = happyGoto action_19 +action_437 (132#) = happyGoto action_195 +action_437 x = happyTcHack x happyFail + +action_438 x = happyTcHack x happyReduce_133 + +action_439 x = happyTcHack x happyReduce_132 + +action_440 (7#) = happyGoto action_457 +action_440 (8#) = happyGoto action_458 +action_440 x = happyTcHack x happyReduce_11 + +action_441 x = happyTcHack x happyReduce_138 + +action_442 (133#) = happyShift action_21 +action_442 (134#) = happyShift action_22 +action_442 (135#) = happyShift action_23 +action_442 (136#) = happyShift action_24 +action_442 (141#) = happyShift action_25 +action_442 (142#) = happyShift action_26 +action_442 (143#) = happyShift action_27 +action_442 (144#) = happyShift action_28 +action_442 (145#) = happyShift action_29 +action_442 (151#) = happyShift action_30 +action_442 (154#) = happyShift action_31 +action_442 (165#) = happyShift action_33 +action_442 (167#) = happyShift action_34 +action_442 (169#) = happyShift action_35 +action_442 (170#) = happyShift action_36 +action_442 (175#) = happyShift action_37 +action_442 (177#) = happyShift action_38 +action_442 (192#) = happyShift action_41 +action_442 (71#) = happyGoto action_237 +action_442 (73#) = happyGoto action_8 +action_442 (74#) = happyGoto action_9 +action_442 (77#) = happyGoto action_10 +action_442 (78#) = happyGoto action_11 +action_442 (79#) = happyGoto action_12 +action_442 (98#) = happyGoto action_13 +action_442 (100#) = happyGoto action_14 +action_442 (102#) = happyGoto action_15 +action_442 (112#) = happyGoto action_16 +action_442 (113#) = happyGoto action_17 +action_442 (114#) = happyGoto action_18 +action_442 (115#) = happyGoto action_19 +action_442 (123#) = happyGoto action_20 +action_442 x = happyTcHack x happyFail + +action_443 (133#) = happyShift action_21 +action_443 (135#) = happyShift action_23 +action_443 (145#) = happyShift action_314 +action_443 (153#) = happyShift action_207 +action_443 (169#) = happyShift action_35 +action_443 (177#) = happyShift action_38 +action_443 (192#) = happyShift action_41 +action_443 (11#) = happyGoto action_451 +action_443 (21#) = happyGoto action_452 +action_443 (22#) = happyGoto action_453 +action_443 (99#) = happyGoto action_454 +action_443 (113#) = happyGoto action_289 +action_443 (115#) = happyGoto action_455 +action_443 (128#) = happyGoto action_456 +action_443 x = happyTcHack x happyReduce_17 + +action_444 x = happyTcHack x happyReduce_288 + +action_445 x = happyTcHack x happyReduce_125 + +action_446 (135#) = happyShift action_23 +action_446 (136#) = happyShift action_24 +action_446 (146#) = happyShift action_450 +action_446 (58#) = happyGoto action_448 +action_446 (114#) = happyGoto action_444 +action_446 (115#) = happyGoto action_19 +action_446 (131#) = happyGoto action_449 +action_446 x = happyTcHack x happyFail + +action_447 x = happyTcHack x happyReduce_105 + +action_448 (146#) = happyShift action_476 +action_448 (153#) = happyShift action_477 +action_448 x = happyTcHack x happyFail + +action_449 x = happyTcHack x happyReduce_129 + +action_450 x = happyTcHack x happyReduce_126 + +action_451 (146#) = happyShift action_475 +action_451 x = happyTcHack x happyFail + +action_452 (153#) = happyShift action_474 +action_452 (11#) = happyGoto action_473 +action_452 x = happyTcHack x happyReduce_17 + +action_453 x = happyTcHack x happyReduce_40 + +action_454 x = happyTcHack x happyReduce_41 + +action_455 x = happyTcHack x happyReduce_285 + +action_456 (145#) = happyShift action_472 +action_456 x = happyTcHack x happyReduce_42 + +action_457 (133#) = happyReduce_279 +action_457 (134#) = happyReduce_279 +action_457 (135#) = happyReduce_279 +action_457 (136#) = happyReduce_279 +action_457 (141#) = happyReduce_279 +action_457 (142#) = happyReduce_279 +action_457 (143#) = happyReduce_279 +action_457 (144#) = happyReduce_279 +action_457 (145#) = happyReduce_279 +action_457 (151#) = happyReduce_279 +action_457 (154#) = happyReduce_279 +action_457 (165#) = happyReduce_279 +action_457 (167#) = happyReduce_279 +action_457 (169#) = happyReduce_279 +action_457 (170#) = happyReduce_279 +action_457 (175#) = happyReduce_279 +action_457 (177#) = happyReduce_279 +action_457 (192#) = happyReduce_279 +action_457 (63#) = happyGoto action_471 +action_457 (124#) = happyGoto action_442 +action_457 x = happyTcHack x happyReduce_10 + +action_458 (147#) = happyShift action_156 +action_458 x = happyTcHack x happyReduce_135 + +action_459 x = happyTcHack x happyReduce_113 + +action_460 x = happyTcHack x happyReduce_116 + +action_461 (133#) = happyShift action_21 +action_461 (135#) = happyShift action_23 +action_461 (136#) = happyShift action_24 +action_461 (145#) = happyShift action_196 +action_461 (151#) = happyShift action_197 +action_461 (169#) = happyShift action_35 +action_461 (177#) = happyShift action_38 +action_461 (192#) = happyShift action_41 +action_461 (41#) = happyGoto action_219 +action_461 (42#) = happyGoto action_190 +action_461 (113#) = happyGoto action_193 +action_461 (114#) = happyGoto action_194 +action_461 (115#) = happyGoto action_19 +action_461 (132#) = happyGoto action_195 +action_461 x = happyTcHack x happyReduce_117 + +action_462 x = happyTcHack x happyReduce_108 + +action_463 (153#) = happyShift action_251 +action_463 (158#) = happyShift action_470 +action_463 x = happyTcHack x happyFail + +action_464 (149#) = happyShift action_468 +action_464 (153#) = happyShift action_469 +action_464 x = happyTcHack x happyFail + +action_465 x = happyTcHack x happyReduce_120 + +action_466 x = happyTcHack x happyReduce_82 + +action_467 x = happyTcHack x happyReduce_109 + +action_468 x = happyTcHack x happyReduce_110 + +action_469 (133#) = happyShift action_21 +action_469 (134#) = happyShift action_22 +action_469 (145#) = happyShift action_108 +action_469 (169#) = happyShift action_35 +action_469 (177#) = happyShift action_38 +action_469 (192#) = happyShift action_41 +action_469 (38#) = happyGoto action_463 +action_469 (55#) = happyGoto action_487 +action_469 (100#) = happyGoto action_466 +action_469 (112#) = happyGoto action_16 +action_469 (113#) = happyGoto action_17 +action_469 x = happyTcHack x happyFail + +action_470 (133#) = happyShift action_21 +action_470 (135#) = happyShift action_23 +action_470 (136#) = happyShift action_24 +action_470 (145#) = happyShift action_196 +action_470 (151#) = happyShift action_197 +action_470 (168#) = happyShift action_486 +action_470 (169#) = happyShift action_35 +action_470 (177#) = happyShift action_38 +action_470 (192#) = happyShift action_41 +action_470 (39#) = happyGoto action_484 +action_470 (40#) = happyGoto action_211 +action_470 (41#) = happyGoto action_189 +action_470 (42#) = happyGoto action_190 +action_470 (56#) = happyGoto action_485 +action_470 (113#) = happyGoto action_193 +action_470 (114#) = happyGoto action_194 +action_470 (115#) = happyGoto action_19 +action_470 (132#) = happyGoto action_195 +action_470 x = happyTcHack x happyFail + +action_471 x = happyTcHack x happyReduce_137 + +action_472 (133#) = happyShift action_21 +action_472 (135#) = happyShift action_23 +action_472 (145#) = happyShift action_291 +action_472 (146#) = happyShift action_482 +action_472 (156#) = happyShift action_483 +action_472 (169#) = happyShift action_35 +action_472 (177#) = happyShift action_38 +action_472 (192#) = happyShift action_41 +action_472 (23#) = happyGoto action_481 +action_472 (24#) = happyGoto action_286 +action_472 (99#) = happyGoto action_287 +action_472 (101#) = happyGoto action_288 +action_472 (113#) = happyGoto action_289 +action_472 (115#) = happyGoto action_290 +action_472 x = happyTcHack x happyFail + +action_473 (146#) = happyShift action_480 +action_473 x = happyTcHack x happyFail + +action_474 (133#) = happyShift action_21 +action_474 (135#) = happyShift action_23 +action_474 (145#) = happyShift action_314 +action_474 (169#) = happyShift action_35 +action_474 (177#) = happyShift action_38 +action_474 (192#) = happyShift action_41 +action_474 (22#) = happyGoto action_479 +action_474 (99#) = happyGoto action_454 +action_474 (113#) = happyGoto action_289 +action_474 (115#) = happyGoto action_455 +action_474 (128#) = happyGoto action_456 +action_474 x = happyTcHack x happyReduce_16 + +action_475 x = happyTcHack x happyReduce_36 + +action_476 x = happyTcHack x happyReduce_127 + +action_477 (135#) = happyShift action_23 +action_477 (136#) = happyShift action_24 +action_477 (114#) = happyGoto action_444 +action_477 (115#) = happyGoto action_19 +action_477 (131#) = happyGoto action_478 +action_477 x = happyTcHack x happyFail + +action_478 x = happyTcHack x happyReduce_128 + +action_479 x = happyTcHack x happyReduce_39 + +action_480 x = happyTcHack x happyReduce_35 + +action_481 (146#) = happyShift action_490 +action_481 (153#) = happyShift action_345 +action_481 x = happyTcHack x happyFail + +action_482 x = happyTcHack x happyReduce_44 + +action_483 (146#) = happyShift action_489 +action_483 x = happyTcHack x happyFail + +action_484 x = happyTcHack x happyReduce_122 + +action_485 x = happyTcHack x happyReduce_121 + +action_486 (133#) = happyShift action_21 +action_486 (135#) = happyShift action_23 +action_486 (136#) = happyShift action_24 +action_486 (145#) = happyShift action_196 +action_486 (151#) = happyShift action_197 +action_486 (169#) = happyShift action_35 +action_486 (177#) = happyShift action_38 +action_486 (192#) = happyShift action_41 +action_486 (41#) = happyGoto action_488 +action_486 (42#) = happyGoto action_190 +action_486 (113#) = happyGoto action_193 +action_486 (114#) = happyGoto action_194 +action_486 (115#) = happyGoto action_19 +action_486 (132#) = happyGoto action_195 +action_486 x = happyTcHack x happyFail + +action_487 x = happyTcHack x happyReduce_119 + +action_488 x = happyTcHack x happyReduce_123 + +action_489 x = happyTcHack x happyReduce_43 + +action_490 x = happyTcHack x happyReduce_45 + +happyReduce_1 = happyReduce 6# 4# happyReduction_1 +happyReduction_1 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut127 happy_x_3 of { happy_var_3 -> + case happyOut9 happy_x_4 of { happy_var_4 -> + case happyOut5 happy_x_6 of { happy_var_6 -> + happyIn4 + (HsModule happy_var_1 happy_var_3 happy_var_4 (fst happy_var_6) (snd happy_var_6) + ) `HappyStk` happyRest}}}} + +happyReduce_2 = happySpecReduce_2 4# happyReduction_2 +happyReduction_2 happy_x_2 + happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut5 happy_x_2 of { happy_var_2 -> + happyIn4 + (HsModule happy_var_1 main_mod (Just [HsEVar (UnQual main_name)]) + (fst happy_var_2) (snd happy_var_2) + )}} + +happyReduce_3 = happySpecReduce_3 5# happyReduction_3 +happyReduction_3 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut6 happy_x_2 of { happy_var_2 -> + happyIn5 + (happy_var_2 + )} + +happyReduce_4 = happySpecReduce_3 5# happyReduction_4 +happyReduction_4 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut6 happy_x_2 of { happy_var_2 -> + happyIn5 + (happy_var_2 + )} + +happyReduce_5 = happyReduce 4# 6# happyReduction_5 +happyReduction_5 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut14 happy_x_2 of { happy_var_2 -> + case happyOut29 happy_x_4 of { happy_var_4 -> + happyIn6 + ((reverse happy_var_2, happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_6 = happySpecReduce_2 6# happyReduction_6 +happyReduction_6 happy_x_2 + happy_x_1 + = case happyOut29 happy_x_2 of { happy_var_2 -> + happyIn6 + (([], happy_var_2) + )} + +happyReduce_7 = happySpecReduce_3 6# happyReduction_7 +happyReduction_7 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut14 happy_x_2 of { happy_var_2 -> + happyIn6 + ((reverse happy_var_2, []) + )} + +happyReduce_8 = happySpecReduce_1 6# happyReduction_8 +happyReduction_8 happy_x_1 + = happyIn6 + (([], []) + ) + +happyReduce_9 = happySpecReduce_2 7# happyReduction_9 +happyReduction_9 happy_x_2 + happy_x_1 + = happyIn7 + (() + ) + +happyReduce_10 = happySpecReduce_1 8# happyReduction_10 +happyReduction_10 happy_x_1 + = happyIn8 + (() + ) + +happyReduce_11 = happySpecReduce_0 8# happyReduction_11 +happyReduction_11 = happyIn8 + (() + ) + +happyReduce_12 = happySpecReduce_1 9# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOut10 happy_x_1 of { happy_var_1 -> + happyIn9 + (Just happy_var_1 + )} + +happyReduce_13 = happySpecReduce_0 9# happyReduction_13 +happyReduction_13 = happyIn9 + (Nothing + ) + +happyReduce_14 = happyReduce 4# 10# happyReduction_14 +happyReduction_14 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn10 + (reverse happy_var_2 + ) `HappyStk` happyRest} + +happyReduce_15 = happySpecReduce_3 10# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn10 + ([] + ) + +happyReduce_16 = happySpecReduce_1 11# happyReduction_16 +happyReduction_16 happy_x_1 + = happyIn11 + (() + ) + +happyReduce_17 = happySpecReduce_0 11# happyReduction_17 +happyReduction_17 = happyIn11 + (() + ) + +happyReduce_18 = happySpecReduce_3 12# happyReduction_18 +happyReduction_18 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + case happyOut13 happy_x_3 of { happy_var_3 -> + happyIn12 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_19 = happySpecReduce_1 12# happyReduction_19 +happyReduction_19 happy_x_1 + = case happyOut13 happy_x_1 of { happy_var_1 -> + happyIn12 + ([happy_var_1] + )} + +happyReduce_20 = happySpecReduce_1 13# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn13 + (HsEVar happy_var_1 + )} + +happyReduce_21 = happySpecReduce_1 13# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn13 + (HsEAbs happy_var_1 + )} + +happyReduce_22 = happyReduce 4# 13# happyReduction_22 +happyReduction_22 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn13 + (HsEThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_23 = happySpecReduce_3 13# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn13 + (HsEThingWith happy_var_1 [] + )} + +happyReduce_24 = happyReduce 4# 13# happyReduction_24 +happyReduction_24 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut130 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn13 + (HsEThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_25 = happySpecReduce_2 13# happyReduction_25 +happyReduction_25 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_2 of { happy_var_2 -> + happyIn13 + (HsEModuleContents happy_var_2 + )} + +happyReduce_26 = happySpecReduce_3 14# happyReduction_26 +happyReduction_26 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut14 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + happyIn14 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_27 = happySpecReduce_1 14# happyReduction_27 +happyReduction_27 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + ([happy_var_1] + )} + +happyReduce_28 = happyReduce 6# 15# happyReduction_28 +happyReduction_28 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut16 happy_x_3 of { happy_var_3 -> + case happyOut127 happy_x_4 of { happy_var_4 -> + case happyOut17 happy_x_5 of { happy_var_5 -> + case happyOut18 happy_x_6 of { happy_var_6 -> + happyIn15 + (HsImportDecl happy_var_1 happy_var_4 happy_var_3 happy_var_5 happy_var_6 + ) `HappyStk` happyRest}}}}} + +happyReduce_29 = happySpecReduce_1 16# happyReduction_29 +happyReduction_29 happy_x_1 + = happyIn16 + (True + ) + +happyReduce_30 = happySpecReduce_0 16# happyReduction_30 +happyReduction_30 = happyIn16 + (False + ) + +happyReduce_31 = happySpecReduce_2 17# happyReduction_31 +happyReduction_31 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_2 of { happy_var_2 -> + happyIn17 + (Just happy_var_2 + )} + +happyReduce_32 = happySpecReduce_0 17# happyReduction_32 +happyReduction_32 = happyIn17 + (Nothing + ) + +happyReduce_33 = happySpecReduce_1 18# happyReduction_33 +happyReduction_33 happy_x_1 + = case happyOut19 happy_x_1 of { happy_var_1 -> + happyIn18 + (Just happy_var_1 + )} + +happyReduce_34 = happySpecReduce_0 18# happyReduction_34 +happyReduction_34 = happyIn18 + (Nothing + ) + +happyReduce_35 = happyReduce 5# 19# happyReduction_35 +happyReduction_35 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_1 of { happy_var_1 -> + case happyOut21 happy_x_3 of { happy_var_3 -> + happyIn19 + ((happy_var_1, reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_36 = happyReduce 4# 19# happyReduction_36 +happyReduction_36 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_1 of { happy_var_1 -> + happyIn19 + ((happy_var_1, []) + ) `HappyStk` happyRest} + +happyReduce_37 = happySpecReduce_1 20# happyReduction_37 +happyReduction_37 happy_x_1 + = happyIn20 + (True + ) + +happyReduce_38 = happySpecReduce_0 20# happyReduction_38 +happyReduction_38 = happyIn20 + (False + ) + +happyReduce_39 = happySpecReduce_3 21# happyReduction_39 +happyReduction_39 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + case happyOut22 happy_x_3 of { happy_var_3 -> + happyIn21 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_40 = happySpecReduce_1 21# happyReduction_40 +happyReduction_40 happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn21 + ([happy_var_1] + )} + +happyReduce_41 = happySpecReduce_1 22# happyReduction_41 +happyReduction_41 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn22 + (HsIVar happy_var_1 + )} + +happyReduce_42 = happySpecReduce_1 22# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn22 + (HsIAbs happy_var_1 + )} + +happyReduce_43 = happyReduce 4# 22# happyReduction_43 +happyReduction_43 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn22 + (HsIThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_44 = happySpecReduce_3 22# happyReduction_44 +happyReduction_44 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn22 + (HsIThingWith happy_var_1 [] + )} + +happyReduce_45 = happyReduce 4# 22# happyReduction_45 +happyReduction_45 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut128 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn22 + (HsIThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_46 = happySpecReduce_3 23# happyReduction_46 +happyReduction_46 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut23 happy_x_1 of { happy_var_1 -> + case happyOut24 happy_x_3 of { happy_var_3 -> + happyIn23 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_47 = happySpecReduce_1 23# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn23 + ([happy_var_1] + )} + +happyReduce_48 = happySpecReduce_1 24# happyReduction_48 +happyReduction_48 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsVarName happy_var_1 + )} + +happyReduce_49 = happySpecReduce_1 24# happyReduction_49 +happyReduction_49 happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsConName happy_var_1 + )} + +happyReduce_50 = happyReduce 4# 25# happyReduction_50 +happyReduction_50 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_2 of { happy_var_2 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + case happyOut28 happy_x_4 of { happy_var_4 -> + happyIn25 + (HsInfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) + ) `HappyStk` happyRest}}}} + +happyReduce_51 = happySpecReduce_0 26# happyReduction_51 +happyReduction_51 = happyIn26 + (9 + ) + +happyReduce_52 = happyMonadReduce 1# 26# happyReduction_52 +happyReduction_52 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + checkPrec happy_var_1} + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_53 = happySpecReduce_1 27# happyReduction_53 +happyReduction_53 happy_x_1 + = happyIn27 + (HsAssocNone + ) + +happyReduce_54 = happySpecReduce_1 27# happyReduction_54 +happyReduction_54 happy_x_1 + = happyIn27 + (HsAssocLeft + ) + +happyReduce_55 = happySpecReduce_1 27# happyReduction_55 +happyReduction_55 happy_x_1 + = happyIn27 + (HsAssocRight + ) + +happyReduce_56 = happySpecReduce_3 28# happyReduction_56 +happyReduction_56 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut28 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_3 of { happy_var_3 -> + happyIn28 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_57 = happySpecReduce_1 28# happyReduction_57 +happyReduction_57 happy_x_1 + = case happyOut108 happy_x_1 of { happy_var_1 -> + happyIn28 + ([happy_var_1] + )} + +happyReduce_58 = happyMonadReduce 2# 29# happyReduction_58 +happyReduction_58 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut30 happy_x_1 of { happy_var_1 -> + checkRevDecls happy_var_1} + ) (\r -> happyReturn (happyIn29 r)) + +happyReduce_59 = happySpecReduce_3 30# happyReduction_59 +happyReduction_59 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut31 happy_x_3 of { happy_var_3 -> + happyIn30 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_60 = happySpecReduce_1 30# happyReduction_60 +happyReduction_60 happy_x_1 + = case happyOut31 happy_x_1 of { happy_var_1 -> + happyIn30 + ([happy_var_1] + )} + +happyReduce_61 = happyReduce 5# 31# happyReduction_61 +happyReduction_61 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + case happyOut39 happy_x_5 of { happy_var_5 -> + happyIn31 + (HsTypeDecl happy_var_1 (fst happy_var_3) (snd happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_62 = happyMonadReduce 6# 31# happyReduction_62 +happyReduction_62 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_3 of { happy_var_3 -> + case happyOut48 happy_x_5 of { happy_var_5 -> + case happyOut57 happy_x_6 of { happy_var_6 -> + do { (cs,c,t) <- checkDataHeader happy_var_3; + return (HsDataDecl happy_var_1 cs c t (reverse happy_var_5) happy_var_6) }}}}} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_63 = happyMonadReduce 6# 31# happyReduction_63 +happyReduction_63 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_3 of { happy_var_3 -> + case happyOut49 happy_x_5 of { happy_var_5 -> + case happyOut57 happy_x_6 of { happy_var_6 -> + do { (cs,c,t) <- checkDataHeader happy_var_3; + return (HsNewTypeDecl happy_var_1 cs c t happy_var_5 happy_var_6) }}}}} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_64 = happyMonadReduce 4# 31# happyReduction_64 +happyReduction_64 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_3 of { happy_var_3 -> + case happyOut59 happy_x_4 of { happy_var_4 -> + do { (cs,c,vs) <- checkClassHeader happy_var_3; + return (HsClassDecl happy_var_1 cs c vs happy_var_4) }}}} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_65 = happyMonadReduce 4# 31# happyReduction_65 +happyReduction_65 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut43 happy_x_3 of { happy_var_3 -> + case happyOut60 happy_x_4 of { happy_var_4 -> + do { (cs,c,ts) <- checkInstHeader happy_var_3; + return (HsInstDecl happy_var_1 cs c ts happy_var_4) }}}} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_66 = happyReduce 5# 31# happyReduction_66 +happyReduction_66 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut32 happy_x_4 of { happy_var_4 -> + happyIn31 + (HsDefaultDecl happy_var_1 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_67 = happySpecReduce_1 31# happyReduction_67 +happyReduction_67 happy_x_1 + = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn31 + (happy_var_1 + )} + +happyReduce_68 = happySpecReduce_1 32# happyReduction_68 +happyReduction_68 happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + happyIn32 + (reverse happy_var_1 + )} + +happyReduce_69 = happySpecReduce_1 32# happyReduction_69 +happyReduction_69 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn32 + ([happy_var_1] + )} + +happyReduce_70 = happySpecReduce_0 32# happyReduction_70 +happyReduction_70 = happyIn32 + ([] + ) + +happyReduce_71 = happyMonadReduce 3# 33# happyReduction_71 +happyReduction_71 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut34 happy_x_2 of { happy_var_2 -> + checkRevDecls happy_var_2} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_72 = happySpecReduce_1 33# happyReduction_72 +happyReduction_72 happy_x_1 + = happyIn33 + ([] + ) + +happyReduce_73 = happySpecReduce_3 34# happyReduction_73 +happyReduction_73 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut34 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn34 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_74 = happySpecReduce_1 34# happyReduction_74 +happyReduction_74 happy_x_1 + = case happyOut35 happy_x_1 of { happy_var_1 -> + happyIn34 + ([happy_var_1] + )} + +happyReduce_75 = happySpecReduce_1 35# happyReduction_75 +happyReduction_75 happy_x_1 + = case happyOut37 happy_x_1 of { happy_var_1 -> + happyIn35 + (happy_var_1 + )} + +happyReduce_76 = happySpecReduce_1 35# happyReduction_76 +happyReduction_76 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn35 + (happy_var_1 + )} + +happyReduce_77 = happySpecReduce_1 35# happyReduction_77 +happyReduction_77 happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn35 + (happy_var_1 + )} + +happyReduce_78 = happySpecReduce_3 36# happyReduction_78 +happyReduction_78 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut33 happy_x_2 of { happy_var_2 -> + happyIn36 + (happy_var_2 + )} + +happyReduce_79 = happySpecReduce_3 36# happyReduction_79 +happyReduction_79 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut33 happy_x_2 of { happy_var_2 -> + happyIn36 + (happy_var_2 + )} + +happyReduce_80 = happyReduce 4# 37# happyReduction_80 +happyReduction_80 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_2 of { happy_var_2 -> + case happyOut43 happy_x_4 of { happy_var_4 -> + happyIn37 + (HsTypeSig happy_var_1 (reverse happy_var_2) happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_81 = happySpecReduce_3 38# happyReduction_81 +happyReduction_81 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + happyIn38 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_82 = happyMonadReduce 1# 38# happyReduction_82 +happyReduction_82 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut100 happy_x_1 of { happy_var_1 -> + do { n <- checkUnQual happy_var_1; + return [n] }} + ) (\r -> happyReturn (happyIn38 r)) + +happyReduce_83 = happySpecReduce_3 39# happyReduction_83 +happyReduction_83 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + happyIn39 + (HsTyFun happy_var_1 happy_var_3 + )}} + +happyReduce_84 = happySpecReduce_1 39# happyReduction_84 +happyReduction_84 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn39 + (happy_var_1 + )} + +happyReduce_85 = happySpecReduce_2 40# happyReduction_85 +happyReduction_85 happy_x_2 + happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn40 + (HsTyApp happy_var_1 happy_var_2 + )}} + +happyReduce_86 = happySpecReduce_1 40# happyReduction_86 +happyReduction_86 happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn40 + (happy_var_1 + )} + +happyReduce_87 = happySpecReduce_1 41# happyReduction_87 +happyReduction_87 happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + happyIn41 + (HsTyCon happy_var_1 + )} + +happyReduce_88 = happySpecReduce_1 41# happyReduction_88 +happyReduction_88 happy_x_1 + = case happyOut132 happy_x_1 of { happy_var_1 -> + happyIn41 + (HsTyVar happy_var_1 + )} + +happyReduce_89 = happySpecReduce_3 41# happyReduction_89 +happyReduction_89 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut45 happy_x_2 of { happy_var_2 -> + happyIn41 + (HsTyTuple (reverse happy_var_2) + )} + +happyReduce_90 = happySpecReduce_3 41# happyReduction_90 +happyReduction_90 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn41 + (HsTyApp list_tycon happy_var_2 + )} + +happyReduce_91 = happySpecReduce_3 41# happyReduction_91 +happyReduction_91 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut39 happy_x_2 of { happy_var_2 -> + happyIn41 + (happy_var_2 + )} + +happyReduce_92 = happySpecReduce_1 42# happyReduction_92 +happyReduction_92 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn42 + (happy_var_1 + )} + +happyReduce_93 = happySpecReduce_2 42# happyReduction_93 +happyReduction_93 happy_x_2 + happy_x_1 + = happyIn42 + (unit_tycon_name + ) + +happyReduce_94 = happySpecReduce_3 42# happyReduction_94 +happyReduction_94 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn42 + (fun_tycon_name + ) + +happyReduce_95 = happySpecReduce_2 42# happyReduction_95 +happyReduction_95 happy_x_2 + happy_x_1 + = happyIn42 + (list_tycon_name + ) + +happyReduce_96 = happySpecReduce_3 42# happyReduction_96 +happyReduction_96 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn42 + (tuple_tycon_name happy_var_2 + )} + +happyReduce_97 = happySpecReduce_3 43# happyReduction_97 +happyReduction_97 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + happyIn43 + (HsQualType happy_var_1 happy_var_3 + )}} + +happyReduce_98 = happySpecReduce_1 43# happyReduction_98 +happyReduction_98 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn43 + (HsQualType [] happy_var_1 + )} + +happyReduce_99 = happyMonadReduce 1# 44# happyReduction_99 +happyReduction_99 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut40 happy_x_1 of { happy_var_1 -> + checkContext happy_var_1} + ) (\r -> happyReturn (happyIn44 r)) + +happyReduce_100 = happySpecReduce_3 45# happyReduction_100 +happyReduction_100 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + happyIn45 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_101 = happySpecReduce_3 45# happyReduction_101 +happyReduction_101 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + case happyOut39 happy_x_3 of { happy_var_3 -> + happyIn45 + ([happy_var_3, happy_var_1] + )}} + +happyReduce_102 = happySpecReduce_2 46# happyReduction_102 +happyReduction_102 happy_x_2 + happy_x_1 + = case happyOut129 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_2 of { happy_var_2 -> + happyIn46 + ((happy_var_1,reverse happy_var_2) + )}} + +happyReduce_103 = happySpecReduce_2 47# happyReduction_103 +happyReduction_103 happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut132 happy_x_2 of { happy_var_2 -> + happyIn47 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_104 = happySpecReduce_0 47# happyReduction_104 +happyReduction_104 = happyIn47 + ([] + ) + +happyReduce_105 = happySpecReduce_3 48# happyReduction_105 +happyReduction_105 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + case happyOut49 happy_x_3 of { happy_var_3 -> + happyIn48 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_106 = happySpecReduce_1 48# happyReduction_106 +happyReduction_106 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn48 + ([happy_var_1] + )} + +happyReduce_107 = happySpecReduce_2 49# happyReduction_107 +happyReduction_107 happy_x_2 + happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_2 of { happy_var_2 -> + happyIn49 + (HsConDecl happy_var_1 (fst happy_var_2) (snd happy_var_2) + )}} + +happyReduce_108 = happyReduce 4# 49# happyReduction_108 +happyReduction_108 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_2 of { happy_var_2 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + case happyOut53 happy_x_4 of { happy_var_4 -> + happyIn49 + (HsConDecl happy_var_1 happy_var_3 [happy_var_2,happy_var_4] + ) `HappyStk` happyRest}}}} + +happyReduce_109 = happyReduce 4# 49# happyReduction_109 +happyReduction_109 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + happyIn49 + (HsRecDecl happy_var_1 happy_var_2 [] + ) `HappyStk` happyRest}} + +happyReduce_110 = happyReduce 5# 49# happyReduction_110 +happyReduction_110 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut101 happy_x_2 of { happy_var_2 -> + case happyOut54 happy_x_4 of { happy_var_4 -> + happyIn49 + (HsRecDecl happy_var_1 happy_var_2 (reverse happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_111 = happyMonadReduce 1# 50# happyReduction_111 +happyReduction_111 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut40 happy_x_1 of { happy_var_1 -> + do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map HsUnBangedTy ts) }} + ) (\r -> happyReturn (happyIn50 r)) + +happyReduce_112 = happySpecReduce_1 50# happyReduction_112 +happyReduction_112 happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_113 = happyMonadReduce 3# 51# happyReduction_113 +happyReduction_113 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut40 happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_3 of { happy_var_3 -> + do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map HsUnBangedTy ts++ + [HsBangedTy happy_var_3]) }}} + ) (\r -> happyReturn (happyIn51 r)) + +happyReduce_114 = happySpecReduce_2 51# happyReduction_114 +happyReduction_114 happy_x_2 + happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + case happyOut52 happy_x_2 of { happy_var_2 -> + happyIn51 + ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) + )}} + +happyReduce_115 = happySpecReduce_1 52# happyReduction_115 +happyReduction_115 happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + happyIn52 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_116 = happySpecReduce_2 52# happyReduction_116 +happyReduction_116 happy_x_2 + happy_x_1 + = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn52 + (HsBangedTy happy_var_2 + )} + +happyReduce_117 = happySpecReduce_1 53# happyReduction_117 +happyReduction_117 happy_x_1 + = case happyOut40 happy_x_1 of { happy_var_1 -> + happyIn53 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_118 = happySpecReduce_2 53# happyReduction_118 +happyReduction_118 happy_x_2 + happy_x_1 + = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn53 + (HsBangedTy happy_var_2 + )} + +happyReduce_119 = happySpecReduce_3 54# happyReduction_119 +happyReduction_119 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + happyIn54 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_120 = happySpecReduce_1 54# happyReduction_120 +happyReduction_120 happy_x_1 + = case happyOut55 happy_x_1 of { happy_var_1 -> + happyIn54 + ([happy_var_1] + )} + +happyReduce_121 = happySpecReduce_3 55# happyReduction_121 +happyReduction_121 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + case happyOut56 happy_x_3 of { happy_var_3 -> + happyIn55 + ((reverse happy_var_1, happy_var_3) + )}} + +happyReduce_122 = happySpecReduce_1 56# happyReduction_122 +happyReduction_122 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn56 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_123 = happySpecReduce_2 56# happyReduction_123 +happyReduction_123 happy_x_2 + happy_x_1 + = case happyOut41 happy_x_2 of { happy_var_2 -> + happyIn56 + (HsBangedTy happy_var_2 + )} + +happyReduce_124 = happySpecReduce_0 57# happyReduction_124 +happyReduction_124 = happyIn57 + ([] + ) + +happyReduce_125 = happySpecReduce_2 57# happyReduction_125 +happyReduction_125 happy_x_2 + happy_x_1 + = case happyOut131 happy_x_2 of { happy_var_2 -> + happyIn57 + ([happy_var_2] + )} + +happyReduce_126 = happySpecReduce_3 57# happyReduction_126 +happyReduction_126 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn57 + ([] + ) + +happyReduce_127 = happyReduce 4# 57# happyReduction_127 +happyReduction_127 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut58 happy_x_3 of { happy_var_3 -> + happyIn57 + (reverse happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_128 = happySpecReduce_3 58# happyReduction_128 +happyReduction_128 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut58 happy_x_1 of { happy_var_1 -> + case happyOut131 happy_x_3 of { happy_var_3 -> + happyIn58 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_129 = happySpecReduce_1 58# happyReduction_129 +happyReduction_129 happy_x_1 + = case happyOut131 happy_x_1 of { happy_var_1 -> + happyIn58 + ([happy_var_1] + )} + +happyReduce_130 = happyMonadReduce 2# 59# happyReduction_130 +happyReduction_130 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut36 happy_x_2 of { happy_var_2 -> + checkClassBody happy_var_2} + ) (\r -> happyReturn (happyIn59 r)) + +happyReduce_131 = happySpecReduce_0 59# happyReduction_131 +happyReduction_131 = happyIn59 + ([] + ) + +happyReduce_132 = happyMonadReduce 4# 60# happyReduction_132 +happyReduction_132 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut61 happy_x_3 of { happy_var_3 -> + checkClassBody happy_var_3} + ) (\r -> happyReturn (happyIn60 r)) + +happyReduce_133 = happyMonadReduce 4# 60# happyReduction_133 +happyReduction_133 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut61 happy_x_3 of { happy_var_3 -> + checkClassBody happy_var_3} + ) (\r -> happyReturn (happyIn60 r)) + +happyReduce_134 = happySpecReduce_0 60# happyReduction_134 +happyReduction_134 = happyIn60 + ([] + ) + +happyReduce_135 = happyMonadReduce 3# 61# happyReduction_135 +happyReduction_135 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut62 happy_x_2 of { happy_var_2 -> + checkRevDecls happy_var_2} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_136 = happySpecReduce_1 61# happyReduction_136 +happyReduction_136 happy_x_1 + = happyIn61 + ([] + ) + +happyReduce_137 = happySpecReduce_3 62# happyReduction_137 +happyReduction_137 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut63 happy_x_3 of { happy_var_3 -> + happyIn62 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_138 = happySpecReduce_1 62# happyReduction_138 +happyReduction_138 happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn62 + ([happy_var_1] + )} + +happyReduce_139 = happyMonadReduce 4# 63# happyReduction_139 +happyReduction_139 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_2 of { happy_var_2 -> + case happyOut65 happy_x_3 of { happy_var_3 -> + case happyOut64 happy_x_4 of { happy_var_4 -> + checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4}}}} + ) (\r -> happyReturn (happyIn63 r)) + +happyReduce_140 = happySpecReduce_2 64# happyReduction_140 +happyReduction_140 happy_x_2 + happy_x_1 + = case happyOut36 happy_x_2 of { happy_var_2 -> + happyIn64 + (happy_var_2 + )} + +happyReduce_141 = happySpecReduce_0 64# happyReduction_141 +happyReduction_141 = happyIn64 + ([] + ) + +happyReduce_142 = happyMonadReduce 2# 65# happyReduction_142 +happyReduction_142 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut68 happy_x_2 of { happy_var_2 -> + do { e <- checkExpr happy_var_2; + return (HsUnGuardedRhs e) }} + ) (\r -> happyReturn (happyIn65 r)) + +happyReduce_143 = happySpecReduce_1 65# happyReduction_143 +happyReduction_143 happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn65 + (HsGuardedRhss (reverse happy_var_1) + )} + +happyReduce_144 = happySpecReduce_2 66# happyReduction_144 +happyReduction_144 happy_x_2 + happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut67 happy_x_2 of { happy_var_2 -> + happyIn66 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_145 = happySpecReduce_1 66# happyReduction_145 +happyReduction_145 happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn66 + ([happy_var_1] + )} + +happyReduce_146 = happyMonadReduce 5# 67# happyReduction_146 +happyReduction_146 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_5 of { happy_var_5 -> + do { g <- checkExpr happy_var_3; + e <- checkExpr happy_var_5; + return (HsGuardedRhs happy_var_1 g e) }}}} + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_147 = happyReduce 4# 68# happyReduction_147 +happyReduction_147 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut71 happy_x_1 of { happy_var_1 -> + case happyOut124 happy_x_3 of { happy_var_3 -> + case happyOut43 happy_x_4 of { happy_var_4 -> + happyIn68 + (HsExpTypeSig happy_var_3 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_148 = happySpecReduce_1 68# happyReduction_148 +happyReduction_148 happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn68 + (happy_var_1 + )} + +happyReduce_149 = happySpecReduce_1 69# happyReduction_149 +happyReduction_149 happy_x_1 + = case happyOut70 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_150 = happySpecReduce_1 69# happyReduction_150 +happyReduction_150 happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_151 = happySpecReduce_3 70# happyReduction_151 +happyReduction_151 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + happyIn70 + (HsInfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_152 = happySpecReduce_1 70# happyReduction_152 +happyReduction_152 happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn70 + (happy_var_1 + )} + +happyReduce_153 = happySpecReduce_3 71# happyReduction_153 +happyReduction_153 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_2 of { happy_var_2 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn71 + (HsInfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_154 = happySpecReduce_1 71# happyReduction_154 +happyReduction_154 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn71 + (happy_var_1 + )} + +happyReduce_155 = happyReduce 5# 72# happyReduction_155 +happyReduction_155 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_2 of { happy_var_2 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_5 of { happy_var_5 -> + happyIn72 + (HsLambda happy_var_2 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_156 = happyReduce 4# 72# happyReduction_156 +happyReduction_156 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut36 happy_x_2 of { happy_var_2 -> + case happyOut68 happy_x_4 of { happy_var_4 -> + happyIn72 + (HsLet happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_157 = happyReduce 6# 72# happyReduction_157 +happyReduction_157 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut68 happy_x_4 of { happy_var_4 -> + case happyOut68 happy_x_6 of { happy_var_6 -> + happyIn72 + (HsIf happy_var_2 happy_var_4 happy_var_6 + ) `HappyStk` happyRest}}} + +happyReduce_158 = happyReduce 4# 73# happyReduction_158 +happyReduction_158 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut68 happy_x_2 of { happy_var_2 -> + case happyOut86 happy_x_4 of { happy_var_4 -> + happyIn73 + (HsCase happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_159 = happySpecReduce_2 73# happyReduction_159 +happyReduction_159 happy_x_2 + happy_x_1 + = case happyOut74 happy_x_2 of { happy_var_2 -> + happyIn73 + (HsNegApp happy_var_2 + )} + +happyReduce_160 = happySpecReduce_2 73# happyReduction_160 +happyReduction_160 happy_x_2 + happy_x_1 + = case happyOut94 happy_x_2 of { happy_var_2 -> + happyIn73 + (HsDo happy_var_2 + )} + +happyReduce_161 = happySpecReduce_1 73# happyReduction_161 +happyReduction_161 happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + happyIn73 + (happy_var_1 + )} + +happyReduce_162 = happySpecReduce_2 74# happyReduction_162 +happyReduction_162 happy_x_2 + happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_2 of { happy_var_2 -> + happyIn74 + (HsApp happy_var_1 happy_var_2 + )}} + +happyReduce_163 = happySpecReduce_1 74# happyReduction_163 +happyReduction_163 happy_x_1 + = case happyOut77 happy_x_1 of { happy_var_1 -> + happyIn74 + (happy_var_1 + )} + +happyReduce_164 = happySpecReduce_2 75# happyReduction_164 +happyReduction_164 happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_2 of { happy_var_2 -> + happyIn75 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_165 = happySpecReduce_1 75# happyReduction_165 +happyReduction_165 happy_x_1 + = case happyOut76 happy_x_1 of { happy_var_1 -> + happyIn75 + ([happy_var_1] + )} + +happyReduce_166 = happyMonadReduce 1# 76# happyReduction_166 +happyReduction_166 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut77 happy_x_1 of { happy_var_1 -> + checkPattern happy_var_1} + ) (\r -> happyReturn (happyIn76 r)) + +happyReduce_167 = happyMonadReduce 3# 77# happyReduction_167 +happyReduction_167 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_3 of { happy_var_3 -> + do { n <- checkUnQual happy_var_1; + return (HsAsPat n happy_var_3) }}} + ) (\r -> happyReturn (happyIn77 r)) + +happyReduce_168 = happySpecReduce_2 77# happyReduction_168 +happyReduction_168 happy_x_2 + happy_x_1 + = case happyOut77 happy_x_2 of { happy_var_2 -> + happyIn77 + (HsIrrPat happy_var_2 + )} + +happyReduce_169 = happySpecReduce_1 77# happyReduction_169 +happyReduction_169 happy_x_1 + = case happyOut78 happy_x_1 of { happy_var_1 -> + happyIn77 + (happy_var_1 + )} + +happyReduce_170 = happyMonadReduce 3# 78# happyReduction_170 +happyReduction_170 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut78 happy_x_1 of { happy_var_1 -> + mkRecConstrOrUpdate happy_var_1 []} + ) (\r -> happyReturn (happyIn78 r)) + +happyReduce_171 = happyMonadReduce 4# 78# happyReduction_171 +happyReduction_171 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut78 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3)}} + ) (\r -> happyReturn (happyIn78 r)) + +happyReduce_172 = happySpecReduce_1 78# happyReduction_172 +happyReduction_172 happy_x_1 + = case happyOut79 happy_x_1 of { happy_var_1 -> + happyIn78 + (happy_var_1 + )} + +happyReduce_173 = happySpecReduce_1 79# happyReduction_173 +happyReduction_173 happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + happyIn79 + (HsVar happy_var_1 + )} + +happyReduce_174 = happySpecReduce_1 79# happyReduction_174 +happyReduction_174 happy_x_1 + = case happyOut98 happy_x_1 of { happy_var_1 -> + happyIn79 + (happy_var_1 + )} + +happyReduce_175 = happySpecReduce_1 79# happyReduction_175 +happyReduction_175 happy_x_1 + = case happyOut123 happy_x_1 of { happy_var_1 -> + happyIn79 + (HsLit happy_var_1 + )} + +happyReduce_176 = happySpecReduce_3 79# happyReduction_176 +happyReduction_176 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_2 of { happy_var_2 -> + happyIn79 + (HsParen happy_var_2 + )} + +happyReduce_177 = happySpecReduce_3 79# happyReduction_177 +happyReduction_177 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut81 happy_x_2 of { happy_var_2 -> + happyIn79 + (HsTuple (reverse happy_var_2) + )} + +happyReduce_178 = happySpecReduce_3 79# happyReduction_178 +happyReduction_178 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut82 happy_x_2 of { happy_var_2 -> + happyIn79 + (happy_var_2 + )} + +happyReduce_179 = happyReduce 4# 79# happyReduction_179 +happyReduction_179 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut71 happy_x_2 of { happy_var_2 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + happyIn79 + (HsLeftSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_180 = happyReduce 4# 79# happyReduction_180 +happyReduction_180 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut110 happy_x_2 of { happy_var_2 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + happyIn79 + (HsRightSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_181 = happySpecReduce_1 79# happyReduction_181 +happyReduction_181 happy_x_1 + = happyIn79 + (HsWildCard + ) + +happyReduce_182 = happySpecReduce_2 80# happyReduction_182 +happyReduction_182 happy_x_2 + happy_x_1 + = case happyOut80 happy_x_1 of { happy_var_1 -> + happyIn80 + (happy_var_1 + 1 + )} + +happyReduce_183 = happySpecReduce_1 80# happyReduction_183 +happyReduction_183 happy_x_1 + = happyIn80 + (1 + ) + +happyReduce_184 = happySpecReduce_3 81# happyReduction_184 +happyReduction_184 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn81 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_185 = happySpecReduce_3 81# happyReduction_185 +happyReduction_185 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn81 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_186 = happySpecReduce_1 82# happyReduction_186 +happyReduction_186 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn82 + (HsList [happy_var_1] + )} + +happyReduce_187 = happySpecReduce_1 82# happyReduction_187 +happyReduction_187 happy_x_1 + = case happyOut83 happy_x_1 of { happy_var_1 -> + happyIn82 + (HsList (reverse happy_var_1) + )} + +happyReduce_188 = happySpecReduce_2 82# happyReduction_188 +happyReduction_188 happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn82 + (HsEnumFrom happy_var_1 + )} + +happyReduce_189 = happyReduce 4# 82# happyReduction_189 +happyReduction_189 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn82 + (HsEnumFromThen happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_190 = happySpecReduce_3 82# happyReduction_190 +happyReduction_190 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn82 + (HsEnumFromTo happy_var_1 happy_var_3 + )}} + +happyReduce_191 = happyReduce 5# 82# happyReduction_191 +happyReduction_191 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_5 of { happy_var_5 -> + happyIn82 + (HsEnumFromThenTo happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_192 = happySpecReduce_3 82# happyReduction_192 +happyReduction_192 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut84 happy_x_3 of { happy_var_3 -> + happyIn82 + (HsListComp happy_var_1 (reverse happy_var_3) + )}} + +happyReduce_193 = happySpecReduce_3 83# happyReduction_193 +happyReduction_193 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut83 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn83 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_194 = happySpecReduce_3 83# happyReduction_194 +happyReduction_194 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn83 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_195 = happySpecReduce_3 84# happyReduction_195 +happyReduction_195 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut84 happy_x_1 of { happy_var_1 -> + case happyOut85 happy_x_3 of { happy_var_3 -> + happyIn84 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_196 = happySpecReduce_1 84# happyReduction_196 +happyReduction_196 happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + happyIn84 + ([happy_var_1] + )} + +happyReduce_197 = happyReduce 4# 85# happyReduction_197 +happyReduction_197 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut93 happy_x_1 of { happy_var_1 -> + case happyOut124 happy_x_2 of { happy_var_2 -> + case happyOut68 happy_x_4 of { happy_var_4 -> + happyIn85 + (HsGenerator happy_var_2 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_198 = happySpecReduce_1 85# happyReduction_198 +happyReduction_198 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn85 + (HsQualifier happy_var_1 + )} + +happyReduce_199 = happySpecReduce_2 85# happyReduction_199 +happyReduction_199 happy_x_2 + happy_x_1 + = case happyOut36 happy_x_2 of { happy_var_2 -> + happyIn85 + (HsLetStmt happy_var_2 + )} + +happyReduce_200 = happySpecReduce_3 86# happyReduction_200 +happyReduction_200 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn86 + (happy_var_2 + )} + +happyReduce_201 = happySpecReduce_3 86# happyReduction_201 +happyReduction_201 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn86 + (happy_var_2 + )} + +happyReduce_202 = happySpecReduce_3 87# happyReduction_202 +happyReduction_202 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut88 happy_x_2 of { happy_var_2 -> + happyIn87 + (reverse happy_var_2 + )} + +happyReduce_203 = happySpecReduce_3 88# happyReduction_203 +happyReduction_203 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + case happyOut89 happy_x_3 of { happy_var_3 -> + happyIn88 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_204 = happySpecReduce_1 88# happyReduction_204 +happyReduction_204 happy_x_1 + = case happyOut89 happy_x_1 of { happy_var_1 -> + happyIn88 + ([happy_var_1] + )} + +happyReduce_205 = happyReduce 4# 89# happyReduction_205 +happyReduction_205 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut93 happy_x_2 of { happy_var_2 -> + case happyOut90 happy_x_3 of { happy_var_3 -> + case happyOut64 happy_x_4 of { happy_var_4 -> + happyIn89 + (HsAlt happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_206 = happySpecReduce_2 90# happyReduction_206 +happyReduction_206 happy_x_2 + happy_x_1 + = case happyOut68 happy_x_2 of { happy_var_2 -> + happyIn90 + (HsUnGuardedAlt happy_var_2 + )} + +happyReduce_207 = happySpecReduce_1 90# happyReduction_207 +happyReduction_207 happy_x_1 + = case happyOut91 happy_x_1 of { happy_var_1 -> + happyIn90 + (HsGuardedAlts (reverse happy_var_1) + )} + +happyReduce_208 = happySpecReduce_2 91# happyReduction_208 +happyReduction_208 happy_x_2 + happy_x_1 + = case happyOut91 happy_x_1 of { happy_var_1 -> + case happyOut92 happy_x_2 of { happy_var_2 -> + happyIn91 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_209 = happySpecReduce_1 91# happyReduction_209 +happyReduction_209 happy_x_1 + = case happyOut92 happy_x_1 of { happy_var_1 -> + happyIn91 + ([happy_var_1] + )} + +happyReduce_210 = happyReduce 5# 92# happyReduction_210 +happyReduction_210 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut69 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_5 of { happy_var_5 -> + happyIn92 + (HsGuardedAlt happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_211 = happyMonadReduce 1# 93# happyReduction_211 +happyReduction_211 (happy_x_1 `HappyStk` + happyRest) + = happyThen (case happyOut71 happy_x_1 of { happy_var_1 -> + checkPattern happy_var_1} + ) (\r -> happyReturn (happyIn93 r)) + +happyReduce_212 = happySpecReduce_3 94# happyReduction_212 +happyReduction_212 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn94 + (happy_var_2 + )} + +happyReduce_213 = happySpecReduce_3 94# happyReduction_213 +happyReduction_213 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn94 + (happy_var_2 + )} + +happyReduce_214 = happyReduce 4# 95# happyReduction_214 +happyReduction_214 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut36 happy_x_2 of { happy_var_2 -> + case happyOut95 happy_x_4 of { happy_var_4 -> + happyIn95 + (HsLetStmt happy_var_2 : happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_215 = happyReduce 6# 95# happyReduction_215 +happyReduction_215 (happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut93 happy_x_1 of { happy_var_1 -> + case happyOut124 happy_x_2 of { happy_var_2 -> + case happyOut68 happy_x_4 of { happy_var_4 -> + case happyOut95 happy_x_6 of { happy_var_6 -> + happyIn95 + (HsGenerator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 + ) `HappyStk` happyRest}}}} + +happyReduce_216 = happySpecReduce_3 95# happyReduction_216 +happyReduction_216 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOut95 happy_x_3 of { happy_var_3 -> + happyIn95 + (HsQualifier happy_var_1 : happy_var_3 + )}} + +happyReduce_217 = happySpecReduce_2 95# happyReduction_217 +happyReduction_217 happy_x_2 + happy_x_1 + = case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn95 + (happy_var_2 + )} + +happyReduce_218 = happySpecReduce_2 95# happyReduction_218 +happyReduction_218 happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn95 + ([HsQualifier happy_var_1] + )} + +happyReduce_219 = happySpecReduce_1 95# happyReduction_219 +happyReduction_219 happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + happyIn95 + ([HsQualifier happy_var_1] + )} + +happyReduce_220 = happySpecReduce_3 96# happyReduction_220 +happyReduction_220 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + case happyOut97 happy_x_3 of { happy_var_3 -> + happyIn96 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_221 = happySpecReduce_1 96# happyReduction_221 +happyReduction_221 happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn96 + ([happy_var_1] + )} + +happyReduce_222 = happySpecReduce_3 97# happyReduction_222 +happyReduction_222 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut100 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn97 + (HsFieldUpdate happy_var_1 happy_var_3 + )}} + +happyReduce_223 = happySpecReduce_2 98# happyReduction_223 +happyReduction_223 happy_x_2 + happy_x_1 + = happyIn98 + (unit_con + ) + +happyReduce_224 = happySpecReduce_2 98# happyReduction_224 +happyReduction_224 happy_x_2 + happy_x_1 + = happyIn98 + (HsList [] + ) + +happyReduce_225 = happySpecReduce_3 98# happyReduction_225 +happyReduction_225 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut80 happy_x_2 of { happy_var_2 -> + happyIn98 + (tuple_con happy_var_2 + )} + +happyReduce_226 = happySpecReduce_1 98# happyReduction_226 +happyReduction_226 happy_x_1 + = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn98 + (HsCon happy_var_1 + )} + +happyReduce_227 = happySpecReduce_1 99# happyReduction_227 +happyReduction_227 happy_x_1 + = case happyOut113 happy_x_1 of { happy_var_1 -> + happyIn99 + (happy_var_1 + )} + +happyReduce_228 = happySpecReduce_3 99# happyReduction_228 +happyReduction_228 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut120 happy_x_2 of { happy_var_2 -> + happyIn99 + (happy_var_2 + )} + +happyReduce_229 = happySpecReduce_1 100# happyReduction_229 +happyReduction_229 happy_x_1 + = case happyOut112 happy_x_1 of { happy_var_1 -> + happyIn100 + (happy_var_1 + )} + +happyReduce_230 = happySpecReduce_3 100# happyReduction_230 +happyReduction_230 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn100 + (happy_var_2 + )} + +happyReduce_231 = happySpecReduce_1 101# happyReduction_231 +happyReduction_231 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn101 + (happy_var_1 + )} + +happyReduce_232 = happySpecReduce_3 101# happyReduction_232 +happyReduction_232 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut117 happy_x_2 of { happy_var_2 -> + happyIn101 + (happy_var_2 + )} + +happyReduce_233 = happySpecReduce_1 102# happyReduction_233 +happyReduction_233 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn102 + (happy_var_1 + )} + +happyReduce_234 = happySpecReduce_3 102# happyReduction_234 +happyReduction_234 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut111 happy_x_2 of { happy_var_2 -> + happyIn102 + (happy_var_2 + )} + +happyReduce_235 = happySpecReduce_1 103# happyReduction_235 +happyReduction_235 happy_x_1 + = case happyOut120 happy_x_1 of { happy_var_1 -> + happyIn103 + (happy_var_1 + )} + +happyReduce_236 = happySpecReduce_3 103# happyReduction_236 +happyReduction_236 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut113 happy_x_2 of { happy_var_2 -> + happyIn103 + (happy_var_2 + )} + +happyReduce_237 = happySpecReduce_1 104# happyReduction_237 +happyReduction_237 happy_x_1 + = case happyOut118 happy_x_1 of { happy_var_1 -> + happyIn104 + (happy_var_1 + )} + +happyReduce_238 = happySpecReduce_3 104# happyReduction_238 +happyReduction_238 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn104 + (happy_var_2 + )} + +happyReduce_239 = happySpecReduce_1 105# happyReduction_239 +happyReduction_239 happy_x_1 + = case happyOut119 happy_x_1 of { happy_var_1 -> + happyIn105 + (happy_var_1 + )} + +happyReduce_240 = happySpecReduce_3 105# happyReduction_240 +happyReduction_240 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn105 + (happy_var_2 + )} + +happyReduce_241 = happySpecReduce_1 106# happyReduction_241 +happyReduction_241 happy_x_1 + = case happyOut117 happy_x_1 of { happy_var_1 -> + happyIn106 + (happy_var_1 + )} + +happyReduce_242 = happySpecReduce_3 106# happyReduction_242 +happyReduction_242 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut115 happy_x_2 of { happy_var_2 -> + happyIn106 + (happy_var_2 + )} + +happyReduce_243 = happySpecReduce_1 107# happyReduction_243 +happyReduction_243 happy_x_1 + = case happyOut111 happy_x_1 of { happy_var_1 -> + happyIn107 + (happy_var_1 + )} + +happyReduce_244 = happySpecReduce_3 107# happyReduction_244 +happyReduction_244 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut114 happy_x_2 of { happy_var_2 -> + happyIn107 + (happy_var_2 + )} + +happyReduce_245 = happySpecReduce_1 108# happyReduction_245 +happyReduction_245 happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn108 + (HsVarOp happy_var_1 + )} + +happyReduce_246 = happySpecReduce_1 108# happyReduction_246 +happyReduction_246 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn108 + (HsConOp happy_var_1 + )} + +happyReduce_247 = happySpecReduce_1 109# happyReduction_247 +happyReduction_247 happy_x_1 + = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn109 + (HsQVarOp happy_var_1 + )} + +happyReduce_248 = happySpecReduce_1 109# happyReduction_248 +happyReduction_248 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn109 + (HsQConOp happy_var_1 + )} + +happyReduce_249 = happySpecReduce_1 110# happyReduction_249 +happyReduction_249 happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn110 + (HsQVarOp happy_var_1 + )} + +happyReduce_250 = happySpecReduce_1 110# happyReduction_250 +happyReduction_250 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn110 + (HsQConOp happy_var_1 + )} + +happyReduce_251 = happySpecReduce_1 111# happyReduction_251 +happyReduction_251 happy_x_1 + = happyIn111 + (list_cons_name + ) + +happyReduce_252 = happySpecReduce_1 111# happyReduction_252 +happyReduction_252 happy_x_1 + = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn111 + (happy_var_1 + )} + +happyReduce_253 = happySpecReduce_1 112# happyReduction_253 +happyReduction_253 happy_x_1 + = case happyOut113 happy_x_1 of { happy_var_1 -> + happyIn112 + (UnQual happy_var_1 + )} + +happyReduce_254 = happySpecReduce_1 112# happyReduction_254 +happyReduction_254 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> + happyIn112 + (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) + )} + +happyReduce_255 = happySpecReduce_1 113# happyReduction_255 +happyReduction_255 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn113 + (HsIdent happy_var_1 + )} + +happyReduce_256 = happySpecReduce_1 113# happyReduction_256 +happyReduction_256 happy_x_1 + = happyIn113 + (as_name + ) + +happyReduce_257 = happySpecReduce_1 113# happyReduction_257 +happyReduction_257 happy_x_1 + = happyIn113 + (qualified_name + ) + +happyReduce_258 = happySpecReduce_1 113# happyReduction_258 +happyReduction_258 happy_x_1 + = happyIn113 + (hiding_name + ) + +happyReduce_259 = happySpecReduce_1 114# happyReduction_259 +happyReduction_259 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn114 + (UnQual happy_var_1 + )} + +happyReduce_260 = happySpecReduce_1 114# happyReduction_260 +happyReduction_260 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn114 + (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) + )} + +happyReduce_261 = happySpecReduce_1 115# happyReduction_261 +happyReduction_261 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn115 + (HsIdent happy_var_1 + )} + +happyReduce_262 = happySpecReduce_1 116# happyReduction_262 +happyReduction_262 happy_x_1 + = case happyOut117 happy_x_1 of { happy_var_1 -> + happyIn116 + (UnQual happy_var_1 + )} + +happyReduce_263 = happySpecReduce_1 116# happyReduction_263 +happyReduction_263 happy_x_1 + = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> + happyIn116 + (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) + )} + +happyReduce_264 = happySpecReduce_1 117# happyReduction_264 +happyReduction_264 happy_x_1 + = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> + happyIn117 + (HsSymbol happy_var_1 + )} + +happyReduce_265 = happySpecReduce_1 118# happyReduction_265 +happyReduction_265 happy_x_1 + = case happyOut120 happy_x_1 of { happy_var_1 -> + happyIn118 + (UnQual happy_var_1 + )} + +happyReduce_266 = happySpecReduce_1 118# happyReduction_266 +happyReduction_266 happy_x_1 + = case happyOut122 happy_x_1 of { happy_var_1 -> + happyIn118 + (happy_var_1 + )} + +happyReduce_267 = happySpecReduce_1 119# happyReduction_267 +happyReduction_267 happy_x_1 + = case happyOut121 happy_x_1 of { happy_var_1 -> + happyIn119 + (UnQual happy_var_1 + )} + +happyReduce_268 = happySpecReduce_1 119# happyReduction_268 +happyReduction_268 happy_x_1 + = case happyOut122 happy_x_1 of { happy_var_1 -> + happyIn119 + (happy_var_1 + )} + +happyReduce_269 = happySpecReduce_1 120# happyReduction_269 +happyReduction_269 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn120 + (HsSymbol happy_var_1 + )} + +happyReduce_270 = happySpecReduce_1 120# happyReduction_270 +happyReduction_270 happy_x_1 + = happyIn120 + (minus_name + ) + +happyReduce_271 = happySpecReduce_1 120# happyReduction_271 +happyReduction_271 happy_x_1 + = happyIn120 + (pling_name + ) + +happyReduce_272 = happySpecReduce_1 121# happyReduction_272 +happyReduction_272 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn121 + (HsSymbol happy_var_1 + )} + +happyReduce_273 = happySpecReduce_1 121# happyReduction_273 +happyReduction_273 happy_x_1 + = happyIn121 + (pling_name + ) + +happyReduce_274 = happySpecReduce_1 122# happyReduction_274 +happyReduction_274 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> + happyIn122 + (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) + )} + +happyReduce_275 = happySpecReduce_1 123# happyReduction_275 +happyReduction_275 happy_x_1 + = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + happyIn123 + (HsInt happy_var_1 + )} + +happyReduce_276 = happySpecReduce_1 123# happyReduction_276 +happyReduction_276 happy_x_1 + = case happyOutTok happy_x_1 of { (Character happy_var_1) -> + happyIn123 + (HsChar happy_var_1 + )} + +happyReduce_277 = happySpecReduce_1 123# happyReduction_277 +happyReduction_277 happy_x_1 + = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> + happyIn123 + (HsFrac happy_var_1 + )} + +happyReduce_278 = happySpecReduce_1 123# happyReduction_278 +happyReduction_278 happy_x_1 + = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + happyIn123 + (HsString happy_var_1 + )} + +happyReduce_279 = happyMonadReduce 0# 124# happyReduction_279 +happyReduction_279 (happyRest) + = happyThen ( getSrcLoc + ) (\r -> happyReturn (happyIn124 r)) + +happyReduce_280 = happyMonadReduce 0# 125# happyReduction_280 +happyReduction_280 (happyRest) + = happyThen ( pushCurrentContext + ) (\r -> happyReturn (happyIn125 r)) + +happyReduce_281 = happySpecReduce_1 126# happyReduction_281 +happyReduction_281 happy_x_1 + = happyIn126 + (() + ) + +happyReduce_282 = happyMonadReduce 1# 126# happyReduction_282 +happyReduction_282 (happy_x_1 `HappyStk` + happyRest) + = happyThen ( popContext + ) (\r -> happyReturn (happyIn126 r)) + +happyReduce_283 = happySpecReduce_1 127# happyReduction_283 +happyReduction_283 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn127 + (Module happy_var_1 + )} + +happyReduce_284 = happySpecReduce_1 127# happyReduction_284 +happyReduction_284 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn127 + (Module (fst happy_var_1 ++ '.':snd happy_var_1) + )} + +happyReduce_285 = happySpecReduce_1 128# happyReduction_285 +happyReduction_285 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn128 + (happy_var_1 + )} + +happyReduce_286 = happySpecReduce_1 129# happyReduction_286 +happyReduction_286 happy_x_1 + = case happyOut115 happy_x_1 of { happy_var_1 -> + happyIn129 + (happy_var_1 + )} + +happyReduce_287 = happySpecReduce_1 130# happyReduction_287 +happyReduction_287 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn130 + (happy_var_1 + )} + +happyReduce_288 = happySpecReduce_1 131# happyReduction_288 +happyReduction_288 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn131 + (happy_var_1 + )} + +happyReduce_289 = happySpecReduce_1 132# happyReduction_289 +happyReduction_289 happy_x_1 + = case happyOut113 happy_x_1 of { happy_var_1 -> + happyIn132 + (happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = action i i tk (HappyState action) sts stk in + case tk of { + EOF -> action 193# 193# (error "reading EOF!") (HappyState action) sts stk; + VarId happy_dollar_dollar -> cont 133#; + QVarId happy_dollar_dollar -> cont 134#; + ConId happy_dollar_dollar -> cont 135#; + QConId happy_dollar_dollar -> cont 136#; + VarSym happy_dollar_dollar -> cont 137#; + ConSym happy_dollar_dollar -> cont 138#; + QVarSym happy_dollar_dollar -> cont 139#; + QConSym happy_dollar_dollar -> cont 140#; + IntTok happy_dollar_dollar -> cont 141#; + FloatTok happy_dollar_dollar -> cont 142#; + Character happy_dollar_dollar -> cont 143#; + StringTok happy_dollar_dollar -> cont 144#; + LeftParen -> cont 145#; + RightParen -> cont 146#; + SemiColon -> cont 147#; + LeftCurly -> cont 148#; + RightCurly -> cont 149#; + VRightCurly -> cont 150#; + LeftSquare -> cont 151#; + RightSquare -> cont 152#; + Comma -> cont 153#; + Underscore -> cont 154#; + BackQuote -> cont 155#; + DotDot -> cont 156#; + Colon -> cont 157#; + DoubleColon -> cont 158#; + Equals -> cont 159#; + Backslash -> cont 160#; + Bar -> cont 161#; + LeftArrow -> cont 162#; + RightArrow -> cont 163#; + At -> cont 164#; + Tilde -> cont 165#; + DoubleArrow -> cont 166#; + Minus -> cont 167#; + Exclamation -> cont 168#; + KW_As -> cont 169#; + KW_Case -> cont 170#; + KW_Class -> cont 171#; + KW_Data -> cont 172#; + KW_Default -> cont 173#; + KW_Deriving -> cont 174#; + KW_Do -> cont 175#; + KW_Else -> cont 176#; + KW_Hiding -> cont 177#; + KW_If -> cont 178#; + KW_Import -> cont 179#; + KW_In -> cont 180#; + KW_Infix -> cont 181#; + KW_InfixL -> cont 182#; + KW_InfixR -> cont 183#; + KW_Instance -> cont 184#; + KW_Let -> cont 185#; + KW_Module -> cont 186#; + KW_NewType -> cont 187#; + KW_Of -> cont 188#; + KW_Then -> cont 189#; + KW_Type -> cont 190#; + KW_Where -> cont 191#; + KW_Qualified -> cont 192#; + _ -> happyError' + }) + +happyError_ tk = happyError' + +happyThen :: () => P a -> (a -> P b) -> P b +happyThen = (>>=) +happyReturn :: () => a -> P a +happyReturn = (return) +happyThen1 = happyThen +happyReturn1 :: () => a -> P a +happyReturn1 = happyReturn +happyError' :: () => P a +happyError' = happyError + +parse = happySomeParser where + happySomeParser = happyThen (happyParse action_0) (\x -> happyReturn (happyOut68 x)) + +happySeq = happyDoSeq + +happyError :: P a +happyError = fail "Parse error" + +-- | Parse of a string, which should contain a complete Haskell 98 expression +parseExpr :: String -> ParseResult HsExp +parseExpr = runParser parse +{-# LINE 1 "GenericTemplate.hs" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "" #-} +{-# LINE 1 "GenericTemplate.hs" #-} +-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp + + +{-# LINE 28 "GenericTemplate.hs" #-} + + + + + + + + + + + + + + + + + + + + + + + +{-# LINE 59 "GenericTemplate.hs" #-} + + + + + + + + + + +infixr 9 `HappyStk` +data HappyStk a = HappyStk a (HappyStk a) + +----------------------------------------------------------------------------- +-- starting the parse + +happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll + +----------------------------------------------------------------------------- +-- Accepting the parse + +-- If the current token is 1#, it means we've just accepted a partial +-- parse (a %partial parser). We must ignore the saved token on the top of +-- the stack in this case. +happyAccept 1# tk st sts (_ `HappyStk` ans `HappyStk` _) = + happyReturn1 ans +happyAccept j tk st sts (HappyStk ans _) = + (happyTcHack j ) (happyReturn1 ans) + +----------------------------------------------------------------------------- +-- Arrays only: do the next action + +{-# LINE 155 "GenericTemplate.hs" #-} + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + + + +newtype HappyState b c = HappyState + (Int# -> -- token number + Int# -> -- token number (yes, again) + b -> -- token semantic value + HappyState b c -> -- current state + [HappyState b c] -> -- state stack + c) + + + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 1# tk st sts stk@(x `HappyStk` _) = + let i = (case unsafeCoerce# x of { (I# (i)) -> i }) in +-- trace "shifting the error token" $ + new_state i i tk (HappyState (new_state)) ((st):(sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state ((st):(sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happySpecReduce_0 nt fn j tk st@((HappyState (action))) sts stk + = action nt j tk st ((st):(sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@(((st@(HappyState (action))):(_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (action nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happySpecReduce_2 nt fn j tk _ ((_):(sts@(((st@(HappyState (action))):(_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (action nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happySpecReduce_3 nt fn j tk _ ((_):(((_):(sts@(((st@(HappyState (action))):(_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (action nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k -# (1# :: Int#)) sts of + sts1@(((st1@(HappyState (action))):(_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (action nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 1# tk st sts stk + = happyFail 1# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + happyThen1 (fn stk) (\r -> action nt j tk st1 sts1 (r `HappyStk` drop_stk)) + where sts1@(((st1@(HappyState (action))):(_))) = happyDrop k ((st):(sts)) + drop_stk = happyDropStk k stk + +happyDrop 0# l = l +happyDrop n ((_):(t)) = happyDrop (n -# (1# :: Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + +{-# LINE 239 "GenericTemplate.hs" #-} +happyGoto action j tk st = action j j tk (HappyState action) + + +----------------------------------------------------------------------------- +-- Error recovery (1# is the error token) + +-- parse error if we are in recovery and we fail again +happyFail 1# tk old_st _ stk = +-- trace "failing" $ + happyError_ tk + +{- We don't need state discarding for our restricted implementation of + "error". In fact, it can cause some bogus parses, so I've disabled it + for now --SDM + +-- discard a state +happyFail 1# tk old_st (((HappyState (action))):(sts)) + (saved_tok `HappyStk` _ `HappyStk` stk) = +-- trace ("discarding state, depth " ++ show (length stk)) $ + action 1# 1# tk (HappyState (action)) sts ((saved_tok`HappyStk`stk)) +-} + +-- Enter error recovery: generate an error token, +-- save the old token and carry on. +happyFail i tk (HappyState (action)) sts stk = +-- trace "entering error recovery" $ + action 1# 1# tk (HappyState (action)) sts ( (unsafeCoerce# (I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Int# -> a -> a +happyTcHack x y = y +{-# INLINE happyTcHack #-} + + +----------------------------------------------------------------------------- +-- Seq-ing. If the --strict flag is given, then Happy emits +-- happySeq = happyDoSeq +-- otherwise it emits +-- happySeq = happyDontSeq + +happyDoSeq, happyDontSeq :: a -> b -> b +happyDoSeq a b = a `seq` b +happyDontSeq a b = b + +----------------------------------------------------------------------------- +-- Don't inline any functions from the template. GHC has a nasty habit +-- of deciding to inline happyGoto everywhere, which increases the size of +-- the generated parser quite a bit. + +{-# LINE 303 "GenericTemplate.hs" #-} +{-# NOINLINE happyShift #-} +{-# NOINLINE happySpecReduce_0 #-} +{-# NOINLINE happySpecReduce_1 #-} +{-# NOINLINE happySpecReduce_2 #-} +{-# NOINLINE happySpecReduce_3 #-} +{-# NOINLINE happyReduce #-} +{-# NOINLINE happyMonadReduce #-} +{-# NOINLINE happyGoto #-} +{-# NOINLINE happyFail #-} + +-- end of Happy Template. diff --git a/Lib/Parser.ly b/Lib/Parser.ly new file mode 100644 --- /dev/null +++ b/Lib/Parser.ly @@ -0,0 +1,817 @@ +> { +> {-# OPTIONS -w #-} +> ----------------------------------------------------------------------------- +> -- | +> -- Module : Lib.Haskell.Parser +> -- Copyright : (c) Simon Marlow, Sven Panne 1997-2000 +> -- License : BSD-style (see the file libraries/base/LICENSE) +> -- +> -- Maintainer : libraries@haskell.org +> -- Stability : experimental +> -- Portability : portable +> -- +> -- Haskell parser, modified to be provide an expression parser. +> -- +> ----------------------------------------------------------------------------- +> +> module Lib.Parser ( +> parseExpr, +> ParseMode(..), defaultParseMode, ParseResult(..)) where +> +> import Language.Haskell.Syntax +> import Language.Haskell.ParseMonad +> import Language.Haskell.Lexer +> import Language.Haskell.ParseUtils +> } + +ToDo: Check exactly which names must be qualified with Prelude (commas and friends) +ToDo: Inst (MPCs?) +ToDo: Polish constr a bit +ToDo: Ugly: exp0b is used for lhs, pat, exp0, ... +ToDo: Differentiate between record updates and labeled construction. + +----------------------------------------------------------------------------- +Conflicts: 2 shift/reduce + +2 for ambiguity in 'case x of y | let z = y in z :: Bool -> b' + (don't know whether to reduce 'Bool' as a btype or shift the '->'. + Similarly lambda and if. The default resolution in favour of the + shift means that a guard can never end with a type signature. + In mitigation: it's a rare case and no Haskell implementation + allows these, because it would require unbounded lookahead.) + There are 2 conflicts rather than one because contexts are parsed + as btypes (cf ctype). + +----------------------------------------------------------------------------- + +> %token +> VARID { VarId $$ } +> QVARID { QVarId $$ } +> CONID { ConId $$ } +> QCONID { QConId $$ } +> VARSYM { VarSym $$ } +> CONSYM { ConSym $$ } +> QVARSYM { QVarSym $$ } +> QCONSYM { QConSym $$ } +> INT { IntTok $$ } +> RATIONAL { FloatTok $$ } +> CHAR { Character $$ } +> STRING { StringTok $$ } + +Symbols + +> '(' { LeftParen } +> ')' { RightParen } +> ';' { SemiColon } +> '{' { LeftCurly } +> '}' { RightCurly } +> vccurly { VRightCurly } -- a virtual close brace +> '[' { LeftSquare } +> ']' { RightSquare } +> ',' { Comma } +> '_' { Underscore } +> '`' { BackQuote } + +Reserved operators + +> '..' { DotDot } +> ':' { Colon } +> '::' { DoubleColon } +> '=' { Equals } +> '\\' { Backslash } +> '|' { Bar } +> '<-' { LeftArrow } +> '->' { RightArrow } +> '@' { At } +> '~' { Tilde } +> '=>' { DoubleArrow } +> '-' { Minus } +> '!' { Exclamation } + +Reserved Ids + +> 'as' { KW_As } +> 'case' { KW_Case } +> 'class' { KW_Class } +> 'data' { KW_Data } +> 'default' { KW_Default } +> 'deriving' { KW_Deriving } +> 'do' { KW_Do } +> 'else' { KW_Else } +> 'hiding' { KW_Hiding } +> 'if' { KW_If } +> 'import' { KW_Import } +> 'in' { KW_In } +> 'infix' { KW_Infix } +> 'infixl' { KW_InfixL } +> 'infixr' { KW_InfixR } +> 'instance' { KW_Instance } +> 'let' { KW_Let } +> 'module' { KW_Module } +> 'newtype' { KW_NewType } +> 'of' { KW_Of } +> 'then' { KW_Then } +> 'type' { KW_Type } +> 'where' { KW_Where } +> 'qualified' { KW_Qualified } + +> %monad { P } +> %lexer { lexer } { EOF } +> %name parse exp +> %tokentype { Token } +> %% + +----------------------------------------------------------------------------- +Module Header + +> module :: { HsModule } +> : srcloc 'module' modid maybeexports 'where' body +> { HsModule $1 $3 $4 (fst $6) (snd $6) } +> | srcloc body +> { HsModule $1 main_mod (Just [HsEVar (UnQual main_name)]) +> (fst $2) (snd $2) } + +> body :: { ([HsImportDecl],[HsDecl]) } +> : '{' bodyaux '}' { $2 } +> | open bodyaux close { $2 } + +> bodyaux :: { ([HsImportDecl],[HsDecl]) } +> : optsemis impdecls semis topdecls { (reverse $2, $4) } +> | optsemis topdecls { ([], $2) } +> | optsemis impdecls optsemis { (reverse $2, []) } +> | optsemis { ([], []) } + +> semis :: { () } +> : optsemis ';' { () } + +> optsemis :: { () } +> : semis { () } +> | {- empty -} { () } + +----------------------------------------------------------------------------- +The Export List + +> maybeexports :: { Maybe [HsExportSpec] } +> : exports { Just $1 } +> | {- empty -} { Nothing } + +> exports :: { [HsExportSpec] } +> : '(' exportlist optcomma ')' { reverse $2 } +> | '(' optcomma ')' { [] } + +> optcomma :: { () } +> : ',' { () } +> | {- empty -} { () } + +> exportlist :: { [HsExportSpec] } +> : exportlist ',' export { $3 : $1 } +> | export { [$1] } + +> export :: { HsExportSpec } +> : qvar { HsEVar $1 } +> | qtyconorcls { HsEAbs $1 } +> | qtyconorcls '(' '..' ')' { HsEThingAll $1 } +> | qtyconorcls '(' ')' { HsEThingWith $1 [] } +> | qtyconorcls '(' cnames ')' { HsEThingWith $1 (reverse $3) } +> | 'module' modid { HsEModuleContents $2 } + +----------------------------------------------------------------------------- +Import Declarations + +> impdecls :: { [HsImportDecl] } +> : impdecls semis impdecl { $3 : $1 } +> | impdecl { [$1] } + +> impdecl :: { HsImportDecl } +> : srcloc 'import' optqualified modid maybeas maybeimpspec +> { HsImportDecl $1 $4 $3 $5 $6 } + +> optqualified :: { Bool } +> : 'qualified' { True } +> | {- empty -} { False } + +> maybeas :: { Maybe Module } +> : 'as' modid { Just $2 } +> | {- empty -} { Nothing } + + +> maybeimpspec :: { Maybe (Bool, [HsImportSpec]) } +> : impspec { Just $1 } +> | {- empty -} { Nothing } + +> impspec :: { (Bool, [HsImportSpec]) } +> : opthiding '(' importlist optcomma ')' { ($1, reverse $3) } +> | opthiding '(' optcomma ')' { ($1, []) } + +> opthiding :: { Bool } +> : 'hiding' { True } +> | {- empty -} { False } + +> importlist :: { [HsImportSpec] } +> : importlist ',' importspec { $3 : $1 } +> | importspec { [$1] } + +> importspec :: { HsImportSpec } +> : var { HsIVar $1 } +> | tyconorcls { HsIAbs $1 } +> | tyconorcls '(' '..' ')' { HsIThingAll $1 } +> | tyconorcls '(' ')' { HsIThingWith $1 [] } +> | tyconorcls '(' cnames ')' { HsIThingWith $1 (reverse $3) } + +> cnames :: { [HsCName] } +> : cnames ',' cname { $3 : $1 } +> | cname { [$1] } + +> cname :: { HsCName } +> : var { HsVarName $1 } +> | con { HsConName $1 } + +----------------------------------------------------------------------------- +Fixity Declarations + +> fixdecl :: { HsDecl } +> : srcloc infix prec ops { HsInfixDecl $1 $2 $3 (reverse $4) } + +> prec :: { Int } +> : {- empty -} { 9 } +> | INT {% checkPrec $1 } + +> infix :: { HsAssoc } +> : 'infix' { HsAssocNone } +> | 'infixl' { HsAssocLeft } +> | 'infixr' { HsAssocRight } + +> ops :: { [HsOp] } +> : ops ',' op { $3 : $1 } +> | op { [$1] } + +----------------------------------------------------------------------------- +Top-Level Declarations + +Note: The report allows topdecls to be empty. This would result in another +shift/reduce-conflict, so we don't handle this case here, but in bodyaux. + +> topdecls :: { [HsDecl] } +> : topdecls1 optsemis {% checkRevDecls $1 } + +> topdecls1 :: { [HsDecl] } +> : topdecls1 semis topdecl { $3 : $1 } +> | topdecl { [$1] } + +> topdecl :: { HsDecl } +> : srcloc 'type' simpletype '=' type +> { HsTypeDecl $1 (fst $3) (snd $3) $5 } +> | srcloc 'data' ctype '=' constrs deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (HsDataDecl $1 cs c t (reverse $5) $6) } } +> | srcloc 'newtype' ctype '=' constr deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (HsNewTypeDecl $1 cs c t $5 $6) } } +> | srcloc 'class' ctype optcbody +> {% do { (cs,c,vs) <- checkClassHeader $3; +> return (HsClassDecl $1 cs c vs $4) } } +> | srcloc 'instance' ctype optvaldefs +> {% do { (cs,c,ts) <- checkInstHeader $3; +> return (HsInstDecl $1 cs c ts $4) } } +> | srcloc 'default' '(' typelist ')' +> { HsDefaultDecl $1 $4 } +> | decl { $1 } + +> typelist :: { [HsType] } +> : types { reverse $1 } +> | type { [$1] } +> | {- empty -} { [] } + +> decls :: { [HsDecl] } +> : optsemis decls1 optsemis {% checkRevDecls $2 } +> | optsemis { [] } + +> decls1 :: { [HsDecl] } +> : decls1 semis decl { $3 : $1 } +> | decl { [$1] } + +> decl :: { HsDecl } +> : signdecl { $1 } +> | fixdecl { $1 } +> | valdef { $1 } + +> decllist :: { [HsDecl] } +> : '{' decls '}' { $2 } +> | open decls close { $2 } + +> signdecl :: { HsDecl } +> : srcloc vars '::' ctype { HsTypeSig $1 (reverse $2) $4 } + +ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var +instead of qvar, we get another shift/reduce-conflict. Consider the +following programs: + + { (+) :: ... } only var + { (+) x y = ... } could (incorrectly) be qvar + +We re-use expressions for patterns, so a qvar would be allowed in patterns +instead of a var only (which would be correct). But deciding what the + is, +would require more lookahead. So let's check for ourselves... + +> vars :: { [HsName] } +> : vars ',' var { $3 : $1 } +> | qvar {% do { n <- checkUnQual $1; +> return [n] } } + +----------------------------------------------------------------------------- +Types + +> type :: { HsType } +> : btype '->' type { HsTyFun $1 $3 } +> | btype { $1 } + +> btype :: { HsType } +> : btype atype { HsTyApp $1 $2 } +> | atype { $1 } + +> atype :: { HsType } +> : gtycon { HsTyCon $1 } +> | tyvar { HsTyVar $1 } +> | '(' types ')' { HsTyTuple (reverse $2) } +> | '[' type ']' { HsTyApp list_tycon $2 } +> | '(' type ')' { $2 } + +> gtycon :: { HsQName } +> : qconid { $1 } +> | '(' ')' { unit_tycon_name } +> | '(' '->' ')' { fun_tycon_name } +> | '[' ']' { list_tycon_name } +> | '(' commas ')' { tuple_tycon_name $2 } + + +(Slightly edited) Comment from GHC's hsparser.y: +"context => type" vs "type" is a problem, because you can't distinguish between + + foo :: (Baz a, Baz a) + bar :: (Baz a, Baz a) => [a] -> [a] -> [a] + +with one token of lookahead. The HACK is to parse the context as a btype +(more specifically as a tuple type), then check that it has the right form +C a, or (C1 a, C2 b, ... Cn z) and convert it into a context. Blaach! + +> ctype :: { HsQualType } +> : context '=>' type { HsQualType $1 $3 } +> | type { HsQualType [] $1 } + +> context :: { HsContext } +> : btype {% checkContext $1 } + +> types :: { [HsType] } +> : types ',' type { $3 : $1 } +> | type ',' type { [$3, $1] } + +> simpletype :: { (HsName, [HsName]) } +> : tycon tyvars { ($1,reverse $2) } + +> tyvars :: { [HsName] } +> : tyvars tyvar { $2 : $1 } +> | {- empty -} { [] } + +----------------------------------------------------------------------------- +Datatype declarations + +> constrs :: { [HsConDecl] } +> : constrs '|' constr { $3 : $1 } +> | constr { [$1] } + +> constr :: { HsConDecl } +> : srcloc scontype { HsConDecl $1 (fst $2) (snd $2) } +> | srcloc sbtype conop sbtype { HsConDecl $1 $3 [$2,$4] } +> | srcloc con '{' '}' { HsRecDecl $1 $2 [] } +> | srcloc con '{' fielddecls '}' { HsRecDecl $1 $2 (reverse $4) } + +> scontype :: { (HsName, [HsBangType]) } +> : btype {% do { (c,ts) <- splitTyConApp $1; +> return (c,map HsUnBangedTy ts) } } +> | scontype1 { $1 } + +> scontype1 :: { (HsName, [HsBangType]) } +> : btype '!' atype {% do { (c,ts) <- splitTyConApp $1; +> return (c,map HsUnBangedTy ts++ +> [HsBangedTy $3]) } } +> | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } + +> satype :: { HsBangType } +> : atype { HsUnBangedTy $1 } +> | '!' atype { HsBangedTy $2 } + +> sbtype :: { HsBangType } +> : btype { HsUnBangedTy $1 } +> | '!' atype { HsBangedTy $2 } + +> fielddecls :: { [([HsName],HsBangType)] } +> : fielddecls ',' fielddecl { $3 : $1 } +> | fielddecl { [$1] } + +> fielddecl :: { ([HsName],HsBangType) } +> : vars '::' stype { (reverse $1, $3) } + +> stype :: { HsBangType } +> : type { HsUnBangedTy $1 } +> | '!' atype { HsBangedTy $2 } + +> deriving :: { [HsQName] } +> : {- empty -} { [] } +> | 'deriving' qtycls { [$2] } +> | 'deriving' '(' ')' { [] } +> | 'deriving' '(' dclasses ')' { reverse $3 } + +> dclasses :: { [HsQName] } +> : dclasses ',' qtycls { $3 : $1 } +> | qtycls { [$1] } + +----------------------------------------------------------------------------- +Class declarations + +> optcbody :: { [HsDecl] } +> : 'where' decllist {% checkClassBody $2 } +> | {- empty -} { [] } + +----------------------------------------------------------------------------- +Instance declarations + +> optvaldefs :: { [HsDecl] } +> : 'where' '{' valdefs '}' {% checkClassBody $3 } +> | 'where' open valdefs close {% checkClassBody $3 } +> | {- empty -} { [] } + +> valdefs :: { [HsDecl] } +> : optsemis valdefs1 optsemis {% checkRevDecls $2 } +> | optsemis { [] } + +> valdefs1 :: { [HsDecl] } +> : valdefs1 semis valdef { $3 : $1 } +> | valdef { [$1] } + +----------------------------------------------------------------------------- +Value definitions + +> valdef :: { HsDecl } +> : srcloc exp0b rhs optwhere {% checkValDef $1 $2 $3 $4 } + +> optwhere :: { [HsDecl] } +> : 'where' decllist { $2 } +> | {- empty -} { [] } + +> rhs :: { HsRhs } +> : '=' exp {% do { e <- checkExpr $2; +> return (HsUnGuardedRhs e) } } +> | gdrhs { HsGuardedRhss (reverse $1) } + +> gdrhs :: { [HsGuardedRhs] } +> : gdrhs gdrh { $2 : $1 } +> | gdrh { [$1] } + +> gdrh :: { HsGuardedRhs } +> : srcloc '|' exp0 '=' exp {% do { g <- checkExpr $3; +> e <- checkExpr $5; +> return (HsGuardedRhs $1 g e) } } + +----------------------------------------------------------------------------- +Expressions + +Note: The Report specifies a meta-rule for lambda, let and if expressions +(the exp's that end with a subordinate exp): they extend as far to +the right as possible. That means they cannot be followed by a type +signature or infix application. To implement this without shift/reduce +conflicts, we split exp10 into these expressions (exp10a) and the others +(exp10b). That also means that only an exp0 ending in an exp10b (an exp0b) +can followed by a type signature or infix application. So we duplicate +the exp0 productions to distinguish these from the others (exp0a). + +> exp :: { HsExp } +> : exp0b '::' srcloc ctype { HsExpTypeSig $3 $1 $4 } +> | exp0 { $1 } + +> exp0 :: { HsExp } +> : exp0a { $1 } +> | exp0b { $1 } + +> exp0a :: { HsExp } +> : exp0b qop exp10a { HsInfixApp $1 $2 $3 } +> | exp10a { $1 } + +> exp0b :: { HsExp } +> : exp0b qop exp10b { HsInfixApp $1 $2 $3 } +> | exp10b { $1 } + +> exp10a :: { HsExp } +> : '\\' srcloc apats '->' exp { HsLambda $2 (reverse $3) $5 } +> | 'let' decllist 'in' exp { HsLet $2 $4 } +> | 'if' exp 'then' exp 'else' exp { HsIf $2 $4 $6 } + +> exp10b :: { HsExp } +> : 'case' exp 'of' altslist { HsCase $2 $4 } +> | '-' fexp { HsNegApp $2 } +> | 'do' stmtlist { HsDo $2 } +> | fexp { $1 } + +> fexp :: { HsExp } +> : fexp aexp { HsApp $1 $2 } +> | aexp { $1 } + +> apats :: { [HsPat] } +> : apats apat { $2 : $1 } +> | apat { [$1] } + +> apat :: { HsPat } +> : aexp {% checkPattern $1 } + +UGLY: Because patterns and expressions are mixed, aexp has to be split into +two rules: One right-recursive and one left-recursive. Otherwise we get two +reduce/reduce-errors (for as-patterns and irrefutable patters). + +Even though the variable in an as-pattern cannot be qualified, we use +qvar here to avoid a shift/reduce conflict, and then check it ourselves +(as for vars above). + +> aexp :: { HsExp } +> : qvar '@' aexp {% do { n <- checkUnQual $1; +> return (HsAsPat n $3) } } +> | '~' aexp { HsIrrPat $2 } +> | aexp1 { $1 } + +Note: The first two alternatives of aexp1 are not necessarily record +updates: they could be labeled constructions. + +> aexp1 :: { HsExp } +> : aexp1 '{' '}' {% mkRecConstrOrUpdate $1 [] } +> | aexp1 '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } +> | aexp2 { $1 } + +According to the Report, the left section (e op) is legal iff (e op x) +parses equivalently to ((e) op x). Thus e must be an exp0b. + +> aexp2 :: { HsExp } +> : qvar { HsVar $1 } +> | gcon { $1 } +> | literal { HsLit $1 } +> | '(' exp ')' { HsParen $2 } +> | '(' texps ')' { HsTuple (reverse $2) } +> | '[' list ']' { $2 } +> | '(' exp0b qop ')' { HsLeftSection $2 $3 } +> | '(' qopm exp0 ')' { HsRightSection $2 $3 } +> | '_' { HsWildCard } + +> commas :: { Int } +> : commas ',' { $1 + 1 } +> | ',' { 1 } + +> texps :: { [HsExp] } +> : texps ',' exp { $3 : $1 } +> | exp ',' exp { [$3,$1] } + +----------------------------------------------------------------------------- +List expressions + +The rules below are little bit contorted to keep lexps left-recursive while +avoiding another shift/reduce-conflict. + +> list :: { HsExp } +> : exp { HsList [$1] } +> | lexps { HsList (reverse $1) } +> | exp '..' { HsEnumFrom $1 } +> | exp ',' exp '..' { HsEnumFromThen $1 $3 } +> | exp '..' exp { HsEnumFromTo $1 $3 } +> | exp ',' exp '..' exp { HsEnumFromThenTo $1 $3 $5 } +> | exp '|' quals { HsListComp $1 (reverse $3) } + +> lexps :: { [HsExp] } +> : lexps ',' exp { $3 : $1 } +> | exp ',' exp { [$3,$1] } + +----------------------------------------------------------------------------- +List comprehensions + +> quals :: { [HsStmt] } +> : quals ',' qual { $3 : $1 } +> | qual { [$1] } + +> qual :: { HsStmt } +> : pat srcloc '<-' exp { HsGenerator $2 $1 $4 } +> | exp { HsQualifier $1 } +> | 'let' decllist { HsLetStmt $2 } + +----------------------------------------------------------------------------- +Case alternatives + +> altslist :: { [HsAlt] } +> : '{' alts '}' { $2 } +> | open alts close { $2 } + +> alts :: { [HsAlt] } +> : optsemis alts1 optsemis { reverse $2 } + +> alts1 :: { [HsAlt] } +> : alts1 semis alt { $3 : $1 } +> | alt { [$1] } + +> alt :: { HsAlt } +> : srcloc pat ralt optwhere { HsAlt $1 $2 $3 $4 } + +> ralt :: { HsGuardedAlts } +> : '->' exp { HsUnGuardedAlt $2 } +> | gdpats { HsGuardedAlts (reverse $1) } + +> gdpats :: { [HsGuardedAlt] } +> : gdpats gdpat { $2 : $1 } +> | gdpat { [$1] } + +> gdpat :: { HsGuardedAlt } +> : srcloc '|' exp0 '->' exp { HsGuardedAlt $1 $3 $5 } + +> pat :: { HsPat } +> : exp0b {% checkPattern $1 } + +----------------------------------------------------------------------------- +Statement sequences + +As per the Report, but with stmt expanded to simplify building the list +without introducing conflicts. This also ensures that the last stmt is +an expression. + +> stmtlist :: { [HsStmt] } +> : '{' stmts '}' { $2 } +> | open stmts close { $2 } + +> stmts :: { [HsStmt] } +> : 'let' decllist ';' stmts { HsLetStmt $2 : $4 } +> | pat srcloc '<-' exp ';' stmts { HsGenerator $2 $1 $4 : $6 } +> | exp ';' stmts { HsQualifier $1 : $3 } +> | ';' stmts { $2 } +> | exp ';' { [HsQualifier $1] } +> | exp { [HsQualifier $1] } + +----------------------------------------------------------------------------- +Record Field Update/Construction + +> fbinds :: { [HsFieldUpdate] } +> : fbinds ',' fbind { $3 : $1 } +> | fbind { [$1] } + +> fbind :: { HsFieldUpdate } +> : qvar '=' exp { HsFieldUpdate $1 $3 } + +----------------------------------------------------------------------------- +Variables, Constructors and Operators. + +> gcon :: { HsExp } +> : '(' ')' { unit_con } +> | '[' ']' { HsList [] } +> | '(' commas ')' { tuple_con $2 } +> | qcon { HsCon $1 } + +> var :: { HsName } +> : varid { $1 } +> | '(' varsym ')' { $2 } + +> qvar :: { HsQName } +> : qvarid { $1 } +> | '(' qvarsym ')' { $2 } + +> con :: { HsName } +> : conid { $1 } +> | '(' consym ')' { $2 } + +> qcon :: { HsQName } +> : qconid { $1 } +> | '(' gconsym ')' { $2 } + +> varop :: { HsName } +> : varsym { $1 } +> | '`' varid '`' { $2 } + +> qvarop :: { HsQName } +> : qvarsym { $1 } +> | '`' qvarid '`' { $2 } + +> qvaropm :: { HsQName } +> : qvarsymm { $1 } +> | '`' qvarid '`' { $2 } + +> conop :: { HsName } +> : consym { $1 } +> | '`' conid '`' { $2 } + +> qconop :: { HsQName } +> : gconsym { $1 } +> | '`' qconid '`' { $2 } + +> op :: { HsOp } +> : varop { HsVarOp $1 } +> | conop { HsConOp $1 } + +> qop :: { HsQOp } +> : qvarop { HsQVarOp $1 } +> | qconop { HsQConOp $1 } + +> qopm :: { HsQOp } +> : qvaropm { HsQVarOp $1 } +> | qconop { HsQConOp $1 } + +> gconsym :: { HsQName } +> : ':' { list_cons_name } +> | qconsym { $1 } + +----------------------------------------------------------------------------- +Identifiers and Symbols + +> qvarid :: { HsQName } +> : varid { UnQual $1 } +> | QVARID { Qual (Module (fst $1)) (HsIdent (snd $1)) } + +> varid :: { HsName } +> : VARID { HsIdent $1 } +> | 'as' { as_name } +> | 'qualified' { qualified_name } +> | 'hiding' { hiding_name } + +> qconid :: { HsQName } +> : conid { UnQual $1 } +> | QCONID { Qual (Module (fst $1)) (HsIdent (snd $1)) } + +> conid :: { HsName } +> : CONID { HsIdent $1 } + +> qconsym :: { HsQName } +> : consym { UnQual $1 } +> | QCONSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) } + +> consym :: { HsName } +> : CONSYM { HsSymbol $1 } + +> qvarsym :: { HsQName } +> : varsym { UnQual $1 } +> | qvarsym1 { $1 } + +> qvarsymm :: { HsQName } +> : varsymm { UnQual $1 } +> | qvarsym1 { $1 } + +> varsym :: { HsName } +> : VARSYM { HsSymbol $1 } +> | '-' { minus_name } +> | '!' { pling_name } + +> varsymm :: { HsName } -- varsym not including '-' +> : VARSYM { HsSymbol $1 } +> | '!' { pling_name } + +> qvarsym1 :: { HsQName } +> : QVARSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) } + +> literal :: { HsLiteral } +> : INT { HsInt $1 } +> | CHAR { HsChar $1 } +> | RATIONAL { HsFrac $1 } +> | STRING { HsString $1 } + +> srcloc :: { SrcLoc } : {% getSrcLoc } + +----------------------------------------------------------------------------- +Layout + +> open :: { () } : {% pushCurrentContext } + +> close :: { () } +> : vccurly { () } -- context popped in lexer. +> | error {% popContext } + +----------------------------------------------------------------------------- +Miscellaneous (mostly renamings) + +> modid :: { Module } +> : CONID { Module $1 } +> | QCONID { Module (fst $1 ++ '.':snd $1) } + +> tyconorcls :: { HsName } +> : conid { $1 } + +> tycon :: { HsName } +> : conid { $1 } + +> qtyconorcls :: { HsQName } +> : qconid { $1 } + +> qtycls :: { HsQName } +> : qconid { $1 } + +> tyvar :: { HsName } +> : varid { $1 } + +----------------------------------------------------------------------------- + +> { +> happyError :: P a +> happyError = fail "Parse error" + +> -- | Parse of a string, which should contain a complete Haskell 98 expression +> parseExpr :: String -> ParseResult HsExp +> parseExpr = runParser parse + +> } diff --git a/Lib/Process.hs b/Lib/Process.hs new file mode 100644 --- /dev/null +++ b/Lib/Process.hs @@ -0,0 +1,55 @@ +-- +-- Copyright (c) 2004-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | A Posix.popen compatibility mapping. +-- +module Lib.Process (popen) where + +import System.Exit +import System.IO +import System.Process +import Control.Concurrent (forkIO) + +import qualified Control.Exception + +-- +-- Ignoring exit status for now. +-- +-- You have to ignore SIGPIPE, otherwise popening a non-existing executable +-- will result in an attempt to write to a closed pipe and crash the wholw +-- program. +-- +-- XXX there are still issues. Large amounts of output can cause what +-- seems to be a dead lock on the pipe write from runplugs, for example. +-- Posix.popen doesn't have this problem, so maybe we can reproduce its +-- pipe handling somehow. +-- +popen :: FilePath -> [String] -> Maybe String -> IO (String,String,ExitCode) +popen file args minput = + Control.Exception.handle (\e -> return ([],show e,error (show e))) $ do + + (inp,out,err,pid) <- runInteractiveProcess file args Nothing Nothing + + case minput of + Just input -> hPutStr inp input >> hClose inp -- importante! + Nothing -> return () + + -- Now, grab the input + output <- hGetContents out + errput <- hGetContents err + + -- SimonM sez: + -- ... avoids blocking the main thread, but ensures that all the + -- data gets pulled as it becomes available. you have to force the + -- output strings before waiting for the process to terminate. + -- + forkIO (Control.Exception.evaluate (length output) >> return ()) + forkIO (Control.Exception.evaluate (length errput) >> return ()) + + -- And now we wait. We must wait after we read, unsurprisingly. + -- blocks without -threaded, you're warned. + -- and maybe the process has already completed.. + e <- Control.Exception.catch (waitForProcess pid) (\_ -> return ExitSuccess) + + return (output,errput,e) diff --git a/Lib/README b/Lib/README new file mode 100644 --- /dev/null +++ b/Lib/README @@ -0,0 +1,25 @@ +Our own custom libraries for various plugin functions. + +AltTime.hs + alternate version of the time library + +Binary.hs + a binary io lib + +Map.hs + a wrapper over Data.Map with extras + +MiniHTTP.hs + a mini http server + +Process.hs + a wrapper over System.Process + +Regex.hsc + a fast packed string regex library + +Serial.hs + a serialisation api + +Util.hs + miscellaneous string, and other, functions diff --git a/Lib/Regex.hsc b/Lib/Regex.hsc new file mode 100644 --- /dev/null +++ b/Lib/Regex.hsc @@ -0,0 +1,151 @@ +{-# OPTIONS -w #-} +-- +-- +-- Module : Text.Regex.Posix +-- +-- Copyright : (c) The University of Glasgow 2002 +-- (c) Don Stewart 2004 +-- +-- License : BSD-style (see the file libraries/base/LICENSE) +-- +-- Maintainer : libraries@haskell.org +-- Stability : experimental +-- Portability : portable +-- + +-- +-- | Interface to the POSIX regular expression library. +-- + +module Lib.Regex ( + + -- * The @Regex@ type + Regex, -- abstract + + -- * Compiling a regular expression + regcomp, -- :: ByteString -> Int -> IO Regex + + -- ** Flags for regcomp + regExtended, -- (flag to regcomp) use extended regex syntax + regIgnoreCase, -- (flag to regcomp) ignore case when matching + regNewline, -- (flag to regcomp) '.' doesn't match newline + regNosub, -- unused + + -- * Matching a regular expression + regexec, -- :: Regex -> Ptr CChar -> Int + -- -> IO (Maybe ((Int,Int), [(Int,Int)])) + matchRegex + + ) where + +# include +# include + +import Foreign.C +import Foreign.C.String +import Foreign.ForeignPtr +import qualified Foreign.Concurrent as FC +import Foreign +import System.IO.Unsafe (unsafePerformIO) + +import qualified Data.ByteString as P +import qualified Data.ByteString.Base as P (unsafeUseAsCString) + +type CRegex = () + +-- | A compiled regular expression +newtype Regex = Regex (ForeignPtr CRegex) + +-- --------------------------------------------------------------------- +-- | Compiles a regular expression +-- +regcomp :: P.ByteString -- ^ The regular expression to compile + -> Int -- ^ Flags (summed together) + -> IO Regex -- ^ Returns: the compiled regular expression + +regcomp ps flags = do + regex_fptr <- mallocForeignPtrBytes (#const sizeof(regex_t)) + r <- P.unsafeUseAsCString ps $ \cstr -> + withForeignPtr regex_fptr $ \p -> + c_regcomp p cstr (fromIntegral flags) + if (r == 0) + then do + FC.addForeignPtrFinalizer regex_fptr $ regfree regex_fptr + return (Regex regex_fptr) + else ioError $ userError $ "Error in pattern: " ++ (show ps) + +-- --------------------------------------------------------------------- +-- | Matches a regular expression against a buffer, returning the buffer +-- indicies of the match, and any submatches +-- +regexec :: Regex -- ^ Compiled regular expression + -> Ptr CChar -- ^ The buffer to match against + -> Int -- ^ Offset in buffer to start searching from + -> IO (Maybe ((Int,Int), [(Int,Int)])) + -- ^ Returns: 'Nothing' if the regex did not match the + -- or Just the start and end indicies of the match and submatches + +regexec (Regex regex_fptr) ptr i = do + withForeignPtr regex_fptr $ \regex_ptr -> do + nsub <- (#peek regex_t, re_nsub) regex_ptr + let nsub_int = fromIntegral (nsub :: CSize) + allocaBytes ((1 + nsub_int)*(#const sizeof(regmatch_t))) $ \p_match-> do + -- add one because index zero covers the whole match + r <- cregexec regex_ptr (ptr `plusPtr` i) + (1 + nsub) p_match 0{-no flags -} + + if (r /= 0) then return Nothing else do + match <- indexOfMatch p_match + sub_matches <- mapM (indexOfMatch) $ take nsub_int $ tail $ + iterate (`plusPtr` (#const sizeof(regmatch_t))) p_match + + return (Just (match, sub_matches)) + +indexOfMatch :: Ptr CRegMatch -> IO (Int, Int) +indexOfMatch p_match = do + start <- (#peek regmatch_t, rm_so) p_match :: IO (#type regoff_t) + end <- (#peek regmatch_t, rm_eo) p_match :: IO (#type regoff_t) + let s = fromIntegral start; e = fromIntegral end + return (s, e) + +-- ----------------------------------------------------------------------------- +-- The POSIX regex C interface + +regExtended :: Int +regExtended = 1 +regIgnoreCase :: Int +regIgnoreCase = 2 +regNosub :: Int +regNosub = 4 +regNewline :: Int +regNewline = 8 + +type CRegMatch = () + +foreign import ccall unsafe "regex.h regcomp" + c_regcomp :: Ptr CRegex -> CString -> CInt -> IO CInt + +foreign import ccall unsafe "regex.h regfree" + c_regfree :: Ptr CRegex -> IO () + +foreign import ccall unsafe "regex.h regexec" + cregexec :: Ptr CRegex + -> Ptr CChar + -> CSize -> Ptr CRegMatch -> CInt -> IO CInt + +regfree :: ForeignPtr CRegex -> IO () +regfree fp = withForeignPtr fp $ c_regfree + +------------------------------------------------------------------------ + +-- | Match a regular expression against a string +matchRegex + :: Regex -- ^ The regular expression + -> String -- ^ The string to match against + -> Bool +matchRegex p str = unsafePerformIO $ withCString str $ \cstr -> do + m <- regexec p cstr 0 + return $ case m of + Nothing -> False + Just _ -> True + diff --git a/Lib/Serial.hs b/Lib/Serial.hs new file mode 100644 --- /dev/null +++ b/Lib/Serial.hs @@ -0,0 +1,147 @@ +-- +-- Copyright (c) 2004-5 Thomas Jaeger, Don Stewart +-- +-- This program is free software; you can redistribute it and/or +-- modify it under the terms of the GNU General Public License as +-- published by the Free Software Foundation; either version 2 of +-- the License, or (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-- General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +-- 02111-1307, USA. +-- +-- +-- | Serialisation +-- +module Lib.Serial ( + Serial(..), + stdSerial, mapSerial, listSerial, + mapPackedSerial, assocListPackedSerial, mapListPackedSerial, + readM, Packable(..), {- instances of Packable -} + packedListSerial, + ) where + +import Data.Maybe (mapMaybe) + +import Data.Map (Map) +import qualified Data.Map as M + +import qualified Data.ByteString.Char8 as P +import Data.ByteString.Char8 (ByteString) + +------------------------------------------------------------------------ + +-- A flexible (moreso than a typeclass) way to define introduction and +-- elimination for persistent state on a per-module basis. +-- +data Serial s = Serial { + serialize :: s -> Maybe ByteString, + deserialize :: ByteString -> Maybe s + } + +-- | Default `instance' for a Serial +stdSerial :: (Show s, Read s) => Serial s +stdSerial = Serial (Just. P.pack.show) (readM.P.unpack) + +-- | Serializes a 'Map' type if both the key and the value are instances +-- of Read and Show. The serialization is done by converting the map to +-- and from lists. Results are saved line-wise, for better editing and +-- revison control. +-- +mapSerial :: (Ord k, Show k, Show v, Read k, Read v) => Serial (Map k v) +mapSerial = Serial { + serialize = Just . P.pack . unlines . map show . M.toList, + deserialize = Just . M.fromList . mapMaybe (readM . P.unpack) . P.lines + } + +-- | Serialize a list of 'a's. As for the 'mapSerializer', its output is line-wise. +listSerial :: (Read a, Show a) => Serial [a] +listSerial = Serial { + serialize = Just .P.pack . unlines . map show, + deserialize = Just . mapMaybe (readM . P.unpack) . P.lines + } + +packedListSerial :: Serial [P.ByteString] +packedListSerial = Serial { + serialize = Just . P.unlines, + deserialize = Just . P.lines + } + +------------------------------------------------------------------------ + +-- | 'readM' behaves like read, but catches failure in a monad. +-- this allocates a 20-30 M on startup... +readM :: (Monad m, Read a) => String -> m a +readM s = case [x | (x,t) <- {-# SCC "Serial.readM.reads" #-} reads s -- bad! + , ("","") <- lex t] of + [x] -> return x + [] -> fail "Serial.readM: no parse" + _ -> fail "Serial.readM: ambiguous parse" + + +class Packable t where + readPacked :: ByteString -> t + showPacked :: t -> ByteString + +-- | An instance for Map Packed [Packed] +instance Packable (Map ByteString [ByteString]) where + readPacked ps = M.fromList (readKV (P.lines ps)) + where + readKV :: [ByteString] -> [(ByteString,[ByteString])] + readKV [] = [] + readKV (k:rest) = + let (vs, rest') = break (== P.empty) rest + in (k,vs) : readKV (drop 1 rest') + + + showPacked m = P.unlines . concatMap (\(k,vs) -> k : vs ++ [P.empty]) $ M.toList m + +instance Packable (Map ByteString ByteString) where + readPacked ps = M.fromList (readKV (P.lines ps)) + where + readKV :: [ByteString] -> [(ByteString,ByteString)] + readKV [] = [] + readKV (k:v:rest) = (k,v) : readKV rest + readKV _ = error "Serial.readPacked: parse failed" + + showPacked m = P.unlines . concatMap (\(k,v) -> [k,v]) $ M.toList m + +instance Packable ([(ByteString,ByteString)]) where + readPacked ps = readKV (P.lines ps) + where + readKV :: [ByteString] -> [(ByteString,ByteString)] + readKV [] = [] + readKV (k:v:rest) = (k,v) : readKV rest + readKV _ = error "Serial.readPacked: parse failed" + + showPacked = P.unlines . concatMap (\(k,v) -> [k,v]) + +instance Packable (M.Map P.ByteString (Bool, [(String, Int)])) where + readPacked = M.fromList . readKV . P.lines + where + readKV :: [P.ByteString] -> [(P.ByteString,(Bool, [(String, Int)]))] + readKV [] = [] + readKV (k:v:rest) = (k, (read . P.unpack) v) : readKV rest + readKV _ = error "Vote.readPacked: parse failed" + + showPacked m = P.unlines . concatMap (\(k,v) -> [k,P.pack . show $ v]) $ M.toList m + +-- And for packed string maps +mapPackedSerial :: Serial (Map ByteString ByteString) +mapPackedSerial = Serial (Just . showPacked) (Just . readPacked) + +-- And for list of packed string maps +mapListPackedSerial :: Serial (Map ByteString [ByteString]) +mapListPackedSerial = Serial (Just . showPacked) (Just . readPacked) + +-- And for association list +assocListPackedSerial :: Serial ([(ByteString,ByteString)]) +assocListPackedSerial = Serial (Just . showPacked) (Just . readPacked) + +------------------------------------------------------------------------ diff --git a/Lib/Signals.hs b/Lib/Signals.hs new file mode 100644 --- /dev/null +++ b/Lib/Signals.hs @@ -0,0 +1,131 @@ +{-# OPTIONS -cpp #-} +-- +-- | The signal story. +-- +-- Posix signals are external events that invoke signal handlers in +-- Haskell. The signal handlers in turn throw dynamic exceptions. Our +-- instance of MonadError for LB maps the dynamic exceptions to +-- SignalCaughts, which can then be caught by a normal catchIrc or +-- handleIrc +-- +-- Here's where we do that. +-- +module Lib.Signals where + +import Lib.Error +import Lib.Util + +import Data.Typeable + +import Control.Concurrent +import Control.Exception +import Control.Monad.Error + +import System.IO.Unsafe +import System.Posix.Signals + +-- A new type for the SignalException, must be Typeable so we can make a +-- dynamic exception out of it. +newtype SignalException = SignalException Signal deriving Typeable + +-- +-- A bit of sugar for installing a new handler +-- +withHandler :: (MonadIO m,MonadError e m) => Signal -> Handler -> m () -> m () +#ifdef mingw32_HOST_OS +withHandler s h m = return () +#else +withHandler s h m + = bracketError (io (installHandler s h Nothing)) + (io . flip (installHandler s) Nothing) + (const m) +#endif + +-- And more sugar for installing a list of handlers +withHandlerList :: (MonadError e m,MonadIO m) + => [Signal] -> (Signal -> Handler) -> m () -> m () +withHandlerList sl h m = foldr (withHandler `ap` h) m sl + +-- +-- Signals we care about. They're all fatal. +-- +-- Be careful adding signals, some signals can't be caught and +-- installHandler just raises an exception if you try +-- +ircSignalsToCatch :: [Signal] +ircSignalsToCatch = [ +#ifndef mingw32_HOST_OS + busError, + segmentationViolation, + keyboardSignal, + softwareTermination, + keyboardTermination, + lostConnection, + internalAbort +#endif + ] + +-- +-- User friendly names for the signals that we can catch +-- +ircSignalMessage :: Signal -> [Char] +ircSignalMessage s +#ifndef mingw32_HOST_OS + | s==busError = "SIGBUS" + | s==segmentationViolation = "SIGSEGV" + | s==keyboardSignal = "SIGINT" + | s==softwareTermination = "SIGTERM" + | s==keyboardTermination = "SIGQUIT" + | s==lostConnection = "SIGHUP" + | s==internalAbort = "SIGABRT" +#endif +-- this case shouldn't happen if the list of messages is kept up to date +-- with the list of signals caught + | otherwise = "killed by unknown signal" + +-- +-- The actual signal handler. It is this function we register for each +-- signal flavour. On receiving a signal, the signal handler maps the +-- signal to a a dynamic exception, and throws it out to the main +-- thread. The LB MonadError instance can then do its trickery to catch +-- it in handler/catchIrc +-- +ircSignalHandler :: ThreadId -> Signal -> Handler +ircSignalHandler threadid s +#ifdef mingw32_HOST_OS + = () +#else + = CatchOnce $ do + putMVar catchLock () + releaseSignals + throwDynTo threadid $ SignalException s + +-- +-- | Release all signal handlers +-- +releaseSignals :: IO () +releaseSignals = + flip mapM_ ircSignalsToCatch + (\sig -> installHandler sig Default Nothing) + +-- +-- Mututally exclusive signal handlers +-- +-- This is clearly a hack, but I have no idea how to accomplish the same +-- thing correctly. The main problem is that signals are often thrown +-- multiple times, and the threads start killing each other if we allow +-- the SignalException to be thrown more than once. +{-# NOINLINE catchLock #-} +catchLock :: MVar () +catchLock = unsafePerformIO newEmptyMVar +#endif + +-- +-- | Register signal handlers to catch external signals +-- +withIrcSignalCatch :: (MonadError e m,MonadIO m) => m () -> m () +withIrcSignalCatch m = do + io $ installHandler sigPIPE Ignore Nothing + io $ installHandler sigALRM Ignore Nothing + threadid <- io myThreadId + withHandlerList ircSignalsToCatch (ircSignalHandler threadid) m diff --git a/Lib/Url.hs b/Lib/Url.hs new file mode 100644 --- /dev/null +++ b/Lib/Url.hs @@ -0,0 +1,148 @@ +-- +-- TODO: How do I avoid threading the 'proxy' argument to the various +-- functions in here? +-- +-- | URL Utility Functions +-- + +module Lib.Url ( + getHtmlPage, + getHeader, + rawPageTitle, + urlPageTitle, + urlTitlePrompt + ) where + +import Data.List +import Data.Maybe +import Text.Regex +import Lib.MiniHTTP + +-- | The string that I prepend to the quoted page title. +urlTitlePrompt :: String +urlTitlePrompt = "Title: " + +-- | Limit the maximum title length to prevent jokers from spamming +-- the channel with specially crafted HTML pages. +maxTitleLength :: Int +maxTitleLength = 80 + +-- | Fetches a page title suitable for display. Ideally, other +-- plugins should make use of this function if the result is to be +-- displayed in an IRC channel because it ensures that a consistent +-- look is used (and also lets the URL plugin effectively ignore +-- contextual URLs that might be generated by another instance of +-- lambdabot; the URL plugin matches on 'urlTitlePrompt'). +urlPageTitle :: String -> Proxy -> IO (Maybe String) +urlPageTitle url proxy = do + title <- rawPageTitle url proxy + return $ maybe Nothing (return . prettyTitle . urlDecode) title + where + limitLength s + | length s > maxTitleLength = (take maxTitleLength s) ++ " ..." + | otherwise = s + + prettyTitle s = urlTitlePrompt ++ "\"" ++ limitLength s ++ "\"" + +-- | Fetches a page title for the specified URL. This function should +-- only be used by other plugins if and only if the result is not to +-- be displayed in an IRC channel. Instead, use 'urlPageTitle'. +rawPageTitle :: String -> Proxy -> IO (Maybe String) +rawPageTitle url proxy + | Just uri <- parseURI url = do + contents <- getHtmlPage uri proxy + return $ extractTitle contents + | otherwise = return Nothing + +-- | Fetch the contents of a URL following HTTP redirects. It returns +-- a list of strings comprising the server response which includes the +-- status line, response headers, and body. +getHtmlPage :: URI -> Proxy -> IO [String] +getHtmlPage uri proxy = do + contents <- getURIContents uri proxy + case responseStatus contents of + 301 -> getHtmlPage (redirectedUrl contents) proxy + 302 -> getHtmlPage (redirectedUrl contents) proxy + 200 -> return contents + _ -> return [] + where + -- | Parse the HTTP response code from a line in the following + -- format: HTTP/1.1 200 Success. + responseStatus hdrs = (read . (!!1) . words . (!!0)) hdrs :: Int + + -- | Return the value of the "Location" header in the server + -- response + redirectedUrl hdrs + | Just loc <- getHeader "Location" hdrs = + case parseURI loc of + Nothing -> (fromJust . parseURI) $ fullUrl loc + Just uri' -> uri' + | otherwise = error("No Location header found in 3xx response.") + + -- | Construct a full absolute URL based on the current uri. This is + -- used when a Location header violates the HTTP RFC and does not send + -- an absolute URI in the response, instead, a relative URI is sent, so + -- we must manually construct the absolute URI. + fullUrl loc = let auth = fromJust $ uriAuthority uri + in (uriScheme uri) ++ "//" ++ + (uriRegName auth) ++ + loc + +-- | Fetch the contents of a URL returning a list of strings +-- comprising the server response which includes the status line, +-- response headers, and body. +getURIContents :: URI -> Proxy -> IO [String] +getURIContents uri proxy = readNBytes 1024 proxy uri request "" + where + request = case proxy of + Nothing -> ["GET " ++ abs_path ++ " HTTP/1.1", + "host: " ++ host, + "Connection: close", ""] + _ -> ["GET " ++ show uri ++ " HTTP/1.0", ""] + + abs_path = case uriPath uri ++ uriQuery uri ++ uriFragment uri of + url@('/':_) -> url + url -> '/':url + + host = uriRegName . fromJust $ uriAuthority uri + +-- | Given a server response (list of Strings), return the text in +-- between the title HTML element, only if it is text/html content. +-- TODO: need to decode character entities (or at least the most +-- common ones) +extractTitle :: [String] -> Maybe String +extractTitle contents + | isTextHtml contents = getTitle $ unlines contents + | otherwise = Nothing + where + begreg = mkRegexWithOpts " *" True False + endreg = mkRegexWithOpts " *" True False + + getTitle text = do + (_,_,start,_) <- matchRegexAll begreg text + (title,_,_,_) <- matchRegexAll endreg start + return $ (unwords . words) title + +-- | Is the server response of type "text/html"? +isTextHtml :: [String] -> Bool +isTextHtml [] = False +isTextHtml contents = val == "text/html" + where + val = takeWhile (/=';') ctype + Just ctype = getHeader "Content-Type" contents + +-- | Retrieve the specified header from the server response being +-- careful to strip the trailing carriage return. I swiped this code +-- from Search.hs, but had to modify it because it was not properly +-- stripping off the trailing CR (must not have manifested itself as a +-- bug in that code; however, parseURI will fail against CR-terminated +-- strings. +getHeader :: String -> [String] -> Maybe String +getHeader _ [] = Nothing +getHeader hdr (_:hs) = lookup hdr $ concatMap mkassoc hs + where + removeCR = takeWhile (/='\r') + mkassoc s = case findIndex (==':') s of + Just n -> [(take n s, removeCR $ drop (n+2) s)] + Nothing -> [] + diff --git a/Lib/Util.hs b/Lib/Util.hs new file mode 100644 --- /dev/null +++ b/Lib/Util.hs @@ -0,0 +1,465 @@ +-- +-- Copyright (c) 2006 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | String and other utilities +-- +module Lib.Util ( + concatWith, + split, split2, + breakOnGlue, + clean, + dropSpace, + dropSpaceEnd, + dropNL, + snoc, + after, + splitFirstWord, + firstWord, + debugStr, + debugStrLn, + lowerCaseString, upperCaseString, + upperize, lowerize, + quote, + listToStr, + listToMaybeWith, listToMaybeAll, + getRandItem, stdGetRandItem, randomElem, + showClean, + expandTab, + closest, closests, + withMWriter, parIO, timeout, + choice, + arePrefixesWithSpaceOf, arePrefixesOf, + + (), (<.>), (<+>), (<>), (<$>), + basename, dirname, dropSuffix, joinPath, + + addList, mapMaybeMap, insertUpd, + + pprKeys, + + isLeft, isRight, unEither, + + io + ) where + +import Data.List (intersperse, isPrefixOf) +import Data.Char (isSpace, toLower, toUpper) +import Data.Maybe +import Control.Monad.State (MonadIO(..)) + +import qualified Data.Map as M +import Data.IORef (newIORef, readIORef, writeIORef) + +import Control.Concurrent (MVar, newEmptyMVar, takeMVar, tryPutMVar, putMVar, + forkIO, killThread, threadDelay) +import Control.Exception (bracket) + +import System.Random hiding (split) + +import System.IO + +------------------------------------------------------------------------ + +-- | 'concatWith' joins lists with the given glue elements. Example: +-- +-- > concatWith ", " ["one","two","three"] ===> "one, two, three" +concatWith :: [a] -- ^ Glue to join with + -> [[a]] -- ^ Elements to glue together + -> [a] -- ^ Result: glued-together list + +concatWith glue xs = (concat . intersperse glue) xs + +-- | Split a list into pieces that were held together by glue. Example: +-- +-- > split ", " "one, two, three" ===> ["one","two","three"] +split :: Eq a => [a] -- ^ Glue that holds pieces together + -> [a] -- ^ List to break into pieces + -> [[a]] -- ^ Result: list of pieces +split glue xs = split' xs + where + split' [] = [] + split' xs' = piece : split' (dropGlue rest) + where (piece, rest) = breakOnGlue glue xs' + dropGlue = drop (length glue) + +-- a variant? +split2 :: Char -> Int -> String -> [String] +split2 c i s = + let fn 0 t = t:[] + fn j t = let (xs,ys) = break (== c) t + in case ys of + [] -> xs:[] + _ -> xs: fn (j-1) (tail ys) + in fn (i-1) s + + +-- | Break off the first piece of a list held together by glue, +-- leaving the glue attached to the remainder of the list. Example: +-- Like break, but works with a [a] match. +-- +-- > breakOnGlue ", " "one, two, three" ===> ("one", ", two, three") +breakOnGlue :: (Eq a) => [a] -- ^ Glue that holds pieces together + -> [a] -- ^ List from which to break off a piece + -> ([a],[a]) -- ^ Result: (first piece, glue ++ rest of list) +breakOnGlue _ [] = ([],[]) +breakOnGlue glue rest@(x:xs) + | glue `isPrefixOf` rest = ([], rest) + | otherwise = (x:piece, rest') + where (piece, rest') = breakOnGlue glue xs +{-# INLINE breakOnGlue #-} + +-- | Reverse cons. Add an element to the back of a list. Example: +-- +-- > snoc 3 [2, 1] ===> [2, 1, 3] +snoc :: a -- ^ Element to be added + -> [a] -- ^ List to add to + -> [a] -- ^ Result: List ++ [Element] +snoc x xs = xs ++ [x] + +-- | 'after' takes 2 strings, called the prefix and data. A necessary +-- precondition is that +-- +-- > Data.List.isPrefixOf prefix data ===> True +-- +-- 'after' returns a string based on data, where the prefix has been +-- removed as well as any excess space characters. Example: +-- +-- > after "This is" "This is a string" ===> "a string" +after :: String -- ^ Prefix string + -> String -- ^ Data string + -> String -- ^ Result: Data string with Prefix string and excess whitespace + -- removed +after [] ys = dropWhile isSpace ys +after (_:_) [] = error "after: (:) [] case" +after (x:xs) (y:ys) + | x == y = after xs ys + | otherwise = error "after: /= case" + +-- | Break a String into it's first word, and the rest of the string. Example: +-- +-- > split_first_word "A fine day" ===> ("A", "fine day) +splitFirstWord :: String -- ^ String to be broken + -> (String, String) +splitFirstWord xs = (w, dropWhile isSpace xs') + where (w, xs') = break isSpace xs + +-- | Get the first word of a string. Example: +-- +-- > first_word "This is a fine day" ===> "This" +firstWord :: String -> String +firstWord = takeWhile (not . isSpace) + +-- refactor, might be good for logging to file later +-- | 'debugStr' checks if we have the verbose flag turned on. If we have +-- it outputs the String given. Else, it is a no-op. + +debugStr :: (MonadIO m) => String -> m () +debugStr = liftIO . putStr + +-- | 'debugStrLn' is a version of 'debugStr' that adds a newline to the end +-- of the string outputted. +debugStrLn :: (MonadIO m) => [Char] -> m () +debugStrLn x = debugStr (x ++ "\n") + +-- | 'lowerCaseString' transforms the string given to lower case. +-- +-- > Example: lowerCaseString "MiXeDCaSe" ===> "mixedcase" +lowerCaseString :: String -> String +lowerCaseString = map toLower + +-- | 'upperCaseString' transforms the string given to upper case. +-- +-- > Example: upperCaseString "MiXeDcaSe" ===> "MIXEDCASE" +upperCaseString :: String -> String +upperCaseString = map toUpper + +-- | 'lowerize' forces the first char of a string to be lowercase. +-- if the string is empty, the empty string is returned. +lowerize :: String -> String +lowerize [] = [] +lowerize (c:cs) = toLower c:cs + +-- | 'upperize' forces the first char of a string to be uppercase. +-- if the string is empty, the empty string is returned. +upperize :: String -> String +upperize [] = [] +upperize (c:cs) = toUpper c:cs + +-- | 'quote' puts a string into quotes but does not escape quotes in +-- the string itself. +quote :: String -> String +quote x = "\"" ++ x ++ "\"" + +-- | Form a list of terms using a single conjunction. Example: +-- +-- > listToStr "and" ["a", "b", "c"] ===> "a, b and c" +listToStr :: String -> [String] -> String +listToStr _ [] = [] +listToStr conj (item:items) = + let listToStr' [] = [] + listToStr' [y] = concat [" ", conj, " ", y] + listToStr' (y:ys) = concat [", ", y, listToStr' ys] + in item ++ listToStr' items + +-- | Like 'listToMaybe', but take a function to use in case of a non-null list. +-- I.e. @listToMaybe = listToMaybeWith head@ +listToMaybeWith :: ([a] -> b) -> [a] -> Maybe b +listToMaybeWith _ [] = Nothing +listToMaybeWith f xs = Just (f xs) + +-- | @listToMaybeAll = listToMaybeWith id@ +listToMaybeAll :: [a] -> Maybe [a] +listToMaybeAll = listToMaybeWith id + +------------------------------------------------------------------------ + +-- | 'getRandItem' takes as input a list and a random number generator. It +-- then returns a random element from the list, paired with the altered +-- state of the RNG +getRandItem :: (RandomGen g) => + [a] -- ^ The list to pick a random item from + -> g -- ^ The RNG to use + -> (a, g) -- ^ A pair of the item, and the new RNG seed +getRandItem [] _ = error "getRandItem: empty list" +getRandItem mylist rng = (mylist !! index,newRng) + where + llen = length mylist + (index, newRng) = randomR (0,llen - 1) rng + +-- | 'stdGetRandItem' is the specialization of 'getRandItem' to the standard +-- RNG embedded within the IO monad. The advantage of using this is that +-- you use the Operating Systems provided RNG instead of rolling your own +-- and the state of the RNG is hidden, so one don't need to pass it +-- explicitly. +stdGetRandItem :: [a] -> IO a +stdGetRandItem = getStdRandom . getRandItem + +randomElem :: [a] -> IO a +randomElem = stdGetRandItem + +------------------------------------------------------------------------ + +-- | 'dropSpace' takes as input a String and strips spaces from the +-- prefix as well as the suffix of the String. Example: +-- +-- > dropSpace " abc " ===> "abc" +dropSpace :: [Char] -> [Char] +dropSpace = let f = reverse . dropWhile isSpace in f . f + +-- | Drop space from the end of the string +dropSpaceEnd :: [Char] -> [Char] +dropSpaceEnd = reverse . dropWhile isSpace . reverse + +-- | 'clean' takes a Char x and returns [x] unless the Char is '\CR' in +-- case [] is returned. +clean :: Char -> [Char] +clean x | x == '\CR' = [] + | otherwise = [x] + +------------------------------------------------------------------------ + +-- | show a list without heavyweight formatting +showClean :: (Show a) => [a] -> String +showClean = concatWith " " . map (init . tail . show) + +dropNL :: [Char] -> [Char] +dropNL = reverse . dropWhile (== '\n') . reverse + +-- | untab an string +expandTab :: String -> String +expandTab [] = [] +expandTab ('\t':xs) = ' ':' ':' ':' ':' ':' ':' ':' ':expandTab xs +expandTab (x:xs) = x : expandTab xs + +------------------------------------------------------------------------ + +-- +-- | Find string in list with smallest levenshtein distance from first +-- argument, return the string and the distance from pat it is. Will +-- return the alphabetically first match if there are multiple matches +-- (this may not be desirable, e.g. "mroe" -> "moo", not "more" +-- +closest :: String -> [String] -> (Int,String) +closest pat ss = minimum ls + where + ls = map (\s -> (levenshtein pat s,s)) ss + +closests :: String -> [String] -> (Int,[String]) +closests pat ss = + let (m,_) = minimum ls + in (m, map snd (filter ((m ==) . fst) ls)) + where + ls = map (\s -> (levenshtein pat s,s)) ss + +-- +-- | Levenshtein edit-distance algorithm +-- Translated from an Erlang version by Fredrik Svensson and Adam Lindberg +-- +levenshtein :: String -> String -> Int +levenshtein [] [] = 0 +levenshtein s [] = length s +levenshtein [] s = length s +levenshtein s t = lvn s t [0..length t] 1 + +lvn :: String -> String -> [Int] -> Int -> Int +lvn [] _ dl _ = last dl +lvn (s:ss) t dl n = lvn ss t (lvn' t dl s [n] n) (n + 1) + +lvn' :: String -> [Int] -> Char -> [Int] -> Int -> [Int] +lvn' [] _ _ ndl _ = ndl +lvn' (t:ts) (dlh:dlt) c ndl ld | length dlt > 0 = lvn' ts dlt c (ndl ++ [m]) m + where + m = foldl1 min [ld + 1, head dlt + 1, dlh + (dif t c)] +lvn' _ _ _ _ _ = error "levenshtein, ran out of numbers" + +dif :: Char -> Char -> Int +dif = (fromEnum .) . (/=) + +{- +-- +-- naive implementation, O(2^n) +-- Too slow after around d = 8 +-- +-- V. I. Levenshtein. Binary codes capable of correcting deletions, +-- insertions and reversals. Doklady Akademii Nauk SSSR 163(4) p845-848, +-- 1965 +-- +-- A Guided Tour to Approximate String Matching, G. Navarro +-- +levenshtein :: (Eq a) => [a] -> [a] -> Int +levenshtein [] [] = 0 +levenshtein s [] = length s +levenshtein [] s = length s +levenshtein (s:ss) (t:ts) = + min3 (eq + (levenshtein ss ts)) + (1 + (levenshtein (ss++[s]) ts)) + (1 + (levenshtein ss (ts++[t]))) + where + eq = fromEnum (s /= t) + min3 a b c = min c (min a b) +-} + +------------------------------------------------------------------------ + +-- | Thread-safe modification of an MVar. +withMWriter :: MVar a -> (a -> (a -> IO ()) -> IO b) -> IO b +withMWriter mvar f = bracket + (do x <- takeMVar mvar; ref <- newIORef x; return (x,ref)) + (\(_,ref) -> tryPutMVar mvar =<< readIORef ref) + (\(x,ref) -> f x $ writeIORef ref) + + +-- stolen from +-- http://www.haskell.org/pipermail/haskell-cafe/2005-January/008314.html +parIO :: IO a -> IO a -> IO a +parIO a1 a2 = do + m <- newEmptyMVar + c1 <- forkIO $ putMVar m =<< a1 + c2 <- forkIO $ putMVar m =<< a2 + r <- takeMVar m + killThread c1 + killThread c2 + return r + +-- | run an action with a timeout +timeout :: Int -> IO a -> IO (Maybe a) +timeout n a = parIO (Just `fmap` a) (threadDelay n >> return Nothing) + +------------------------------------------------------------------------ + +-- some filename manipulation stuff + +-- +-- | , <.> : join two path components +-- +infixr 6 +infixr 6 <.> +infixr 6 <+> +infixr 6 <> +infixr 6 <$> + +(), (<.>), (<+>), (<>), (<$>) :: FilePath -> FilePath -> FilePath +[] b = b +a b = a ++ "/" ++ b + +[] <.> b = b +a <.> b = a ++ "." ++ b + +[] <+> b = b +a <+> b = a ++ " " ++ b + +[] <> b = b +a <> b = a ++ b + +[] <$> b = b +a <$> b = a ++ "\n" ++ b + +basename :: FilePath -> FilePath +basename = reverse . takeWhile ('/' /=) . reverse + +dirname :: FilePath -> FilePath +dirname p = + case reverse $ dropWhile (/= '/') $ reverse p of + [] -> "." + p' -> p' + +dropSuffix :: FilePath -> FilePath +dropSuffix = reverse . tail . dropWhile ('.' /=) . reverse + +joinPath :: FilePath -> FilePath -> FilePath +joinPath p q = + case reverse p of + '/':_ -> p ++ q + [] -> q + _ -> p ++ "/" ++ q + +{-# INLINE choice #-} +choice :: (r -> Bool) -> (r -> a) -> (r -> a) -> (r -> a) +choice p f g x = if p x then f x else g x + +-- Generalizations: +-- choice :: ArrowChoice (~>) => r ~> Bool -> r ~> a -> r ~> a -> r ~> a +-- choice :: Monad m => m Bool -> m a -> m a -> m a + +------------------------------------------------------------------------ + +addList :: (Ord k) => [(k,a)] -> M.Map k a -> M.Map k a +addList l m = M.union (M.fromList l) m +{-# INLINE addList #-} + +-- | Data.Maybe.mapMaybe for Maps +mapMaybeMap :: Ord k => (a -> Maybe b) -> M.Map k a -> M.Map k b +mapMaybeMap f = fmap fromJust . M.filter isJust . fmap f + +-- | This makes way more sense than @insertWith@ because we don't need to +-- remember the order of arguments of @f@. +insertUpd :: Ord k => (a -> a) -> k -> a -> M.Map k a -> M.Map k a +insertUpd f = M.insertWith (\_ -> f) + +-- | Print map keys +pprKeys :: (Show k) => M.Map k a -> String +pprKeys = showClean . M.keys + +-- | Two functions that really should be in Data.Either +isLeft, isRight :: Either a b -> Bool +isLeft (Left _) = True +isLeft _ = False +isRight = not . isLeft + +-- | Another useful Either function to easily get out of an Either +unEither :: Either a a -> a +unEither = either id id + + +-- convenience: +io :: forall a (m :: * -> *). (MonadIO m) => IO a -> m a +io = liftIO +{-# INLINE io #-} + + +arePrefixesWithSpaceOf :: [String] -> String -> Bool +arePrefixesWithSpaceOf els str = any (flip isPrefixOf str) $ map (++" ") els + +arePrefixesOf :: [String] -> String -> Bool +arePrefixesOf = flip (any . flip isPrefixOf) diff --git a/Main.hs b/Main.hs new file mode 100644 --- /dev/null +++ b/Main.hs @@ -0,0 +1,82 @@ +-- +-- | Let's go lambdabot! +-- +module Main where + +import Shared +import Lambdabot +import Config +import Modules +import Message + +import qualified Data.Map as M + +import System.Environment + +import Data.Maybe +import Control.Monad.State (get, liftIO, modify) + +------------------------------------------------------------------------ + +-- do argument handling +main :: IO () +main = main' Nothing + +dynmain :: DynLoad -> IO () +dynmain fn = main' (Just fn) + +main' :: Maybe DynLoad -> IO () +main' dyn = do + x <- getArgs + case x of + ["--online"] -> runIrc Online loadStaticModules onlineMain load + [] -> runIrc Offline loadStaticModules offlineMain load + _ -> putStrLn "Usage: lambdabot [--online]" + + where load = fromMaybe (error "no dynamic loading") dyn + +-- +-- special online target for ghci use +online :: IO () +online = runIrc Online loadStaticModules onlineMain $ + fromMaybe (error "no dynamic loading") Nothing + +------------------------------------------------------------------------ + +onlineMain :: LB () +onlineMain = serverSignOn (protocol config) (name config) (userinfo config) >> mainloop + +offlineMain :: LB () +offlineMain = do + modify (\st -> let privUsers = ircPrivilegedUsers st + privUsers' = M.insert "null" True privUsers + in st { ircPrivilegedUsers = privUsers' }) + mainloop + +------------------------------------------------------------------------ + +-- it's all asynchronous, remember, the reader and writer threads +-- communicating over chans in the LB state. maybe its too much? +mainloop :: LB () +mainloop = do + mmsg <- ircRead + case mmsg of + Nothing -> return () + Just msg -> do + s <- get + case M.lookup (command msg) (ircCallbacks s) of + Just cbs -> allCallbacks (map snd cbs) msg + _ -> return () + mainloop + +-- If an error reaches allCallbacks, then all we can sensibly do is +-- write it on standard out. Hopefully BaseModule will have caught it already +-- if it can see a better place to send it + +allCallbacks :: Message a => [a -> LB ()] -> a -> LB () +allCallbacks [] _ = return () +allCallbacks (f:fs) msg = do + handleIrc (liftIO . putStrLn . ("Main: caught (and ignoring) "++). show) (f msg) + allCallbacks fs msg + +------------------------------------------------------------------------ diff --git a/Message.hs b/Message.hs new file mode 100644 --- /dev/null +++ b/Message.hs @@ -0,0 +1,41 @@ +-- +-- Provides interface to messages, message pipes +-- +module Message where + +import Control.Concurrent + +-- TODO: probably remove "Show a" later +class Show a => Message a where + -- | extracts the nickname involved in a given message. + nick :: a -> String + + -- | 'fullName' extracts the full user name involved in a given message. + fullName :: a -> String + + -- | 'names' builds a NAMES message from a list of channels. + names :: [String] -> a + + -- | 'channels' extracts the channels a Message operate on. + channels :: a -> [String] + + -- | 'join' creates a join message. String given is the location (channel) to join + joinChannel :: String -> a + + -- | 'part' parts the channel given. + partChannel :: String -> a + + -- | 'getTopic' Returns the topic for a channel, given as a String + getTopic :: String -> a + + -- | 'setTopic' takes a channel and a topic. It then returns the message + -- which sets the channels topic. + setTopic :: String -> String -> a + + -- TODO: recheck this. It's usage heavily relies on the fact that message comes from IRC + body :: a -> [String] + + -- TODO: too IRC-specific + command :: a -> String + +type Pipe a = Chan (Maybe a) diff --git a/Modules.hs b/Modules.hs new file mode 100644 --- /dev/null +++ b/Modules.hs @@ -0,0 +1,1 @@ +MODULES Base System Dict Dummy Karma Quote Seen State Topic Type Eval Babel Version More Pl Help Dice Search Vixen Fact Todo Spell Haddock Hoogle Where Elite Localtime Poll Djinn Pretty Compose Lambda Unlambda Log Slap DrHylo Instances Fresh Tell Url diff --git a/Modules.hs-boot b/Modules.hs-boot new file mode 100644 --- /dev/null +++ b/Modules.hs-boot @@ -0,0 +1,1 @@ +module Modules where { plugins::[[Char]] } diff --git a/Plugin.hs b/Plugin.hs new file mode 100644 --- /dev/null +++ b/Plugin.hs @@ -0,0 +1,68 @@ +-- +-- Copyright (c) 2006 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- Syntactic sugar for developing plugins. +-- Simplifies import lists, and abstracts over common patterns +-- +module Plugin ( + ios, list, ios80, + + module Lambdabot, + module LBState, + module Config, + + module Lib.Util, + module Lib.Serial, + module Lib.Process, + module Lib.MiniHTTP, + module Lib.Url, + + module Data.List, + module Data.Char, + module Data.Maybe, + module Data.Either, + module Text.Regex, + module System.IO, + + module Control.Monad.Error + + ) where + +import Lambdabot +import LBState +import Config + +import Lib.Util +import Lib.Serial +import Lib.Process +import Lib.MiniHTTP +import Lib.Url + +import Data.List +import Data.Char +import Data.Maybe +import Data.Either +import Text.Regex + +import System.IO + +import Control.Monad.Error +import Control.Monad.Trans + +-- | convenience, we often want to perform some io, get a string, and box it. +ios :: (Functor m, MonadIO m) => IO a -> m [a] +ios = list . io + +list :: (Functor m, Monad m) => m a -> m [a] +list = (return `fmap`) + +-- | convenience, similar to ios but also cut output to channel to 80 characters +-- usage: @process _ _ to _ s = ios80 to (plugs s)@ +ios80 :: (Functor m, MonadIO m) => String -> IO String -> m [String] +ios80 to what = list . io $ what >>= return . lim + where lim = case to of + ('#':_) -> abbr 80 -- message to channel: be nice + _ -> id -- private message: get everything + abbr n s = let (b, t) = splitAt n s in + if null t then b else take (n-3) b ++ "..." diff --git a/Plugin/Babel.hs b/Plugin/Babel.hs new file mode 100644 --- /dev/null +++ b/Plugin/Babel.hs @@ -0,0 +1,134 @@ +-- +-- Copyright (c) 2004 Simon Winwood - http://www.cse.unsw.edu.au/~sjw +-- Copyright (c) 2004-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | A translator module for lambdabot, a binding to babelfish +-- +module Plugin.Babel where + +import Plugin + +PLUGIN Babel + +instance Module BabelModule () where + moduleCmds _ = ["babel"] + process_ _ _ = babel + moduleHelp _ _ = unlines ["babel ." + ,"Translate a phrase in lang1 to lang2." + ,"Language is an element of" ++ showClean supportedLangs] + +-- +-- The @babel command. +-- +-- * translate a phrase +-- * translate last 'i' lines of history buffer +-- * translate a line of history indexed by a regex +-- +-- TODO add range/context. i.e. !f-3 or 5-4 +-- +babel :: String -> LB [String] +babel s = do + let cmd = split2 ' ' 3 s + msg <- babel' cmd + let msg' = map (" " ++) msg + return [unlines msg'] + +-- help msg +babel' :: (MonadIO m) => [String] -> m [String] +babel' ["help"] = return $ ["usage: babel lang lang phrase"] +babel' ["languages"] = return $ [show shortLangs] +babel' [f,t,i] = do p <- liftIO $ babelFish f t i ; return [p] +babel' _ = return ["bzzt."] + +------------------------------------------------------------------------ + +babelFishURL :: [Char] +babelFishURL = "http://babelfish.altavista.com/babelfish/tr" + +supportedLangs :: [([Char], [Char])] +supportedLangs = + [("german", "de") + ,("greek", "el") + ,("english", "en") + ,("spanish", "es") + ,("french", "fr") + ,("italian", "it") + ,("dutch", "nl") + ,("portuguese", "pt") +-- ("japanese", "ja") +-- ("korean", "ko") +-- ("russian", "ru") +-- ("chinese-simp", "zh") +-- ("chinese-trad", "zt") + ] + +shortLangs :: [[Char]] +shortLangs = ["de","el","en","es","fr","it","ja","ko","nl","pt","ru","zh","zt"] + +type URIVars = [(String, String)] + +constantVars :: URIVars +constantVars = + [("doit", "done"), + ("intl", "1"), + ("tt", "urltext")] + +justEither :: a -> Maybe b -> Either a b +justEither a Nothing = Left a +justEither _ (Just v) = Right v + +langVars :: String -> String -> URIVars -> Either String URIVars +langVars inLang outLang vars = + lookupLang inLang >>= \ins -> + lookupLang outLang >>= \outs -> + Right (("lp", ins ++ "_" ++ outs) : vars) + where + lookupLang lang | length lang == 2 && lang `elem` shortLangs = Right lang + lookupLang lang = justEither ("Language " ++ lang ++ " not supported") + (lookup (map toLower lang) supportedLangs) + +mkBody :: String -> String -> String -> Either String String +mkBody inLang outLang string + = mapconcat mkString "&" vars + where + vars = langVars inLang outLang (("urltext", string) : constantVars) + mkString (var, val) = var ++ "=" ++ (urlEncode val) + mapconcat :: (a -> String) -> String -> Either String [a] -> Either String String + mapconcat _ _ (Left s) = Left s + mapconcat f m (Right l) = Right $ concat (intersperse m (map f l)) + +getBabel :: [String] -> String +getBabel lins = cleanLine (concat (intersperse " " region)) + where + region = hd ++ [(head tl)] + (hd, tl) = span (\x -> (matchRegex reEnd x) == Nothing) + (dropWhile (\x -> (matchRegex reStart x) == Nothing) lins) + + cleanLine x = maybe "can't parse this language" head $ matchRegex reLine x + + reLine = mkRegex ".*padding:10px[^>]*>(.*).*" + reStart = mkRegex ".*padding:10px[^>]*>" + reEnd = mkRegex "" + +babelFish :: String -> String -> String -> IO String +babelFish inLang outLang string = do + body <- either (\s -> error ("Error: " ++ s)) + (\body -> return body) (mkBody inLang outLang string) + lins <- readPage (proxy config) uri (mkPost uri body) body + return (getBabel lins) + where + uri = (fromJust $ parseURI babelFishURL) + +-------------------------------------------------------------- + + {- + -- totally unrelated :} + process _ _ src "timein" s = + if s == "help" + then ircPrivmsg src " http://www.timeanddate.com" + else do (o,_,_) <- liftIO $ popen "timein" [s] Nothing + ircPrivmsg src $ " " ++ o + -} diff --git a/Plugin/Base.hs b/Plugin/Base.hs new file mode 100644 --- /dev/null +++ b/Plugin/Base.hs @@ -0,0 +1,321 @@ +-- +-- | Lambdabot base module. Controls message send and receive +-- +module Plugin.Base (theModule) where + +import Plugin + +import IRC (IrcMessage, timeReply, errShowMsg) +import Message (getTopic, nick, joinChannel, body) + +import qualified Data.Map as M (insert, delete) + +import Control.Monad.State (MonadState(..), when, gets) + +import GHC.IOBase (Exception(NoMethodError)) + +-- valid command prefixes +commands :: [String] +commands = commandPrefixes config + +PLUGIN Base + +type BaseState = GlobalPrivate () () + +instance Module BaseModule BaseState where + moduleDefState _ = return $ mkGlobalPrivate 20 () + moduleInit _ = do + ircSignalConnect "PING" doPING + ircSignalConnect "NOTICE" doNOTICE + ircSignalConnect "PART" doPART + ircSignalConnect "JOIN" doJOIN + ircSignalConnect "NICK" doNICK + ircSignalConnect "MODE" doMODE + ircSignalConnect "TOPIC" doTOPIC + ircSignalConnect "QUIT" doQUIT + ircSignalConnect "PRIVMSG" doPRIVMSG + ircSignalConnect "001" doRPL_WELCOME + + {- ircSignalConnect "002" doRPL_YOURHOST + ircSignalConnect "003" doRPL_CREATED + ircSignalConnect "004" doRPL_MYINFO -} + + ircSignalConnect "005" doRPL_BOUNCE + + {- ircSignalConnect "250" doRPL_STATSCONN + ircSignalConnect "251" doRPL_LUSERCLIENT + ircSignalConnect "252" doRPL_LUSEROP + ircSignalConnect "253" doRPL_LUSERUNKNOWN + ircSignalConnect "254" doRPL_LUSERCHANNELS + ircSignalConnect "255" doRPL_LUSERME + ircSignalConnect "265" doRPL_LOCALUSERS + ircSignalConnect "266" doRPL_GLOBALUSERS -} + + ircSignalConnect "332" doRPL_TOPIC + + {- ircSignalConnect "353" doRPL_NAMRELY + ircSignalConnect "366" doRPL_ENDOFNAMES + ircSignalConnect "372" doRPL_MOTD + ircSignalConnect "375" doRPL_MOTDSTART + ircSignalConnect "376" doRPL_ENDOFMOTD -} + +doIGNORE :: Callback +doIGNORE msg = debugStrLn $ show msg + -- = debugStrLn $ "IGNORING> <" ++ msgPrefix msg ++ +-- "> [" ++ msgCommand msg ++ "] " ++ show (body msg) + + +doPING :: Callback +doPING msg + = debugStrLn $ errShowMsg msg + +-- If this is a "TIME" then we need to pass it over to the localtime plugin +-- otherwise, dump it to stdout +doNOTICE :: ModState BaseState Callback +doNOTICE msg = + if isCTCPTimeReply + then do + -- bind implicit params to Localtime module. boo on implict params :/ + -- withModule ircModules + -- "Localtime" + -- (error "Plugin/Base: no Localtime plugin? So I can't handle CTCP time messges") + -- (\_ -> doPRIVMSG (timeReply msg)) + + -- need to say which module to run the privmsg in + + doPRIVMSG (timeReply msg) + + else debugStrLn $ "NOTICE: " ++ show (body msg) + where + isCTCPTimeReply = ":\SOHTIME" `isPrefixOf` (last (body msg)) + +doJOIN :: Callback +doJOIN msg + = do s <- get + put (s { ircChannels = M.insert (mkCN loc) "[currently unknown]" (ircChannels s)}) -- the empty topic causes problems + send_ $ getTopic loc -- initialize topic + where (_, aloc) = breakOnGlue ":" (head (body msg)) + loc = case aloc of + [] -> [] + _ -> tail aloc + +doPART :: Callback +doPART msg + = when (name config == nick msg) $ do + let loc = head (body msg) + s <- get + put (s { ircChannels = M.delete (mkCN loc) (ircChannels s) }) + +doNICK :: Callback +doNICK msg + = doIGNORE msg + +doMODE :: Callback +doMODE msg + = doIGNORE msg + + +doTOPIC :: Callback +doTOPIC msg + = do let loc = (head (body msg)) + s <- get + put (s { ircChannels = M.insert (mkCN loc) (tail $ head $ tail $ body msg) (ircChannels s)}) + +doRPL_WELCOME :: Callback +doRPL_WELCOME _msg = mapM_ (send_ . joinChannel) (autojoin config) + +doQUIT :: Callback +doQUIT msg = doIGNORE msg + +doRPL_BOUNCE :: Callback +doRPL_BOUNCE _msg = debugStrLn "BOUNCE!" + +doRPL_TOPIC :: Callback +doRPL_TOPIC msg -- nearly the same as doTOPIC but has our nick on the front of body + = do let loc = (body msg) !! 1 + s <- get + put (s { ircChannels = M.insert (mkCN loc) (tail $ last $ body msg) (ircChannels s) }) + +doPRIVMSG :: ModState BaseState Callback +doPRIVMSG msg = do + debugStrLn (show msg) + doPRIVMSG' (name config) msg + +-- +-- | What does the bot respond to? +-- +doPRIVMSG' :: String -> IRC.IrcMessage -> ModuleT BaseState LB () +doPRIVMSG' myname msg + | myname `elem` targets + = let (cmd, params) = breakOnGlue " " text + in doPersonalMsg cmd (dropWhile (== ' ') params) + + | flip any ":," $ \c -> (myname ++ [c]) `isPrefixOf` text + = let Just wholeCmd = maybeCommand myname text + (cmd, params) = breakOnGlue " " wholeCmd + in doPublicMsg cmd (dropWhile (==' ') params) + + | (commands `arePrefixesOf` text) && length text > 1 + && (text !! 1 /= ' ') -- elem of prefixes + && (not (commands `arePrefixesOf` [text !! 1])) + = let (cmd, params) = breakOnGlue " " (dropWhile (==' ') text) + in doPublicMsg cmd (dropWhile (==' ') params) + +{- + -- special syntax for @run + | evals `arePrefixesWithSpaceOf` text + = let expr = drop 2 text + in doPublicMsg "@run" (dropWhile (==' ') expr) +-} + + -- send to all modules for contextual processing + | otherwise = doContextualMsg text + + where + alltargets = head (body msg) + targets = split "," alltargets + text = tail (head (tail (body msg))) + who = nick msg + + doPersonalMsg s r + | commands `arePrefixesOf` s = doMsg (tail s) r who + | s `elem` (evalPrefixes config) = doMsg "run" r who -- TODO + | otherwise = doIGNORE msg -- contextual? + + doPublicMsg s r + | commands `arePrefixesOf` s = doMsg (tail s) r alltargets + | (evalPrefixes config) `arePrefixesWithSpaceOf` s = doMsg "run" r alltargets -- TODO + | otherwise = doIGNORE msg -- contextual? + + -- + -- normal commands. + -- + -- check privledges, do any spell correction, dispatch, handling + -- possible timeouts. + -- + -- todo, refactor + -- + doMsg cmd rest towhere = do + let ircmsg = ircPrivmsg towhere + allcmds <- getDictKeys ircCommands + let ms = filter (isPrefixOf cmd) allcmds + case ms of + [s] -> docmd s -- a unique prefix + _ | cmd `elem` ms -> docmd cmd -- correct command (usual case) + _ | otherwise -> case closests cmd allcmds of + (n,[s]) | n < e , ms == [] -> docmd s -- unique edit match + (n,ss) | n < e || ms /= [] -- some possibilities + -> ircmsg . Just $ "Maybe you meant: "++showClean(nub(ms++ss)) + _ -> docmd cmd -- no prefix, edit distance too far + where + e = 3 -- edit distance cut off. Seems reasonable for small words + + docmd cmd' = + forkLB $ withPS towhere $ \_ _ -> do + withModule ircCommands cmd' -- Important. + (ircPrivmsg towhere (Just "Unknown command, try @list")) + (\m -> do + privs <- gets ircPrivCommands + ok <- liftM2 (||) (return $ cmd' `notElem` privs) + (checkPrivs msg) + if not ok + then ircPrivmsg towhere $ Just "Not enough privileges" + else catchIrc + (do mstrs <- catchError + (process m msg towhere cmd' rest) + (\ex -> case (ex :: IRCError) of -- dispatch + (IRCRaised (NoMethodError _)) -> + process_ m cmd' rest + _ -> throwError ex) + case mstrs of + [] -> ircPrivmsg towhere Nothing + _ -> mapM_ (ircPrivmsg towhere . Just) mstrs) + + (ircPrivmsg towhere . Just .((?name++" module failed: ")++).show)) + + -- + -- contextual messages are all input that isn't an explicit command. + -- they're passed to all modules (todo, sounds inefficient) for + -- scanning, and any that implement 'contextual' will reply. + -- + -- we try to run the contextual functions from all modules, on every + -- non-command. better hope this is efficient. + -- + -- Note how we catch any plugin errors here, rather than letting + -- them bubble back up to the mainloop + -- + doContextualMsg r = do + withAllModules (\m -> + forkLB $ catchIrc + (do ms <- contextual m msg alltargets r + mapM_ (ircPrivmsg alltargets . Just) ms) + (\e -> debugStrLn + (?name++" module failed in contextual handler: "++show e)) ) + return () + +------------------------------------------------------------------------ + +maybeCommand :: String -> String -> Maybe String +maybeCommand nm text = case matchRegexAll re text of + Nothing -> Nothing + Just (_, _, cmd, _) -> Just cmd + where re = mkRegex (nm ++ "[.:,]*[[:space:]]*") + +-- +-- And stuff we don't care about +-- + +{- +doRPL_YOURHOST :: Callback +doRPL_YOURHOST _msg = return () + +doRPL_CREATED :: Callback +doRPL_CREATED _msg = return () + +doRPL_MYINFO :: Callback +doRPL_MYINFO _msg = return () + +doRPL_STATSCONN :: Callback +doRPL_STATSCONN _msg = return () + +doRPL_LUSERCLIENT :: Callback +doRPL_LUSERCLIENT _msg = return () + +doRPL_LUSEROP :: Callback +doRPL_LUSEROP _msg = return () + +doRPL_LUSERUNKNOWN :: Callback +doRPL_LUSERUNKNOWN _msg = return () + +doRPL_LUSERCHANNELS :: Callback +doRPL_LUSERCHANNELS _msg = return () + +doRPL_LUSERME :: Callback +doRPL_LUSERME _msg = return () + +doRPL_LOCALUSERS :: Callback +doRPL_LOCALUSERS _msg = return () + +doRPL_GLOBALUSERS :: Callback +doRPL_GLOBALUSERS _msg = return () + +doUNKNOWN :: Callback +doUNKNOWN msg + = debugStrLn $ "UNKNOWN> <" ++ msgPrefix msg ++ + "> [" ++ msgCommand msg ++ "] " ++ show (body msg) + +doRPL_NAMREPLY :: Callback +doRPL_NAMREPLY _msg = return () + +doRPL_ENDOFNAMES :: Callback +doRPL_ENDOFNAMES _msg = return () + +doRPL_MOTD :: Callback +doRPL_MOTD _msg = return () + +doRPL_MOTDSTART :: Callback +doRPL_MOTDSTART _msg = return () + +doRPL_ENDOFMOTD :: Callback +doRPL_ENDOFMOTD _msg = return () +-} diff --git a/Plugin/Code.hs b/Plugin/Code.hs new file mode 100644 --- /dev/null +++ b/Plugin/Code.hs @@ -0,0 +1,78 @@ +-- +-- Copyright (c) 2005-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- grab a random line of code from a directory full of .hs code +-- + +module Plugin.Code where + +import Plugin + +PLUGIN Code + +instance Module CodeModule [FilePath] where + + moduleDefState _ = io $ getSourceFiles $ + fptoolsPath config "libraries" "base" + + moduleHelp _ _ = "code. Print random line of code from $fptools" + moduleCmds _ = ["code"] + + process_ _ "code" _ = do + fs <- readMS + (file,line) <- liftIO $ do + f <- stdGetRandItem fs + h <- openFile f ReadMode + s <- hGetContents h + l <- getRandSrcOf (lines s) 1000 -- number of times to try + hClose h + return (f, (dropSpace . expandTab $ l)) + + -- dump raw output + return [basename file ++ ": " ++ line] + +-- +-- work out our list of potential source files +-- evil! +-- +-- Going to be expensive at startup, no? +-- +getSourceFiles :: FilePath -> IO [FilePath] +getSourceFiles d = do + (o,_,_) <- popen "/usr/bin/find" [d,"-name","*.hs","-o","-name","*.lhs"] Nothing + return (lines o) + +-- give up: +getRandSrcOf :: [String] -> Int -> IO String +getRandSrcOf s 0 | s == [] = return [] + | otherwise = return $ head s + +-- otherwise get a random src line +getRandSrcOf ss n = do + s <- stdGetRandItem ss + case () of {_ + | Just _ <- comment `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- ws `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- nl `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- pragma `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- imports `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- wheres `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- mods `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- nested `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- cpp `matchRegex` s -> getRandSrcOf ss (n-1) + | Just _ <- cpp' `matchRegex` s -> getRandSrcOf ss (n-1) + | length s < 30 -> getRandSrcOf ss (n-1) + | otherwise -> return s -- got it + } + where comment = mkRegex "--" + nested = mkRegex "{" + pragma = mkRegex "OPTION" + cpp = mkRegex "#if" + cpp' = mkRegex "#include" + ws = mkRegex "^ " -- line *must* start with an identifer + nl = mkRegex "\n" + imports = mkRegex "^import" + wheres = mkRegex "^ *where" + mods = mkRegex "module" + diff --git a/Plugin/Compose.hs b/Plugin/Compose.hs new file mode 100644 --- /dev/null +++ b/Plugin/Compose.hs @@ -0,0 +1,54 @@ +-- +-- Copyright (c) 2005 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- Another progressive plugin. Compose two (for now) plugins transparently +-- A sort of mini interpreter. Could do with some more thinking. +-- +module Plugin.Compose (theModule) where + +import Plugin +import Message + +import Control.Monad.State +import GHC.IOBase (Exception(NoMethodError)) + +PLUGIN Compose + +instance Module ComposeModule () where + moduleCmds _ = [".", "compose"] + moduleHelp _ _ = unlines [". [args]." + ,". [or compose] is the composition of two plugins" + ," The following semantics are used: . f g xs == g xs >>= f"] + + process _ a b _ args = case split " " args of + (f:g:xs) -> do + f' <- lookupP (a,b) f + g' <- lookupP (a,b) g + compose f' g' (concat $ intersperse " " xs) + + _ -> return ["Not enough arguments to @."] + + +-- | Compose two plugin functions +compose :: (String -> LB [String]) -> (String -> LB [String]) -> (String -> LB [String]) +compose f g xs = g xs >>= f . unlines + +------------------------------------------------------------------------ +-- | Lookup the `process' method we're after, and apply it to the dummy args +-- Fall back to process_ if there's no process. +-- +lookupP :: Message a => (a, String) -> String -> LB (String -> LB [String]) +lookupP (a,b) cmd = withModule ircCommands cmd + (error $ "Parse error: " ++ show cmd) + (\m -> do + privs <- gets ircPrivCommands -- no priv commands can be composed + when (cmd `elem` privs) $ error "Privledged commands cannot be composed" + return $ \str -> catchError + (process m a b cmd str) + (\ex -> case (ex :: IRCError) of + (IRCRaised (NoMethodError _)) -> process_ m cmd str + _ -> throwError ex)) + diff --git a/Plugin/DarcsPatchWatch.hs b/Plugin/DarcsPatchWatch.hs new file mode 100644 --- /dev/null +++ b/Plugin/DarcsPatchWatch.hs @@ -0,0 +1,283 @@ +-- +-- Copyright (c) 2005 Stefan Wehr (http://www.stefanwehr.de) +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | Watch darcs patches arriving... +-- +module Plugin.DarcsPatchWatch (theModule) where + +import Plugin + +import qualified Data.ByteString.Char8 as P +import Prelude hiding ( catch ) + +import Control.Concurrent +import Control.Exception +import Control.Monad ( when ) + +import System.Directory +import System.Time + +newtype DarcsPatchWatch = DarcsPatchWatch () + +theModule :: MODULE +theModule = MODULE $ DarcsPatchWatch () + + +-- +-- Configuration variables +-- + +maxNumberOfRepos :: Int +maxNumberOfRepos = 20 + +debugFlag :: Bool +debugFlag = False + +announceTarget :: String +announceTarget = "#z123lambdabot" + +inventoryFile :: String +inventoryFile = "_darcs/inventory" + +-- in seconds +checkInterval :: Int +checkInterval = 30 + +darcsCmd :: String +darcsCmd = "darcs" + +-- +-- The repository data type +-- + +-- Repositories is a list of Repo's +type Repos = [Repo] + +-- A repository has a location, a time where it was last (known to be) +-- announced and a number of lines for the last announcement. +data Repo = Repo { repo_location :: FilePath + , repo_lastAnnounced :: Maybe CalendarTime + , repo_nlinesAtLastAnnouncement :: Int } + deriving (Eq,Ord,Show,Read) + +-- | 'showRepo' takes a repository, repo, to a String for pretty printing. +showRepo :: Repo -> String +showRepo repo = + "{Repository " ++ show (repo_location repo) ++ ", last announcement: " ++ + (case repo_lastAnnounced repo of + Nothing -> "unknown" + Just ct -> formatTime ct) ++ "}" + +-- | 'showRepos' is the logical lifting of showRepo to to list types. +showRepos :: Repos -> String +showRepos [] = "{no repositories defined}" +showRepos l = '{' : ((concat . intersperse ", " . map showRepo) l ++ "}") + +-- +-- The state of the plugin +-- + +-- A darcs repository watcher state. +data DarcsPatchWatchState = DarcsPatchWatchState + { dpw_threadId :: Maybe ThreadId + , dpw_repos :: Repos } + +-- DPW is our monadic state transformer. +type DPW a = ModuleT DarcsPatchWatchState LB a + +-- Serialize and unserialize DarcsPatchWatch state. +stateSerial :: Serial DarcsPatchWatchState +stateSerial = Serial ser deSer + where ser (DarcsPatchWatchState _ repos) = Just . P.pack $ show repos + deSer s = + do repos <- readM (P.unpack s) + return $ (DarcsPatchWatchState + { dpw_threadId = Nothing + , dpw_repos = repos }) + +getRepos :: DPW Repos +getRepos = dpw_repos `fmap` readMS + +-- | 'withRepos' operates on the current state of the repos with a +-- given function. +withRepos :: (Repos -> (Repos -> LB ()) -> LB a) -- ^ Function to apply + -> DPW a +-- template haskell? +withRepos = accessorMS $ \s -> (dpw_repos s, \t -> s { dpw_repos = t }) + + + +-- +-- The plugin itself +-- + +instance Module DarcsPatchWatch DarcsPatchWatchState where + + moduleCmds _ = ["repos", "repo-add", "repo-del"] + + moduleHelp _ s = case s of + "repos" -> "repos. List all registered darcs repositories" + "repo-add" -> "repo-add . Add a repository" + "repo-del" -> "repo-del . Delete a repository" + _ -> "Watch darcs repositories. Provides: repos, repo-add, repo-del" + + moduleSerialize _ = Just stateSerial + moduleDefState _ = return (DarcsPatchWatchState Nothing []) + moduleInit _ = do + tid <- lbIO (\conv -> forkIO $ conv watchRepos) + modifyMS (\s -> s { dpw_threadId = Just tid }) + + moduleExit _ = + do s <- readMS + case dpw_threadId s of + Nothing -> return () + Just tid -> io (killThread tid) + + process_ _ cmd rest = case cmd of + "repos" -> printRepos rest + "repo-add" -> addRepo rest + "repo-del" -> delRepo rest + +-- +-- Configuration commands +-- +printRepos :: String -> DPW [String] +printRepos [] = getRepos >>= return . (:[]) . showRepos +printRepos _ = error "@todo given arguments, try @todo-add or @list todo" + +addRepo :: String -> DPW [String] +addRepo rest | null (dropSpace rest) = return ["argument required"] +addRepo rest = do + x <- mkRepo rest + case x of + Right r -> withRepos $ \repos setRepos -> case () of {_ + | length repos >= maxNumberOfRepos -> + return ["maximum number of repositories reached!"] + | r `elem` repos -> + return ["cannot add already existing repository " ++ showRepo r] + | otherwise -> + do setRepos (r:repos) + return ["repository " ++ showRepo r ++ " added"] + } + + Left s -> return ["cannot add invalid repository: " ++ s] + +delRepo :: String -> DPW [String] +delRepo rest | null (dropSpace rest) = return ["argument required"] +delRepo rest = do + x <- mkRepo rest + case x of + Left s -> return ["cannot delete invalid repository: " ++ s] + Right r -> withRepos $ \repos setRepos -> case findRepo r repos of + Nothing -> + return ["no repository registered with path " ++ repo_location r] + Just realRepo -> + do setRepos (delete realRepo repos) + return ["repository " ++ showRepo realRepo ++ " deleted"] + + where + cmpRepos r1 r2 = repo_location r1 == repo_location r2 + findRepo _ [] = Nothing + findRepo x (y:ys) = if cmpRepos x y then Just y else findRepo x ys + +mkRepo :: String -> LB (Either String Repo) +mkRepo pref_ = + do x <- io $ do let pth = mkInventoryPath pref_ + pref = dropSpace pref_ + perms <- getPermissions pth + return (Right (pref, perms)) + `catch` (\e -> return $ Left (show e)) + case x of + Left e -> return $ Left e + Right (pref, perms) + | readable perms -> return $ Right $ Repo pref Nothing 0 + | otherwise -> + return $ Left ("repository's inventory file not readable") + + +-- +-- The heart of the plugin: watching darcs repositories +-- + +watchRepos :: DPW () +watchRepos = + do withRepos $ \repos setRepos -> + do debug ("checking darcs repositories " ++ showRepos repos) + repos_ <- mapM checkRepo repos + setRepos repos_ + io $ threadDelay sleepTime + watchRepos + where sleepTime :: Int -- in milliseconds + sleepTime = checkInterval * 1000 * 1000 + +-- actually work out if we need to send a message +-- +checkRepo :: Repo -> LB Repo +checkRepo r = do + (output, errput) <- io $ runDarcs (repo_location r) + nlines <- + if not (null errput) + then do info ("\ndarcs failed: " ++ errput) + return (repo_nlinesAtLastAnnouncement r) + else do let olines = lines output + lastN = repo_nlinesAtLastAnnouncement r + new = take (length olines - lastN) olines + when (not (null new)) $ + send' $ mkMsg (repo_location r) (parseDarcsMsg (unlines new)) + return (length olines) + + now <- io getClockTime + ct <- io $ toCalendarTime now + return $ r { repo_nlinesAtLastAnnouncement = nlines + , repo_lastAnnounced = Just ct } + where + send' = ircPrivmsg announceTarget . Just + +mkMsg :: String -> (String,String,Integer) -> String +mkMsg r (who,msg,0) = "[" ++ basename r ++ ":" ++ who ++ "] " ++ msg +mkMsg r (who,msg,n) = (mkMsg r (who,msg,0)) ++ " (and "++show n++" more)" + +runDarcs :: FilePath -> IO (String, String) +runDarcs loc = do + (output, errput, _) <- popen darcsCmd ["changes", "--repo=" ++ loc] Nothing + when (not (null errput)) $ info errput + return (output, errput) + +-- Extract the committer, and commit msg from the darcs msg +parseDarcsMsg :: String -> (String,String,Integer) +parseDarcsMsg s = + let (_,rest) = breakOnGlue " " s -- two spaces + (who,msg') = breakOnGlue "\n" rest + (msg,n) = countRest (drop 1 msg') + who' = if '@' `elem` who then fst (breakOnGlue "@" who) else who + in (dropSpace who', drop 2 (dropSpace msg),n) + where + countRest t = let (m,r) = breakOnGlue "\n" t in (m, countRest' r) + + countRest' [] = 0 + countRest' (' ':'*':' ':cs) = 1 + countRest' cs + countRest' (_:cs) = countRest' cs + +-- +-- Helpers +-- + +mkInventoryPath :: String -> FilePath +mkInventoryPath prefix = + let pref = dropSpace prefix + in joinPath pref inventoryFile + +debug :: MonadIO m => String -> m () +debug s = if debugFlag + then io (putStrLn ("[DarcsPatchWatch] " ++ s)) + else return () + +info :: MonadIO m => String -> m () +info s = io $ putStrLn ("[DarcsPatchWatch] " ++ s) + +formatTime :: CalendarTime -> String +formatTime = calendarTimeToString + diff --git a/Plugin/Dice.hs b/Plugin/Dice.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dice.hs @@ -0,0 +1,46 @@ +-- +-- | This module is for throwing dice for e.g. RPGs. (\@dice 3d6+2) +-- +-- Copyright Einar Karttunen 2005-04-06. +-- +module Plugin.Dice (theModule) where + +import Plugin + +import Control.Monad (replicateM,foldM) +import System.Random (randomRIO) +import Text.ParserCombinators.Parsec + +PLUGIN Dice + +instance Module DiceModule () where + moduleCmds _ = ["dice"] + moduleHelp _ _ = "dice . Throw random dice. is of the form 3d6+2." + process_ _ _ xs = ios (dice xs) + +dice :: String -> IO String +dice str = case parse expr "dice" (filter (not.isSpace) str) of + Left err -> return $ show err + Right e -> do res <- eval e + return (str++" => "++show res) + +eval :: [(Int, Int)] -> IO Int +eval = foldM ef 0 + where ef acc (v,1) = return (acc+v) + ef acc (n,d) = if n > 100 + then return 0 + else do ls <- replicateM n (randomRIO (1,d)) + return (acc + sum ls) + + +expr :: CharParser st [(Int, Int)] +expr = primExp `sepBy1` (char '+') + +primExp :: CharParser st (Int, Int) +primExp = do v <- number + d <- option 1 (char 'd' >> number) + return (v,d) + +number :: CharParser st Int +number = read `fmap` many1 digit + diff --git a/Plugin/Dict.hs b/Plugin/Dict.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dict.hs @@ -0,0 +1,117 @@ +-- +-- | DICT (RFC 2229) Lookup Module for lambdabot IRC robot. +-- Tom Moertel +-- +module Plugin.Dict (theModule) where + +import Plugin +import qualified Plugin.Dict.DictLookup as Dict + +PLUGIN Dict + +-- | This is the module handler. Here we process commands from users. + +instance Module DictModule () where + moduleHelp _ _ = getHelp [] + moduleCmds _ = "dict" : "dict-help" : dictNames + + process_ _ "dict" _ = return [quickHelp] + process_ _ "dict-help" rest = return [getHelp (words rest)] + process_ _ cmd rest = do + results <- mapM doLookup (parseTerms rest) + return [concat results] + where + doLookup w = io $ do + result <- lookupFn w + return $ either ("Error: " ++) id result + lookupFn = uncurry Dict.simpleDictLookup . fst $ + fromJust (lookup cmd dictTable) + +-- | Configuration. + +dictTable :: [(String, ((Dict.QueryConfig, String), String))] +dictTable = + -- @command ((server , database), description) + [ ("all-dicts",((dict_org, "*") , "Query all databases on dict.org")) + , ("elements", ((dict_org, "elements"), "Elements database")) + , ("web1913" , ((dict_org, "web1913"), + "Webster's Revised Unabridged Dictionary (1913)")) + , ("wn" , ((dict_org, "wn"), "WordNet (r) 1.7")) + , ("gazetteer",((dict_org, "gazetteer"),"U.S. Gazetteer (1990)")) + , ("jargon" , ((dict_org, "jargon"), "Jargon File")) + , ("foldoc" , ((dict_org, "foldoc"), + "The Free On-line Dictionary of Computing")) + , ("easton" , ((dict_org, "easton"), "Easton's 1897 Bible Dictionary")) + , ("hitchcock",((dict_org, "hitchcock"), + "Hitchcock's Bible Names Dictionary (late 1800's)")) + , ("devils" , ((dict_org, "devils"), "The Devil's Dictionary")) + , ("world02" , ((dict_org, "world02"), "CIA World Factbook 2002")) + , ("vera" , ((dict_org, "vera"), + "V.E.R.A.: Virtual Entity of Relevant Acronyms")) +-- , ("prelude" , ((moertel_com, "prelude"), "Haskell Standard Prelude")) + , ("lojban" , ((lojban_org, "lojban"), "Search lojban.org")) + ] + where + dict_org = Dict.QC "dict.org" 2628 +-- moertel_com = Dict.QC "dict.moertel.com" 2628 + lojban_org = Dict.QC "lojban.org" 2628 + +dictNames :: [String] +dictNames = sort (map fst dictTable) + + +-- | Print out help. + +quickHelp :: String +quickHelp = unlines [ "Supported dictionary-lookup commands:" + , " " ++ concatWith " " (map ('@':) dictNames) + , "Use \"@dict-help [cmd...]\" for more." + ] + +getHelp :: [String] -> String +getHelp [] = "I perform dictionary lookups via the following " + ++ show (length dictNames) ++ " commands:\n" + ++ (getHelp dictNames) + +getHelp dicts = unlines . map gH $ dicts + where + gH dict = case lookup dict' dictTable of + Just (_, descr) -> pad ('@':dict') ++ " " ++ descr + Nothing -> "There is no dictionary database '" + ++ dict' ++ "'." + where dict' = filter (/='@') dict + pad xs = take padWidth (xs ++ " " ++ repeat '.') + padWidth = maximum (map length dictNames) + 4 + + +-- | Break a string into dictionary-query terms, handling quoting and +-- escaping along the way. (This is ugly, and I don't particularly +-- like it.) Given a string like the following, we want to do the +-- right thing, which is to break it into five query strings: +-- +-- firefly "c'est la vie" 'pound cake' 'rock n\' roll' et\ al +-- +-- (1) firefly +-- (2) "c'est la vie" +-- (3) 'pound cake' +-- (4) 'rock n\' roll' +-- (5) et\ al + +parseTerms :: String -> [String] +parseTerms = pW . words + where + pW [] = [] + pW (w@(f:_):ws) + | f `elem` "'\"" = concatWith " " qws : pW ws' + | last w == '\\' = let (w':rest) = pW ws in concatWith " " [w, w'] : rest + | otherwise = w : pW ws + where + (qws, ws') = case break isCloseQuotedWord (w:ws) of + (qws', []) -> (init qws' ++ [last qws' ++ [f]], []) + (qw, w':rest) -> (qw ++ [w'], rest) + isCloseQuotedWord xs = case reverse xs of + x:y:_ -> f == x && y /= '\\' -- quote doesn't count if escaped + x:_ -> f == x + _ -> False + pW _ = error "DictModule: parseTerms: can't parse" + diff --git a/Plugin/Dict/DictLookup.hs b/Plugin/Dict/DictLookup.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dict/DictLookup.hs @@ -0,0 +1,99 @@ +-- +-- | DICT (RFC 2229) Lookup +-- Tom Moertel +-- +--Here's how you might write a program to query the Jargon database for +--the definition of "hacker" and then print the result: +-- +-- > main = doJargonLookup "hacker" >>= putStr +-- > +-- > doJargonLookup :: String -> IO String +-- > doJargonLookup query = do +-- > result <- simpleDictLookup (QC "dict.org" 2628) "jargon" query +-- > return $ case result of +-- > Left errorResult -> "ERROR: " ++ errorResult +-- > Right dictResult -> dictResult +-- > +-- +module Plugin.Dict.DictLookup ( simpleDictLookup, QueryConfig(..), LookupResult) where + +import Data.List +import System.IO +import Control.Exception (handle) +import Network + +data QueryConfig = QC { host :: String, port :: Int } +type DictConnection = Handle +data DictCommand = Quit | Define DictName String +type DictName = String -- dict-db name | "!" 1st match | "*" all matches +type LookupResult = Either String String -- Left | Right + +simpleDictLookup :: QueryConfig -> DictName -> String -> IO LookupResult +simpleDictLookup config dictnm query = + handle (\e -> (return $ Left (show e))) $ do + conn <- openDictConnection config + result <- queryDict conn dictnm query + closeDictConnection conn + return result + +openDictConnection :: QueryConfig -> IO DictConnection +openDictConnection config = do + hDictServer <- connectTo (host config) (mkPortNumber $ port config) + hSetBuffering hDictServer LineBuffering + readResponseLine hDictServer -- ignore response + return hDictServer + where + mkPortNumber = PortNumber . fromIntegral + +closeDictConnection :: DictConnection -> IO () +closeDictConnection conn = do + sendCommand conn Quit + readResponseLine conn -- ignore response + hClose conn + +{- +queryAllDicts :: DictConnection -> String -> IO LookupResult +queryAllDicts = flip queryDict "*" +-} + +queryDict :: DictConnection -> DictName -> String -> IO LookupResult +queryDict conn dictnm query = do + sendCommand conn (Define dictnm query) + response <- readResponseLine conn + case response of + '1':'5':_ -> readDefinition >>= return . formatDefinition + '5':'5':'2':_ -> return $ Right ("No match for \"" ++ query ++ "\".\n") + '5':_ -> return $ Left response -- error response + _ -> return $ Left ("Bogus response: " ++ response) + + where + + readDefinition = do + line <- readResponseLine conn + case line of + '2':'5':'0':_ -> return [] + _ -> readDefinition >>= return . (line:) + + formatDefinition = Right . unlines . concatMap formater + + formater ('1':'5':'1':rest) = ["", "***" ++ rest] + formater "." = [] + formater line = [line] + + +readResponseLine :: DictConnection -> IO String +readResponseLine conn = do + line <- hGetLine conn + return (filter (/='\r') line) + +sendCommand :: DictConnection -> DictCommand -> IO () +sendCommand conn cmd = + hSendLine conn $ case cmd of + Quit -> "QUIT" + Define db target -> join " " ["DEFINE", db, target] + +join :: [a] -> [[a]] -> [a] +join = (concat.) . intersperse + +hSendLine :: Handle -> String -> IO () +hSendLine h line = hPutStr h (line ++ "\r\n") diff --git a/Plugin/Djinn.hs b/Plugin/Djinn.hs new file mode 100644 --- /dev/null +++ b/Plugin/Djinn.hs @@ -0,0 +1,142 @@ +-- +-- Copyright (c) 2005 Donald Bruce Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- Written: Mon Dec 12 10:16:56 EST 2005 +-- + +-- +-- | A binding to Djinn. +-- +module Plugin.Djinn (theModule) where + +import Plugin +import System.Directory + +PLUGIN Djinn + +-- | We can accumulate an interesting environment +type DjinnEnv = ([Decl] {- prelude -}, [Decl]) +type Decl = String + +instance Module DjinnModule DjinnEnv where + + moduleHelp _ s = case s of + "djinn" -> "djinn .\nGenerates Haskell code from a type.\n" ++ + "http://darcs.augustsson.net/Darcs/Djinn" + "djinn-add" -> "djinn-add .\nDefine a new function type or type synonym" + "djinn-del" -> "djinn-del .\nRemove a symbol from the environment" + "djinn-clr" -> "djinn-clr.\nReset the djinn environment" + "djinn-env" -> "djinn-env.\nShow the current djinn environment" + "djinn-ver" -> "djinn-ver.\nShow current djinn version" + + moduleCmds _ = ["djinn" + ,"djinn-add" + ,"djinn-del" + ,"djinn-env" + ,"djinn-clr" + ,"djinn-ver"] + + moduleSerialize _ = Nothing -- Just listSerial + + -- this means djinn better be visible at boot time + moduleDefState _ = do + -- check that's djinn's there, otherwise don't bother + d <- io $ doesFileExist binary + if not d + then do io $ debugStrLn "Plugin.Djinn: couldn't find djinn binary" + return ([],[]) + else do st <- io $ getDjinnEnv ([],[]) -- get the prelude + return (either (const []) snd{-!-} st, []) + + -- rule out attempts to do IO, if these get into the env, + -- they'll be executed by djinn + process_ _ _ s | Just _ <- cmd `matchRegex` s = end + where end = return ["Invalid command"] + cmd = mkRegex "^ *:" + + -- Normal commands + process_ _ "djinn" s = do + (_,env) <- readMS + e <- io $ djinn env $ ":set +sorted" <$> "f ?" <+> dropForall s + return $ either id (tail . lines) e + where + dropForall t + | Just (_, _, x, _) <- matchRegexAll re t = x + | otherwise = t + re = mkRegex "^forall [[:alnum:][:space:]]+\\." + + -- Augment environment. Have it checked by djinn. + process_ _ "djinn-add" s = do + (p,st) <- readMS + est <- io $ getDjinnEnv $ (p, dropSpace s : st) + case est of + Left e -> return [head e] + Right st'' -> modifyMS (const st'') >> return [] + + -- Display the environment + process_ _ "djinn-env" _ = do + (prelude,st) <- readMS + return $ prelude ++ st + + -- Reset the env + process_ _ "djinn-clr" _ = modifyMS (flip (,) [] . fst) >> return [] + + -- Remove sym from environment. We let djinn do the hard work of + -- looking up the symbols. + process_ _ "djinn-del" s = do + (_,env) <- readMS + eenv <- io $ djinn env $ ":delete" <+> dropSpace s <$> ":environment" + case eenv of + Left e -> return [head e] + Right env' -> do + modifyMS $ \(prel,_) -> + (prel,filter (\p -> p `notElem` prel) . nub . lines $ env') + return [] + + -- Version number + process_ _ "djinn-ver" _ = do + (out,_,_) <- io $ popen binary [] (Just ":q") + let v = dropNL . clean_ . drop 18 . head . lines $ out + return [v] + +------------------------------------------------------------------------ + +-- | Should be built inplace by the build system +binary :: String +binary = "./djinn" + +-- | Extract the default environment +getDjinnEnv :: DjinnEnv -> IO (Either [String] DjinnEnv) +getDjinnEnv (prel,env') = do + env <- djinn env' ":environment" + case env of + Left e -> return $ Left e + Right o -> do let new = filter (\p -> p `notElem` prel) . nub . lines $ o + return $ Right (prel, new) + +-- | Call the binary: + +djinn :: [Decl] -> String -> IO (Either [String] String) +djinn env' src = do + let env = concat . intersperse "\n" $ env' + (out,_,_) <- popen binary [] (Just (env <$> src <$> ":q")) + let o = dropNL . clean_ . unlines . init . drop 2 . lines $ out + return $ case () of {_ + | Just _ <- failed `matchRegexAll` o -> Left (lines o) + | Just _ <- unify `matchRegexAll` o -> Left (lines o) + | otherwise -> Right o + } + where + failed = mkRegex "Cannot parse command" + unify = mkRegex "cannot be realized" + +-- +-- Clean up djinn output +-- +clean_ :: String -> String +clean_ s | Just (a,_,b,_) <- prompt `matchRegexAll` s = a ++ clean_ b + | otherwise = s + where + prompt = mkRegex "Djinn>[^\n]*\n" + diff --git a/Plugin/DrHylo.hs b/Plugin/DrHylo.hs new file mode 100644 --- /dev/null +++ b/Plugin/DrHylo.hs @@ -0,0 +1,379 @@ +{-# OPTIONS -fno-warn-name-shadowing #-} +-- +-- A wrapper over DrHylo, from the UMinho Haskell Software +-- DrHylo derives hylomorphisms from restricted Haskell syntax +-- +-- The original DrHylo written by alcino@di.uminho.pt. +-- +-- See also +-- http://wiki.di.uminho.pt/twiki/bin/view/Alcino/PointlessHaskell +-- + +module Plugin.DrHylo where + +import Language.Haskell.Syntax +import Language.Haskell.Parser +import Language.Haskell.Pretty +import Control.Monad.State + +import Plugin hiding (Module, Config(..)) +import qualified Plugin as P (Module) + +PLUGIN DrHylo + +instance P.Module DrHyloModule () where + + process_ _ _ xs = io (hylo xs) + + moduleCmds _ = ["hylo"] + moduleHelp _ _ = unlines + ["hylo . Derive hylomorphism for . Based on DrHylo." + ,"Uses the Pointless.Combinators from:" + ," http://wiki.di.uminho.pt/twiki/bin/view/Alcino/PointlessHaskell" + ,"Mirrored:" + ," http://www.cse.unsw.edu.au/~dons/Pointless/"] + +hylo :: String -> IO [String] +hylo = ((drop 4 . lines . prettyPrint . dhModule) `fmap`) . parse + +------------------------------------------------------------------------ + +-- I'm not collecting the global ids yet + +mkHsImportDecl :: String -> HsImportDecl +mkHsImportDecl n = HsImportDecl mkLoc (Module n) False Nothing Nothing + +dhModule :: HsModule -> HsModule +dhModule (HsModule loc name exports imports decls) = + let decls' = map aux decls + imports' = imports++[ mkHsImportDecl "Pointless.Combinators" + , mkHsImportDecl "Pointless.Functors" + , mkHsImportDecl "Pointless.RecursionPatterns"] + in HsModule loc name exports imports' decls' + where aux d = case (evalStateT (dhDecl d) initialSt) + of Just d' -> d' + Nothing -> d + +dhDecl :: HsDecl -> ST HsDecl +dhDecl (HsFunBind matches) = + do setNMatches (sum (map aux matches)) + sequence (map dMatch matches) + functor <- gets functor + cata <- gets cata + ana <- gets ana + name <- gets name + return (mkHylo (fromJust name) + (HsTyApp (HsTyVar (mkName "Mu")) + (foldr1 mkSum functor)) ana cata) + where aux (HsMatch _ _ _ (HsUnGuardedRhs _) _) = 1 + aux (HsMatch _ _ _ (HsGuardedRhss l) _) = length l +dhDecl _ = fail "Hylo derivation is only applied to functions" + +mkHylo :: HsName -> HsType -> [HsMatch] -> [HsMatch] -> HsDecl +mkHylo name functor cata ana = + let rhs = HsUnGuardedRhs (HsApp (HsApp (HsApp (mkVar "hylo") (HsParen (HsExpTypeSig mkLoc (mkVar "_L") (HsQualType [] functor)))) (mkVar "g")) (mkVar "h")) + in HsFunBind [(HsMatch mkLoc name [] rhs [HsFunBind ana, HsFunBind cata])] + +dMatch :: HsMatch -> ST () +dMatch (HsMatch _loc id pats (HsUnGuardedRhs rhs) wheres) = + do unless (length pats == 1 && null wheres) (fail "We only accept functions with one parameter and without wheres") + setName id + catarhs <- dExp rhs + recs <- gets recs + fvars <- gets fvars + match <- gets match + nmatches <- gets nmatches + tyvar <- getFreshVar + let functorrecs = map (\_ -> mkId) recs + catarecs = map (\(HsVar (UnQual v)) -> HsPVar v) (map fst recs) + functorfvars = if (null fvars) then (if (null recs) then [mkConst (mkName "()")] else []) else [mkConst tyvar] + anafvars = if (null fvars && not (null recs)) then [] else [HsTuple fvars] + catafvars = if (null fvars && not (null recs)) then [] else [HsPTuple (map (\(HsVar (UnQual v)) -> HsPVar v) fvars)] + addFunctor (foldr1 mkProd (functorfvars ++ functorrecs)) + addCata (HsMatch mkLoc (mkName "g") [mkPCons nmatches match (foldr1 mkPTuple (catafvars ++ catarecs))] (HsUnGuardedRhs catarhs) []) + addAna (HsMatch mkLoc (mkName "h") pats (HsUnGuardedRhs (mkCons nmatches match (foldr1 mkTuple (anafvars ++ (map snd recs))))) []) + nextMatch + return () +dMatch (HsMatch _loc id pats (HsGuardedRhss rhs) wheres) = + do unless (length pats == 1 && null wheres) (fail "We only accept functions with one parameter and without wheres") + setName id + mapM (dGuardedRhs pats) rhs + return () + +dGuardedRhs :: [HsPat] -> HsGuardedRhs -> ST () +dGuardedRhs pats (HsGuardedRhs loc guard exp) = + do catarhs <- dExp exp + recs <- gets recs + fvars <- gets fvars + match <- gets match + nmatches <- gets nmatches + tyvar <- getFreshVar + let functorrecs = map (\_ -> mkId) recs + catarecs = map (\(HsVar (UnQual v)) -> HsPVar v) (map fst recs) + functorfvars = if (null fvars) then (if (null recs) then [mkConst (mkName "()")] else []) else [mkConst tyvar] + anafvars = if (null fvars && not (null recs)) then [] else [HsTuple fvars] + catafvars = if (null fvars && not (null recs)) then [] else [HsPTuple (map (\(HsVar (UnQual v)) -> HsPVar v) fvars)] + addFunctor (foldr1 mkProd (functorfvars ++ functorrecs)) + addCata (HsMatch mkLoc (mkName "g") [mkPCons nmatches match (foldr1 mkPTuple (catafvars ++ catarecs))] (HsUnGuardedRhs catarhs) []) + addAna (HsMatch mkLoc (mkName "h") pats (HsGuardedRhss [HsGuardedRhs loc guard (mkCons nmatches match (foldr1 mkTuple (anafvars ++ (map snd recs))))]) []) + nextMatch + return () + + + +-- Not exactly like in the paper: for the moment, I only consider the function to have 1 parameter +dExp :: HsExp -> ST HsExp +dExp (HsLit x) = return (HsLit x) +dExp (HsApp (HsVar (UnQual f)) e) = + do f' <- gets name + if (f == (fromJust f')) + then (do {u <- getFreshVar; + e' <- rLets e; + addRec ((HsVar (UnQual u)),e'); + return (HsVar (UnQual u))}) + else (do {e' <- dExp e; + return (HsApp (HsVar (UnQual f)) e')}) +dExp (HsApp (HsCon (UnQual c)) e) = + do e' <- dExp e + return (HsApp (HsCon (UnQual c)) e') +dExp (HsApp a b) = + do a' <- dExp a + b' <- dExp b + return (HsApp a' b') +dExp (HsList l) = + do l' <- mapM dExp l + return (HsList l') +dExp (HsTuple l) = + do l' <- mapM dExp l + return (HsTuple l') +dExp (HsInfixApp l o r) = + do l' <- dExp l + r' <- dExp r + return (HsInfixApp l' o r') +-- there is an error in the paper concerning lets +dExp (HsLet [HsPatBind loc (HsPVar v) (HsUnGuardedRhs d) []] e) = + do addLet (v,d) + e' <- dExp e + removeLet (v,d) + d' <- dExp d + return (HsLet [HsPatBind loc (HsPVar v) (HsUnGuardedRhs d') []] e') +dExp (HsVar (UnQual v)) = + do lets <- gets lets + unless (v `elem` (map fst lets)) (addFVar (HsVar (UnQual v))) + return (HsVar (UnQual v)) +dExp (HsCon c) = return (HsCon c) +dExp (HsParen e) = + do e' <- dExp e + return (HsParen e') +dExp _ = fail "Can not handle all HsExps" + + +-- Replace lets + +rLets :: HsExp -> ST HsExp +rLets (HsLit x) = return (HsLit x) +rLets (HsApp a b) = + do a' <- rLets a + b' <- rLets b + return (HsApp a' b') +rLets (HsList l) = + do l' <- mapM rLets l + return (HsList l') +rLets (HsTuple l) = + do l' <- mapM rLets l + return (HsTuple l') +rLets (HsInfixApp l o r) = + do l' <- rLets l + r' <- rLets r + return (HsInfixApp l' o r') +rLets (HsLeftSection l o) = + do l' <- rLets l + return (HsLeftSection l' o) +rLets (HsRightSection o l) = + do l' <- rLets l + return (HsRightSection o l') +rLets (HsVar (UnQual v)) = + do lets <- gets lets + case (lookup v lets) + of Nothing -> do {return (HsVar (UnQual v))} + Just e -> do {return (HsParen (HsLet [HsPatBind mkLoc (HsPVar v) (HsUnGuardedRhs e) []] (HsVar (UnQual v))))} +rLets (HsCon c) = return (HsCon c) +rLets (HsParen e) = + do e' <- rLets e + return (HsParen e') +rLets _ = fail "Can not handle all HsExps" + +-- Auxiliary definitions + +mkSum :: HsType -> HsType -> HsType +mkSum l r = HsTyApp (HsTyApp l (HsTyVar (mkName ":+:"))) r + +mkProd :: HsType -> HsType -> HsType +mkProd l r = HsTyApp (HsTyApp l (HsTyVar (mkName ":*:"))) r + +mkId :: HsType +mkId = HsTyVar (mkName "Id") + +mkConst :: HsName -> HsType +mkConst n = HsTyApp (HsTyVar (mkName "Const")) (HsTyVar n) + +mkLoc :: SrcLoc +mkLoc = SrcLoc "" 0 0 + +mkVar :: String -> HsExp +mkVar s = HsVar (UnQual (mkName s)) + +mkName :: String -> HsName +mkName s = (HsIdent s) + +mkTuple :: HsExp -> HsExp -> HsExp +mkTuple l r = HsTuple [l,r] + +mkPTuple :: HsPat -> HsPat -> HsPat +mkPTuple l r = HsPTuple [l,r] + +mkCons :: Int -> Int -> HsExp -> HsExp +mkCons 1 0 e = e +mkCons m n e = + let aux = (replicate n (HsCon (UnQual (mkName "Right")))) ++ (if (n==(m-1)) then [] else [HsCon (UnQual (mkName "Left"))]) + in foldr1 (\l r -> HsApp l (HsParen r)) (aux++[e]) + +mkPCons :: Int -> Int -> HsPat -> HsPat +mkPCons 1 0 e = e +mkPCons m n e = + let aux = (replicate n (HsPVar (mkName "Right"))) ++ (if (n==(m-1)) then [] else [HsPVar (mkName "Left")]) + in HsPParen (foldr1 (\(HsPVar l) r -> HsPApp (UnQual l) [(HsPParen r)]) (aux++[e])) + +-- The State of our Monad + +type ST = StateT St Maybe + +data St = St {lets :: [(HsName,HsExp)], + name :: Maybe HsName, + seed :: Int, + fvars :: [HsExp], + recs :: [(HsExp,HsExp)], + ana :: [HsMatch], + cata :: [HsMatch], + functor :: [HsType], + match :: Int, + nmatches :: Int + } + +initialSt :: St +initialSt = St {lets = [], + name = Nothing, + seed = 0, + fvars = [], + recs = [], + cata = [], + ana = [], + functor = [], + match = 0, + nmatches = 0 + } + +setName :: HsName -> ST () +setName n = modify (\s -> s {name = Just n}) + +nextMatch :: ST () +nextMatch = modify (\s -> s {fvars = [], recs = [], match = match s + 1}) + +setNMatches :: Int -> ST () +setNMatches n = modify (\s -> s {nmatches = n}) + +getSeed :: ST Int +getSeed = do n <- gets seed + modify (\s -> s {seed = n+1}) + return n + +getFreshVar :: ST HsName +getFreshVar = do s <- getSeed + return (HsIdent ("v"++(show s))) + +addLet :: (HsName,HsExp) -> ST () +addLet v = modify (\s -> s {lets = v:(lets s)}) + +removeLet :: (HsName,HsExp) -> ST () +removeLet v = modify (\s -> s {lets = delete v (lets s)}) + +addFVar :: HsExp -> ST () +addFVar v = modify (\s -> s {fvars = fvars s ++ [v]}) + +addRec :: (HsExp,HsExp) -> ST () +addRec r = modify (\s -> s {recs = recs s ++ [r]}) + +addCata :: HsMatch -> ST () +addCata v = modify (\s -> s {cata = cata s ++ [v]}) + +addAna :: HsMatch -> ST () +addAna v = modify (\s -> s {ana = ana s ++ [v]}) + +addFunctor :: HsType -> ST () +addFunctor v = modify (\s -> s {functor = functor s ++ [v]}) + +------------------------------------------------------------------------ + +parse :: String -> IO HsModule +parse s = case (parseModule s) + of ParseOk m -> return m + ParseFailed l d -> fail ((show l)++": "++d) + +{- + +plus :: (Int, Int) -> Int +plus = uncurry (+) + +fib :: Int -> Int +fib 0 = 1 +fib 1 = 1 +fib x = fib (x-1) + fib (x-2) + +isort :: Ord a => [a] -> [a] +isort [] = [] +isort (x:xs) = insert (x,(isort xs)) + +insert :: Ord a => (a,[a]) -> [a] +insert (x,[]) = [x] +insert (x,y:ys) | x<=y = x:y:ys + | otherwise = y:(insert (x,ys)) + +fact 0 = 1 +fact n = n * fact (n-1) + +len [] = 0 +len (x:xs) = 1+(len xs) + +qsort :: (Ord a) => [a] -> [a] +qsort [] = [] +qsort (x:xs) = qsort (filter (<=x) xs) ++ [x] ++ qsort (filter (>x) xs) + +msort :: (Ord a) => [a] -> [a] +msort [] = [] +msort [x] = [x] +msort l = let aux = msplit l + in merge (msort (fst aux), msort (snd aux)) + +msplit :: [a] -> ([a],[a]) +msplit [] = ([],[]) +msplit (x:xs) = let aux = msplit xs + in (x:snd aux, fst aux) + +merge :: (Ord a) => ([a],[a]) -> [a] +merge ([],l) = l +merge (l,[]) = l +merge (x:xs,y:ys) | x<=y = x:merge (xs,y:ys) + | otherwise = y:merge (x:xs,ys) + +hsort :: (Ord a) => [a] -> [a] +hsort [] = [] +hsort l = let aux = hsplit l + in (fst aux):(merge (hsort (fst (snd aux)), hsort (snd (snd aux)))) + +hsplit :: (Ord a) => [a] -> (a,([a],[a])) +hsplit [x] = (x,([],[])) +hsplit (h:t) | h < m = (h,(m:l,r)) + | otherwise = (m,(h:r,l)) + where (m,(l,r)) = hsplit t + +-} diff --git a/Plugin/Dummy.hs b/Plugin/Dummy.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dummy.hs @@ -0,0 +1,91 @@ +-- +-- | Simple template module +-- Contains many constant bot commands. +-- +module Plugin.Dummy (theModule) where + +import Plugin + +import Plugin.Dummy.DocAssocs (docAssocs) +import Plugin.Dummy.Moo (cows) + +import qualified Data.Map as M +import qualified Data.ByteString.Char8 as P + +PLUGIN Dummy + +instance Module DummyModule [String] where + moduleDefState = const . return . cycle $ cows + + moduleCmds _ = "eval" : {-"moo" : -} map fst dummylst + + moduleHelp _ s = case s of + "dummy" -> "dummy. Print a string constant" + "eval" -> "eval. Do nothing (perversely)" + + "id" -> "id . The identiy plugin" + "wiki" -> "wiki . URLs of Haskell wiki pages" + "oldwiki" -> "oldwiki . URLs of the old hawiki pages" + "paste" -> "paste. Paste page url" + + "docs" -> "docs . Lookup the url for this library's documentation" + "libsrc" -> "libsrc . Lookup the url of fptools libraries" + "fptools" -> "fptools . Lookup url of ghc base library modules" + + "learn" -> "learn. The learning page url." + "eurohaskell" -> "eurohaskell. Historical." + "moo" -> "moo. Vegans rock!" + "map" -> "map. #haskell user map" + "botsnack" -> "botsnakc. Feeds the bot a snack." + "get-shapr" -> "get-shapr. Summon shapr instantly" + "shootout" -> "shootout. The debian language shootout" + "faq" -> "faq. Answer frequently asked questions about Haskell" + + +{- + process _ _ src "moo" _ = do + cow' <- withMS $ \(cow:farm) writer -> do + writer farm + return cow + mapM_ (ircPrivmsg' src) (lines cow') +-} + process_ _ "eval" _ = return [] + process_ _ cmd rest = case lookup cmd dummylst of + Nothing -> error "Dummy: invalid command" + Just f -> return $ lines $ f rest + + +dummylst :: [(String, String -> String)] +dummylst = + [("id", id) + + ,("dummy", const "dummy") + ,("get-shapr", const "shapr!!") + ,("faq", const "The answer is: Yes! Haskell can do that.") + ,("paste", const "http://paste.lisp.org/new/haskell") + ,("learn", const "http://www.haskell.org/learning.html") + ,("map", const "http://www.haskell.org/hawiki/HaskellUserLocations") + ,("shootout", const "http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all") + ,("botsnack", const ":)") + + ,("wiki", ("http://www.haskell.org/haskellwiki/" ++)) + ,("oldwiki", ("http://www.haskell.org/hawiki/" ++)) + + ,("docs", \x -> case x of + [] -> "http://haskell.org/ghc/docs/latest/html/libraries/index.html" + _ -> case M.lookup (P.pack x) docAssocs of + Nothing -> x ++ " not available" + Just m -> "http://haskell.org/ghc/docs/latest/html/libraries/" <> + (P.unpack m) map (choice (=='.') (const '-') id) x <.> "html") + + -- broken: + ,("libsrc", \x -> case M.lookup (P.pack x) docAssocs of + Nothing -> x ++ " not available" + Just m -> "http://darcs.complete.org/fptools/libraries/" <> + (P.unpack m) map (choice (=='.') (const '/') id) x <.> "hs") + + ,("fptools", \x -> case M.lookup (P.pack x) docAssocs of + Nothing -> x ++ " not available" + Just m -> "http://darcs.haskell.org/packages/" <> + (P.unpack m) map (choice (=='.') (const '/') id) x <.> "hs") + ] diff --git a/Plugin/Dummy/DocAssocs.hs b/Plugin/Dummy/DocAssocs.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dummy/DocAssocs.hs @@ -0,0 +1,384 @@ + +module Plugin.Dummy.DocAssocs (docAssocs) where + +import qualified Data.Map as M +import qualified Data.ByteString.Base as P +import qualified Data.ByteString as P () -- instances + +-- pack all these strings + +base :: P.ByteString +base = P.unsafePackAddress 4 "base"# +stm :: P.ByteString +stm = P.unsafePackAddress 3 "stm"# +mtl :: P.ByteString +mtl = P.unsafePackAddress 3 "mtl"# +fgl :: P.ByteString +fgl = P.unsafePackAddress 3 "fgl"# +qc :: P.ByteString +qc = P.unsafePackAddress 10 "QuickCheck"# +hunit :: P.ByteString +hunit = P.unsafePackAddress 5 "HUnit"# +parsec :: P.ByteString +parsec = P.unsafePackAddress 6 "parsec"# +unix :: P.ByteString +unix = P.unsafePackAddress 4 "unix"# +readline :: P.ByteString +readline = P.unsafePackAddress 8 "readline"# +network :: P.ByteString +network = P.unsafePackAddress 7 "network"# +th :: P.ByteString +th = P.unsafePackAddress 16 "template-haskell"# +hs :: P.ByteString +hs = P.unsafePackAddress 11 "haskell-src"# +cabal :: P.ByteString +cabal = P.unsafePackAddress 5 "Cabal"# +hgl :: P.ByteString +hgl = P.unsafePackAddress 3 "HGL"# +glut :: P.ByteString +glut = P.unsafePackAddress 4 "GLUT"# +x11 :: P.ByteString +x11 = P.unsafePackAddress 3 "X11"# +opengl :: P.ByteString +opengl = P.unsafePackAddress 6 "OpenGL"# + +docAssocs :: M.Map P.ByteString P.ByteString +docAssocs = {-# SCC "Dummy.DocAssocs" #-} M.fromList [ + (P.packAddress "Control.Arrow"#, base), + (P.packAddress "Control.Concurrent"#, base), + (P.packAddress "Control.Concurrent.Chan"#, base), + (P.packAddress "Control.Concurrent.MVar"#, base), + (P.packAddress "Control.Concurrent.QSem"#, base), + (P.packAddress "Control.Concurrent.QSemN"#, base), + (P.packAddress "Control.Concurrent.STM"#, stm), + (P.packAddress "Control.Concurrent.STM.TChan"#, stm), + (P.packAddress "Control.Concurrent.STM.TMVar"#, stm), + (P.packAddress "Control.Concurrent.STM.TVar"#, stm), + (P.packAddress "Control.Concurrent.SampleVar"#, base), + (P.packAddress "Control.Exception"#, base), + (P.packAddress "Control.Monad"#, base), + (P.packAddress "Control.Monad.Cont"#, mtl), + (P.packAddress "Control.Monad.Error"#, mtl), + (P.packAddress "Control.Monad.Fix"#, base), + (P.packAddress "Control.Monad.Identity"#, mtl), + (P.packAddress "Control.Monad.List"#, mtl), + (P.packAddress "Control.Monad.RWS"#, mtl), + (P.packAddress "Control.Monad.Reader"#, mtl), + (P.packAddress "Control.Monad.ST"#, base), + (P.packAddress "Control.Monad.ST.Lazy"#, base), + (P.packAddress "Control.Monad.ST.Strict"#, base), + (P.packAddress "Control.Monad.State"#, mtl), + (P.packAddress "Control.Monad.Trans"#, mtl), + (P.packAddress "Control.Monad.Writer"#, mtl), + (P.packAddress "Control.Parallel"#, base), + (P.packAddress "Control.Parallel.Strategies"#, base), + (P.packAddress "Data.Array"#, base), + (P.packAddress "Data.Array.Diff"#, base), + (P.packAddress "Data.Array.IArray"#, base), + (P.packAddress "Data.Array.IO"#, base), + (P.packAddress "Data.Array.MArray"#, base), + (P.packAddress "Data.Array.ST"#, base), + (P.packAddress "Data.Array.Storable"#, base), + (P.packAddress "Data.Array.Unboxed"#, base), + (P.packAddress "Data.Bits"#, base), + (P.packAddress "Data.Bool"#, base), + (P.packAddress "Data.Char"#, base), + (P.packAddress "Data.Complex"#, base), + (P.packAddress "Data.Dynamic"#, base), + (P.packAddress "Data.Either"#, base), + (P.packAddress "Data.FiniteMap"#, base), + (P.packAddress "Data.FunctorM"#, base), + (P.packAddress "Data.Generics"#, base), + (P.packAddress "Data.Generics.Aliases"#, base), + (P.packAddress "Data.Generics.Basics"#, base), + (P.packAddress "Data.Generics.Instances"#, base), + (P.packAddress "Data.Generics.Schemes"#, base), + (P.packAddress "Data.Generics.Text"#, base), + (P.packAddress "Data.Generics.Twins"#, base), + (P.packAddress "Data.Graph"#, base), + (P.packAddress "Data.Graph.Inductive"#, fgl), + (P.packAddress "Data.Graph.Inductive.Basic"#, fgl), + (P.packAddress "Data.Graph.Inductive.Example"#, fgl), + (P.packAddress "Data.Graph.Inductive.Graph"#, fgl), + (P.packAddress "Data.Graph.Inductive.Graphviz"#, fgl), + (P.packAddress "Data.Graph.Inductive.Internal.FiniteMap"#, fgl), + (P.packAddress "Data.Graph.Inductive.Internal.Heap"#, fgl), + (P.packAddress "Data.Graph.Inductive.Internal.Queue"#, fgl), + (P.packAddress "Data.Graph.Inductive.Internal.RootPath"#, fgl), + (P.packAddress "Data.Graph.Inductive.Internal.Thread"#, fgl), + (P.packAddress "Data.Graph.Inductive.Monad"#, fgl), + (P.packAddress "Data.Graph.Inductive.Monad.IOArray"#, fgl), + (P.packAddress "Data.Graph.Inductive.NodeMap"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.ArtPoint"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.BCC"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.BFS"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.DFS"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.Dominators"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.GVD"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.Indep"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.MST"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.MaxFlow"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.MaxFlow2"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.Monad"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.SP"#, fgl), + (P.packAddress "Data.Graph.Inductive.Query.TransClos"#, fgl), + (P.packAddress "Data.Graph.Inductive.Tree"#, fgl), + (P.packAddress "Data.HashTable"#, base), + (P.packAddress "Data.IORef"#, base), + (P.packAddress "Data.Int"#, base), + (P.packAddress "Data.IntMap"#, base), + (P.packAddress "Data.IntSet"#, base), + (P.packAddress "Data.Ix"#, base), + (P.packAddress "Data.List"#, base), + (P.packAddress "Data.Map"#, base), + (P.packAddress "Data.Maybe"#, base), + (P.packAddress "Data.Monoid"#, base), + (P.packAddress "Data.PackedString"#, base), + (P.packAddress "Data.Queue"#, base), + (P.packAddress "Data.Ratio"#, base), + (P.packAddress "Data.STRef"#, base), + (P.packAddress "Data.STRef.Lazy"#, base), + (P.packAddress "Data.STRef.Strict"#, base), + (P.packAddress "Data.Set"#, base), + (P.packAddress "Data.Tree"#, base), + (P.packAddress "Data.Tuple"#, base), + (P.packAddress "Data.Typeable"#, base), + (P.packAddress "Data.Unique"#, base), + (P.packAddress "Data.Version"#, base), + (P.packAddress "Data.Word"#, base), + (P.packAddress "Debug.QuickCheck"#, qc), + (P.packAddress "Debug.QuickCheck.Batch"#, qc), + (P.packAddress "Debug.QuickCheck.Poly"#, qc), + (P.packAddress "Debug.QuickCheck.Utils"#, qc), + (P.packAddress "Debug.Trace"#, base), + (P.packAddress "Distribution.Compat.Directory"#, cabal), + (P.packAddress "Distribution.Compat.Exception"#, cabal), + (P.packAddress "Distribution.Compat.FilePath"#, cabal), + (P.packAddress "Distribution.Compat.RawSystem"#, cabal), + (P.packAddress "Distribution.Compat.ReadP"#, cabal), + (P.packAddress "Distribution.Extension"#, cabal), + (P.packAddress "Distribution.GetOpt"#, cabal), + (P.packAddress "Distribution.InstalledPackageInfo"#, cabal), + (P.packAddress "Distribution.License"#, cabal), + (P.packAddress "Distribution.Make"#, cabal), + (P.packAddress "Distribution.Package"#, cabal), + (P.packAddress "Distribution.PackageDescription"#, cabal), + (P.packAddress "Distribution.PreProcess"#, cabal), + (P.packAddress "Distribution.PreProcess.Unlit"#, cabal), + (P.packAddress "Distribution.Setup"#, cabal), + (P.packAddress "Distribution.Simple"#, cabal), + (P.packAddress "Distribution.Simple.Build"#, cabal), + (P.packAddress "Distribution.Simple.Configure"#, cabal), + (P.packAddress "Distribution.Simple.GHCPackageConfig"#, cabal), + (P.packAddress "Distribution.Simple.Install"#, cabal), + (P.packAddress "Distribution.Simple.LocalBuildInfo"#, cabal), + (P.packAddress "Distribution.Simple.Register"#, cabal), + (P.packAddress "Distribution.Simple.SrcDist"#, cabal), + (P.packAddress "Distribution.Simple.Utils"#, cabal), + (P.packAddress "Distribution.Version"#, cabal), + (P.packAddress "Foreign"#, base), + (P.packAddress "Foreign.C"#, base), + (P.packAddress "Foreign.C.Error"#, base), + (P.packAddress "Foreign.C.String"#, base), + (P.packAddress "Foreign.C.Types"#, base), + (P.packAddress "Foreign.Concurrent"#, base), + (P.packAddress "Foreign.ForeignPtr"#, base), + (P.packAddress "Foreign.Marshal"#, base), + (P.packAddress "Foreign.Marshal.Alloc"#, base), + (P.packAddress "Foreign.Marshal.Array"#, base), + (P.packAddress "Foreign.Marshal.Error"#, base), + (P.packAddress "Foreign.Marshal.Pool"#, base), + (P.packAddress "Foreign.Marshal.Utils"#, base), + (P.packAddress "Foreign.Ptr"#, base), + (P.packAddress "Foreign.StablePtr"#, base), + (P.packAddress "Foreign.Storable"#, base), + (P.packAddress "GHC.Conc"#, base), + (P.packAddress "GHC.ConsoleHandler"#, base), + (P.packAddress "GHC.Dotnet"#, base), + (P.packAddress "GHC.Exts"#, base), + (P.packAddress "Graphics.HGL"#, hgl), + (P.packAddress "Graphics.HGL.Core"#, hgl), + (P.packAddress "Graphics.HGL.Draw"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Brush"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Font"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Monad"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Pen"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Picture"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Region"#, hgl), + (P.packAddress "Graphics.HGL.Draw.Text"#, hgl), + (P.packAddress "Graphics.HGL.Key"#, hgl), + (P.packAddress "Graphics.HGL.Run"#, hgl), + (P.packAddress "Graphics.HGL.Units"#, hgl), + (P.packAddress "Graphics.HGL.Utils"#, hgl), + (P.packAddress "Graphics.HGL.Window"#, hgl), + (P.packAddress "Graphics.Rendering.OpenGL"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Antialiasing"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.BasicTypes"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.BeginEnd"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Bitmaps"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.BufferObjects"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Clipping"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.ColorSum"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Colors"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.CoordTrans"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.DisplayLists"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Evaluators"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Feedback"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.FlushFinish"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Fog"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Framebuffer"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Hints"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.LineSegments"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PerFragment"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Points"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Polygons"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.RasterPos"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.ReadCopyPixels"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Rectangles"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.SavingState"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Selection"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.StateVar"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.StringQueries"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Application"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Environments"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Objects"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Parameters"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Queries"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.Texturing.Specification"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.VertexArrays"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GL.VertexSpec"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Errors"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Initialization"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Matrix"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Mipmapping"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.NURBS"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Quadrics"#, opengl), + (P.packAddress "Graphics.Rendering.OpenGL.GLU.Tessellation"#, opengl), + (P.packAddress "Graphics.SOE"#, hgl), + (P.packAddress "Graphics.UI.GLUT"#, glut), + (P.packAddress "Graphics.UI.GLUT.Begin"#, glut), + (P.packAddress "Graphics.UI.GLUT.Callbacks"#, glut), + (P.packAddress "Graphics.UI.GLUT.Callbacks.Global"#, glut), + (P.packAddress "Graphics.UI.GLUT.Callbacks.Window"#, glut), + (P.packAddress "Graphics.UI.GLUT.Colormap"#, glut), + (P.packAddress "Graphics.UI.GLUT.Debugging"#, glut), + (P.packAddress "Graphics.UI.GLUT.DeviceControl"#, glut), + (P.packAddress "Graphics.UI.GLUT.Fonts"#, glut), + (P.packAddress "Graphics.UI.GLUT.GameMode"#, glut), + (P.packAddress "Graphics.UI.GLUT.Initialization"#, glut), + (P.packAddress "Graphics.UI.GLUT.Menu"#, glut), + (P.packAddress "Graphics.UI.GLUT.Objects"#, glut), + (P.packAddress "Graphics.UI.GLUT.Overlay"#, glut), + (P.packAddress "Graphics.UI.GLUT.State"#, glut), + (P.packAddress "Graphics.UI.GLUT.Window"#, glut), + (P.packAddress "Graphics.X11.Types"#, x11), + (P.packAddress "Graphics.X11.Xlib"#, x11), + (P.packAddress "Graphics.X11.Xlib.Atom"#, x11), + (P.packAddress "Graphics.X11.Xlib.Color"#, x11), + (P.packAddress "Graphics.X11.Xlib.Context"#, x11), + (P.packAddress "Graphics.X11.Xlib.Display"#, x11), + (P.packAddress "Graphics.X11.Xlib.Event"#, x11), + (P.packAddress "Graphics.X11.Xlib.Font"#, x11), + (P.packAddress "Graphics.X11.Xlib.Misc"#, x11), + (P.packAddress "Graphics.X11.Xlib.Region"#, x11), + (P.packAddress "Graphics.X11.Xlib.Screen"#, x11), + (P.packAddress "Graphics.X11.Xlib.Types"#, x11), + (P.packAddress "Graphics.X11.Xlib.Window"#, x11), + (P.packAddress "Language.Haskell.Parser"#, hs), + (P.packAddress "Language.Haskell.Pretty"#, hs), + (P.packAddress "Language.Haskell.Syntax"#, hs), + (P.packAddress "Language.Haskell.TH"#, th), + (P.packAddress "Language.Haskell.TH.Lib"#, th), + (P.packAddress "Language.Haskell.TH.Ppr"#, th), + (P.packAddress "Language.Haskell.TH.PprLib"#, th), + (P.packAddress "Language.Haskell.TH.Syntax"#, th), + (P.packAddress "Network"#, network), + (P.packAddress "Network.BSD"#, network), + (P.packAddress "Network.CGI"#, network), + (P.packAddress "Network.Socket"#, network), + (P.packAddress "Network.URI"#, network), + (P.packAddress "Numeric"#, base), + (P.packAddress "Prelude"#, base), + (P.packAddress "System.CPUTime"#, base), + (P.packAddress "System.Cmd"#, base), + (P.packAddress "System.Console.GetOpt"#, base), + (P.packAddress "System.Console.Readline"#, readline), + (P.packAddress "System.Console.SimpleLineEditor"#, readline), + (P.packAddress "System.Directory"#, base), + (P.packAddress "System.Environment"#, base), + (P.packAddress "System.Exit"#, base), + (P.packAddress "System.IO"#, base), + (P.packAddress "System.IO.Error"#, base), + (P.packAddress "System.IO.Unsafe"#, base), + (P.packAddress "System.Info"#, base), + (P.packAddress "System.Locale"#, base), + (P.packAddress "System.Mem"#, base), + (P.packAddress "System.Mem.StableName"#, base), + (P.packAddress "System.Mem.Weak"#, base), + (P.packAddress "System.Posix"#, unix), + (P.packAddress "System.Posix.Directory"#, unix), + (P.packAddress "System.Posix.DynamicLinker"#, unix), + (P.packAddress "System.Posix.DynamicLinker.Module"#, unix), + (P.packAddress "System.Posix.DynamicLinker.Prim"#, unix), + (P.packAddress "System.Posix.Env"#, unix), + (P.packAddress "System.Posix.Error"#, unix), + (P.packAddress "System.Posix.Files"#, unix), + (P.packAddress "System.Posix.IO"#, unix), + (P.packAddress "System.Posix.Process"#, unix), + (P.packAddress "System.Posix.Resource"#, unix), + (P.packAddress "System.Posix.Signals"#, base), + (P.packAddress "System.Posix.Signals.Exts"#, unix), + (P.packAddress "System.Posix.Temp"#, unix), + (P.packAddress "System.Posix.Terminal"#, unix), + (P.packAddress "System.Posix.Time"#, unix), + (P.packAddress "System.Posix.Types"#, base), + (P.packAddress "System.Posix.Unistd"#, unix), + (P.packAddress "System.Posix.User"#, unix), + (P.packAddress "System.Process"#, base), + (P.packAddress "System.Random"#, base), + (P.packAddress "System.Time"#, base), + (P.packAddress "Test.HUnit"#, hunit), + (P.packAddress "Test.HUnit.Base"#, hunit), + (P.packAddress "Test.HUnit.Lang"#, hunit), + (P.packAddress "Test.HUnit.Terminal"#, hunit), + (P.packAddress "Test.HUnit.Text"#, hunit), + (P.packAddress "Test.QuickCheck"#, qc), + (P.packAddress "Test.QuickCheck.Batch"#, qc), + (P.packAddress "Test.QuickCheck.Poly"#, qc), + (P.packAddress "Test.QuickCheck.Utils"#, qc), + (P.packAddress "Text.Html"#, base), + (P.packAddress "Text.Html.BlockTable"#, base), + (P.packAddress "Text.ParserCombinators.Parsec"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Char"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Combinator"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Error"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Expr"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Language"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Perm"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Pos"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Prim"#, parsec), + (P.packAddress "Text.ParserCombinators.Parsec.Token"#, parsec), + (P.packAddress "Text.ParserCombinators.ReadP"#, base), + (P.packAddress "Text.ParserCombinators.ReadPrec"#, base), + (P.packAddress "Text.PrettyPrint"#, base), + (P.packAddress "Text.PrettyPrint.HughesPJ"#, base), + (P.packAddress "Text.Printf"#, base), + (P.packAddress "Text.Read"#, base), + (P.packAddress "Text.Read.Lex"#, base), + (P.packAddress "Text.Regex"#, base), + (P.packAddress "Text.Regex.Posix"#, base), + (P.packAddress "Text.Show"#, base), + (P.packAddress "Text.Show.Functions"#, base)] diff --git a/Plugin/Dummy/Moo.hs b/Plugin/Dummy/Moo.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dummy/Moo.hs @@ -0,0 +1,887 @@ +-- +-- | Default cows +-- + +module Plugin.Dummy.Moo (cows) where + +cows :: [String] +cows = map unlines + [[" (__)", + " (oo)", + " /-------\\/", + " / | ||", + "* ||----||", + " ~~ ~~", + " Cow"], + [" (__)", + " (oo)", + " /-------\\/", + " / | ||", + "* ||W---||", + " ~~ ~~", + " Cow laden", + " with milk"], + [" (__)", + " (oo)", + " /-------\\/", + " / | ||", + "* ||V---||", + " ~~ ~~", + "Betty Ford-type", + "cow with milk"], + [" (___)", + " (o o)", + " /-------\\ /", + " / | ||O", + "* ||,---||", + " ~~ ~~", + " Bull"], + [" (__)", + " (oo)", + " /-------\\/-*", + " / | || \\", + "* ||----|| *", + "\\/|(/)(/\\/(,,/", + " Cow munching", + " on grass"], + [" (__)", + " (oo)", + " /-------\\/", + " )*)(\\/* / *", + "\\ |||/)|/()(", + "\\)|(/\\/|)(/\\", + "Grass munching", + " on cow"], + [" (__)", + " (oo)", + " /-------\\/", + " / | ||", + "~~~~~~~~~~~~~~", + "", + " Cow in water"], + [" (__)", + " (oo)", + "~~~~~~~~~~~~~~~~~~~~~", + "", + "", + "", + " Cow in trouble"], + [" (__)", + " (oo)", + " /--------\\/", + " * o| ||", + " ||----||", + " ooo^^ ^^", + " Cow taking", + " a shit"], + [" (__)", + " (oo)", + " /-oooooo-\\/", + " * ooooooooo", + " ooooooooooooo", + "ooooooooooooooooo", + " Cow in deep", + " shit"], + [" * (__) * (__)", + " \\ (oo) | (oo)", + " \\-------\\/ \\-------\\/", + "o o| || / ||", + " ||----||>==/-----||", + " ^^ ^^ ^^", + " Cow getting the shit", + " kicked out of her"], + [" U", + " /---V", + " * |--|", + "", + "", + "Cow at 100 meters."], + [" .", + "", + "", + "", + "Cow at 10,000 meters."], + [" )__(", + " (oo)", + " *-------\\/", + " / | ||", + "/ ||----||", + " vv vv", + "", + " Polish Cow"], + [" vv vv", + " ||----|| *", + " || | /", + " /\\-------/", + " (oo)", + " (~~)", + "", + "Australian Cow"], + [" (__)", + " ____ (oo)", + " /- --\\/", + " / | ||", + " * ||___-||", + " ^^ ^^", + "", + " Freshman Cow", + "After the \"Freshman 15\""], + [" (__)", + " (OO)", + " /-------\\/", + " / | ||", + "* ||----||", + " ^^ ^^", + "", + "Cow who drank Jolt"], + [" (__)", + " (@@)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + "", + " Cow who ate", + "psychadelic mushrooms"], + [" (__)", + " (xx)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + "", + " Cow who used Jolt to wash", + "down psychadelic mushrooms"], + [" (__)", + " SooS", + " /------S\\/S", + " / | ||", + " * ||----||", + " ^^ ^^", + " This cow belonged", + " to George Washington"], + [" /\\", + " / \\", + " (__) \\ /", + " (oo) \\/", + " /-------\\/ /S", + " / | || / S", + "* ||----||___/ S", + " ^^ ^^", + " Ben Franklin owned", + " this cow"], + [" __", + " ||", + " (_||_)", + " (oo)", + " /-------\\/", + " / | ||", + "* ||----||", + " ^^ ^^", + "Abe Lincoln's", + " cow"], + [" (__) (__)", + " (oo) (oo)", + " \\/--------\\/", + " | |", + " ||------||", + " ^^ ^^", + "This cow lived with", + " Dr. Doolittle"], + [" (__)", + " (oo)", + " /------\\/", + " /| |/ |", + " / | [) ||", + " * ||----||", + " ^^ ^^", + " This cow was given to", + "Hugh Hefner for his Birthday"], + [" * (__)", + " \\ (oo)", + " \\-------\\/", + " | ==$ ||", + " ||----||", + " ^^ ^^", + "Old \"One Arm\" belonged", + " to Ceasar's Palace"], + [" (___)", + " ( O )", + " /-------\\ /", + " / | ||V", + " * ||----||", + " ^^ ^^", + " The cyclops that Jason and", + "the Argonauts met had this cow"], + [" (__)", + " [##]", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + " This cow belonged", + " to Flash Gordon"], + [" (__)", + " (@o)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + "This cow lived with", + "the Little Rascals"], + [" /------- (__)", + " / | || (oo)", + " * ||----|---\\/", + " ^^ ^", + "This cow belonged to", + "the Headless Horseman"], + [" \\_|_/", + " (oo)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + "Cow visiting the Statue of Liberty"], + [" (____)", + " (o o)", + " /-----\\ /----", + " / | | \\/ |", + " \\ | | | | |", + " *| | |-----| | |", + " /\\ /\\ /\\ /\\", + " This was Salvatore", + " Dali's favorite cow"], + [" (____)", + " ( O O)", + " /-----------\\ /", + " / || | \\/", + " / || ||||", + " * ||||-----||||", + " ^^^^ ^^^^", + " No one was sure whether", + " M.C. Escher's cow had four", + " legs or eight"], + [" (____)", + " (oo )", + " /-----------\\ /", + " / || | \\/", + " / || ||||", + " * ||||-----||||", + " /\\/\\ /\\/\\", + "This cow belonged", + " to Pablo Picasso"], + [" O__O", + " (oo)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + " Cow at Disneyland"], + [" (__)", + " ^^ (oo)", + " ^^^^ /-------\\/", + " ^^^^^ / | ||", + " ^^^^^ * ||----||", + " ^^^^^^^^ ====^^====^^====", + "^^^^^^^^^^^^^/", + "^^^^^^^^^^^^^^^^^^", + "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", + " Cow Hanging Ten at Malibu"], + [" (__)", + " (--)", + " /-\\/-\\", + " /| |\\", + " ^ | | ^", + " | |", + " /----\\", + " / \\ \\", + " ^ * ^", + "Cow sunning at Fort Lauderdale", + " (What a bod, huh guys?)"], + [" / / / / / / / / / / /", + " / / / / / / / / / / / /", + " / / / / / _______ / /", + " / / / / | \\ / /", + " / / / (__)| / /", + " / / / (oo)| / /", + " /-------\\/ |", + " / | ||^_|", + " * ||----|", + " ^^ ^", + "", + "Cow sheltering from English Weather"], + [" (__)", + " (DD)", + " /-------\\/", + " / | ||_\\_/", + " * ||----|", + " ^^ ^", + "Cow chugging brews and staring at", + " sunbathers at Fort Lauderdale"], + [" )\\ (__)", + " / \\ (oo)", + " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", + " Cow swimming at Amityville", + "(Where Jaws was filmed, for those less educated)"], + [" *", + " \\", + " \\", + " |\\", + " \\ | \\ (__)", + " \\\\|| \\(oo)", + " \\||\\ \\\\/", + " ^^ \\||", + " \\\\ ||", + " \\\\||", + " \\||", + " ^^", + " \\\\_", + " \\_", + " Cow skiing a Black Diamond at Aspen"], + [" ( @@@ )", + " ( @@ ) (------------)", + " @@ (__) ( *>COUGH<* )", + " @@ (oo) . . . ( *>COUGH<* )", + " /--UU--\\/ (____________)", + " / | ||", + " * ||---||", + "", + " (New) Jersey Cow"], + [" O O O O", + " \\ \\ / /", + " \\ \\ (__) /", + " (__) \\ \\ (xx)/", + " (DD) \\ +--------+\\//", + " /-------\\/ \\| | /", + " / | || +--------+", + " * ||----||", + " ^^ ^^", + "Cow fantasizing about \"Riding the Mechanical Bull\"", + " at Gillies in Texas"], + [" x", + " xxxx|xxxx", + " xxxxxxx|xxxxxxx", + " |", + " //", + " (__) //", + " (oo)//", + " /-------\\//", + " / | |//", + " * ||----|", + " ^^ ^^", + " Julie Andrews Cow"], + [" (__) (__)", + " (oo)===(oo)", + " /-------\\/ \\/-------\\", + " / | || || | \\", + "* ||----|| ||----|| *", + " ^^ ^^ ^^ ^^", + " Siamese cows"], + [" o o", + " \\ /", + " \\ /", + " \\__/", + " _______(oo)", + " /| ___ \\/", + " / | { }||", + "* ||{___}||", + " ||-----||", + " ^^ ^^", + "", + " Television", + " Cow", + " (Cow-thode", + " Ray Tube)"], + [" (__) ^", + " (oo) /", + " _____\\/___/", + " / /\\ / /", + " ^ / * /", + " / ___/", + " *----/\\", + " / \\", + " / /", + " ^ ^", + "", + " This cow does Disco", + " (That's what comes of", + " snorting cow-caine)"], + [" (__)", + " (oo)", + " /---------\\/", + " / | x=a(b)||", + " * ||------||", + " ^^ ^^", + "", + " Mathematical", + " Cow", + " (developer of", + " cow-culus)"], + [" o", + " | [---]", + " | |", + " | | |------========|", + " /----|---|\\ | **** |=======|", + " /___/___\\___\\ o | **** |=======|", + " | | ___| |==============|", + " | | ___ {(__)} |==============|", + " \\-----------/ []( )={(oo)} |==============|", + " \\ \\ / / /---===--{ \\/ } |", + " ----------------- / | NASA |==== |", + " | | * ||------||-----^", + " ----------------- || | |", + " / / \\ \\ ^^ ^ |", + " / ---- \\", + " ^^ ^^ This cow jumped over the Moon"], + [" (__)", + " ([][]) \"I have this recurring dream", + " __\\/_--U about golden arches.\".. (__)", + " /\\ \\__ ^ :..(\"\")", + " /\\\\\\ / / //\\ ____\\_____\\/ //", + " /----^/__/\\ /\\ // \\\\/ \\___ / //", + " \\\\\\____/--\\-- // /-/__________/ //", + " /====== \\/ =======/==============//", + " *_/ / \\ /^ // / \\\\", + " / \\ ^ // \\\\", + "", + " Psycowlogist and patient"], + [" \\^^^^^^^^\\ (__)", + " \\^^^^^^^^\\\\ (oo)", + " *-----\\_______\\/\\/", + " ^_______/ --- \\______^", + " ^--------\\ \\S/ /\\_____^", + " \\______/", + "", + " It's a bird...", + " It's a plane..."], + [" (___)", + " (o o)", + " \\ /", + " \\--O--/", + " // -----\\", + " \\\\/_^{} /==V===[]", + " \\_____\\\\//", + " \\__/", + " //\\\\ The Boss", + " // \\\\ (Bruce Holstien)", + " // //", + " ^^ ^^"], + [" ==================", + " _____________________________ H H", + " | |-------------| H (__) H", + " | | ________ | H (oo) H __", + " | COWNTY | | (|__|) | | H / \\/ \\ H / \\", + " | JAIL | | |oo| | | H | | | | H | STOP |", + " | | |__|\\/|__| | H D===b=----- H \\ __ /", + " | | o | H^^^^^^^^^^^^^^^^H ||", + " | | ^ | H H ||", + " | | ] | H H ||", + " | | | H H ||", + " |_____________|_____________| H H ||", + " ^^^^^^^^^^^^^^^^^^ ^^^^^^^", + " Some cows get in trouble... Cattle Guard"], + [" ( ( )", + " ( ( ) )", + " ( ( )", + " ( / )", + " ( ( \\\\ )", + " ( | // )", + " | | (__)", + " | | (oo)", + " | | ----\\/", + " | | ||", + " **| | ---||", + " ``'---------^^", + " Cow Hide"], + [" (__)", + " ______(oo)_____", + "( _)_______(__) )", + " \\ __________/", + "", + " Cow Pie"], + [" \\ | / ___________", + " ____________ \\ \\_# / | ___ | _________", + " | | \\ #/ | | | | | = = = = |", + " | | | | | \\\\# | |`v'| | | |", + " | | \\# // | --- ___ | | | || | |", + " | | | | | #_// | | | | | |", + " | | \\\\ #_/_______ | | | | | | || | |", + " | | | | | \\\\# /_____/ \\ | --- | | |", + " | | \\# |+ ++| | | |^^^^^^| | | | || | |", + " | | \\# |+ ++| | | |^^^^^^| | | | || | |", + "^^^| (^^^^^) |^^^^^#^| H |_ |^| | |||| | |^^^^^^| |", + " | ( ||| ) | # ^^^^^^ | | |||| | | | ||||||| |", + " ^^^^^^^^^^^^^________/ /_____ | | |||| | | | ||||||| |", + " `v'- ^^^^^^^^^^^^^ | ||||||| |", + " || |`. (__) (__) ( )", + " (oo) (oo) /---V", + " /-------\\/ \\/ --------\\ * | |", + " / | || ||_______| \\", + " * ||W---|| || || *", + " ^^ ^^ ^^ ^^", + " \"Cow Town\""], + [" \\ (__)", + " \\\\(oo)", + " /-----\\\\\\/", + " / | (##)", + " * ||----||\"", + " ^^ ^^", + " This cow plays bagpipes."], + [" (__)", + " (\\/)", + " /-------\\/", + " / | 666 ||", + "* ||----||", + " ^^ ^^", + "", + "Satanic cow"], + [" (__)", + " ($$)", + " /-------\\/", + " / |=====||", + " * ||----||", + " ^^ ^^", + "", + "This cow is a Yuppie"], + [" (__)", + " (**)", + " /-------\\/", + " / | ||", + "* ||----||", + " ^^ ^^", + "", + " Cow in love"], + [" (---)", + " ( )", + " /-----\\", + " | |", + " | | |", + " | | |", + " | * |", + " ^^ ^^", + " Coward"], + [" (__)", + " (xx)", + " __------\\/", + "* ||____||", + " / | |\\", + "", + " Hamburger"], + [" . /\\ . .", + " . / \\ . .", + " / \\ . . *", + " / \\ *", + " | (__) | . . **", + " . /| (oo) |\\ **", + " / | /\\/\\ | \\ . . *", + " . / |=|==|=| \\ . *", + " . / | | | | \\ .", + " / USA | ^||^ |NASA \\ .", + " |______| ^^ |______| .", + " . (__||__) . .", + " . /_\\ /_\\ . . .", + " !!! !!!", + "", + " The cow that jumped over the moon."], + [" ...---...", + " ../ / | \\ \\..", + " ./ / / | \\ \\ \\.", + " / / / | \\ \\ \\", + " / / / | \\ \\ \\", + " ^^^^^^^^^^^^^^^^^^^^^^^", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /", + " \\ | /(__)", + " \\|/ (oo)", + " /---++--\\/", + " / | || ||", + " * ||-++-||", + " ^^ ^^", + " Cow surviving attack by Red Baron"], + [" ..---.. (__)", + " / \\ (oo)", + " | RIP | /-------\\/", + " | | / | ||", + " | | * ||----||", + " | | ^^ ^^", + "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\/////////////////", + "", + " Elvis's Cow... ...Or is it alive and living in tax exile???"], + [" (__)", + " (oo)", + " /---+ +--\\/", + " / | | | ||", + " * ||-+ +-||", + " ^^ ^^ *", + "", + " David Copperfield's Cow David Copperfield's other Cow"], + [" (__)", + " (oo)", + " /-------\\/", + " / | ||", + " * ||----||", + " ^^ ^^", + " (__) (__)", + " (oo) (oo)", + " /-------\\/ \\/-------\\", + " / | || -^^- || | \\", + " * ||---- -^^- || *", + " ^^ ^^", + " (__) (__)", + " (oo) (oo)", + " /-------\\/ \\/-------\\", + " / | || || | \\", + " * ||----|| ||----|| *", + " ^^ ^^ ^^ ^^", + " Barnum's Troupe of performing cows"], + [" (__) _--------_", + " (oo) |__________| BIG", + " /-------\\/ XXXXXXXXXX MAC", + " / | 007 || __________", + " * ||----|| |_ _|", + " ^^ ^^ --------", + " Cow licenced to kill Enemy Cow after having met previous cow"], + [" (__)", + " (oo) o /| /|/|_", + " / \\/ / / _ /", + " / _\\===^ ___\\_____/___", + " ___|__/ |/\\ (___________(_)", + " * ^ ^", + "", + " Mrs. O'Leary's Cow"], + [" (__)", + " (oo)", + " /'^^^-m", + " / '' ` )", + " | /|", + " | | | |", + " |_____|_|", + " //|| ||", + " * ww ww", + "", + "Cow'nt Dracula"], + [" ____ ____ |+++++|", + "|++++| ___ |++++| ____ |+++++|", + "|++++| |++ ______________________ |++++| |+++++|", + "|++++| |++/ /( )\\ \\ |++++| |+++++| __", + "| | |+| |-oo- | \\______ |++++| |+++++| |++|", + "-----(__)--| \\__\\/ _(__)_ \\ --------------------------------", + " o ( oo /_______________________| (oo) \\ | __", + " | _/\\_| | M O O - B U S T E R S|__\\/\\ /| | /oo| - Bleaurgh!", + " |-| \\\\____ ------ )_ /| /\\", + " -|_ \\_|-_|^^^^^^^^^^^^^^^^^^^^^^^^^^ 0 _| * \\/ *", + " \\ | __________________________________/", + " | W| \\ \\_/ /----------------- \\ \\_/ /", + " / /\\ \\ \\___/ \\___/", + " / / \\ \\", + " ^^^ ^^^ Who you gonna call...?"], + [" (__)", + " (-o)", + " /------\\/", + " /| ||", + " * ||----||", + "", + "Flirtatious cow (winking)"], + [" (__)", + " (00)", + " /------\\/", + " /| ||", + "* ||----||", + "", + "Cow w/ Glasses"], + [" (__) (----------)", + " (--) . . . ( *>YAWN<* )", + " /------\\/ (----------)", + " /| ||", + " * ||----||", + "", + "Cow after pulling an all-nighter"], + [" \\ _ /", + " - ( ) -", + " / \" \\", + " (__)", + " ________(oo)", + " /| \\/", + " / |_______||", + " * || ||", + " ~~ ~~", + " Thomas Edison's cow"], + [" ______________________ _______________________", + " | | | |", + " | (__) | | (__) |", + " | (oo) | | (oo) |", + " | /-------\\/ | |---\\/ /----|", + " | / | || | | || / | |", + " | * ||----|| | |--|| * ||--|", + " | ~~ ~~ | | ~~ ~~ |", + " |--------------------| |---------------------|", + " Normal Cow 0 Cow modulo one 1"], + [" ______________(__)_________________", + " /_______________(oo)_______________ /", + " | \\/ ||", + " _|_ _||", + " /__/_______________________________/__/|", + " ( ) ( )|", + " | |________________________________| | |", + " \\_____________________________________/]", + " [] [] []", + "", + " COW-CH"], + [" (__)", + " (oo)", + " \\/", + " ||", + " ||", + " ||", + " ||", + " /------- /", + " / | ||", + "* ||----||", + " ~~ ~~", + " Cowraffe"], + [" * *", + " \\ /", + " \\ /", + " /~~~~~~~~~~~~~~~~~~~~~~~\\ \\/", + " / (__) \\ +----------+", + " | (oo) ~~~~~~~~~~~\\ | | |", + " |~~~| \\/. \\\\ // \\_* |~~~| | |", + " | |-----`//`====='\\\\-----| | | |", + " | |-----//---------||----| | | |", + " | |_ _ _\"_ _ _ _ _ \"_ _ _| | +----------+", + " ~||~ ~||~ || ||", + "", + " \"COWCH POTATO\""], + [" (__)", + " (oo) -------------------------", + " /-------\\/ - | Don't have a Bart, man! |", + " / | || -------------------------", + "* ||----||", + " ~~ ~~", + " The Simpsons' cow"], + [" _______________________", + "|\\ ~ ~ /|", + "| \\ ~ ~ ~ / |", + "|(_\\ ~ COW-PIE ~ /_)|", + "|(oo\\ ~ /oo)|", + "| \\/ \\ ~ ~ / \\/ |", + "|(__) \\ / (__)|", + "\\(oo)(_\\ ~ ~ /_)(oo)|", + " \\\\/ (oo\\ /oo) \\//", + " \\ \\/ \\ ~ / \\/ /", + " \\ (__)\\ / (__) /", + " \\ (oo) \\~/ (oo)/", + " \\ \\/ :(__)\\//", + " \\ (__):(oo) /", + " \\(oo): \\/ /", + " \\\\/(__) /", + " \\ (oo)/", + " \\ \\//", + " \\:/"], + [" \\ /", + " \\_____________/", + " /\\___________/\\", + " Cow in / /\\_________/\\ \\", + " trouble / / /\\_______/\\ \\ \\", + " / / / / (__) /\\ \\ \\ \\", + " ___/_/_/_/_ (oo) \\_\\_\\_\\_\\___", + " \\ \\ \\ \\ \\ \\/ / / / / /", + " \\ \\ \\ \\/_____\\/ / / /", + " \\ \\ \\/_______\\/ / /", + " \\ \\/_________\\/ /", + " \\/___________\\/", + " / \\", + " / \\"], + [" (___)", + " ( OO", + " ______ ______ _____\\_ | ______ (__) ______", + " | | | | | |\\O cowstle | | (oo)| |", + " | |____| |____| | | |__\\/_| |", + " | | | |", + " | | (__) | |", + " | __________ | (oo) | __________ |", + " | | | | \\/-------\\ | | | |", + " | | | | ___ | ___ |_\\_ | | | |", + " | | (__) | |_| |_|_| |__|| |__| | (__) | |", + " | | (oo) | | (oo) | |", + " | \\___\\/___/ \\___\\/___/ |", + " | |", + " | |", + " ( ______ )", + " ( / \\ )", + " ( / \\ )", + " ( | | )", + " | | | |", + " | | | |", + " |_________________________|________|______________|"], + [" \\ \\", + " \\ \\", + " \\ \\", + " \\ \\ (__)", + " \\ \\ (oo)", + " /---\\----\\/", + " / | \\ ||", + " * ||---\\-\\\\", + " ~~ ~~", + " ~~ ~~", + " \\\\_____//", + " || |", + " /\\------\\", + " (oo) \\", + " (--) *", + "", + "Cow Circus: The flying Cowlendas"], + [" /", + " /", + " * (__) /", + " \\ ( OO /", + " \\---\\___/\\_|\\=/>", + " | \\===/>", + " | /______/ /", + "_________\\\\_\\\\_____/__________________", + " ~ ~ /", + " /", + " /", + "", + " Cow Circus: Tightrope walking"], + [" *", + " \\", + " w \\ w", + " \\\\ /\\ //", + " \\\\/ \\//", + " | |", + " |(__)|", + " \\(OO)/", + " //\\/\\\\", + " || ||", + " ||__||", + " /~~ ~~\\", + " / ======== \\", + " / \\", + " |==============|", + " \\ /", + " \\ ======== /", + " \\ _____ /", + "Cow balancing on ball"], + [" (__)", + " (oo)", + " .-\\/-.", + " <| |>", + " \\ \\/ /", + " |\\/\\/|", + " /----\\", + " / \\", + " /* * * \\", + "/__*_*_*_\\", + " || ||", + " ~~ ~~", + "", + " Cowslip"]] + diff --git a/Plugin/Dynamic.hs b/Plugin/Dynamic.hs new file mode 100644 --- /dev/null +++ b/Plugin/Dynamic.hs @@ -0,0 +1,63 @@ +-- +-- Copyright (c) 2004-06 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | Dynamic module, binding to the dynamic linker +-- +module Plugin.Dynamic (theModule) where + +import {-# SOURCE #-} Modules (plugins) + +import Plugin +import Control.Monad.State + +PLUGIN Dynamic + +instance Module DynamicModule () where + + moduleSticky _ = True + moduleHelp _ _ = "An interface to dynamic linker" + modulePrivs _ = ["dynamic-load","dynamic-unload","dynamic-reload"] + + moduleInit _ = do + mapM_ (\p -> load p >> liftIO (putChar '!' >> hFlush stdout)) plugins + + process_ _ s rest = case s of + "dynamic-load" -> load rest >> return ["module loaded"] + "dynamic-unload" -> unload rest >> return ["module unloaded"] + "dynamic-reload" -> unload rest >> load rest >> return ["module reloaded"] + +-- +-- | Load value "theModule" from each plugin, given simple name of a +-- plugin, i.e. "google" +-- +load :: String -> LB Bool +load nm = do + let file = getModuleFile nm + catchError + (do (_,md) <- ircLoad file "theModule" + ircInstallModule md nm + return True) -- need to put mod in state + (\_ -> do + ircUnload file + liftIO $ putStrLn $ "\nCouldn't load "++nm++", ignoring" + return False) + +-- +-- | Unload a module, e.g. "vixen" +-- +unload :: String -> LB () +unload nm = do + unless (nm `elem` plugins) $ error "unknown or static module" + ircUnloadModule nm + ircUnload (getModuleFile nm) + +-- +-- | Convert simple plugin name to a valid plugin. Could sanity check. +-- +getModuleFile :: [Char] -> [Char] +getModuleFile s = "Plugin/" ++ upperise s ++ ".o" + where + upperise :: [Char] -> [Char] + upperise [] = [] + upperise (c:cs) = toUpper c:cs diff --git a/Plugin/Elite.hs b/Plugin/Elite.hs new file mode 100644 --- /dev/null +++ b/Plugin/Elite.hs @@ -0,0 +1,80 @@ +-- +-- (c) Josef Svenningsson, 2005 +-- Licence: No licence, public domain +-- +-- Inspired by the following page: +-- http://www.microsoft.com/athome/security/children/kidtalk.mspx +-- +module Plugin.Elite (theModule) where + +import Plugin + +import Control.Arrow +import Control.Monad.State + +PLUGIN Elite + +instance Module EliteModule () where + moduleCmds _ = ["elite"] + moduleHelp _ _ = "elite . Translate English to elitespeak" + process_ _ _ args = ios $ + case words args of + [] -> return "Say again?" + wds -> do let instr = map toLower (unwords wds) + transWords <- translate instr + return transWords + +translate :: MonadIO m => String -> m String +translate [] = return [] +translate str = case alts of + [] -> do rest <- translate (tail str) + return (head str : rest) + _ -> do (subst,rest) <- liftIO $ stdGetRandItem alts + translatedRest <- translate rest + return (subst ++ translatedRest) + where alts = (map (\ (Just (_,_,rest,_),subst) -> (subst,rest)) $ + filter isJustEmpty $ + map (\ (regex, subst) -> (matchRegexAll regex str,subst)) $ + ruleList) + ++ [([toUpper $ head str],tail str) + ,([head str],tail str) + ] + + +isJustEmpty :: (Maybe([a],b,c,d),e) -> Bool +isJustEmpty (Just ([],_,_,_),_) = True +isJustEmpty (_,_) = False + +ruleList :: [(Regex,String)] +ruleList = map (first mkRegex) + [("a","4") + ,("b","8") + ,("c","(") + ,("ck","xx") + ,("cks ","x ") + ,(" cool "," kewl ") + ,("e","3") + ,("elite","1337") + ,("f","ph") + ,(" for "," 4 ") + ,("g","9") + ,("h","|-|") + ,("k","x") + ,("l","|") + ,("l","1") + ,("m","/\\/\\") + ,("o","0") + ,("ph","f") + ,("s","z") + ,("s","$") + ,("s","5") + ,("s ","z0rz ") + ,("t","7") + ,("t","+") + ,("v","\\/") + ,("w","\\/\\/") + ,(" you "," u ") + ,(" you "," joo ") + ,("z","s") + ] + diff --git a/Plugin/Eval.hs b/Plugin/Eval.hs new file mode 100644 --- /dev/null +++ b/Plugin/Eval.hs @@ -0,0 +1,128 @@ +-- +-- Copyright (c) 2004-6 Donald Bruce Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | A Haskell evaluator for the pure part, using plugs +-- +module Plugin.Eval where + +import Plugin +import Lib.Parser + +PLUGIN Plugs + +instance Module PlugsModule () where + moduleCmds _ = ["run"] -- not "eval", clashes with perl6 bot + moduleHelp _ _ = "run \nYou have Haskell, 3 seconds and no IO. Go nuts!" + process _ _ to _ s = ios80 to (plugs s) + contextual _ _ to txt | isEval txt = ios80 to . plugs . dropPrefix $ txt + | otherwise = return [] + +binary :: String +binary = "./runplugs" + +isEval :: String -> Bool +isEval = ((evalPrefixes config) `arePrefixesWithSpaceOf`) + +dropPrefix :: String -> String +dropPrefix = dropWhile (' ' ==) . drop 2 + +plugs :: String -> IO String +plugs src = do + -- first, verify the source is actually a Haskell 98 expression, to + -- avoid code injection bugs. + case parseExpr (src ++ "\n") of + ParseFailed _ e -> return $ " " ++ e + ParseOk _ -> do + (out,err,_) <- popen binary [] (Just src) + let o = munge out + e = munge err + return $ case () of {_ + | null o && null e -> "Terminated\n" + | null o -> " " ++ e + | otherwise -> " " ++ o + } + + where munge = expandTab . dropWhile (=='\n') . dropNL . clean_ + +-- +-- Clean up runplugs' output +-- +clean_ :: String -> String +clean_ s | Just _ <- no_io `matchRegex` s = "No IO allowed\n" + | Just _ <- terminated `matchRegex` s = "Terminated\n" + | Just _ <- hput `matchRegex` s = "Terminated\n" + | Just _ <- stack_o_f `matchRegex` s = "Stack overflow\n" + | Just _ <- loop `matchRegex` s = "Loop\n" + | Just _ <- undef `matchRegex` s = "Undefined\n" + | Just _ <- type_sig `matchRegex` s = "Add a type signature\n" + | Just (_,m,_,_) <- ambiguous `matchRegexAll` s = m + | Just (_,_,b,_) <- inaninst `matchRegexAll` s = clean_ b + | Just (_,_,b,_) <- irc `matchRegexAll` s = clean_ b + | Just (_,m,_,_) <- nomatch `matchRegexAll` s = m + | Just (_,m,_,_) <- notinscope `matchRegexAll` s = m + | Just (_,m,_,_) <- hsplugins `matchRegexAll` s = m + | Just (a,_,_,_) <- columnnum `matchRegexAll` s = a + | Just (a,_,_,_) <- extraargs `matchRegexAll` s = a + | Just (_,_,b,_) <- filename' `matchRegexAll` s = clean_ b + | Just (a,_,b,_) <- filename `matchRegexAll` s = a ++ clean_ b + | Just (a,_,b,_) <- filepath `matchRegexAll` s = a ++ clean_ b + | Just (a,_,b,_) <- runplugs `matchRegexAll` s = a ++ clean_ b + | otherwise = s + where + -- s/<[^>]*>:[^:]: // + type_sig = mkRegex "add a type signature that fixes these type" + no_io = mkRegex "No instance for \\(Show \\(IO" + terminated = mkRegex "waitForProc" + stack_o_f = mkRegex "Stack space overflow" + loop = mkRegex "runplugs: <>" + irc = mkRegex "\n*:[^:]*:[^:]*:\n*" + filename = mkRegex "\n*<[^>]*>:[^:]*:\\?[^:]*:\\?\n* *" + filename' = mkRegex "/tmp/.*\\.hs[^\n]*\n" + filepath = mkRegex "\n*/[^\\.]*.hs:[^:]*:\n* *" + undef = mkRegex "Prelude.undefined" + ambiguous = mkRegex "Ambiguous type variable `a\' in the constraints" + runplugs = mkRegex "runplugs: " + notinscope = mkRegex "Variable not in scope:[^\n]*" + hsplugins = mkRegex "Compiled, but didn't create object" + extraargs = mkRegex "[ \t\n]*In the [^ ]* argument" + columnnum = mkRegex " at <[^\\.]*\\.[^\\.]*>:[^ ]*" + nomatch = mkRegex "Couldn't match[^\n]*\n" + inaninst = mkRegex "^[ \t]*In a.*$" + hput = mkRegex ": hPutStr" + +------------------------------------------------------------------------ +-- +-- Plugs tests: +-- * too long, should be terminated. +-- @plugs last [ 1 .. 100000000 ] +-- @plugs last [ 1 .. ] +-- @plugs product [1..] +-- @plugs let loop () = loop () in loop () :: () +-- +-- * stack oflow +-- @plugs scanr (*) 1 [1..] +-- +-- * type errors, or module scope errors +-- @plugs unsafePerformIO (return 42) +-- @plugs GHC.Exts.I# 1# +-- @plugs $( Language.Haskell.THSyntax.Q (putStr "heya") >> [| 3 |] ) +-- @plugs Data.Array.listArray (minBound::Int,maxBound) (repeat 0) +-- +-- * syntax errors +-- @plugs map foo bar +-- @plugs $( [| 1 |] ) +-- +-- * success +-- @plugs head [ 1 .. ] +-- @plugs [1..] +-- @plugs last $ sort [1..100000 ] +-- @plugs let fibs = 1:1:zipWith (+) fibs (tail fibs) in take 20 fibs +-- @plugs sort [1..10000] +-- @plugs ((error "throw me") :: ()) +-- @plugs Random.randomRs (0,747737437443734::Integer) (Random.mkStdGen 1122) +-- +-- More at http://www.scannedinavian.org/~shae/joyXlogs.txt +-- diff --git a/Plugin/Fact.hs b/Plugin/Fact.hs new file mode 100644 --- /dev/null +++ b/Plugin/Fact.hs @@ -0,0 +1,79 @@ +-- +-- Module : Fact +-- Copyright : 2003 Shae Erisson +-- Copyright : 2005-06 Don Stewart +-- +-- License: lGPL +-- +-- Quick ugly hack to get factoids in lambdabot. This is a rewrite of +-- Shae's original code to use internal module states. jlouis +-- +module Plugin.Fact (theModule) where + +import Plugin +import qualified Data.Map as M +import qualified Data.ByteString.Char8 as P + +------------------------------------------------------------------------ + +PLUGIN Fact + +type FactState = M.Map P.ByteString P.ByteString +type FactWriter = FactState -> LB () +type Fact m a = ModuleT FactState m a + +instance Module FactModule FactState where + + moduleCmds _ = ["fact","fact-set","fact-delete" + ,"fact-cons","fact-snoc","fact-update"] + moduleHelp _ s = case s of + "fact" -> "fact , Retrieve a fact from the database" + "fact-set" -> "Define a new fact, guard if exists" + "fact-update" -> "Define a new fact, overwriting" + "fact-delete" -> "Delete a fact from the database" + "fact-cons" -> "cons information to fact" + "fact-snoc" -> "snoc information to fact" + _ -> "Store and retrieve facts from a database" + + moduleDefState _ = return $ M.empty + moduleSerialize _ = Just mapPackedSerial + + process_ _ cmd rest = + list $ withMS $ \factFM writer -> case words rest of + [] -> return "I can not handle empty facts." + (fact:dat) -> processCommand factFM writer + (P.pack $ lowerCaseString fact) + cmd + (P.pack $ unwords dat) + +------------------------------------------------------------------------ + +processCommand :: FactState -> FactWriter + -> P.ByteString -> String -> P.ByteString -> Fact LB String +processCommand factFM writer fact cmd dat = case cmd of + "fact" -> return $ getFact factFM fact + "fact-set" -> updateFact True factFM writer fact dat + "fact-update" -> updateFact False factFM writer fact dat + "fact-cons" -> alterFact ((dat `P.append` (P.pack " ")) `P.append`) factFM writer fact + "fact-snoc" -> alterFact (P.append ((P.pack " ") `P.append` dat)) factFM writer fact + "fact-delete" -> writer ( M.delete fact factFM ) >> return "Fact deleted." + _ -> return "Unknown command." + +updateFact :: Bool -> FactState -> FactWriter -> P.ByteString -> P.ByteString -> Fact LB String +updateFact guarded factFM writer fact dat = + if guarded && M.member fact factFM + then return "Fact already exists, not updating" + else writer ( M.insert fact dat factFM ) >> return "Fact recorded." + +alterFact :: (P.ByteString -> P.ByteString) + -> FactState -> FactWriter -> P.ByteString -> Fact LB String +alterFact f factFM writer fact = + case M.lookup fact factFM of + Nothing -> return "A fact must exist to alter it" + Just x -> do writer $ M.insert fact (f x) factFM + return "Fact altered." + +getFact :: M.Map P.ByteString P.ByteString -> P.ByteString -> String +getFact fm fact = case M.lookup fact fm of + Nothing -> "I know nothing about " ++ P.unpack fact + Just x -> P.unpack fact ++ ": " ++ P.unpack x diff --git a/Plugin/Fresh.hs b/Plugin/Fresh.hs new file mode 100644 --- /dev/null +++ b/Plugin/Fresh.hs @@ -0,0 +1,26 @@ +-- +-- | Haskell project name generation +-- semi-joke +-- +module Plugin.Fresh (theModule) where + +import Plugin + +PLUGIN Fresh + +instance Module FreshModule Integer where + moduleCmds _ = ["freshname"] + moduleHelp _ _ = "freshname. Return a unique Haskell project name." + moduleDefState _ = return 0 + moduleSerialize _ = Just stdSerial + process_ _ _ _ = withMS $ \n f -> do + f (n+1) + return ["Ha" ++ reverse (freshname n)] + +freshname :: Integer -> String +freshname i + | i == 0 = [chr (ord 'a')] + | r == 0 = [chr (ord 'a' + (fromIntegral a))] + | otherwise = chr (ord 'a' + (fromIntegral a)) : freshname r + where + (r,a) = i `quotRem` 26 diff --git a/Plugin/Haddock.hs b/Plugin/Haddock.hs new file mode 100644 --- /dev/null +++ b/Plugin/Haddock.hs @@ -0,0 +1,29 @@ +-- +-- | Hackish Haddock module. +-- +module Plugin.Haddock (theModule) where + +import Plugin + +import qualified Data.Map as M +import qualified Data.ByteString.Char8 as P + +PLUGIN Haddock + +type HaddockState = M.Map P.ByteString [P.ByteString] + +instance Module HaddockModule HaddockState where + moduleCmds _ = ["index"] + moduleHelp _ _ = "index . Returns the Haskell modules in which is defined" + moduleDefState _ = return M.empty + moduleSerialize _ = Just $ Serial { deserialize = Just . readPacked + , serialize = const Nothing } + process_ _ _ rest = do + assocs <- readMS + return . (:[]) $ maybe "bzzt" (concatWith ", " . (map P.unpack)) + (M.lookup (P.pack (stripParens rest)) assocs) + +-- | make \@index ($) work. +stripParens :: String -> String +stripParens = reverse . dropWhile (==')') . reverse . dropWhile (=='(') + diff --git a/Plugin/Hello.hs b/Plugin/Hello.hs new file mode 100644 --- /dev/null +++ b/Plugin/Hello.hs @@ -0,0 +1,12 @@ +-- +-- | Hello world plugin +-- +module Plugin.Hello where + +PLUGIN Hello + +instance Module Hello () where + moduleCmds _ = ["hello","goodbye"] + moduleHelp _ = "hello/goodbye . Simplest possible plugin" + process_ _ xs = return ["Hello world. " ++ xs] + diff --git a/Plugin/Help.hs b/Plugin/Help.hs new file mode 100644 --- /dev/null +++ b/Plugin/Help.hs @@ -0,0 +1,41 @@ +-- +-- | Provide help for plugins +-- +module Plugin.Help (theModule) where + +import Plugin +import Control.Exception (Exception(..), evaluate) + +PLUGIN Help + +instance Module HelpModule () where + moduleHelp _ _ = "help . Ask for help for . Try 'list' for all commands" + moduleCmds _ = ["help"] + process_ _ cmd rest = doHelp cmd rest + +doHelp :: String -> [Char] -> ModuleLB () +doHelp cmd [] = doHelp cmd "help" + +-- +-- If a target is a command, find the associated help, otherwise if it's +-- a module, return a list of commands that module implements. +-- +doHelp cmd rest = + withModule ircCommands arg -- see if it is a command + (withModule ircModules arg -- else maybe it's a module name + (doHelp cmd "help") -- else give up + (\md -> do -- its a module + let ss = moduleCmds md + let s | null ss = arg ++ " is a module." + | otherwise = arg ++ " provides: " ++ showClean ss + return [s])) + + -- so it's a valid command, try to find its help + (\md -> do + s <- catchError (liftIO $ evaluate $ moduleHelp md arg) $ \e -> + case e of + IRCRaised (NoMethodError _) -> return "This command is unknown." + _ -> throwError e + return [s]) + + where (arg:_) = words rest diff --git a/Plugin/Hoogle.hs b/Plugin/Hoogle.hs new file mode 100644 --- /dev/null +++ b/Plugin/Hoogle.hs @@ -0,0 +1,71 @@ +-- +-- Copyright (c) 2004-5 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- Talk to Neil Mitchell's `Hoogle' program +-- + +module Plugin.Hoogle (theModule) where + +import Plugin + +PLUGIN Hoogle + +type HoogleState = [String] + +instance Module HoogleModule HoogleState where + moduleDefState _ = return [] + moduleCmds _ = ["hoogle", "hoogle+"] + moduleHelp _ _ = "hoogle . Haskell API Search for either names, or types." + + process_ _ "hoogle" s = do + o <- io (hoogle s) + let (this,that) = splitAt 3 o + writeMS that + return [unlines this] + + process_ _ "hoogle+" _ = do + this <- withMS $ \st write -> do + let (this,that) = splitAt 3 st + write that + return this + return [unlines this] + +------------------------------------------------------------------------ + +hoogleBinary :: FilePath +hoogleBinary = "./hoogle" + +hoogleText :: FilePath +hoogleText = "./scripts/hoogle/src/hoogle.txt" + +-- arbitrary cutoff point +cutoff :: Int +cutoff = -10 + +-- | Actually run the hoogle binary +hoogle :: String -> IO [String] +hoogle s = do + let args = ["--count", "20" + ,"-l", hoogleText + ,"--verbose" + ,s] + (out,err,_) <- popen hoogleBinary args (Just "") + return $ result out err + + where result [] [] = ["A Hoogle error occured."] + result [] ys = [ys] + result xs _ = + let xs' = map toPair $ lines xs + res = map snd $ filter ((>=cutoff) . fst) xs' + in if null res + then ["No matches, try a more general search"] + else res + + toPair s' = let (res, meta) = break (=='@') s' + rank = takeWhile (/=' ') . drop 2 $ meta + in case readM rank :: Maybe Int of + Just n -> (n,res) + Nothing -> (0,res) diff --git a/Plugin/Instances.hs b/Plugin/Instances.hs new file mode 100644 --- /dev/null +++ b/Plugin/Instances.hs @@ -0,0 +1,132 @@ +{- | A module to output the instances of a typeclass. + Some sample input\/output: + +> lambdabot> @instances Monad +> [], ArrowMonad a, WriterT w m, Writer w, ReaderT r m, Reader r, +> StateT s m, State s, RWST r w s m, RWS r w s, ErrorT e m, Either e, +> ContT r m, Cont r, Maybe, ST s, IO +> +> lambdabot> @instances Show +> Float, Double, Integer, ST s a, [a], (a, b, c, d), (a, b, c), (a, b), +> (), Ordering, Maybe a, Int, Either a b, Char, Bool +> +> lambdabot> @instances-importing Text.Html Data.Tree Show +> Float, Double, Tree a, HtmlTable, HtmlAttr, Html, HotLink, Integer, +> ST s a, [a], (a, b, c, d), (a, b, c), (a, b), (), Ordering, Maybe a, +> Int +-} + +module Plugin.Instances where + +import Text.ParserCombinators.Parsec + +import Plugin + +type Instance = String +type ClassName = String +type ModuleName = String + +PLUGIN Instances + +instance Module InstancesModule () where + moduleCmds _ = map fst help + moduleHelp _ = fromJust . flip lookup help + process_ _ "instances" cls = fetchInstances cls + process_ _ "instances-importing" args = fetchInstancesImporting args + +-- | Lookup table for the help for this module +help :: [(String, String)] +help = [("instances", + "instances . Fetch the instances of a typeclass."), + ("instances-importing", + "instances-importing [ [ [. " ++ + "Fetch the instances of a typeclass, importing specified modules first.")] + +-- | Nice little combinator used to throw away error messages from an Either +-- and just keep a Maybe indicating the success of the computation. +eitherToMaybe :: Either a b -> Maybe b +eitherToMaybe = either (const Nothing) Just + +-- * Parsing +-- + +-- | Parse an instance declaration. Sample inputs: +-- +-- > instance Monad [] +-- > instance (Monoid w) => Monad (Writer w) +-- > instance (State s) +-- +instanceP :: ClassName -> CharParser st Instance +instanceP cls = do string "instance " + try constrained <|> unconstrained + skipMany space + -- break on the "imported from" comment or a newline. use + -- return so it typechecks. + let end = try (string "--") <|> (eof >> return " ") + anyChar `manyTill` end + where constrained = noneOf "=" `manyTill` string ("=> " ++ cls) + unconstrained = string cls + +-- | Wrapper for the instance parser. +parseInstance :: ClassName -> String -> Maybe Instance +parseInstance cls = fmap dropSpace . eitherToMaybe + . parse (instanceP cls) "GHCi output" + +-- | Split the input into a list of the instances, then run each instance +-- through the parser. Collect successes. +getInstances :: String -> ClassName -> [Instance] +getInstances s cls | Nothing <- classDeclP + -- can't trust those dodgy folk in #haskell + = ["Not a class! Perhaps you need to import the " ++ + " module that defines it? Try @help instances-importing."] + | otherwise = sort $ mapMaybe doParse (tail splut) + where classDeclP = matchRegex (mkRegex $ "class.*" ++ cls ++ ".*where") s + splut = split "instance" s -- splut being the past participle + -- of 'to split', obviously. :) + notOperator = all (\c -> or + [ isAlpha c, + isSpace c, + c `elem` "()" ]) + unbracket str | head str == '(' && last str == ')' && + all (/=',') str && notOperator str && str /= "()" = + init $ tail str + | otherwise = str + doParse = fmap unbracket . parseInstance cls . ("instance"++) + +-- * Delegation; interface with GHCi +-- + +-- | The standard modules we ask GHCi to load. +stdMdls :: [ModuleName] +stdMdls = controls + where monads = map ("Monad."++) + [ "Cont", "Error", "Fix", "Reader", "RWS", "ST", + "State", "Trans", "Writer" ] + controls = map ("Control." ++) $ monads ++ ["Arrow"] + +-- | Main processing function for \@instances. Takes a class name and +-- return a list of lines to output (which will actually only be one). +fetchInstances :: ClassName -> LB [String] +fetchInstances cls = ios (fetchInstances' cls stdMdls) + +-- | Main processing function for \@instances-importing. Takes the args, which +-- are words'd. The all but the last argument are taken to be the modules to +-- import, and the last is the typeclass whose instances we want to print. +fetchInstancesImporting :: String -> LB [String] +fetchInstancesImporting args = ios (fetchInstances' cls mdls) + where args' = words args + cls = last args' + mdls = nub $ init args' ++ stdMdls + +-- | Interface with GHCi to get the input for the parser, then send it through +-- the parser. +fetchInstances' :: String -> [ModuleName] -> IO String +fetchInstances' cls mdls = do + (out, err, _) <- popen (ghci config) ["-fglasgow-exts"] $ + Just (unlines [cxt, command]) + let is = getInstances out cls + return $ if null is + then err + else concatWith ", " is + where cxt = ":m " ++ unwords mdls + command = ":i " ++ cls diff --git a/Plugin/Karma.hs b/Plugin/Karma.hs new file mode 100644 --- /dev/null +++ b/Plugin/Karma.hs @@ -0,0 +1,66 @@ +-- +-- | Karma +-- +module Plugin.Karma (theModule) where + +import Plugin +import qualified Message (nick) +import qualified Data.Map as M +import Text.Printf + +PLUGIN Karma + +type KarmaState = M.Map String Integer +type Karma m a = ModuleT KarmaState m a + +instance Module KarmaModule KarmaState where + + moduleCmds _ = ["karma", "karma+", "karma-", "karma-all"] + moduleHelp _ "karma" = "karma . Return a person's karma value" + moduleHelp _ "karma+" = "karma+ . Increment someone's karma" + moduleHelp _ "karma-" = "karma- . Decrement someone's karma" + moduleHelp _ "karma-all" = "karma-all. List all karma" + + moduleDefState _ = return $ M.empty + moduleSerialize _ = Just mapSerial + + process _ _ _ "karma-all" _ = listKarma + process _ msg _ cmd rest = + case words rest of + [] -> tellKarma sender sender + (nick:_) -> do + case cmd of + "karma" -> tellKarma sender nick + "karma+" -> changeKarma 1 sender nick + "karma-" -> changeKarma (-1) sender nick + _ -> error "KarmaModule: can't happen" + where sender = Message.nick msg + +------------------------------------------------------------------------ + +getKarma :: String -> KarmaState -> Integer +getKarma nick karmaFM = fromMaybe 0 (M.lookup nick karmaFM) + +tellKarma :: String -> String -> Karma LB [String] +tellKarma sender nick = do + karma <- getKarma nick `fmap` readMS + return [concat [if sender == nick then "You have" else nick ++ " has" + ," a karma of " + ,show karma]] + +listKarma :: Karma LB [String] +listKarma = do + ks <- M.toList `fmap` readMS + let ks' = sortBy (\(_,e) (_,e') -> e' `compare` e) ks + return $ (:[]) . unlines $ map (\(k,e) -> printf " %-20s %4d" k e :: String) ks' + +changeKarma :: Integer -> String -> String -> Karma LB [String] +changeKarma km sender nick + | sender == nick = return ["You can't change your own karma, silly."] + | otherwise = withMS $ \fm write -> do + let fm' = M.insertWith (+) nick km fm + let karma = getKarma nick fm' + write fm' + return [fmt nick km (show karma)] + where fmt n v k | v < 0 = n ++ "'s karma lowered to " ++ k ++ "." + | otherwise = n ++ "'s karma raised to " ++ k ++ "." diff --git a/Plugin/LShell.hs b/Plugin/LShell.hs new file mode 100644 --- /dev/null +++ b/Plugin/LShell.hs @@ -0,0 +1,49 @@ +-- +-- Wed Dec 21 15:29:52 EST 2005 +-- +-- Copyright (c) 2005 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- A binding to Robert Dockins' Lambda Shell +-- +-- darcs get http://www.eecs.tufts.edu/~rdocki01/lambda/ +-- +module Plugin.LShell where + +import Plugin + +PLUGIN LShell + +instance Module LShellModule () where + moduleCmds _ = ["lam"] + moduleHelp _ _ = "lam \n\ + \Evaluate terms of the pure, untyped lambda calculus" <$> + "darcs get http://www.eecs.tufts.edu/~rdocki01/lambda" + + -- rule out attempts to do IO + process_ _ _ s | Just _ <- cmd `matchRegex` s = end + where end = return ["Invalid command"] + cmd = mkRegex "^ *:" + + process_ _ _ s = io (lambdashell s) + +------------------------------------------------------------------------ + +lambdashell :: String -> IO [String] +lambdashell src = do + (out,_,_) <- popen "./lambda" [] $ Just $ + ":load State/prelude.lam" <$> src <$> ":quit" + let o = let s = init . drop 11 . lines $ out + in if null s then "Terminated" else dropNL . doclean . last $ s + return [o] + +-- +-- Clean up djinn output +-- +doclean :: String -> String +doclean s | Just (a,_,b,_) <- prompt `matchRegexAll` s = a ++ doclean b + | otherwise = s + where + prompt = mkRegex ">[^\n]*\n" diff --git a/Plugin/Lambda.hs b/Plugin/Lambda.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda.hs @@ -0,0 +1,139 @@ +-- +-- | Lambda calculus interpreter +-- +module Plugin.Lambda (theModule) where + +import Plugin +import Plugin.Lambda.LMEngine (evaluate, define, resume, Environment) + +import qualified Data.Map as M +import Lib.Util (mapMaybeMap) + +import Data.Dynamic (Dynamic) + +import qualified Data.ByteString.Char8 as P + +PLUGIN Eval + +initFuel, maxFuel :: Int +initFuel = 1000 +maxFuel = 500000 -- ~ 200M mem usage for "sum $ enumFrom 1" + +maxPrivate :: Int +maxPrivate = 10 + +initEnv :: Environment +initEnv = M.empty + +initDefns :: M.Map String String +initDefns = M.empty + +outOfFuelMsg :: [Char] +outOfFuelMsg = "out of fuel - use @resume to continue" + +type EvalGlobal = (Int, Environment, M.Map String String) +type EvalState = GlobalPrivate EvalGlobal Dynamic + +instance Module EvalModule EvalState where + moduleDefState _ = return $ mkGlobalPrivate (maxPrivate) + (initFuel, initEnv, initDefns) + + moduleSerialize _ = Just $ Serial { + serialize = Just . (\(fuel,_,defns) -> + P.pack . unlines $ show fuel: map show (M.toList defns)) . global, + deserialize = fmap (mkGlobalPrivate maxPrivate) . loadDefinitions . P.unpack + } + + moduleHelp _ s = case s of + "lambda" -> "lambda . Evaluate the lambda calculus expression, " + "define" -> "define . Define name to be expr" + "get-definition" -> "get-definition . Get the expression defining name" + "definitions" -> "definitions . Get the definitions starting with prefix" + "del-definition" -> "del-definition . Delete name" + "set-fuel" -> "set-fuel . How many ticks before @lambda runs out of fuel" + "resume" -> "resume. Continue an expression that has run out of fuel" + + moduleCmds _ = ["lambda","define","get-definition","definitions","resume"] + modulePrivs _ = ["set-fuel","del-definition"] + + process _ _ target cmd rest = do + let writeRes = writePS target + (fuel, env, defns) <- readGS + res <- readPS target + case cmd of + "lambda" -> do + let r_or_s = evaluate rest env fuel + case r_or_s of + Right s -> writeRes Nothing >> return [s] + Left nr -> writeRes (Just nr) >> return [outOfFuelMsg] + + "define" -> + let rslt = define defn + (nm,defn) = break (' '==) rest + in case rslt of + Left s -> return [s] + Right v -> do + withGS $ \(fuel', env', defns') writer -> do + writer (fuel', M.insert nm v env', + M.insert nm defn defns') + return [nm ++ " defined"] + + "definitions" -> + let nm = M.keys defns + in return . (:[]) $ if null rest + then unlines $ map show $ + groupBy (\(x:_) (y:_) -> x == y) $ nm + else show [x | x <- sort nm, rest `isPrefixOf` x] + + "get-definition" -> + let defn = M.lookup rest defns + out = maybe (rest++" not defined") ((rest++" =")++) defn + in return [out] + + "set-fuel" -> case readM rest of + Nothing -> return ["Not a number"] + Just x -> if x > 0 && x <= maxFuel + then do writeGS (x,env,defns) + return ["Fuel set to "++show x] + else return ["Can't set fuel above "++show maxFuel] + + "del-definition" -> case words rest of + (d:_) -> do + withGS $ \(fuel',env',defns') writer -> + writer (fuel', M.delete d env', M.delete d defns') + return [d++" removed"] + _ -> return [] + + "resume" -> case res of + Nothing -> return [] + Just r -> case resume r fuel of + Left nr -> do + writeRes $ Just nr + return [outOfFuelMsg] + Right s -> do + writeRes Nothing + return [s] + +-- +-- this is so ugly (at least it's only init) +-- +-- This stuff is slow +-- +loadDefinitions :: String -> Maybe EvalGlobal +loadDefinitions s = do + -- grab fuel val from definitions. + fuel':rest <- return $ lines s + fuel <- readM fuel' + -- rest is a list of paris of ids and rhs defins + let rests = mapMaybe readM rest + -- parse the lot. :/ + let dMap = M.fromList $! rests + eMap = mapMaybeMap ((const Nothing `either` \x -> Just $! x) . define) $ dMap + + keys = M.keys eMap + + fuel `seq` eMap `seq` dMap `seq` return + (fuel, + eMap, + M.filterWithKey (\k _ -> k `elem` keys) dMap) + diff --git a/Plugin/Lambda/ArithTerm.hs b/Plugin/Lambda/ArithTerm.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/ArithTerm.hs @@ -0,0 +1,43 @@ + +module Plugin.Lambda.ArithTerm where + +import Plugin.Lambda.LangPack + +import Data.Dynamic +import Control.Monad.Error + +data ArithTerm term + = Num !Integer + | Neg term + | Add term term + | Sub term term + | Mul term term + | Div term term + +prjI :: (MonadError String m) => m Dynamic -> m Integer +prjI = prj' + +phiArith :: (MonadError String m) => ArithTerm (m Dynamic) -> m Dynamic +phiArith (Num n) = return (inj n) +phiArith (Neg n) = do n' <- prjI n; return $ inj (-n') +phiArith (Add l r) = do l' <- prjI l + r' <- prjI r + return $ inj (l' + r') +phiArith (Sub l r) = do l' <- prjI l + r' <- prjI r + return $ inj (l' - r') +phiArith (Mul l r) = do l' <- prjI l + r' <- prjI r + return $ inj (l' * r') +phiArith (Div l r) = do l' <- prjI l + r' <- prjI r + if r' == 0 then throwError "divide by zero" + else return $ inj (l' `div` r') + +instance Functor ArithTerm where + fmap _ (Num n) = Num n + fmap f (Neg n) = Neg (f n) + fmap f (Add l r) = Add (f l) (f r) + fmap f (Sub l r) = Sub (f l) (f r) + fmap f (Mul l r) = Mul (f l) (f r) + fmap f (Div l r) = Div (f l) (f r) diff --git a/Plugin/Lambda/COPYING b/Plugin/Lambda/COPYING new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/COPYING @@ -0,0 +1,20 @@ +Copyright (c) 2003 Derek Elkins + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject +to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Plugin/Lambda/LMEngine.hs b/Plugin/Lambda/LMEngine.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/LMEngine.hs @@ -0,0 +1,192 @@ +{-# OPTIONS -fallow-overlapping-instances #-} +-- until we fix it properly + +module Plugin.Lambda.LMEngine ( + evaluate, + define, + Environment, + resume + ) where + +import Plugin.Lambda.LangPack +import Plugin.Lambda.ArithTerm +import Plugin.Lambda.LambdaTerm +import Plugin.Lambda.RelTerm +import Plugin.Lambda.ListTerm +import Plugin.Lambda.LMParser + +import Data.Map (Map) +import qualified Data.Map as Map hiding (Map) + +import Data.Maybe (fromJust) +import Data.Dynamic +import Control.Monad.State +import Control.Monad.Reader +import Control.Monad.Error +import Control.Monad.Cont +import Control.Monad.Identity + +import Text.ParserCombinators.Parsec.Error (ParseError) + +-- temporarily +-- import Maybe +-- import Debug.Trace + +------------------------------------------------------------------------ + +-- TODO: replace showTerm + +evaluate :: String -> Environment -> Int -> Either Dynamic String +evaluate s env fuel = eval env fuel $ parseTerm s + +define :: String -> Either String (EvalMonad Value) +define = either (Left . show) (Right . fold phi) . parseTerm + +type Environment = Map String (EvalMonad Value) +type Value = Dynamic +type Result = Either Dynamic (Either String String) + +newtype EvalMonad a = EM { runEM :: (StateT (IState EvalMonad) + (ReaderT Environment + (ErrorT String + (Cont Result)))) a } + deriving Typeable + +phi :: Term (EvalMonad Value) -> EvalMonad Value +phi (ArithT x) = phiArith x +phi (LambdaT x) = phiLambda x +phi (RelT x) = phiRel x +phi (ListT x) = phiList x + +run :: EvalMonad Value -> Environment -> Int -> Result +run m env fuel = flip runCont Right $ + runErrorT $ + runReaderT (evalStateT (runEM (m >>= showDyn)) (0,Map.empty,fuel)) env + +eval :: Environment -> Int -> Either ParseError (Fix Term) -> Either Dynamic String +eval env fuel = either (Right . show) doit + where doit x = -- trace (x `seq` showTerm x) $ + res_or_str $ run (do env' <- startup + local (const $ Map.fromList env') + (fold phi x)) + Map.empty fuel + startup = Map.foldWithKey mkThunk (return []) env + mkThunk k c cs = do env' <- cs + rr <- thunkify c + return ((k,rr):env') + + +res_or_str :: Either a (Either b b) -> Either a b +res_or_str = either Left (either Right Right) + + +-- TODO: get rid of fromJust +resume :: Dynamic -> Int -> Either Dynamic String +resume r i = res_or_str $ fromJust (fromDynamic r) i + +showDyn :: Dynamic -> EvalMonad String +showDyn d = case (fromDynamic d :: Maybe Integer) of { + Just i -> return $ show i; + _ -> + case (fromDynamic d :: Maybe Bool) of { + Just b -> return $ show b; + _ -> + case (fromDynamic d :: Maybe Char) of { + Just c -> return [c]; + _ -> + case (fromDynamic d :: Maybe ()) of { + Just _ -> return "[]"; + _ -> + case (fromDynamic d :: Maybe (EvalMonad Dynamic, EvalMonad Dynamic)) of { + Just l -> (do b <- foldList (\x y -> do + b <- isCharacter x + liftM (b&&) y) + (return True) (return d) + if b then showListDyn "" l + else do x <- showListDyn ", " l + return $ "["++x++"]"); + _ -> return $ show d; + }}}}} + +showListDyn :: String -> (EvalMonad Dynamic, EvalMonad Dynamic) -> EvalMonad String +showListDyn sep (hd,tl) = do + hd' <- hd + tl' <- tl + case (fromDynamic tl' :: Maybe ()) of { + Just _ -> showDyn hd'; + Nothing -> + case (fromDynamic tl' :: Maybe (EvalMonad Dynamic,EvalMonad Dynamic)) of { + Just p -> (do hs <- showDyn hd';ts <- showListDyn sep p;return $ hs++sep++ts); + Nothing -> throwError "type error" + }} + +{- +showTerm :: Fix Term -> [Char] +showTerm (In f) = showIn f + where showIn (ArithT t) = showArithTerm t + showIn (LambdaT t) = showLambdaTerm t + showIn (RelT t) = showRelTerm t + showIn (ListT t) = showListTerm t + showArithTerm (Num n) = "(Num "++show n++")" + showArithTerm (Neg n) = "(Neg "++showTerm n++")" + showArithTerm (Add l r) = "(Add "++showTerm l++" "++showTerm r++")" + showArithTerm (Sub l r) = "(Sub "++showTerm l++" "++showTerm r++")" + showArithTerm (Mul l r) = "(Mul "++showTerm l++" "++showTerm r++")" + showArithTerm (Div l r) = "(Div "++showTerm l++" "++showTerm r++")" + showLambdaTerm (Var v) = "(Var "++v++")" + showLambdaTerm (Lam v b) = "(Lam "++v++" "++showTerm b++")" + showLambdaTerm (App f' x) = "(App "++showTerm f'++" "++showTerm x++")" + showRelTerm (Not x) = "(Not "++showTerm x++")" + showRelTerm (Or l r) = "(Or "++showTerm l++" "++showTerm r++")" + showRelTerm (And l r) = "(And "++showTerm l++" "++showTerm r++")" + showRelTerm (Boolean b) = "(Boolean "++show b++")" + showRelTerm (IfE c t e) = "(If "++showTerm c++" "++showTerm t++" "++showTerm e++")" + showRelTerm (Equal l r) = "(Equal "++showTerm l++" "++showTerm r++")" + showRelTerm (NotEqual l r) = "(NotEqual "++showTerm l++" "++showTerm r++")" + showRelTerm (LessThan l r) = "(LessThan "++showTerm l++" "++showTerm r++")" + showRelTerm (GreaterThan l r) = "(GreaterThan "++showTerm l++" "++showTerm r++")" + showRelTerm (LessThanOrEqual l r) = "(LessThanOrEqual "++showTerm l++" "++showTerm r++")" + showRelTerm (GreaterThanOrEqual l r) = "(GreaterThanOrEqual "++showTerm l++" "++showTerm r++")" + showListTerm Nil = "Nil" + showListTerm (Character c) = "(Character '"++c:"')" + showListTerm (Head l) = "(Head "++showTerm l++")" + showListTerm (Tail l) = "(Tail "++showTerm l++")" + showListTerm (Null l) = "(Null "++showTerm l++")" + showListTerm (Cons l r) = "(Cons "++showTerm l++" "++showTerm r++")" + showListTerm (Append l r) = "(Append "++showTerm l++" "++showTerm r++")" +-} + +instance Pause EvalMonad Result where + pause = EM . lift . lift . lift . Cont + +-- TODO: +-- I need to find a better way to break the circular dependency between +-- Environment and EvalMonad +-- Comment out what isn't true, uncomment what is + +instance Monad EvalMonad where + return = EM . return + (EM m) >>= f = EM $ m >>= (runEM . f) + +-- TODO: make an appropriate instance +instance MonadCont EvalMonad where + callCC = error "EvalModule/LMEngine: no default instance for callCC" + +instance MonadError String EvalMonad where + catchError (EM m) f = EM $ catchError m (runEM . f) + throwError = EM . throwError + +instance MonadState (IState EvalMonad) EvalMonad where + put = EM . put + get = EM get + +instance MonadReader Environment EvalMonad where + local f (EM m) = EM $ local f m + ask = EM ask + +{- this probably won't work without editting +instance MonadWriter EvalMonad where + pass = EM . pass + listen = EM . listen + tell = EM . tell +-} diff --git a/Plugin/Lambda/LMParser.hs b/Plugin/Lambda/LMParser.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/LMParser.hs @@ -0,0 +1,190 @@ + +-- +-- screw modularity (at least temporarily) +-- +module Plugin.Lambda.LMParser (parseTerm,Term(..)) where + +import Plugin.Lambda.LangPack +import Plugin.Lambda.ArithTerm (ArithTerm(..)) +import Plugin.Lambda.LambdaTerm (LambdaTerm(..)) +import Plugin.Lambda.RelTerm (RelTerm(..)) +import Plugin.Lambda.ListTerm (ListTerm(..)) + +import Text.ParserCombinators.Parsec +import Text.ParserCombinators.Parsec.Expr +import Text.ParserCombinators.Parsec.Language (emptyDef, reservedNames) +import qualified Text.ParserCombinators.Parsec.Token as P hiding (reservedNames) + +tp :: P.TokenParser st +tp = P.makeTokenParser + (emptyDef { reservedNames = + ["if","then","else","True","False","head","tail","null"] }) +{-# INLINE tp #-} + +-- integer :: CharParser st Integer +-- integer = P.integer tp + +natural :: CharParser st Integer +natural = P.natural tp + +boolean :: GenParser Char st Bool +boolean = (reserved "True" >> return True) + <|> (reserved "False" >> return False) + +reserved :: String -> CharParser st () +reserved = P.reserved tp + +symbol :: String -> CharParser st String +symbol = P.symbol tp + +parens, brackets :: CharParser st a -> CharParser st a +parens = P.parens tp +brackets = P.brackets tp + +identifier, dot, comma :: CharParser st String +identifier = P.identifier tp +dot = P.dot tp +comma = P.comma tp + +charLiteral :: CharParser st Char +charLiteral = P.charLiteral tp + +stringLiteral :: CharParser st String +stringLiteral = P.stringLiteral tp + +identStart, identLetter :: CharParser st Char +identStart = P.identStart emptyDef +identLetter = P.identLetter emptyDef + +class Up f x where + up :: f x -> x + +data Term x + = ArithT (ArithTerm x) + | LambdaT (LambdaTerm x) + | RelT (RelTerm x) + | ListT (ListTerm x) + +type Term' = Fix Term + +instance Functor Term where + fmap f (ArithT x) = ArithT (fmap f x) + fmap f (LambdaT x) = LambdaT (fmap f x) + fmap f (RelT x) = RelT (fmap f x) + fmap f (ListT x) = ListT (fmap f x) + +instance Up ArithTerm Term' where + up = In . ArithT + +instance Up LambdaTerm Term' where + up = In . LambdaT + +instance Up RelTerm Term' where + up = In . RelT + +instance Up ListTerm Term' where + up = In . ListT + +-- up' :: (Up f x) => Parser (f x) -> Parser x +-- up' p = p >>= return . up + +up2 :: (Up f x) => (t -> t1 -> f x) -> t -> t1 -> x +up2 f = (\x y -> up $ f x y) + +parseTerm :: [Char] -> Either ParseError Term' +parseTerm = parse (do spaces; r <- parser';eof; return r) "" + +application :: GenParser Char () Term' +application = do v <- (var <|> listOp) + es <- many (var <|> listOp <|> literal <|> parens parser') + case es of + [] -> return v + es'-> return $ foldl1 (up2 App) (v:es') + +parser' :: GenParser Char () Term' +parser' = do e <- expr + es <- many expr' + case es of + [] -> return e + es'-> return $ foldl1 (up2 App) (e:es') + +var :: GenParser Char st Term' +var = (identifier >>= return . up . Var) "var" + +-- var without stripping trailing spaces +var' :: GenParser Char st Term' +var' = (do c <- identStart; cs <- many identLetter; return $ up $ Var (c:cs)) "var" + +num :: GenParser Char st Term' +num = (natural >>= return . up . Num) "num" + +bool :: GenParser Char st Term' +bool = (boolean >>= return . up . Boolean) "bool" + +character :: GenParser Char st Term' +character = (charLiteral >>= return . up . Character) "character" + +stringL :: GenParser Char st Term' +stringL = (stringLiteral >>= return . foldr (up2 Cons . up . Character) (up Nil)) "string" + +listOp :: GenParser Char st Term' +listOp = do o <- (reserved "head" >> return Head) <|> + (reserved "tail" >> return Tail) <|> + (reserved "null" >> return Null) + return $ up2 Lam "x" (up $ o $ up $ Var "x") + +list :: GenParser Char () Term' +list = do es <- brackets (parser' `sepBy` comma) + return (foldr (up2 Cons) (up Nil) es) "list" + +literal :: GenParser Char () Term' +literal = bool <|> num <|> character <|> list <|> stringL + +term :: GenParser Char () Term' -> GenParser Char () Term' +term x = x <|> literal <|> ifEx <|> listOp <|> + abstraction <|> parens parser' "simple term" + +expr :: GenParser Char () Term' +expr = buildExpressionParser table (term application) +{-# INLINE expr #-} + +expr' :: GenParser Char () Term' +expr' = buildExpressionParser table (term var) + +table :: OperatorTable Char () Term' +table = [[Infix (op "." (\f g -> Lam "#x#" $ up2 App f $ up2 App g (up $ Var "#x#"))) AssocRight, + Infix (do v <- between (char '`') (symbol "`") var'; return $ up2 App . up2 App v) AssocLeft], + [Infix (op "*" Mul) AssocLeft, Infix (try $ do char '/'; notFollowedBy (char '='); spaces; return $ up2 Div) AssocLeft], + [Infix (op "-" Sub) AssocLeft, Infix (try $ do char '+'; notFollowedBy (char '+'); spaces; return $ up2 Add) AssocLeft], + [Infix (op ":" Cons) AssocRight, Infix (op "++" Append) AssocRight], + [Infix (op "<=" LessThanOrEqual) AssocNone, Infix (op ">=" GreaterThanOrEqual) AssocNone, + Infix (op "<" LessThan) AssocNone, Infix (op ">" GreaterThan) AssocNone, + Infix (op "==" Equal) AssocNone, Infix (op "/=" NotEqual) AssocNone], + [Infix (op "&&" And) AssocRight], + [Infix (op "||" Or) AssocRight], + [Infix (op "$" App) AssocRight]] + +-- +-- This gets hammered +-- +op :: (Up f trm) => String -> (trm -> trm -> f trm) -> Parser (trm -> trm -> trm) +op s o = try $ do symbol s; return (up2 o) +{-# INLINE op #-} + +abstraction :: GenParser Char () Term' +abstraction = do symbol "\\" + vs <- many1 identifier + (dot <|> symbol "->") -- yay! + b <- parser' + return $ foldr (up2 Lam) b vs + "abstraction" + +ifEx :: GenParser Char () Term' +ifEx = do reserved "if" + c <- parser' + reserved "then" + t <- parser' + reserved "else" + e <- parser' + return $ up $ IfE c t e + "if" diff --git a/Plugin/Lambda/LambdaTerm.hs b/Plugin/Lambda/LambdaTerm.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/LambdaTerm.hs @@ -0,0 +1,97 @@ + +module Plugin.Lambda.LambdaTerm where + +import Plugin.Lambda.LangPack + +import Data.Map (Map) +import qualified Data.Map as Map hiding (Map) + +import Control.Monad.Error +import Control.Monad.State +import Control.Monad.Reader +import Control.Monad.Cont + +import Data.Dynamic + +type Fun m = (m Dynamic -> m Dynamic) + +data LambdaTerm term + = Lam !String term + | App term term + | Var !String + +type IState m = (Int,Map Int (m Dynamic),Int) -- record instead of tuple would be more robust +type Ref = Int + +prjF :: (Typeable (m Dynamic), MonadError String m) => m Dynamic -> m (Fun m) +prjF = prj' + +phiLambda :: (MonadError String m, + MonadState (IState m) m, + Typeable (m Dynamic), + Pause m (Either Dynamic b), + Typeable b, + MonadReader (Map String (m Dynamic)) m) => + LambdaTerm (m Dynamic) -> m Dynamic +phiLambda (Var v) = do step; lookupEnv v +{- +phiLambda (Lam v b) = do env <- ask + return $ inj (\v' -> do loc <- newRef undefined + let thunk = + do r <- v' + writeRef loc + (return r) + return r + writeRef loc thunk + let env' = addToFM env v (readRef loc) + inEnv env' b) +-} +phiLambda (Lam v b) = do env <- ask + return $ inj (\v' -> do rr <- thunkify v' + inEnv (Map.insert v rr env) b) +phiLambda (App f x) = do f' <- prjF f; env <- ask; f' (inEnv env x) + +thunkify :: (MonadState (IState m) m) => m Dynamic -> m (m Dynamic) +thunkify c = do + loc <- newRef (error "empty reference") + let thunk = do r <- c + writeRef loc (return r) + return r + writeRef loc thunk + return (readRef loc) + +lookupEnv :: (MonadReader (Map String (m Dynamic)) m, + Typeable (m Dynamic), + MonadError String m) => String -> m Dynamic +lookupEnv k = do env <- ask + let v = Map.lookup k env + maybe (throwError ("unbound variable: "++k)) id v + +inEnv :: (MonadReader (Map String (m Dynamic)) m) => + Map String (m Dynamic) -> m Dynamic -> m Dynamic +inEnv env b = local (const env) b + +step :: (MonadState (IState m) m, MonadError String m, + Typeable b, + Pause m (Either Dynamic b)) => m () +step = do (c,hp,fuel) <- get + if fuel == 0 then do refuel <- pause $ Left . inj + put (c,hp,refuel) + else put (c,hp,fuel-1) + +newRef :: (MonadState (IState m) m) => m Dynamic -> m Ref +newRef v = do (c,hp,fuel) <- get + put (c+1,Map.insert c v hp,fuel) + return c + +readRef :: (MonadState (IState m) m) => Ref -> m Dynamic +readRef loc = do (_,hp,_) <- get; let {Just x = Map.lookup loc hp}; x + +writeRef :: (MonadState (IState m) m) => Ref -> m Dynamic -> m () +writeRef loc v = do (c,hp,fuel) <- get + put (c,Map.insert loc v hp,fuel) + +instance Functor LambdaTerm where + fmap _ (Var v) = Var v + fmap f (Lam v b) = Lam v (f b) + fmap f (App g x) = App (f g) (f x) diff --git a/Plugin/Lambda/LangPack.hs b/Plugin/Lambda/LangPack.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/LangPack.hs @@ -0,0 +1,80 @@ +-- +-- | Based on (ripping) ideas from +-- /Language Prototyping using Modular Monadic Semantics/ +-- +module Plugin.Lambda.LangPack where + +import Control.Monad.Error + +import Data.Dynamic + +newtype Fix f = In { out :: f (Fix f) } + +fold :: (Functor f) => (f a -> a) -> Fix f -> a +fold phi = phi . fmap (fold phi) . out + +(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> a -> m c +f @@ g = \x -> g x >>= f + +mFold :: (MFunctor f m) => (f a -> m a) -> Fix f -> m a +mFold mPhi = mPhi @@ mMap (mFold mPhi) @@ (return . out) + +class (Functor f, Monad m) => MFunctor f m where + mMap :: (a -> m b) -> f a -> m (f b) + +class Pause m r | m -> r where + pause :: ((a -> r) -> r) -> m a + +-------------------------------------------------------------------------------- + +{- bugger it, I'll just use Dynamics +-- Functional dependencies may help +-- Extensible sums (as seen in many places e.g. +-- "Monad Transformers and Modular Interpreters") +class Subtype sub sup where + inj :: sub -> sup + prj :: sup -> Maybe sub + +instance Subtype a (Either a b) where + inj = Left + prj = either Just (const Nothing) + +instance Subtype a b => Subtype a (Either c b) where + inj = Right . inj + prj = either (const Nothing) prj +-} + +-- prj' :: (Subtype sub sup, MonadError String m) => m sup -> m sub +prj' :: (MonadError String m, Typeable a) => m Dynamic -> m a +prj' x = do x' <- x + case {-trace (show x')-} prj x' of + Nothing -> throwError "type error" + Just xr -> return xr + +inj :: (Typeable a) => a -> Dynamic +inj = toDyn + +prj :: (Typeable a) => Dynamic -> Maybe a +prj = fromDynamic + +newtype SumF f g x = S { unS :: Either (f x) (g x) } + +instance (Functor f, Functor g) => Functor (SumF f g) where + fmap f = S . either (Left . fmap f) (Right . fmap f) . unS + +-------------------------------------------------------------------------------- +-- More Labragayo, but with a some of my own concoctions +{- +class HasParser t where + parser :: Parser t + +class HasParserF f where + parserF :: (f x -> x) -> Parser x -> Parser (f x) + +instance (HasParserF f, HasParserF g) => HasParserF (SumF f g) where + parserF up parser = fmap S $ try (fmap Left (parserF (up . S . Left) parser)) <|> + fmap Right (parserF (up . S . Right) parser) + +instance (HasParserF f) => HasParser (Fix f) where + parser = fmap In (parserF In parser) +-} diff --git a/Plugin/Lambda/ListTerm.hs b/Plugin/Lambda/ListTerm.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/ListTerm.hs @@ -0,0 +1,77 @@ + +module Plugin.Lambda.ListTerm where + +import Plugin.Lambda.LangPack +import Plugin.Lambda.LambdaTerm + +import Data.Map (Map) + +import Data.Dynamic +import Control.Monad.Error +import Control.Monad.Reader + +data ListTerm term + = Nil + | Character !Char + | Head term + | Tail term + | Null term + | Cons term term + | Append term term + +prjL :: (MonadError String m, + Typeable (m Dynamic)) => m Dynamic -> m (m Dynamic, m Dynamic) +prjL = prj' + +prjN :: (MonadError String m) => m Dynamic -> m () +prjN = prj' + +prjC :: (MonadError String m) => m Dynamic -> m Char +prjC = prj' + +phiList :: (MonadError String m, + MonadReader (Map String (m Dynamic)) m, + Typeable (m Dynamic)) => ListTerm (m Dynamic) -> m Dynamic +phiList Nil = return $ inj () +phiList (Character c) = return $ inj c +-- TODO: double evaluation of l +phiList (Head l) = do b <- isNull l; if b then throwError "head of empty list" + else prjL l >>= fst +phiList (Tail l) = do b <- isNull l; if b then throwError "tail of empty list" + else prjL l >>= snd +phiList (Null l) = do b <- isNull l; if b then return (inj True) + else do prjL l; return (inj False) +-- TODO: this is call-by-name, not call-by-need +phiList (Cons l r) = do env <- ask; return $ inj (inEnv env l,inEnv env r) +phiList (Append l r) = do env <- ask + foldList (\x y -> return $ inj (x,y)) + (inEnv env r) + (inEnv env l) + +isNull :: (Monad m) => m Dynamic -> m Bool +isNull m = do d <- m; case (fromDynamic d :: Maybe ()) of + Just _ -> return True + Nothing -> return False + +isCharacter :: (Monad m) => m Dynamic -> m Bool +isCharacter m = do d <- m; case (fromDynamic d :: Maybe Char) of + Just _ -> return True + Nothing -> return False + +foldList :: (MonadError String m, Typeable (m Dynamic)) => + (m Dynamic -> m a -> m a) -> + m a -> m Dynamic -> m a +foldList c n l = do + b <- isNull l + if b then n + else do (f,r) <- prjL l + c f $ foldList c n r + +instance Functor ListTerm where + fmap _ Nil = Nil + fmap _ (Character c) = Character c + fmap f (Head l) = Head (f l) + fmap f (Tail l) = Tail (f l) + fmap f (Null l) = Null (f l) + fmap f (Cons l r) = Cons (f l) (f r) + fmap f (Append l r) = Append (f l) (f r) diff --git a/Plugin/Lambda/RelTerm.hs b/Plugin/Lambda/RelTerm.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/RelTerm.hs @@ -0,0 +1,68 @@ + +module Plugin.Lambda.RelTerm where + +import Plugin.Lambda.LangPack +import Plugin.Lambda.ArithTerm (prjI) +import Plugin.Lambda.ListTerm (prjC,prjL,prjN) + +import Data.Dynamic +import Control.Monad.Error + +data RelTerm term + = Boolean !Bool + | And term term + | Or term term + | Not term + | Equal term term + | NotEqual term term + | LessThan term term + | GreaterThan term term + | LessThanOrEqual term term + | GreaterThanOrEqual term term + | IfE term term term + +prjB :: (MonadError String m) => m Dynamic -> m Bool +prjB = prj' + +doOp :: (MonadError String m, Typeable (m Dynamic)) => (forall a.Ord a => a -> a -> Bool) -> + m Dynamic -> m Dynamic -> m Dynamic +doOp op l r + = catchError (do l' <- prjI l; r' <- prjI r; return $ inj (l' `op` r')) + (\_ -> catchError (do l' <- prjC l; r' <- prjC r; return $ inj (l' `op` r')) + (\_ -> catchError (do l' <- prjB l; r' <- prjB r; return $ inj (l' `op` r')) + (\_ -> catchError (do l' <- prjN l; r' <- prjN r; return $ inj (l' `op` r')) + (\_ -> catchError (do _ <- prjL l; _ <- prjN r; return $ inj False) + (\_ -> catchError (do _ <- prjN l; _ <- prjL r; return $ inj False) + (\_ -> catchError (do (a,b) <- prjL l + (x,y) <- prjL r + s <- prjB $ doOp op a x + t <- prjB $ doOp op b y + return $ inj (s && t)) + throwError)))))) + +phiRel :: (MonadError String m, Typeable (m Dynamic)) => RelTerm (m Dynamic) -> m Dynamic +phiRel (Boolean b) = return (inj b) +phiRel (IfE c t e) = do b <- prjB c + if b then t else e +phiRel (Equal l r) = doOp (==) l r +phiRel (NotEqual l r) = doOp (/=) l r +phiRel (LessThan l r) = doOp (<) l r +phiRel (GreaterThan l r) = doOp (>) l r +phiRel (LessThanOrEqual l r) = doOp (<=) l r +phiRel (GreaterThanOrEqual l r) = doOp (>=) l r +phiRel (And l r) = do l' <- prjB l; if not l' then return $ inj False else do r' <- prjB r; return $ inj (l' && r') +phiRel (Or l r) = do l' <- prjB l; if l' then return $ inj True else do r' <- prjB r; return $ inj (l' || r') +phiRel (Not x) = do x' <- prjB x; return $ inj (not x') + +instance Functor RelTerm where + fmap f (Not x) = Not (f x) + fmap f (Or l r) = Or (f l) (f r) + fmap f (And l r) = And (f l) (f r) + fmap _ (Boolean b) = (Boolean b) + fmap f (IfE c t e) = IfE (f c) (f t) (f e) + fmap f (Equal l r) = Equal (f l) (f r) + fmap f (NotEqual l r) = NotEqual (f l) (f r) + fmap f (LessThan l r) = LessThan (f l) (f r) + fmap f (GreaterThan l r) = GreaterThan (f l) (f r) + fmap f (LessThanOrEqual l r) = LessThanOrEqual (f l) (f r) + fmap f (GreaterThanOrEqual l r) = GreaterThanOrEqual (f l) (f r) diff --git a/Plugin/Lambda/tests.hs b/Plugin/Lambda/tests.hs new file mode 100644 --- /dev/null +++ b/Plugin/Lambda/tests.hs @@ -0,0 +1,153 @@ +module Main where + +import Plugin.Lambda.LMEngine (evaluate, define) + +#if __GLASGOW_HASKELL__ >= 604 +import Test.HUnit +#else +import HUnit +#endif + +-- import QuickCheck +-- import QuickCheckM + +import qualified Map (empty) + + +-- TODO: add tests for define, need to test List interactions (e.g. 1+head l) + +main = runTestTT tests >>= print + +tests = TestList + [ + test_Arith, + test_Rel, + test_List, + test_Lambda, + test_Misc, + list_ender -- for rearranging and removing tests + ] + +list_ender = TestCase $ return () + +typeErrorMsg = "type error" +-- outOfFuelMsg = "out of fuel" +divideByZeroMsg = "divide by zero" +unboundVariableMsg = "unbound variable" +tailMsg = "tail of empty list" +headMsg = "head of empty list" + +infFuel = -1 +emptyEnv = Map.empty + +-- no label +genericTest' :: String -> String -> Test +genericTest' expected code = expected ~=? case evaluate code emptyEnv infFuel of + Left _ -> error "shouldn't get here" + Right s -> s + +-- labelled with code +genericTest :: String -> String -> Test +genericTest expected code = genericTestLbl code expected code + +-- explicit label +genericTestLbl :: String -> String -> String -> Test +genericTestLbl lbl expected code = lbl ~: genericTest' expected code + +-- The tests ------------------------------------------------------------------- + +-- Arith -- + +test_Arith = TestLabel "Arith" $ TestList + [ + genericTest "-85" "4 + 3-2*(6+5*8)", + genericTest divideByZeroMsg "1/0", + genericTest "5" "5", + list_ender + ] + +-- Lambda -- + +test_Lambda = TestLabel "Lambda" $ TestList + [ + genericTest "10" "(\\x.x) 10", + genericTest "5" "(\\x.x+3) 2", + genericTestLbl "factorial" "120" "(\\f.(\\x.f(x x))(\\x.f(x x)))(\\fac n.if n == 0 then 1 else n*fac (n-1)) 5", + genericTest "10" "(\\n.if n == 0 then n+3 else n+5) 5", + genericTest "12" "(\\f.f 7) ((\\x y.x+y) 5)", + genericTest "0" "(\\f.(\\x.f(x x))(\\x.f(x x)))(\\count n.if n==0 then 0 else count (n-1)) 1000", + genericTest "15" "(\\S K I g f.(S (S (K S) (K I)) (S (K K) I)) g f) (\\f g x.f x (g x)) (\\r t.r) (\\l.l) 5 (\\m.m+10)", + genericTest "14" "(\\x.x*2) $ 4+3", + genericTest "-6" "((\\x.x*3) . (\\x.x-2)) 0", + list_ender + ] + +-- Rel -- + +test_Rel = TestLabel "Rel" $ TestList + [ + genericTest "True" "if 10 == 10 then True else False", + genericTest "True" "5 == 5", + genericTest "True" "5 /= 6", + genericTest "False" "5 /= 5", + genericTest "False" "5 == 6", + genericTest "True" "5 <= 6", + genericTest "False" "5 >= 6", + genericTest "True" "5 < 6", + genericTest "False" "5 > 6", + genericTest "True" "5 == 10 || 6 == 6", + genericTest "False" "5 == 10 && 6 == 6", + genericTest "True" "True == True", + genericTest "False" "'b' == 'c'", + genericTest "True" "[] == []", + genericTest "True" "[5,\"aoe\"] == [5,\"aoe\"]", + genericTest "True" "null [] || 5 <= 6", + genericTest "False" "\"aoeu\" == \"\"", + genericTest "True" "1 == 1 || 1/0 == 1", + genericTest "False" "1 == 0 && 1/0 == 1", + list_ender + ] + +-- List -- + +test_List = TestLabel "List" $ TestList + [ + genericTest "aoeu" "\"aoeu\"", + genericTest "aoeu" "['a','o','e','u']", + genericTest "a" "'a'", + genericTest "[1, True, 3]" "[1,True,3]", + genericTest "[1, True, 3]" "1:True:3:[]", + genericTest "[True, 3]" "tail [1,True,3]", + genericTest "1" "head [1,2,3]", + genericTest tailMsg "tail []", + genericTest headMsg "head []", + genericTest "False" "null \"aoeu\"", + genericTest "True" "null []", + genericTest "True" "null \"\"", + genericTest "[]" "[]", + genericTest "1" "(\\f.f [1,2]) head", + genericTestLbl "Tree" "(a (b c))" "(\\Leaf Branch tree.(\\f.(\\x.f(x x))(\\x.f(x x)))(\\showTree t.tree (\\l.[l]) (\\l r.'(':showTree l++' ':showTree r++\")\") t) (Branch (Leaf 'a') (Branch (Leaf 'b') (Leaf 'c')))) (\\c l b.l c) (\\l r lk bk.bk l r) (\\l b t.t l b)", + list_ender + ] + +-- Misc -- + +test_Misc = TestLabel "Misc" $ TestList + [ + test_TypeError, + "ConsStrictness" ~: "1" ~=? case evaluate "head [1,(\\x.x x)(\\x.x x)]" emptyEnv 100 of Left _ -> "ConsStrictness";Right s -> s, + "NullStrictness" ~: "False" ~=? case evaluate "null [1,(\\x.x x)(\\x.x x)]" emptyEnv 100 of Left _ -> "NullStrictness";Right s -> s, + "ConsStrictness2" ~: "1" ~=? case evaluate "head ((\\f.(\\x.f(x x))(\\x.f(x x))) (\\x.1:x))" emptyEnv 100 of Left _ -> "ConsStrictness";Right s -> s, +-- "OutOfFuel" ~: (outOfFuelMsg ~=? evaluate "(\\x.x x) (\\x.x x)" emptyEnv 100), + list_ender + ] + +test_TypeError = TestLabel "TypeError" $ TestList + [ + genericTest typeErrorMsg "(\\f.f 5) 7", + genericTest typeErrorMsg "(\\x.x)+4", + genericTest typeErrorMsg "if 4 then True else False", + genericTest typeErrorMsg "null 5", + list_ender + ] + diff --git a/Plugin/Localtime.hs b/Plugin/Localtime.hs new file mode 100644 --- /dev/null +++ b/Plugin/Localtime.hs @@ -0,0 +1,47 @@ +-- +-- Copyright (c) 2005 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | Simple wrapper over privmsg to get time information via the CTCP +-- +-- +module Plugin.Localtime (theModule) where + +import Plugin +import qualified Data.Map as M + +PLUGIN Localtime + +type TimeMap = M.Map String -- the person who's time we requested + [String] -- a list of targets waiting on this time + +instance Module LocaltimeModule TimeMap where + + moduleHelp _ _ = "time . Print a user's local time. User's client must support ctcp pings." + moduleCmds _ = ["time", "localtime", "localtime-reply"] + moduleDefState _ = return M.empty + + -- synonym + process x y z "time" a = process x y z "localtime" a + + -- record this person as a callback, for when we (asynchronously) get a result + process _ _ whoAsked "localtime" rawWho = do + let (whoToPing,_) = break (== ' ') rawWho + modifyMS $ \st -> M.insertWith (++) whoToPing [whoAsked] st + -- this is a CTCP time call, which returns a NOTICE + ircPrivmsg' whoToPing (Just "\^ATIME\^A") -- has to be raw + return [] + + -- the Base module caught the NOTICE TIME, mapped it to a PRIVMGS, and here it is :) + process _ _ _ "localtime-reply" text = do + let (whoGotPinged, time') = break (== ':') text + time = drop 1 time' + + targets <- withMS $ \st set -> do + case M.lookup whoGotPinged st of + Nothing -> return [] + Just xs -> do set (M.insert whoGotPinged [] st) -- clear the callback state + return xs + let msg = "Local time for " ++ whoGotPinged ++ " is " ++ time + flip mapM_ targets $ flip ircPrivmsg' (Just msg) + return [] diff --git a/Plugin/Log.hs b/Plugin/Log.hs new file mode 100644 --- /dev/null +++ b/Plugin/Log.hs @@ -0,0 +1,268 @@ +-- +-- Copyright (c) 2004 Thomas Jaeger +-- Copyright (c) 2005 Simon Winwood +-- Copyright (c) 2005 Don Stewart +-- Copyright (c) 2005 David House +-- +-- | Logging an IRC channel.. +-- +module Plugin.Log (theModule) where + +import Plugin +import qualified Message as Msg + +import Control.Monad (when) +import qualified Data.Map as M +import System.Time +import System.Directory (createDirectoryIfMissing) + +-- ------------------------------------------------------------------------ + +type Channel = String + +newtype LogModule = LogModule () + +type DateStamp = (Int, Month, Int) +data ChanState = CS { chanHandle :: Handle, + chanDate :: DateStamp, + chanHistory :: [Event] } + deriving (Show, Eq) +type LogState = M.Map Channel ChanState + +type Log a = ModuleT LogState LB a + +data Event = + Said String ClockTime String + | Joined String String ClockTime + | Parted String String ClockTime -- covers quitting as well + | Renick String String ClockTime String + deriving (Eq) + +theModule :: MODULE +theModule = MODULE $ LogModule () + +instance Show Event where + show (Said nick ct what) = timeStamp ct ++ " <" ++ nick ++ "> " ++ what + show (Joined nick user ct) = timeStamp ct ++ " " ++ nick + ++ " (" ++ user ++ ") joined." + show (Parted nick user ct) = timeStamp ct ++ " " ++ nick + ++ " (" ++ user ++ ") left." + show (Renick nick user ct new) = timeStamp ct ++ " " ++ nick + ++ " (" ++ user ++ ") is now " ++ new ++ "." + +-- * Dispatchers and Module instance declaration +-- + +-- | Default number of lines to show with @last. +numLastLines :: Int +numLastLines = 10 + +-- | Command -> Help lookup +commands :: [(String,String)] +commands = [("last", + "@last [] [] The last (default 10) " + ++ "posts to channel ."), + ("log-email", + "@log-email [] Email the log to the given " + ++ "address (default to todays)"), + ("print-logs", + "print the current internal state")] + +-- | CTCP command -> logger function lookup +loggers :: Msg.Message m => [(String, m -> ClockTime -> Event)] +loggers = [("PRIVMSG", msgCB ), + ("JOIN", joinCB), + ("PART", partCB), + ("NICK", nickCB)] + +instance Module LogModule LogState where + moduleHelp _ s = fromJust $ lookup s commands + moduleCmds _ = map fst commands + moduleDefState _ = return M.empty + moduleExit _ = cleanLogState + + contextual _ msg _ _ = do + case lookup (Msg.command msg) loggers of + Just f -> do + now <- io getClockTime + -- map over the channels this message was directed to, adding to each + -- of their log files. + when (notMe msg) $ + mapM_ (\c -> withValidLog (doLog c f msg) now c) (Msg.channels msg) + Nothing -> return () + return [] + where notMe m = (lowerCaseString $ name config) + /= (lowerCaseString . head $ Msg.channels m) + -- We don't log /msgs to the lambdabot + doLog chan f m hdl ct = do + let event = f m ct + logString hdl (show event) + appendEvent chan event + + process _ _ _ "last" rest = showHistory rest + process _ _ _ "print-logs" _ = fmap ((:[]) . show) readMS + +-- * The @last command +-- + +-- | Filter all the nicks by one person +-- FIXME --- maybe we should take into consideration nick changes? +filterNick :: String -> [Event] -> [Event] +filterNick who = filter filterOneNick + where + filterOneNick (Said who' _ _) = who == who' + filterOneNick (Joined who' _ _) = who == who' + filterOneNick (Parted who' _ _) = who == who' + filterOneNick (Renick old _ _ new) = who == old || who == new + +-- | Show the last 10 (or whatever) lines from the channel, in reverse order. +showHistory :: String -> Log [String] +showHistory args = do + st <- readMS + case M.lookup chan' st of + Just cs -> let his = chanHistory cs + in return [unlines . reverse . map show + . take nLines'. reverse $ lines' his] + Nothing -> return ["I haven't got any logs for that channel."] + where chan:nLines:nick:_ = map listToMaybeAll (words args ++ repeat "") + chan' = fromMaybe (error "The channel name is required") chan + nLines' = maybe numLastLines read nLines + lines' fm = maybe fm (\n -> filterNick n fm) nick + +-- * Event -> String helpers +-- + +-- | Show a number, padded to the left with zeroes up to the specified width +showWidth :: Int -- ^ Width to fill to + -> Int -- ^ Number to show + -> String -- ^ Padded string +showWidth width n = zeroes ++ num + where num = show n + zeroes = replicate (width - length num) '0' + +-- | Show a TimeStamp. +timeStamp :: ClockTime -> String +timeStamp ct = let cal = toUTCTime ct + in (showWidth 2 $ ctHour cal) ++ ":" ++ + (showWidth 2 $ ctMin cal) ++ ":" ++ + (showWidth 2 $ ctSec cal) + +-- * Logging helpers +-- + +-- | Show a DateStamp. +dateToString :: DateStamp -> String +dateToString (d, m, y) = (showWidth 2 y) ++ "-" ++ + (showWidth 2 $ fromEnum m + 1) ++ "-" ++ + (showWidth 2 d) + +-- | ClockTime -> DateStamp conversion +dateStamp :: ClockTime -> DateStamp +dateStamp ct = let cal = toUTCTime ct in (ctDay cal, ctMonth cal, ctYear cal) + +-- * State manipulation functions +-- + +-- | Cleans up after the module (closes files) +cleanLogState :: Log () +cleanLogState = + withMS $ \state writer -> do + io $ M.fold (\(CS hdl _ _) iom -> iom >> hClose hdl) (return ()) state + writer M.empty + +-- | Fetch a channel from the internal map. Uses LB's fail if not found. +getChannel :: Channel -> Log ChanState +getChannel c = (readMS >>=) . M.lookup $ c + +getDate :: Channel -> Log DateStamp +getDate c = fmap chanDate . getChannel $ c + +getHandle :: Channel -> Log Handle +getHandle c = fmap chanHandle . getChannel $ c + -- add points. otherwise: + -- Unbound implicit parameters (?ref::GHC.IOBase.MVar LogState, ?name::String) + -- arising from instantiating a type signature at + -- Plugin/Log.hs:187:30-39 + -- Probable cause: `getChannel' is applied to too few arguments + +{-getHistory :: Channel -> Log [Event] +getHistory = fmap chanHistory . getChannel-} + +-- | Put a DateStamp and a Handle. Used by 'openChannelFile' and +-- 'reopenChannelMaybe'. +putHdlAndDS :: Channel -> Handle -> DateStamp -> Log () +putHdlAndDS c hdl ds = + modifyMS (M.adjust (\(CS _ _ his) -> CS hdl ds his) c) + +-- | Append an event to the history of a channel +appendEvent :: Channel -> Event -> Log () +appendEvent c e = + modifyMS (M.adjust (\(CS hdl ds his) -> CS hdl ds (his ++ [e])) c) + +-- * Logging IO +-- + +-- | Open a file to write the log to. +openChannelFile :: Channel -> ClockTime -> Log Handle +openChannelFile chan ct = + io $ createDirectoryIfMissing True dir >> openFile file AppendMode + where dir = outputDir config "Log" host config chan + date = dateStamp ct + file = dir (dateToString date) <.> "txt" + +-- | Close and re-open a log file, and update the state. +reopenChannelMaybe :: Channel -> ClockTime -> Log () +reopenChannelMaybe chan ct = do + date <- getDate chan + when (date /= dateStamp ct) $ do + hdl <- getHandle chan + io $ hClose hdl + hdl' <- openChannelFile chan ct + putHdlAndDS chan hdl' (dateStamp ct) + +-- | Initialise the channel state (if it not already inited) +initChannelMaybe :: String -> ClockTime -> Log () +initChannelMaybe chan ct = do + chanp <- liftM (M.member chan) readMS + --io (putStr "chanp: " >> print chanp) + unless chanp $ do + hdl <- openChannelFile chan ct + modifyMS (M.insert chan $ CS hdl (dateStamp ct) []) + +-- | Ensure that the log is correctly initialised etc. +withValidLog :: (Handle -> ClockTime -> LB a) + -> ClockTime -> Channel -> Log a +withValidLog f ct chan = do + initChannelMaybe chan ct + reopenChannelMaybe chan ct + hdl <- getHandle chan + rv <- f hdl ct + return rv + +-- | Log a string. Main logging workhorse. +logString :: Handle -> String -> LB () +logString hdl str = io $ hPutStrLn hdl str >> hFlush hdl + -- We flush on each operation to ensure logs are up to date. + +-- * The event loggers themselves +-- + +-- | When somebody joins. +joinCB :: Msg.Message a => a -> ClockTime -> Event +joinCB msg ct = Joined (Msg.nick msg) (Msg.fullName msg) ct + +-- | When somebody quits. +partCB :: Msg.Message a => a -> ClockTime -> Event +partCB msg ct = Parted (Msg.nick msg) (Msg.fullName msg) ct + +-- | When somebody changes his\/her name. +-- FIXME: We should only do this for channels that the user is currently on. +nickCB :: Msg.Message a => a -> ClockTime -> Event +nickCB msg ct = Renick (Msg.nick msg) (Msg.fullName msg) ct + (drop 1 $ head $ Msg.body msg) + +-- | When somebody speaks. +msgCB :: Msg.Message a => a -> ClockTime -> Event +msgCB msg ct = Said (Msg.nick msg) ct + (tail . concat . tail $ Msg.body msg) + -- each lines is :foo diff --git a/Plugin/More.hs b/Plugin/More.hs new file mode 100644 --- /dev/null +++ b/Plugin/More.hs @@ -0,0 +1,35 @@ +-- +-- | Support for more(1) buffering +-- +module Plugin.More (theModule) where + +import Plugin + +PLUGIN More + +type MoreState = GlobalPrivate () [String] + +-- the @more state is handled centrally +instance Module MoreModule MoreState where + moduleHelp _ _ = "@more. Return more output from the bot buffer." + moduleCmds _ = ["more"] + moduleDefState _ = return $ mkGlobalPrivate 20 () + moduleInit _ = ircInstallOutputFilter moreFilter + process _ _ target _ _ = do + morestate <- readPS target + case morestate of + Nothing -> return [] + Just ls -> do mapM_ (ircPrivmsg' target . Just) =<< moreFilter target ls + return [] -- special + +moreFilter :: String -> [String] -> ModuleLB MoreState +moreFilter target msglines = do + let (morelines, thislines) = case drop (maxLines+2) msglines of + [] -> ([],msglines) + _ -> (drop maxLines msglines, take maxLines msglines) + writePS target $ if null morelines then Nothing else Just morelines + return $ thislines ++ if null morelines + then [] + else ['[':shows (length morelines) " @more lines]"] + + where maxLines = 5 -- arbitrary, really diff --git a/Plugin/Paste.hs b/Plugin/Paste.hs new file mode 100644 --- /dev/null +++ b/Plugin/Paste.hs @@ -0,0 +1,28 @@ +-- +-- | Skeletal paste support +-- +module Plugin.Paste (theModule) where + +import Plugin +import Control.Concurrent + +PLUGIN Paste + +announceTarget :: String +announceTarget = "#haskell" -- hmm :/ + +instance Module PasteModule ThreadId where + moduleInit _ = do + tid <- lbIO (\conv -> + forkIO $ pasteListener $ conv . ircPrivmsg announceTarget . Just) + writeMS tid + moduleExit _ = io . killThread =<< readMS + + +-- | Implements a server that listens for pastes from a paste script. +-- Authentification is done via... +pasteListener :: (String -> IO ()) -> IO () +pasteListener say = do + -- ... + say "someone has pasted something somewhere" + -- ... diff --git a/Plugin/Pl.hs b/Plugin/Pl.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl.hs @@ -0,0 +1,90 @@ +{-# OPTIONS -fvia-C -O2 -optc-O3 #-} +-- ^ required to get results. -fasm seems to slow(!) +-- +-- | Pointfree programming fun +-- +-- A catalogue of refactorings is at: +-- http://www.cs.kent.ac.uk/projects/refactor-fp/catalogue/ +-- http://www.cs.kent.ac.uk/projects/refactor-fp/catalogue/RefacIdeasAug03.html +-- +-- Use more Arrow stuff +-- +-- TODO would be to plug into HaRe and use some of their refactorings. +-- +module Plugin.Pl (theModule) where + +import Plugin + +import Plugin.Pl.Common (TopLevel, mapTopLevel, getExpr) +import Plugin.Pl.Parser (parsePF) +import Plugin.Pl.PrettyPrinter (Expr) +import Plugin.Pl.Transform (transform, optimize) + +import Control.Concurrent.Chan (Chan, newChan, isEmptyChan, readChan, writeList2Chan) + +-- firstTimeout is the timeout when the expression is simplified for the first +-- time. After each unsuccessful attempt, this number is doubled until it hits +-- maxTimeout. +firstTimeout, maxTimeout :: Int +firstTimeout = 3000000 -- 3 seconds +maxTimeout = 15000000 -- 15 seconds + +type PlState = GlobalPrivate () (Int, TopLevel) + +PLUGIN Pl + +type Pl = ModuleLB PlState + +instance Module PlModule PlState where + + moduleCmds _ = ["pointless","pl-resume","pl"] + + moduleHelp _ "pl-resume" = "pl-resume. Resume a suspended pointless transformation." + moduleHelp _ _ = "pointless . Play with pointfree code." + + moduleDefState _ = return $ mkGlobalPrivate 15 () + + process _ _ target "pointless" rest = pf target rest + process _ _ target "pl" rest = pf target rest + process _ _ target "pl-resume" _ = res target + +------------------------------------------------------------------------ + +res :: String -> Pl +res target = do + d <- readPS target + case d of + Nothing -> return ["pointless: sorry, nothing to resume."] + Just d' -> optimizeTopLevel target d' + +pf :: String -> String -> Pl +pf target inp = case parsePF inp of + Right d -> optimizeTopLevel target (firstTimeout, mapTopLevel transform d) + Left err -> return [err] + +optimizeTopLevel :: String -> (Int, TopLevel) -> Pl +optimizeTopLevel target (to, d) = do + let (e,decl) = getExpr d + (e', finished) <- io $ optimizeIO to e + extra <- if finished + then do writePS target Nothing + return [] + else do writePS target $ Just (min (2*to) maxTimeout, decl e') + return ["optimization suspended, use @pl-resume to continue."] + return $ (show $ decl e') : extra + +------------------------------------------------------------------------ + +optimizeIO :: Int -> Expr -> IO (Expr, Bool) +optimizeIO to e = do + chan <- newChan + result <- timeout to $ writeList2Chan chan $ optimize e + e' <- getChanLast chan e + return $ case result of + Nothing -> (e', False) + Just _ -> (e', True) + +getChanLast :: Chan a -> a -> IO a +getChanLast c x = do + b <- isEmptyChan c + if b then return x else getChanLast c =<< readChan c diff --git a/Plugin/Pl/COPYING b/Plugin/Pl/COPYING new file mode 100644 --- /dev/null +++ b/Plugin/Pl/COPYING @@ -0,0 +1,20 @@ +Copyright (c) 2005 Thomas Jäger + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject +to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Plugin/Pl/Common.hs b/Plugin/Pl/Common.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Common.hs @@ -0,0 +1,139 @@ +{-# OPTIONS -fvia-C #-} + +module Plugin.Pl.Common ( + Fixity(..), Expr(..), Pattern(..), Decl(..), TopLevel(..), + bt, sizeExpr, mapTopLevel, getExpr, + operators, opchars, reservedOps, lookupOp, lookupFix, minPrec, maxPrec, + comp, flip', id', const', scomb, cons, nil, fix', if', + makeList, getList, + Assoc(..), + module Data.Maybe, + module Control.Arrow, + module Data.List, + module Control.Monad, + module GHC.Base + ) where + +import Data.Maybe (isJust, fromJust) +import Data.List (intersperse, minimumBy) +import qualified Data.Map as M + +import Control.Monad +import Control.Arrow (first, second, (***), (&&&), (|||), (+++)) + +import Text.ParserCombinators.Parsec.Expr (Assoc(..)) + +import GHC.Base (assert) + + +-- The rewrite rules can be found at the end of the file Rules.hs + +-- Not sure if passing the information if it was used as infix or prefix +-- is worth threading through the whole thing is worth the effort, +-- but it stays that way until the prettyprinting algorithm gets more +-- sophisticated. +data Fixity = Pref | Inf deriving Show + +instance Eq Fixity where + _ == _ = True + +instance Ord Fixity where + compare _ _ = EQ + +data Expr + = Var Fixity String + | Lambda Pattern Expr + | App Expr Expr + | Let [Decl] Expr + deriving (Eq, Ord) + +data Pattern + = PVar String + | PCons Pattern Pattern + | PTuple Pattern Pattern + deriving (Eq, Ord) + +data Decl = Define { + declName :: String, + declExpr :: Expr +} deriving (Eq, Ord) + +data TopLevel = TLD Bool Decl | TLE Expr deriving (Eq, Ord) + +mapTopLevel :: (Expr -> Expr) -> TopLevel -> TopLevel +mapTopLevel f tl = case getExpr tl of (e, c) -> c $ f e + +getExpr :: TopLevel -> (Expr, Expr -> TopLevel) +getExpr (TLD True (Define foo e)) = (Let [Define foo e] (Var Pref foo), + \e' -> TLD False $ Define foo e') +getExpr (TLD False (Define foo e)) = (e, \e' -> TLD False $ Define foo e') +getExpr (TLE e) = (e, TLE) + +sizeExpr :: Expr -> Int +sizeExpr (Var _ _) = 1 +sizeExpr (App e1 e2) = sizeExpr e1 + sizeExpr e2 + 1 +sizeExpr (Lambda _ e) = 1 + sizeExpr e +sizeExpr (Let ds e) = 1 + sum (map sizeDecl ds) + sizeExpr e where + sizeDecl (Define _ e') = 1 + sizeExpr e' + +comp, flip', id', const', scomb, cons, nil, fix', if' :: Expr +comp = Var Inf "." +flip' = Var Pref "flip" +id' = Var Pref "id" +const' = Var Pref "const" +scomb = Var Pref "ap" +cons = Var Inf ":" +nil = Var Pref "[]" +fix' = Var Pref "fix" +if' = Var Pref "if'" + +makeList :: [Expr] -> Expr +makeList = foldr (\e1 e2 -> cons `App` e1 `App` e2) nil + +-- Modularity is a drag +getList :: Expr -> ([Expr], Expr) +getList (c `App` x `App` tl) | c == cons = first (x:) $ getList tl +getList e = ([],e) + +bt :: a +bt = undefined + +shift, minPrec, maxPrec :: Int +shift = 0 +maxPrec = shift + 10 +minPrec = 0 + +-- operator precedences are needed both for parsing and prettyprinting +operators :: [[(String, (Assoc, Int))]] +operators = (map . map . second . second $ (+shift)) + [[inf "." AssocRight 9, inf "!!" AssocLeft 9], + [inf name AssocRight 8 | name <- ["^", "^^", "**"]], + [inf name AssocLeft 7 + | name <- ["*", "/", "`quot`", "`rem`", "`div`", "`mod`", ":%", "%"]], + [inf name AssocLeft 6 | name <- ["+", "-"]], + [inf name AssocRight 5 | name <- [":", "++"]], + [inf name AssocNone 4 + | name <- ["==", "/=", "<", "<=", ">=", ">", "`elem`", "`notElem`"]], + [inf "&&" AssocRight 3], + [inf "||" AssocRight 2], + [inf ">>" AssocLeft 1, inf ">>=" AssocLeft 1, inf "=<<" AssocRight 1], + [inf name AssocRight 0 | name <- ["$", "$!", "`seq`"]] + ] where + inf name assoc fx = (name, (assoc, fx)) + +opchars :: [Char] +opchars = "!@#$%^*./|=-+:?<>&" + +reservedOps :: [String] +reservedOps = ["->", "..", "="] + +opFM :: M.Map String (Assoc, Int) +opFM = (M.fromList $ concat operators) + +lookupOp :: String -> Maybe (Assoc, Int) +lookupOp k = M.lookup k opFM + +lookupFix :: String -> (Assoc, Int) +lookupFix str = case lookupOp $ str of + Nothing -> (AssocLeft, 9 + shift) + Just x -> x diff --git a/Plugin/Pl/Makefile b/Plugin/Pl/Makefile new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Makefile @@ -0,0 +1,9 @@ +all: + #ghc -package HUnit -i.. -O --make -fglasgow-exts -funfolding-use-threshold -o Test Test.hs + ghc -Wall -cpp -funbox-strict-fields -i../.. --make -O -fglasgow-exts -o Test Test.hs + +tests: all + ./Test tests + +clean: + rm *.o *.hi diff --git a/Plugin/Pl/Parser.hs b/Plugin/Pl/Parser.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Parser.hs @@ -0,0 +1,221 @@ +{-# OPTIONS -fvia-C -O2 -optc-O3 #-} +-- +-- Todo, use Language.Haskell +-- +-- Doesn't handle string literals? +-- +module Plugin.Pl.Parser (parsePF) where + +import Plugin.Pl.Common + +import Text.ParserCombinators.Parsec +import Text.ParserCombinators.Parsec.Expr +import Text.ParserCombinators.Parsec.Language +import qualified Text.ParserCombinators.Parsec.Token as T + +-- is that supposed to be done that way? +tp :: T.TokenParser () +tp = T.makeTokenParser $ haskellStyle { + reservedNames = ["if","then","else","let","in"] +} + +parens :: Parser a -> Parser a +parens = T.parens tp + +brackets :: Parser a -> Parser a +brackets = T.brackets tp + +symbol :: String -> Parser String +symbol = T.symbol tp + +atomic :: Parser String +atomic = try (show `fmap` T.natural tp) <|> T.identifier tp + +reserved :: String -> Parser () +reserved = T.reserved tp + +charLiteral :: Parser Char +charLiteral = T.charLiteral tp + +stringLiteral :: Parser String +stringLiteral = T.stringLiteral tp + +table :: [[Operator Char st Expr]] +table = addToFirst def $ map (map inf) operators where + addToFirst y (x:xs) = ((y:x):xs) + addToFirst _ _ = assert False bt + + def :: Operator Char st Expr + def = Infix (try $ do + name <- parseOp + guard $ not $ isJust $ lookupOp name + spaces + return $ \e1 e2 -> App (Var Inf name) e1 `App` e2 + ) AssocLeft + + inf :: (String, (Assoc, Int)) -> Operator Char st Expr + inf (name, (assoc, _)) = Infix (try $ do + string name + notFollowedBy $ oneOf opchars + spaces + let name' = if head name == '`' + then tail . reverse . tail . reverse $ name + else name + return $ \e1 e2 -> App (Var Inf name') e1 `App` e2 + ) assoc + + +parseOp :: CharParser st String +parseOp = (between (char '`') (char '`') $ many1 (letter <|> digit)) + <|> try (do + op <- many1 $ oneOf opchars + guard $ not $ op `elem` reservedOps + return op) + +pattern :: Parser Pattern +pattern = buildExpressionParser ptable ((PVar `fmap` + ( atomic + <|> (symbol "_" >> return ""))) + <|> parens pattern) + "pattern" where + ptable = [[Infix (symbol ":" >> return PCons) AssocRight], + [Infix (symbol "," >> return PTuple) AssocNone]] + +lambda :: Parser Expr +lambda = do + symbol "\\" + vs <- many1 pattern + symbol "->" + e <- myParser False + return $ foldr Lambda e vs + "lambda abstraction" + +var :: Parser Expr +var = try (makeVar `fmap` atomic <|> + parens (try rightSection <|> try (makeVar `fmap` many1 (char ',')) + <|> tuple) <|> list <|> (Var Pref . show) `fmap` charLiteral + <|> stringVar `fmap` stringLiteral) + "variable" where + makeVar v | Just _ <- lookupOp v = Var Inf v -- operators always want to + -- be infixed + | otherwise = Var Pref v + stringVar :: String -> Expr + stringVar str = makeList $ (Var Pref . show) `map` str + +list :: Parser Expr +list = msum (map (try . brackets) plist) "list" where + plist = [ + foldr (\e1 e2 -> cons `App` e1 `App` e2) nil `fmap` + (myParser False `sepBy` symbol ","), + do e <- myParser False + symbol ".." + return $ Var Pref "enumFrom" `App` e, + do e <- myParser False + symbol "," + e' <- myParser False + symbol ".." + return $ Var Pref "enumFromThen" `App` e `App` e', + do e <- myParser False + symbol ".." + e' <- myParser False + return $ Var Pref "enumFromTo" `App` e `App` e', + do e <- myParser False + symbol "," + e' <- myParser False + symbol ".." + e'' <- myParser False + return $ Var Pref "enumFromThenTo" `App` e `App` e' `App` e'' + ] + +tuple :: Parser Expr +tuple = do + elts <- myParser False `sepBy` symbol "," + guard $ length elts /= 1 + let name = Var Pref $ replicate (length elts - 1) ',' + return $ foldl App name elts + "tuple" + +rightSection :: Parser Expr +rightSection = do + v <- Var Inf `fmap` parseOp + spaces + let rs e = flip' `App` v `App` e + option v (rs `fmap` myParser False) + "right section" + + +myParser :: Bool -> Parser Expr +myParser b = lambda <|> expr b + +expr :: Bool -> Parser Expr +expr b = buildExpressionParser table (term b) "expression" + +decl :: Parser Decl +decl = do + f <- atomic + args <- pattern `endsIn` symbol "=" + e <- myParser False + return $ Define f (foldr Lambda e args) + +letbind :: Parser Expr +letbind = do + reserved "let" + ds <- decl `sepBy` symbol ";" + reserved "in" + e <- myParser False + return $ Let ds e + +ifexpr :: Parser Expr +ifexpr = do + reserved "if" + p <- myParser False + reserved "then" + e1 <- myParser False + reserved "else" + e2 <- myParser False + return $ if' `App` p `App` e1 `App` e2 + +term :: Bool -> Parser Expr +term b = application <|> lambda <|> letbind <|> ifexpr <|> + (guard b >> (notFollowedBy (noneOf ")") >> return (Var Pref ""))) + "simple term" + +application :: Parser Expr +application = do + e:es <- many1 $ var <|> parens (myParser True) + return $ foldl App e es + "application" + +endsIn :: Parser a -> Parser b -> Parser [a] +endsIn p end = do + xs <- many p + end + return $ xs + +input :: Parser TopLevel +input = do + spaces + tl <- try (do + f <- atomic + args <- pattern `endsIn` symbol "=" + e <- myParser False + return $ TLD True $ Define f (foldr Lambda e args) + ) <|> TLE `fmap` myParser False + eof + return tl + +parsePF :: String -> Either String TopLevel +parsePF inp = case runParser input () "" inp of + Left err -> Left $ show err + Right e -> Right $ mapTopLevel postprocess e + + +postprocess :: Expr -> Expr +postprocess (Var f v) = (Var f v) +postprocess (App e1 (Var Pref "")) = postprocess e1 +postprocess (App e1 e2) = App (postprocess e1) (postprocess e2) +postprocess (Lambda v e) = Lambda v (postprocess e) +postprocess (Let ds e) = Let (mapDecl postprocess `map` ds) $ postprocess e where + mapDecl :: (Expr -> Expr) -> Decl -> Decl + mapDecl f (Define foo e') = Define foo $ f e' + diff --git a/Plugin/Pl/PrettyPrinter.hs b/Plugin/Pl/PrettyPrinter.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/PrettyPrinter.hs @@ -0,0 +1,150 @@ +{-# OPTIONS -fvia-C #-} +module Plugin.Pl.PrettyPrinter (Expr) where + +-- Dummy export to make ghc -Wall happy + +import Lib.Serial (readM) +import Plugin.Pl.Common + +instance Show Decl where + show (Define f e) = f ++ " = " ++ show e + showList ds = (++) $ concat $ intersperse "; " $ map show ds + +instance Show TopLevel where + showsPrec p (TLE e) = showsPrec p e + showsPrec p (TLD _ d) = showsPrec p d + +data SExpr + = SVar !String + | SLambda ![Pattern] !SExpr + | SLet ![Decl] !SExpr + | SApp !SExpr !SExpr + | SInfix !String !SExpr !SExpr + | LeftSection !String !SExpr -- (x +) + | RightSection !String !SExpr -- (+ x) + | List ![SExpr] + | Tuple ![SExpr] + | Enum !Expr !(Maybe Expr) !(Maybe Expr) + +{-# INLINE toSExprHead #-} +toSExprHead :: String -> [Expr] -> Maybe SExpr +toSExprHead hd tl + | all (==',') hd, length hd+1 == length tl + = Just . Tuple . reverse $ map toSExpr tl + | otherwise = case (hd,reverse tl) of + ("enumFrom", [e]) -> Just $ Enum e Nothing Nothing + ("enumFromThen", [e,e']) -> Just $ Enum e (Just e') Nothing + ("enumFromTo", [e,e']) -> Just $ Enum e Nothing (Just e') + ("enumFromThenTo", [e,e',e'']) -> Just $ Enum e (Just e') (Just e'') + _ -> Nothing + +toSExpr :: Expr -> SExpr +toSExpr (Var _ v) = SVar v +toSExpr (Lambda v e) = case toSExpr e of + (SLambda vs e') -> SLambda (v:vs) e' + e' -> SLambda [v] e' +toSExpr (Let ds e) = SLet ds $ toSExpr e +toSExpr e | Just (hd,tl) <- getHead e, Just se <- toSExprHead hd tl = se +toSExpr e | (ls, tl) <- getList e, tl == nil + = List $ map toSExpr ls +toSExpr (App e1 e2) = case e1 of + App (Var Inf v) e0 + -> SInfix v (toSExpr e0) (toSExpr e2) + Var Inf v | v /= "-" + -> LeftSection v (toSExpr e2) + + Var _ "flip" | Var Inf v <- e2, v == "-" -> toSExpr $ Var Pref "subtract" + + App (Var _ "flip") (Var pr v) + | v == "-" -> toSExpr $ Var Pref "subtract" `App` e2 + | v == "id" -> RightSection "$" (toSExpr e2) + | Inf <- pr -> RightSection v (toSExpr e2) + _ -> SApp (toSExpr e1) (toSExpr e2) + +getHead :: Expr -> Maybe (String, [Expr]) +getHead (Var _ v) = Just (v, []) +getHead (App e1 e2) = second (e2:) `fmap` getHead e1 +getHead _ = Nothing + +instance Show Expr where + showsPrec p = showsPrec p . toSExpr + +instance Show SExpr where + showsPrec _ (SVar v) = (getPrefName v ++) + showsPrec p (SLambda vs e) = showParen (p > minPrec) $ ('\\':) . + foldr (.) id (intersperse (' ':) (map (showsPrec $ maxPrec+1) vs)) . + (" -> "++) . showsPrec minPrec e + showsPrec p (SApp e1 e2) = showParen (p > maxPrec) $ + showsPrec maxPrec e1 . (' ':) . showsPrec (maxPrec+1) e2 + showsPrec _ (LeftSection fx e) = showParen True $ + showsPrec (snd (lookupFix fx) + 1) e . (' ':) . (getInfName fx++) + showsPrec _ (RightSection fx e) = showParen True $ + (getInfName fx++) . (' ':) . showsPrec (snd (lookupFix fx) + 1) e + showsPrec _ (Tuple es) = showParen True $ + (concat `id` intersperse ", " (map show es) ++) + + showsPrec _ (List es) + | Just cs <- mapM ((=<<) readM . fromSVar) es = shows (cs::String) + | otherwise = ('[':) . + (concat `id` intersperse ", " (map show es) ++) . (']':) + where fromSVar (SVar str) = Just str + fromSVar _ = Nothing + showsPrec _ (Enum fr tn to) = ('[':) . shows fr . + showsMaybe (((',':) . show) `fmap` tn) . (".."++) . + showsMaybe (show `fmap` to) . (']':) + where showsMaybe = maybe id (++) + showsPrec _ (SLet ds e) = ("let "++) . shows ds . (" in "++) . shows e + + + showsPrec p (SInfix fx e1 e2) = showParen (p > fixity) $ + showsPrec f1 e1 . (' ':) . (getInfName fx++) . (' ':) . + showsPrec f2 e2 where + fixity = snd $ lookupFix fx + (f1, f2) = case fst $ lookupFix fx of + AssocRight -> (fixity+1, fixity + infixSafe e2 AssocLeft fixity) + AssocLeft -> (fixity + infixSafe e1 AssocRight fixity, fixity+1) + AssocNone -> (fixity+1, fixity+1) + + -- This is a little bit awkward, but at least seems to produce no false + -- results anymore + infixSafe :: SExpr -> Assoc -> Int -> Int + infixSafe (SInfix fx'' _ _) assoc fx' + | lookupFix fx'' == (assoc, fx') = 1 + | otherwise = 0 + infixSafe _ _ _ = 0 -- doesn't matter + +instance Show Pattern where + showsPrec _ (PVar v) = (v++) + showsPrec _ (PTuple p1 p2) = showParen True $ + showsPrec 0 p1 . (", "++) . showsPrec 0 p2 + showsPrec p (PCons p1 p2) = showParen (p>5) $ + showsPrec 6 p1 . (':':) . showsPrec 5 p2 + +isOperator :: String -> Bool +isOperator = all (`elem` opchars) + +getInfName :: String -> String +getInfName str = if isOperator str then str else "`"++str++"`" + +getPrefName :: String -> String +getPrefName str = if isOperator str || ',' `elem` str then "("++str++")" else str + +instance Eq Assoc where + AssocLeft == AssocLeft = True + AssocRight == AssocRight = True + AssocNone == AssocNone = True + _ == _ = False + +{- +instance Show Assoc where + show AssocLeft = "AssocLeft" + show AssocRight = "AssocRight" + show AssocNone = "AssocNone" + +instance Ord Assoc where + AssocNone <= _ = True + _ <= AssocNone = False + AssocLeft <= _ = True + _ <= AssocLeft = False + _ <= _ = True +-} diff --git a/Plugin/Pl/Rules.hs b/Plugin/Pl/Rules.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Rules.hs @@ -0,0 +1,764 @@ +{-# OPTIONS -fvia-C #-} +{-# OPTIONS -fno-warn-name-shadowing #-} +-- 6.4 gives a name shadow warning I haven't tracked down. + +-- +-- | This marvellous module contributed by Thomas J\344ger +-- +module Plugin.Pl.Rules (RewriteRule(..), rules, fire) where + +import Lib.Serial (readM) + +import Plugin.Pl.Common + +import Data.Array +import qualified Data.Set as S + +import Control.Monad.Fix (fix) + +--import PlModule.PrettyPrinter + +-- Next time I do somthing like this, I'll actually think about the combinator +-- language before, instead of producing something ad-hoc like this: +data RewriteRule + = RR Rewrite Rewrite + | CRR (Expr -> Maybe Expr) + | Down RewriteRule RewriteRule + | Up RewriteRule RewriteRule + | Or [RewriteRule] + | OrElse RewriteRule RewriteRule + | Then RewriteRule RewriteRule + | Opt RewriteRule + | If RewriteRule RewriteRule + | Hard RewriteRule + +-- No MLambda here because we only consider closed Terms (no alpha-renaming!). +data MExpr + = MApp !MExpr !MExpr + | Hole !Int + | Quote !Expr + deriving Eq + +--instance Show MExpr where +-- show = show . fromMExpr + +data Rewrite = Rewrite { + holes :: MExpr, + rid :: Int -- rlength - 1 +} --deriving Show + +-- What are you gonna do when no recursive modules are possible? +class RewriteC a where + getRewrite :: a -> Rewrite + +instance RewriteC MExpr where + getRewrite rule = Rewrite { + holes = rule, + rid = 0 + } + +type ExprArr = Array Int Expr + +myFire :: ExprArr -> MExpr -> MExpr +myFire xs (MApp e1 e2) = MApp (myFire xs e1) (myFire xs e2) +myFire xs (Hole h) = Quote $ xs ! h +myFire _ me = me + +nub' :: Ord a => [a] -> [a] +nub' = S.toList . S.fromList + +uniqueArray :: Ord v => Int -> [(Int, v)] -> Maybe (Array Int v) +uniqueArray n lst + | length (nub' lst) == n = Just $ array (0,n-1) lst + | otherwise = Nothing + +match :: Rewrite -> Expr -> Maybe ExprArr +match (Rewrite hl rid') e = uniqueArray rid' =<< matchWith hl e + +fire' :: Rewrite -> ExprArr -> MExpr +fire' (Rewrite hl _) = (`myFire` hl) + +fire :: Rewrite -> Rewrite -> Expr -> Maybe Expr +fire r1 r2 e = (fromMExpr . fire' r2) `fmap` match r1 e + +matchWith :: MExpr -> Expr -> Maybe [(Int, Expr)] +matchWith (MApp e1 e2) (App e1' e2') = + liftM2 (++) (matchWith e1 e1') (matchWith e2 e2') +matchWith (Quote e) e' = if e == e' then Just [] else Nothing +matchWith (Hole k) e = Just [(k,e)] +matchWith _ _ = Nothing + +fromMExpr :: MExpr -> Expr +fromMExpr (MApp e1 e2) = App (fromMExpr e1) (fromMExpr e2) +fromMExpr (Hole _) = Var Pref "Hole" -- error "Hole in MExpr" +fromMExpr (Quote e) = e + +instance RewriteC a => RewriteC (MExpr -> a) where + getRewrite rule = Rewrite { + holes = holes . getRewrite . rule . Hole $ pid, + rid = pid + 1 + } where + pid = rid $ getRewrite (bt :: a) + +-- Yet another pointless transformation +transformM :: Int -> MExpr -> MExpr +transformM _ (Quote e) = constE `a` Quote e +transformM n (Hole n') = if n == n' then idE else constE `a` Hole n' +transformM n (Quote (Var _ ".") `MApp` e1 `MApp` e2) + | e1 `hasHole` n && not (e2 `hasHole` n) + = flipE `a` compE `a` e2 `c` transformM n e1 +transformM n e@(MApp e1 e2) + | fr1 && fr2 = sE `a` transformM n e1 `a` transformM n e2 + | fr1 = flipE `a` transformM n e1 `a` e2 + | fr2, Hole n' <- e2, n' == n = e1 + | fr2 = e1 `c` transformM n e2 + | otherwise = constE `a` e + where + fr1 = e1 `hasHole` n + fr2 = e2 `hasHole` n + +hasHole :: MExpr -> Int -> Bool +hasHole (MApp e1 e2) n = e1 `hasHole` n || e2 `hasHole` n +hasHole (Quote _) _ = False +hasHole (Hole n') n = n == n' + +-- +-- haddock doesn't like n+k patterns, so rewrite them +-- +getVariants, getVariants' :: Rewrite -> [Rewrite] +getVariants' r@(Rewrite _ 0) = [r] +getVariants' r@(Rewrite e nk) + | nk >= 1 = r : getVariants (Rewrite e' (nk-1)) + | otherwise = error "getVariants' : nk went negative" + where + e' = decHoles $ transformM 0 e + + decHoles (Hole n') = Hole (n'-1) + decHoles (MApp e1 e2) = decHoles e1 `MApp` decHoles e2 + decHoles me = me + +getVariants = getVariants' -- r = trace (show vs) vs where vs = getVariants' r + +rr, rr0, rr1, rr2 :: RewriteC a => a -> a -> RewriteRule +-- use this rewrite rule and rewrite rules derived from it by iterated +-- pointless transformation +rrList :: RewriteC a => a -> a -> [RewriteRule] +rrList r1 r2 = zipWith RR (getVariants r1') (getVariants r2') where + r1' = getRewrite r1 + r2' = getRewrite r2 + +rr r1 r2 = Or $ rrList r1 r2 +rr1 r1 r2 = Or . take 2 $ rrList r1 r2 +rr2 r1 r2 = Or . take 3 $ rrList r1 r2 + +-- use only this rewrite rule +rr0 r1 r2 = RR r1' r2' where + r1' = getRewrite r1 + r2' = getRewrite r2 + +down, up :: RewriteRule -> RewriteRule +down = fix . Down +up = fix . Up + + +idE, flipE, bindE, extE, returnE, consE, appendE, nilE, foldrE, foldlE, fstE, + sndE, dollarE, constE, uncurryE, curryE, compE, headE, tailE, sE, commaE, + fixE, foldl1E, notE, equalsE, nequalsE, plusE, multE, zeroE, oneE, lengthE, + sumE, productE, concatE, concatMapE, joinE, mapE, fmapE, fmapIE, subtractE, + minusE, liftME, apE, liftM2E, seqME, zipE, zipWithE, + crossE, firstE, secondE, andE, orE, allE, anyE :: MExpr +idE = Quote $ Var Pref "id" +flipE = Quote $ Var Pref "flip" +constE = Quote $ Var Pref "const" +compE = Quote $ Var Inf "." +sE = Quote $ Var Pref "ap" +fixE = Quote $ Var Pref "fix" +bindE = Quote $ Var Inf ">>=" +extE = Quote $ Var Inf "=<<" +returnE = Quote $ Var Pref "return" +consE = Quote $ Var Inf ":" +nilE = Quote $ Var Pref "[]" +appendE = Quote $ Var Inf "++" +foldrE = Quote $ Var Pref "foldr" +foldlE = Quote $ Var Pref "foldl" +fstE = Quote $ Var Pref "fst" +sndE = Quote $ Var Pref "snd" +dollarE = Quote $ Var Inf "$" +uncurryE = Quote $ Var Pref "uncurry" +curryE = Quote $ Var Pref "curry" +headE = Quote $ Var Pref "head" +tailE = Quote $ Var Pref "tail" +commaE = Quote $ Var Inf "," +foldl1E = Quote $ Var Pref "foldl1" +equalsE = Quote $ Var Inf "==" +nequalsE = Quote $ Var Inf "/=" +notE = Quote $ Var Pref "not" +plusE = Quote $ Var Inf "+" +multE = Quote $ Var Inf "*" +zeroE = Quote $ Var Pref "0" +oneE = Quote $ Var Pref "1" +lengthE = Quote $ Var Pref "length" +sumE = Quote $ Var Pref "sum" +productE = Quote $ Var Pref "product" +concatE = Quote $ Var Pref "concat" +concatMapE = Quote $ Var Pref "concatMap" +joinE = Quote $ Var Pref "join" +mapE = Quote $ Var Pref "map" +fmapE = Quote $ Var Pref "fmap" +fmapIE = Quote $ Var Inf "fmap" +subtractE = Quote $ Var Pref "subtract" +minusE = Quote $ Var Inf "-" +liftME = Quote $ Var Pref "liftM" +liftM2E = Quote $ Var Pref "liftM2" +apE = Quote $ Var Inf "ap" +seqME = Quote $ Var Inf ">>" +zipE = Quote $ Var Pref "zip" +zipWithE = Quote $ Var Pref "zipWith" +crossE = Quote $ Var Inf "***" +firstE = Quote $ Var Pref "first" +secondE = Quote $ Var Pref "second" +andE = Quote $ Var Pref "and" +orE = Quote $ Var Pref "or" +allE = Quote $ Var Pref "all" +anyE = Quote $ Var Pref "any" + + + +a, c :: MExpr -> MExpr -> MExpr +a = MApp +c e1 e2 = compE `a` e1 `a` e2 +infixl 9 `a` +infixr 8 `c` + + +collapseLists :: Expr -> Maybe Expr +collapseLists (Var _ "++" `App` e1 `App` e2) + | (xs,x) <- getList e1, x==nil, + (ys,y) <- getList e2, y==nil = Just $ makeList $ xs ++ ys +collapseLists _ = Nothing + +data Binary = forall a b c. (Read a, Show a, Read b, Show b, Read c, Show c) => BA (a -> b -> c) + +evalBinary :: [(String, Binary)] -> Expr -> Maybe Expr +evalBinary fs (Var _ f' `App` Var _ x' `App` Var _ y') + | Just (BA f) <- lookup f' fs = (Var Pref . show) `fmap` liftM2 f (readM x') (readM y') +evalBinary _ _ = Nothing + +data Unary = forall a b. (Read a, Show a, Read b, Show b) => UA (a -> b) + +evalUnary :: [(String, Unary)] -> Expr -> Maybe Expr +evalUnary fs (Var _ f' `App` Var _ x') + | Just (UA f) <- lookup f' fs = (Var Pref . show . f) `fmap` readM x' +evalUnary _ _ = Nothing + +assocR, assocL, assoc :: [String] -> Expr -> Maybe Expr +-- (f `op` g) `op` h --> f `op` (g `op` h) +assocR ops (Var f1 op1 `App` (Var f2 op2 `App` e1 `App` e2) `App` e3) + | op1 == op2 && op1 `elem` ops + = Just (Var f1 op1 `App` e1 `App` (Var f2 op2 `App` e2 `App` e3)) +assocR _ _ = Nothing + +-- f `op` (g `op` h) --> (f `op` g) `op` h +assocL ops (Var f1 op1 `App` e1 `App` (Var f2 op2 `App` e2 `App` e3)) + | op1 == op2 && op1 `elem` ops + = Just (Var f1 op1 `App` (Var f2 op2 `App` e1 `App` e2) `App` e3) +assocL _ _ = Nothing + +-- op f . op g --> op (f `op` g) +assoc ops (Var _ "." `App` (Var f1 op1 `App` e1) `App` (Var f2 op2 `App` e2)) + | op1 == op2 && op1 `elem` ops + = Just (Var f1 op1 `App` (Var f2 op2 `App` e1 `App` e2)) +assoc _ _ = Nothing + +commutative :: [String] -> Expr -> Maybe Expr +commutative ops (Var f op `App` e1 `App` e2) + | op `elem` ops = Just (Var f op `App` e2 `App` e1) +commutative ops (Var _ "flip" `App` e@(Var _ op)) | op `elem` ops = Just e +commutative _ _ = Nothing + +-- TODO: Move rules into a file. +{-# INLINE simplifies #-} +simplifies :: RewriteRule +simplifies = Or [ + -- (f . g) x --> f (g x) + rr0 (\f g x -> (f `c` g) `a` x) + (\f g x -> f `a` (g `a` x)), + -- id x --> x + rr0 (\x -> idE `a` x) + (\x -> x), + -- flip (flip x) --> x + rr (\x -> flipE `a` (flipE `a` x)) + (\x -> x), + -- flip id x . f --> flip f x + rr0 (\f x -> (flipE `a` idE `a` x) `c` f) + (\f x -> flipE `a` f `a` x), + -- id . f --> f + rr0 (\f -> idE `c` f) + (\f -> f), + -- f . id --> f + rr0 (\f -> f `c` idE) + (\f -> f), + -- const x y --> x + rr0 (\x y -> constE `a` x `a` y) + (\x _ -> x), + -- not (not x) --> x + rr (\x -> notE `a` (notE `a` x)) + (\x -> x), + -- fst (x,y) --> x + rr (\x y -> fstE `a` (commaE `a` x `a` y)) + (\x _ -> x), + -- snd (x,y) --> y + rr (\x y -> sndE `a` (commaE `a` x `a` y)) + (\_ y -> y), + -- head (x:xs) --> x + rr (\x xs -> headE `a` (consE `a` x `a` xs)) + (\x _ -> x), + -- tail (x:xs) --> xs + rr (\x xs -> tailE `a` (consE `a` x `a` xs)) + (\_ xs -> xs), + -- uncurry f (x,y) --> f x y + rr1 (\f x y -> uncurryE `a` f `a` (commaE `a` x `a` y)) + (\f x y -> f `a` x `a` y), + -- uncurry (,) --> id + rr (uncurryE `a` commaE) + (idE), + -- uncurry f . s (,) g --> s f g + rr1 (\f g -> (uncurryE `a` f) `c` (sE `a` commaE `a` g)) + (\f g -> sE `a` f `a` g), + -- curry fst --> const + rr (curryE `a` fstE) (constE), + -- curry snd --> const id + rr (curryE `a` sndE) (constE `a` idE), + -- s f g x --> f x (g x) + rr0 (\f g x -> sE `a` f `a` g `a` x) + (\f g x -> f `a` x `a` (g `a` x)), + -- flip f x y --> f y x + rr0 (\f x y -> flipE `a` f `a` x `a` y) + (\f x y -> f `a` y `a` x), + -- flip (=<<) --> (>>=) + rr0 (flipE `a` extE) + bindE, + + -- TODO: Think about map/fmap + -- fmap id --> id + rr (fmapE `a` idE) + (idE), + -- map id --> id + rr (mapE `a` idE) + (idE), + -- (f . g) . h --> f . (g . h) + rr0 (\f g h -> (f `c` g) `c` h) + (\f g h -> f `c` (g `c` h)), + -- fmap f . fmap g -> fmap (f . g) + rr0 (\f g -> fmapE `a` f `c` fmapE `a` g) + (\f g -> fmapE `a` (f `c` g)), + -- map f . map g -> map (f . g) + rr0 (\f g -> mapE `a` f `c` mapE `a` g) + (\f g -> mapE `a` (f `c` g)) + + ] + +onceRewrites :: RewriteRule +onceRewrites = Hard $ Or [ + -- ($) --> id + rr0 (dollarE) + idE, + -- concatMap --> (=<<) + rr concatMapE extE, + -- concat --> join + rr concatE joinE, + -- liftM --> fmap + rr liftME fmapE, + -- map --> fmap + rr mapE fmapE, + -- subtract -> flip (-) + rr subtractE + (flipE `a` minusE) + ] + +-- Now we can state rewrite rules in a nice high level way +-- Rewrite rules should be as pointful as possible since the pointless variants +-- will be derived automatically. +rules :: RewriteRule +rules = Or [ + -- f (g x) --> (f . g) x + Hard $ + rr (\f g x -> f `a` (g `a` x)) + (\f g x -> (f `c` g) `a` x), + -- (>>=) --> flip (=<<) + Hard $ + rr bindE + (flipE `a` extE), + -- (.) id --> id + rr (compE `a` idE) + idE, + -- (++) [x] --> (:) x + rr (\x -> appendE `a` (consE `a` x `a` nilE)) + (\x -> consE `a` x), + -- (=<<) return --> id + rr (extE `a` returnE) + idE, + -- (=<<) f (return x) -> f x + rr (\f x -> extE `a` f `a` (returnE `a` x)) + (\f x -> f `a` x), + -- (=<<) ((=<<) f . g) --> (=<<) f . (=<<) g + rr (\f g -> extE `a` ((extE `a` f) `c` g)) + (\f g -> (extE `a` f) `c` (extE `a` g)), + -- flip (f . g) --> flip (.) g . flip f + Hard $ + rr (\f g -> flipE `a` (f `c` g)) + (\f g -> (flipE `a` compE `a` g) `c` (flipE `a` f)), + -- flip (.) f . flip id --> flip f + rr (\f -> (flipE `a` compE `a` f) `c` (flipE `a` idE)) + (\f -> flipE `a` f), + -- flip (.) f . flip flip --> flip (flip . f) + rr (\f -> (flipE `a` compE `a` f) `c` (flipE `a` flipE)) + (\f -> flipE `a` (flipE `c` f)), + -- flip (flip (flip . f) g) --> flip (flip . flip f) g + rr1 (\f g -> flipE `a` (flipE `a` (flipE `c` f) `a` g)) + (\f g -> flipE `a` (flipE `c` flipE `a` f) `a` g), + + -- flip (.) id --> id + rr (flipE `a` compE `a` idE) + idE, + -- (.) . flip id --> flip flip + rr (compE `c` (flipE `a` idE)) + (flipE `a` flipE), + -- s const x y --> y + rr (\x y -> sE `a` constE `a` x `a` y) + (\_ y -> y), + -- s (const . f) g --> f + rr1 (\f g -> sE `a` (constE `c` f) `a` g) + (\f _ -> f), + -- s (const f) --> (.) f + rr (\f -> sE `a` (constE `a` f)) + (\f -> compE `a` f), + -- s (f . fst) snd --> uncurry f + rr (\f -> sE `a` (f `c` fstE) `a` sndE) + (\f -> uncurryE `a` f), + -- fst (join (,) x) --> x + rr (\x -> fstE `a` (joinE `a` commaE `a` x)) + (\x -> x), + -- snd (join (,) x) --> x + rr (\x -> sndE `a` (joinE `a` commaE `a` x)) + (\x -> x), + -- The next two are `simplifies', strictly speaking, but invoked rarely. + -- uncurry f (x,y) --> f x y +-- rr (\f x y -> uncurryE `a` f `a` (commaE `a` x `a` y)) +-- (\f x y -> f `a` x `a` y), + -- curry (uncurry f) --> f + rr (\f -> curryE `a` (uncurryE `a` f)) + (\f -> f), + -- uncurry (curry f) --> f + rr (\f -> uncurryE `a` (curryE `a` f)) + (\f -> f), + -- (const id . f) --> const id + rr (\f -> (constE `a` idE) `c` f) + (\_ -> constE `a` idE), + -- const x . f --> const x + rr (\x f -> constE `a` x `c` f) + (\x _ -> constE `a` x), + -- fix f --> f (fix x) + Hard $ + rr0 (\f -> fixE `a` f) + (\f -> f `a` (fixE `a` f)), + -- f (fix f) --> fix x + Hard $ + rr0 (\f -> f `a` (fixE `a` f)) + (\f -> fixE `a` f), + -- fix f --> f (f (fix x)) + Hard $ + rr0 (\f -> fixE `a` f) + (\f -> f `a` (f `a` (fixE `a` f))), + -- fix (const f) --> f + rr (\f -> fixE `a` (constE `a` f)) + (\f -> f), + -- flip const x --> id + rr (\x -> flipE `a` constE `a` x) + (\_ -> idE), + -- const . f --> flip (const f) + Hard $ + rr (\f -> constE `c` f) + (\f -> flipE `a` (constE `a` f)), + -- not (x == y) -> x /= y + rr2 (\x y -> notE `a` (equalsE `a` x `a` y)) + (\x y -> nequalsE `a` x `a` y), + -- not (x /= y) -> x == y + rr2 (\x y -> notE `a` (nequalsE `a` x `a` y)) + (\x y -> equalsE `a` x `a` y), + If (Or [rr plusE plusE, rr minusE minusE, rr multE multE]) $ down $ Or [ + -- 0 + x --> x + rr (\x -> plusE `a` zeroE `a` x) + (\x -> x), + -- 0 * x --> 0 + rr (\x -> multE `a` zeroE `a` x) + (\_ -> zeroE), + -- 1 * x --> x + rr (\x -> multE `a` oneE `a` x) + (\x -> x), + -- x - x --> 0 + rr (\x -> minusE `a` x `a` x) + (\_ -> zeroE), + -- x - y + y --> x + rr (\y x -> plusE `a` (minusE `a` x `a` y) `a` y) + (\_ x -> x), + -- x + y - y --> x + rr (\y x -> minusE `a` (plusE `a` x `a` y) `a` y) + (\_ x -> x), + -- x + (y - z) --> x + y - z + rr (\x y z -> plusE `a` x `a` (minusE `a` y `a` z)) + (\x y z -> minusE `a` (plusE `a` x `a` y) `a` z), + -- x - (y + z) --> x - y - z + rr (\x y z -> minusE `a` x `a` (plusE `a` y `a` z)) + (\x y z -> minusE `a` (minusE `a` x `a` y) `a` z), + -- x - (y - z) --> x + y - z + rr (\x y z -> minusE `a` x `a` (minusE `a` y `a` z)) + (\x y z -> minusE `a` (plusE `a` x `a` y) `a` z) + ], + + Hard onceRewrites, + -- join (fmap f x) --> f =<< x + rr (\f x -> joinE `a` (fmapE `a` f `a` x)) + (\f x -> extE `a` f `a` x), + -- (=<<) id --> join + rr (extE `a` idE) joinE, + -- join --> (=<<) id + Hard $ + rr joinE (extE `a` idE), + -- join (return x) --> x + rr (\x -> joinE `a` (returnE `a` x)) + (\x -> x), + -- (return . f) =<< m --> fmap f m + rr (\f m -> extE `a` (returnE `c` f) `a` m) + (\f m -> fmapIE `a` f `a` m), + -- (x >>=) . (return .) . f --> flip (fmap . f) x + rr (\f x -> bindE `a` x `c` (compE `a` returnE) `c` f) + (\f x -> flipE `a` (fmapIE `c` f) `a` x), + -- (>>=) (return f) --> flip id f + rr (\f -> bindE `a` (returnE `a` f)) + (\f -> flipE `a` idE `a` f), + -- liftM2 f x --> ap (f `fmap` x) + Hard $ + rr (\f x -> liftM2E `a` f `a` x) + (\f x -> apE `a` (fmapIE `a` f `a` x)), + -- liftM2 f (return x) --> fmap (f x) + rr (\f x -> liftM2E `a` f `a` (returnE `a` x)) + (\f x -> fmapIE `a` (f `a` x)), + -- f `fmap` return x --> return (f x) + rr (\f x -> fmapE `a` f `a` (returnE `a` x)) + (\f x -> returnE `a` (f `a` x)), + -- (=<<) . flip (fmap . f) --> flip liftM2 f + Hard $ + rr (\f -> extE `c` flipE `a` (fmapE `c` f)) + (\f -> flipE `a` liftM2E `a` f), + + -- (.) -> fmap + Hard $ + rr compE fmapE, + + -- map f (zip xs ys) --> zipWith (curry f) xs ys + Hard $ + rr (\f xs ys -> mapE `a` f `a` (zipE `a` xs `a` ys)) + (\f xs ys -> zipWithE `a` (curryE `a` f) `a` xs `a` ys), + -- zipWith (,) --> zip (,) + rr (zipWithE `a` commaE) zipE, + + -- all f --> and . map f + Hard $ + rr (\f -> allE `a` f) + (\f -> andE `c` mapE `a` f), + -- and . map f --> all f + rr (\f -> andE `c` mapE `a` f) + (\f -> allE `a` f), + -- any f --> or . map f + Hard $ + rr (\f -> anyE `a` f) + (\f -> orE `c` mapE `a` f), + -- or . map f --> any f + rr (\f -> orE `c` mapE `a` f) + (\f -> anyE `a` f), + + -- return f `ap` x --> fmap f x + rr (\f x -> apE `a` (returnE `a` f) `a` x) + (\f x -> fmapIE `a` f `a` x), + -- ap (f `fmap` x) --> liftM2 f x + rr (\f x -> apE `a` (fmapIE `a` f `a` x)) + (\f x -> liftM2E `a` f `a` x), + -- f `ap` x --> (`fmap` x) =<< f + Hard $ + rr (\f x -> apE `a` f `a` x) + (\f x -> extE `a` (flipE `a` fmapIE `a` x) `a` f), + -- (`fmap` x) =<< f --> f `ap` x + rr (\f x -> extE `a` (flipE `a` fmapIE `a` x) `a` f) + (\f x -> apE `a` f `a` x), + -- (x >>=) . flip (fmap . f) -> liftM2 f x + rr (\f x -> bindE `a` x `c` flipE `a` (fmapE `c` f)) + (\f x -> liftM2E `a` f `a` x), + + -- (f =<< m) x --> f (m x) x + rr0 (\f m x -> extE `a` f `a` m `a` x) + (\f m x -> f `a` (m `a` x) `a` x), + -- (fmap f g x) --> f (g x) + rr0 (\f g x -> fmapE `a` f `a` g `a` x) + (\f g x -> f `a` (g `a` x)), + -- return x y --> y + rr (\y x -> returnE `a` x `a` y) + (\y _ -> y), + -- liftM2 f g h x --> g x `h` h x + rr0 (\f g h x -> liftM2E `a` f `a` g `a` h `a` x) + (\f g h x -> f `a` (g `a` x) `a` (h `a` x)), + -- ap f id --> join f + rr (\f -> apE `a` f `a` idE) + (\f -> joinE `a` f), + + -- (=<<) const q --> flip (>>) q + Hard $ -- ?? + rr (\q p -> extE `a` (constE `a` q) `a` p) + (\q p -> seqME `a` p `a` q), + -- p >> q --> const q =<< p + Hard $ + rr (\p q -> seqME `a` p `a` q) + (\p q -> extE `a` (constE `a` q) `a` p), + + -- experimental support for Control.Arrow stuff + -- (costs quite a bit of performace) + -- uncurry ((. g) . (,) . f) --> f *** g + rr (\f g -> uncurryE `a` ((flipE `a` compE `a` g) `c` commaE `c` f)) + (\f g -> crossE `a` f `a` g), + -- uncurry ((,) . f) --> first f + rr (\f -> uncurryE `a` (commaE `c` f)) + (\f -> firstE `a` f), + -- uncurry ((. g) . (,)) --> second g + rr (\g -> uncurryE `a` ((flipE `a` compE `a` g) `c` commaE)) + (\g -> secondE `a` g), + -- I think we need all three of them: + -- uncurry (const f) --> f . snd + rr (\f -> uncurryE `a` (constE `a` f)) + (\f -> f `c` sndE), + -- uncurry const --> fst + rr (uncurryE `a` constE) + (fstE), + -- uncurry (const . f) --> f . fst + rr (\f -> uncurryE `a` (constE `c` f)) + (\f -> f `c` fstE), + + -- TODO is this the right place? + -- [x] --> return x + Hard $ + rr (\x -> consE `a` x `a` nilE) + (\x -> returnE `a` x), + -- list destructors + Hard $ + If (Or [rr consE consE, rr nilE nilE]) $ Or [ + down $ Or [ + -- length [] --> 0 + rr (lengthE `a` nilE) + zeroE, + -- length (x:xs) --> 1 + length xs + rr (\x xs -> lengthE `a` (consE `a` x `a` xs)) + (\_ xs -> plusE `a` oneE `a` (lengthE `a` xs)) + ], + -- map/fmap elimination + down $ Or [ + -- map f (x:xs) --> f x: map f xs + rr (\f x xs -> mapE `a` f `a` (consE `a` x `a` xs)) + (\f x xs -> consE `a` (f `a` x) `a` (mapE `a` f `a` xs)), + -- fmap f (x:xs) --> f x: Fmap f xs + rr (\f x xs -> fmapE `a` f `a` (consE `a` x `a` xs)) + (\f x xs -> consE `a` (f `a` x) `a` (fmapE `a` f `a` xs)), + -- map f [] --> [] + rr (\f -> mapE `a` f `a` nilE) + (\_ -> nilE), + -- fmap f [] --> [] + rr (\f -> fmapE `a` f `a` nilE) + (\_ -> nilE) + ], + -- foldr elimination + down $ Or [ + -- foldr f z (x:xs) --> f x (foldr f z xs) + rr (\f x xs z -> (foldrE `a` f `a` z) `a` (consE `a` x `a` xs)) + (\f x xs z -> (f `a` x) `a` (foldrE `a` f `a` z `a` xs)), + -- foldr f z [] --> z + rr (\f z -> foldrE `a` f `a` z `a` nilE) + (\_ z -> z) + ], + -- foldl elimination + down $ Opt (CRR $ assocL ["."]) `Then` Or [ + -- sum xs --> foldl (+) 0 xs + rr (\xs -> sumE `a` xs) + (\xs -> foldlE `a` plusE `a` zeroE `a` xs), + -- product xs --> foldl (*) 1 xs + rr (\xs -> productE `a` xs) + (\xs -> foldlE `a` multE `a` oneE `a` xs), + -- foldl1 f (x:xs) --> foldl f x xs + rr (\f x xs -> foldl1E `a` f `a` (consE `a` x `a` xs)) + (\f x xs -> foldlE `a` f `a` x `a` xs), + -- foldl f z (x:xs) --> foldl f (f z x) xs + rr (\f z x xs -> (foldlE `a` f `a` z) `a` (consE `a` x `a` xs)) + (\f z x xs -> foldlE `a` f `a` (f `a` z `a` x) `a` xs), + -- foldl f z [] --> z + rr (\f z -> foldlE `a` f `a` z `a` nilE) + (\_ z -> z), + -- special rule: + -- foldl f z [x] --> f z x + rr (\f z x -> foldlE `a` f `a` z `a` (returnE `a` x)) + (\f z x -> f `a` z `a` x), + rr (\f z x -> foldlE `a` f `a` z `a` (consE `a` x `a` nilE)) + (\f z x -> f `a` z `a` x) + ] `OrElse` ( + -- (:) x --> (++) [x] + Opt (rr0 (\x -> consE `a` x) + (\x -> appendE `a` (consE `a` x `a` nilE))) `Then` + -- More special rule: (:) x . (++) ys --> (++) (x:ys) + up (rr0 (\x ys -> (consE `a` x) `c` (appendE `a` ys)) + (\x ys -> appendE `a` (consE `a` x `a` ys))) + ) + ], + + -- Complicated Transformations + CRR (collapseLists), + up $ Or [CRR (evalUnary unaryBuiltins), CRR (evalBinary binaryBuiltins)], + up $ CRR (assoc assocOps), + up $ CRR (assocL assocOps), + up $ CRR (assocR assocOps), + Up (CRR (commutative commutativeOps)) $ down $ Or [CRR $ assocL assocLOps, + CRR $ assocR assocROps], + + Hard $ simplifies + ] `Then` Opt (up simplifies) +assocLOps, assocROps, assocOps :: [String] +assocLOps = ["+", "*", "&&", "||", "max", "min"] +assocROps = [".", "++"] +assocOps = assocLOps ++ assocROps + +commutativeOps :: [String] +commutativeOps = ["*", "+", "==", "/=", "max", "min"] + +unaryBuiltins :: [(String,Unary)] +unaryBuiltins = [ + ("not", UA (not :: Bool -> Bool)), + ("negate", UA (negate :: Integer -> Integer)), + ("signum", UA (signum :: Integer -> Integer)), + ("abs", UA (abs :: Integer -> Integer)) + ] + +binaryBuiltins :: [(String,Binary)] +binaryBuiltins = [ + ("+", BA ((+) :: Integer -> Integer -> Integer)), + ("-", BA ((-) :: Integer -> Integer -> Integer)), + ("*", BA ((*) :: Integer -> Integer -> Integer)), + ("^", BA ((^) :: Integer -> Integer -> Integer)), + ("<", BA ((<) :: Integer -> Integer -> Bool)), + (">", BA ((>) :: Integer -> Integer -> Bool)), + ("==", BA ((==) :: Integer -> Integer -> Bool)), + ("/=", BA ((/=) :: Integer -> Integer -> Bool)), + ("<=", BA ((<=) :: Integer -> Integer -> Bool)), + (">=", BA ((>=) :: Integer -> Integer -> Bool)), + ("div", BA (div :: Integer -> Integer -> Integer)), + ("mod", BA (mod :: Integer -> Integer -> Integer)), + ("max", BA (max :: Integer -> Integer -> Integer)), + ("min", BA (min :: Integer -> Integer -> Integer)), + ("&&", BA ((&&) :: Bool -> Bool -> Bool)), + ("||", BA ((||) :: Bool -> Bool -> Bool)) + ] + diff --git a/Plugin/Pl/Test.hs b/Plugin/Pl/Test.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Test.hs @@ -0,0 +1,260 @@ +module Main where + +#define READLINE +#if __GLASGOW_HASKELL__ > 602 +import Test.HUnit +import Test.QuickCheck hiding (test) +#else +import HUnit +import Debug.QuickCheck hiding (test) +#endif + +import Plugin.Pl.Common +import Plugin.Pl.Transform +import Plugin.Pl.Parser +import Plugin.Pl.PrettyPrinter + +import Data.List ((\\)) +import Data.Char (isSpace) + +import Control.Monad.Error + +import System.IO (hSetBuffering, stdout, BufferMode(NoBuffering)) +import System.Environment (getArgs) + +#ifdef READLINE +import System.Console.Readline (readline, addHistory, initialize) +#endif + +import Debug.Trace + +instance Arbitrary Expr where + arbitrary = sized $ \size -> frequency $ zipWith (,) [1,size,size] + [arbVar, + liftM2 Lambda arbPat arbitrary, + let se = resize (size `div` 2) arbitrary in liftM2 App se se ] + coarbitrary = error "Expr.coarbitrary" + +arbVar :: Gen Expr +arbVar = oneof [(Var Pref . return) `fmap` choose ('a','z'), + (Var Inf . return) `fmap` elements (opchars\\"=")] + +arbPat :: Gen Pattern +arbPat = sized $ \size -> + let + spat = resize (size `div` 5) arbPat + in + frequency $ zipWith (,) [1,size,size] [ + (PVar . return) `fmap` choose ('a','z'), + liftM2 PTuple spat spat, + liftM2 PCons spat spat] + +propRoundTrip :: Expr -> Bool +propRoundTrip e = Right (TLE e) == parsePF (show e) + +-- hacking qc2 functionality (?) in here +propRoundTrip' :: Expr -> Property +propRoundTrip' e = not (propRoundTrip e) ==> trace (show $ findMin e) False + where + findMin e' = case filter (not . propRoundTrip) $ subExpr e' of + [] -> e' + (x:_) -> findMin x + +propMonotonic1 :: Expr -> Expr -> Expr -> Bool +propMonotonic1 e e1 e2 = App e e1 `compare` App e e2 == e1 `compare` e2 + +propMonotonic2 :: Expr -> Expr -> Expr -> Bool +propMonotonic2 e e1 e2 = App e1 e `compare` App e2 e == e1 `compare` e2 + +subExpr :: Expr -> [Expr] +subExpr (Var _ _) = [] +subExpr (Lambda v e) = [e] ++ Lambda v `map` subExpr e +subExpr (App e1 e2) = [e1, e2] + ++ App e1 `map` subExpr e2 ++ (`App` e2) `map` subExpr e1 +subExpr (Let {}) = bt + +sizeTest :: IO () +sizeTest = quickCheck $ \e -> collect (sizeExpr e) (propRoundTrip e) + +quick :: Config +quick = Config + { configMaxTest = 100 + , configMaxFail = 1000 + , configSize = const 40 + , configEvery = \n _ -> let sh = show n in sh ++ [ '\b' | _ <- sh ] + } + +myTest :: IO () +myTest = check quick propRoundTrip' + +qcTests :: IO () +qcTests = do + quickCheck propRoundTrip + quickCheck propMonotonic1 + quickCheck propMonotonic2 + +pf :: String -> IO () +pf inp = case parsePF inp of + Right d -> do + putStrLn "Your expression:" + print d + putStrLn "Transformed to pointfree style:" + let d' = mapTopLevel transform d + print $ d' + putStrLn "Optimized expression:" + mapM_ print $ mapTopLevel' optimize d' + Left err -> putStrLn $ err + +mapTopLevel' :: Functor f => (Expr -> f Expr) -> TopLevel -> f TopLevel +mapTopLevel' f tl = case getExpr tl of (e, c) -> fmap c $ f e + +pf' :: String -> IO () +pf' = putStrLn . (id ||| show) . parsePF + +-- NB: this is a special case of (import Control.Monad.Reader) +-- ap :: m (a -> b) -> m a -> m b +s :: (t -> a -> b) -> (t -> a) -> t -> b +s f g x = f x $ g x + +unitTest :: String -> [String] -> Test +unitTest inp out = TestCase $ do + d <- case parsePF inp of + Right x -> return x + Left err -> fail $ "Parse error on input " ++ inp ++ ": " ++ err + let d' = mapTopLevel (last . optimize . transform) d + foldr1 mplus [assertEqual (inp++" failed.") o (show d') | o <- out] + +unitTests :: Test +unitTests = TestList [ + unitTest "foldr (++) []" ["join"], + unitTest "flip flip [] . ((:) .)" ["(return .)"], + unitTest "\\x -> x - 2" ["subtract 2"], + unitTest "\\(x,_) (y,_) -> x == y" ["(. fst) . (==) . fst"], + unitTest "\\x y z -> return x >>= \\x' -> return y >>= \\y' -> return z >>= \\z' -> f x' y' z'" ["f"], + unitTest "let (x,y) = (1,2) in y" ["2"], + unitTest "fix . const" ["id"], + unitTest "all f . map g" ["all (f . g)"], + unitTest "any f . map g" ["any (f . g)"], + unitTest "liftM2 ($)" ["ap"], + unitTest "\\f -> f x" ["($ x)"], + unitTest "flip (-)" ["subtract"], + unitTest "\\xs -> [f x | x <- xs, p x]" ["map f . filter p"], + unitTest "all id" ["and"], + unitTest "any id" ["or"], + unitTest "and . map f" ["all f"], + unitTest "or . map f" ["any f"], + unitTest "return ()" ["return ()"], + unitTest "f (fix f)" ["fix f"], + unitTest "concat ([concat (map h (k a))])" ["h =<< k a"], + unitTest "uncurry (const f)" ["f . snd"], + unitTest "uncurry const" ["fst"], + unitTest "uncurry (const . f)" ["f . fst"], + unitTest "\\a b -> a >>= \\x -> b >>= \\y -> return (x,y)" ["liftM2 (,)"], + unitTest "\\b a -> a >>= \\x -> b >>= \\y -> return (x,y)" ["flip liftM2 (,)"], + unitTest "curry snd" ["const id"], + unitTest "\\x -> return x y" ["const y"], + unitTest "\\x -> f x x" ["join f"], + unitTest "join (+) 1" ["2"], + unitTest "fmap f g x" ["f (g x)"], + unitTest "liftM2 (+) f g 0" ["f 0 + g 0", "g 0 + f 0"], + unitTest "return 1 x" ["x"], + unitTest "f =<< return x" ["f x"], + unitTest "(=<<) id" ["join"], + unitTest "zipWith (,)" ["zip"], + unitTest "map fst . zip [1..]" ["zipWith const [1..]"], + unitTest "curry . uncurry" ["id"], + unitTest "uncurry . curry" ["id"], + unitTest "curry fst" ["const"], + unitTest "return x >> y" ["y"], + -- What were they smoking when they decided >> should be infixl + unitTest "a >>= \\_ -> b >>= \\_ -> return $ const (1 + 2) $ a + b" ["a >> (b >> return 3)"], + unitTest "foo = m >>= \\x -> return 1" ["foo = m >> return 1"], + unitTest "foo m = m >>= \\x -> return 1" ["foo = (>> return 1)"], + unitTest "return (+) `ap` return 1 `ap` return 2" ["return 3"], + unitTest "liftM2 (+) (return 1) (return 2)" ["return 3"], + unitTest "(. ((return .) . (+))) . (>>=)" ["flip (fmap . (+))"], + unitTest "\\a b -> a >>= \\x -> b >>= \\y -> return $ x + y" ["liftM2 (+)"], + unitTest "ap (flip const . f)" ["id"], + unitTest "uncurry (flip (const . flip (,) (snd t))) . ap (,) id" ["flip (,) (snd t)"], + unitTest "foo = (1, fst foo)" ["foo = (1, 1)"], + unitTest "foo = (snd foo, 1)" ["foo = (1, 1)"], + unitTest "map (+1) [1,2,3]" ["[2, 3, 4]"], + unitTest "snd . (,) (\\x -> x*x)" ["id"], + unitTest "return x >>= f" ["f x"], + unitTest "m >>= return" ["m"], + unitTest "m >>= \\x -> f x >>= g" ["m >>= f >>= g", "g =<< f =<< m"], + unitTest "\\x -> 1:2:3:4:x" ["([1, 2, 3, 4] ++)"], + unitTest "\\(x:xs) -> x" ["head"], + unitTest "\\(x:xs) -> xs" ["tail"], + unitTest "\\(x,y) -> x" ["fst"], + unitTest "\\(x,y) -> y" ["snd"], + unitTest "\\x -> x" ["id"], + unitTest "\\x y -> x" ["const"], + unitTest "\\f x y -> f y x" ["flip"], + unitTest "t f g x = f x (g x)" ["t = ap"], + unitTest "(+2).(+3).(+4)" ["(9 +)"], + unitTest "head $ fix (x:)" ["x"], + unitTest "head $ tail $ let xs = x:ys; ys = y:ys in xs" ["y"], + unitTest "head $ tail $ let ys = y:ys in let xs = x:ys in xs" ["y"], + unitTest "2+3*4-3*3" ["5"], + unitTest "foldr (+) x [1,2,3,4]" ["10 + x", "x + 10"], + unitTest "foldl (+) x [1,2,3,4]" ["10 + x", "x + 10"], + unitTest "head $ fst (x:xs, y:ys)" ["x"], + unitTest "snd $ (,) 2 3" ["3"], + unitTest "\\id x -> id" ["const"], + unitTest "\\y -> let f x = foo x; g = f in g y" ["foo"], + unitTest "neq x y = not $ x == y" ["neq = (/=)"], + unitTest "not (x /= y)" ["x == y"], + unitTest "\\x x -> x" ["const id"], + unitTest "\\(x, x) -> x" ["snd"], + unitTest "not $ not 4" ["4"], + unitTest "\\xs -> foldl (+) 0 (1:2:xs)" ["foldl (+) 3"], + unitTest "\\x -> foldr (+) x [0,1,2,3]" ["(6 +)"], + unitTest "foldr (+) 0 [x,y,z]" ["x + y + z"], + unitTest "foldl (*) 0 [x,y,z]" ["0"], + unitTest "length \"abcdefg\"" ["7"], + unitTest "ap (f x . fst) snd" ["uncurry (f x)"], + unitTest "sum [1,2,3,x]" ["6 + x", "x + 6"], + unitTest "p x = product [1,2,3,x]" ["p = (6 *)"], + unitTest "(concat .) . map" ["(=<<)"], + unitTest "let f ((a,b),(c,d)) = a + b + c + d in f ((1,2),(3,4))" ["10"], + unitTest "let x = const 3 y; y = const 4 x in x + y" ["7"] -- yay! + ] + +main :: IO () +main = do + hSetBuffering stdout NoBuffering + args <- getArgs + case args of + ("tests":_) -> doTests + xs -> do + mapM_ pf xs +#ifdef READLINE + initialize +#endif + pfloop + + +pfloop :: IO () +pfloop = do +#ifdef READLINE + line' <- readline "pointless> " +#else + line' <- Just `fmap` getLine +#endif + case line' of + Just line + | all isSpace line -> pfloop + | otherwise -> do +#ifdef READLINE + addHistory line +#endif + pf line + pfloop + Nothing -> putStrLn "Bye." + +doTests :: IO () +doTests = do + runTestTT unitTests +-- qcTests + return () diff --git a/Plugin/Pl/Transform.hs b/Plugin/Pl/Transform.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pl/Transform.hs @@ -0,0 +1,215 @@ +{-# OPTIONS -fvia-C -O2 -optc-O3 #-} +module Plugin.Pl.Transform ( + transform, optimize, + ) where + +import Plugin.Pl.Common +import Plugin.Pl.Rules +import Plugin.Pl.PrettyPrinter + +import Data.List (nub) +import qualified Data.Map as M + +import Data.Graph (stronglyConnComp, flattenSCC, flattenSCCs) +import Control.Monad.State + +{- +nub :: Ord a => [a] -> [a] +nub = nub' S.empty where + nub' _ [] = [] + nub' set (x:xs) + | x `S.member` set = nub' set xs + | otherwise = x: nub' (x `S.insert` set) xs +-} + +occursP :: String -> Pattern -> Bool +occursP v (PVar v') = v == v' +occursP v (PTuple p1 p2) = v `occursP` p1 || v `occursP` p2 +occursP v (PCons p1 p2) = v `occursP` p1 || v `occursP` p2 + +freeIn :: String -> Expr -> Int +freeIn v (Var _ v') = fromEnum $ v == v' +freeIn v (Lambda pat e) = if v `occursP` pat then 0 else freeIn v e +freeIn v (App e1 e2) = freeIn v e1 + freeIn v e2 +freeIn v (Let ds e') = if v `elem` map declName ds then 0 + else freeIn v e' + sum [freeIn v e | Define _ e <- ds] + +isFreeIn :: String -> Expr -> Bool +isFreeIn v e = freeIn v e > 0 + +tuple :: [Expr] -> Expr +tuple es = foldr1 (\x y -> Var Inf "," `App` x `App` y) es + +tupleP :: [String] -> Pattern +tupleP vs = foldr1 PTuple $ PVar `map` vs + +dependsOn :: [Decl] -> Decl -> [Decl] +dependsOn ds d = [d' | d' <- ds, declName d' `isFreeIn` declExpr d] + +unLet :: Expr -> Expr +unLet (App e1 e2) = App (unLet e1) (unLet e2) +unLet (Let [] e) = unLet e +unLet (Let ds e) = unLet $ + (Lambda (tupleP $ declName `map` dsYes) (Let dsNo e)) `App` + (fix' `App` (Lambda (tupleP $ declName `map` dsYes) + (tuple $ declExpr `map` dsYes))) + where + comps = stronglyConnComp [(d',d',dependsOn ds d') | d' <- ds] + dsYes = flattenSCC $ head comps + dsNo = flattenSCCs $ tail comps + +unLet (Lambda v e) = Lambda v (unLet e) +unLet (Var f x) = Var f x + +type Env = M.Map String String + +-- It's a pity we still need that for the pointless transformation. +-- Otherwise a newly created id/const/... could be bound by a lambda +-- e.g. transform' (\id x -> x) ==> transform' (\id -> id) ==> id +alphaRename :: Expr -> Expr +alphaRename e = alpha e `evalState` M.empty where + alpha :: Expr -> State Env Expr + alpha (Var f v) = do fm <- get; return $ Var f $ maybe v id (M.lookup v fm) + alpha (App e1 e2) = liftM2 App (alpha e1) (alpha e2) + alpha (Let _ _) = assert False bt + alpha (Lambda v e') = inEnv $ liftM2 Lambda (alphaPat v) (alpha e') + + -- act like a reader monad + inEnv :: State s a -> State s a + inEnv (State f) = State $ \s -> (fst $ f s, s) + + alphaPat (PVar v) = do + fm <- get + let v' = "$" ++ show (M.size fm) + put $ M.insert v v' fm + return $ PVar v' + alphaPat (PTuple p1 p2) = liftM2 PTuple (alphaPat p1) (alphaPat p2) + alphaPat (PCons p1 p2) = liftM2 PCons (alphaPat p1) (alphaPat p2) + + +transform :: Expr -> Expr +transform = transform' . alphaRename . unLet + +transform' :: Expr -> Expr +transform' (Let {}) = assert False bt +transform' (Var f v) = Var f v +transform' (App e1 e2) = App (transform' e1) (transform' e2) +transform' (Lambda (PTuple p1 p2) e) + = transform' $ Lambda (PVar "z") $ + (Lambda p1 $ Lambda p2 $ e) `App` f `App` s where + f = Var Pref "fst" `App` Var Pref "z" + s = Var Pref "snd" `App` Var Pref "z" +transform' (Lambda (PCons p1 p2) e) + = transform' $ Lambda (PVar "z") $ + (Lambda p1 $ Lambda p2 $ e) `App` f `App` s where + f = Var Pref "head" `App` Var Pref "z" + s = Var Pref "tail" `App` Var Pref "z" +transform' (Lambda (PVar v) e) = transform' $ getRidOfV e where + getRidOfV (Var f v') | v == v' = id' + | otherwise = const' `App` Var f v' + getRidOfV l@(Lambda pat _) = assert (not $ v `occursP` pat) $ + getRidOfV $ transform' l + getRidOfV (Let {}) = assert False bt + getRidOfV e'@(App e1 e2) + | fr1 && fr2 = scomb `App` getRidOfV e1 `App` getRidOfV e2 + | fr1 = flip' `App` getRidOfV e1 `App` e2 + | Var _ v' <- e2, v' == v = e1 + | fr2 = comp `App` e1 `App` getRidOfV e2 + | True = const' `App` e' + where + fr1 = v `isFreeIn` e1 + fr2 = v `isFreeIn` e2 + +cut :: [a] -> [a] +cut = take 1 + +toMonadPlus :: MonadPlus m => Maybe a -> m a +toMonadPlus Nothing = mzero +toMonadPlus (Just x)= return x + +type Size = Double +-- This seems to be a better size for our purposes, +-- despite being "a little" slower because of the wasteful uglyprinting +sizeExpr' :: Expr -> Size +sizeExpr' e = fromIntegral (length $ show e) + adjust e where + -- hackish thing to favor some expressions if the length is the same: + -- (+ x) --> (x +) + -- x >>= f --> f =<< x + -- f $ g x --> f (g x) + adjust :: Expr -> Size + adjust (Var _ str) -- Just n <- readM str = log (n*n+1) / 4 + | str == "uncurry" = -4 +-- | str == "s" = 5 + | str == "flip" = 0.1 + | str == ">>=" = 0.05 + | str == "$" = 0.01 + | str == "subtract" = 0.01 + | str == "ap" = 2 + | str == "liftM2" = 1.01 + | str == "return" = -2 + | str == "zipWith" = -4 + | str == "const" = 0 -- -2 + | str == "fmap" = -1 + adjust (Lambda _ e') = adjust e' + adjust (App e1 e2) = adjust e1 + adjust e2 + adjust _ = 0 + +optimize :: Expr -> [Expr] +optimize e = result where + result :: [Expr] + result = map (snd . fromJust) . takeWhile isJust . + iterate ((=<<) simpleStep) $ Just (sizeExpr' e, e) + + simpleStep :: (Size, Expr) -> Maybe (Size, Expr) + simpleStep t = do + let chn = let ?first = True in step (snd t) + chnn = let ?first = False in step =<< chn + new = filter (\(x,_) -> x < fst t) . map (sizeExpr' &&& id) $ + snd t: chn ++ chnn + case new of + [] -> Nothing + (new':_) -> return new' + +step :: (?first :: Bool) => Expr -> [Expr] +step e = nub $ rewrite rules e + +rewrite :: (?first :: Bool) => RewriteRule -> Expr -> [Expr] +rewrite rl e = case rl of + Up r1 r2 -> let e' = cut $ rewrite r1 e + e'' = rewrite r2 =<< e' + in if null e'' then e' else e'' + OrElse r1 r2 -> let e' = rewrite r1 e + in if null e' then rewrite r2 e else e' + Then r1 r2 -> rewrite r2 =<< nub (rewrite r1 e) + Opt r -> e: rewrite r e + If p r -> if null (rewrite p e) then mzero else rewrite r e + Hard r -> if ?first then rewrite r e else mzero + Or rs -> (\x -> rewrite x e) =<< rs + RR {} -> rewDeep rl e + CRR {} -> rewDeep rl e + Down {} -> rewDeep rl e + + where -- rew = ...; rewDeep = ... + +rewDeep :: (?first :: Bool) => RewriteRule -> Expr -> [Expr] +rewDeep rule e = rew rule e `mplus` case e of + Var _ _ -> mzero + Lambda _ _ -> error "lambda: optimizer only works for closed expressions" + Let _ _ -> error "let: optimizer only works for closed expressions" + App e1 e2 -> ((`App` e2) `map` rewDeep rule e1) `mplus` + ((e1 `App`) `map` rewDeep rule e2) + +rew :: (?first :: Bool) => RewriteRule -> Expr -> [Expr] +rew (RR r1 r2) e = toMonadPlus $ fire r1 r2 e +rew (CRR r) e = toMonadPlus $ r e +rew (Or rs) e = (\x -> rew x e) =<< rs +rew (Down r1 r2) e + = if null e'' then e' else e'' where + e' = cut $ rew r1 e + e'' = rewDeep r2 =<< e' +rew r@(Then {}) e = rewrite r e +rew r@(OrElse {}) e = rewrite r e +rew r@(Up {}) e = rewrite r e +rew r@(Opt {}) e = rewrite r e +rew r@(If {}) e = rewrite r e +rew r@(Hard {}) e = rewrite r e diff --git a/Plugin/Poll.hs b/Plugin/Poll.hs new file mode 100644 --- /dev/null +++ b/Plugin/Poll.hs @@ -0,0 +1,181 @@ +-- +-- | Module: Vote +-- | Support for voting +-- | +-- | License: lGPL +-- | +-- | added by Kenneth Hoste (boegel), 22/11/2005 +-- | inspiration: Where plugin (thanks shapr,dons) +-- +module Plugin.Poll (theModule) where + +import Plugin hiding (choice) +import qualified Data.ByteString.Char8 as P +import qualified Data.Map as M + +PLUGIN Vote + +newPoll :: Poll +newPoll = (True,[]) + +appendPoll :: String -> Poll -> (Maybe Poll) +appendPoll choice (o,ls) = Just (o,(choice,0):ls) + +voteOnPoll :: Poll -> String -> (Poll,String) +voteOnPoll (o,poll) choice = + if any (\(x,_) -> x == choice) poll + then ((o,map (\(c,n) -> + if c == choice then (c,n+1) + else (c,n)) poll) + ,"voted on " ++ show choice) + else ((o,poll),show choice ++ " is not currently a candidate in this poll") + +------------------------------------------------------------------------ + +type Count = Int +type Candidate = String +type PollName = P.ByteString +type Poll = (Bool, [(Candidate, Count)]) +type VoteState = M.Map PollName Poll +type VoteWriter = VoteState -> LB () +type Vote m a = ModuleT VoteState m a + +------------------------------------------------------------------------ +-- Define a serialiser + +voteSerial :: Serial VoteState +voteSerial = Serial (Just . showPacked) (Just . readPacked) + +------------------------------------------------------------------------ + +instance Module VoteModule VoteState where + moduleCmds _ = ["poll-list" + ,"poll-show" + ,"poll-add" + ,"choice-add" + ,"vote" + ,"poll-result" + ,"poll-close" + ,"poll-remove"] +-- + -- todo, should @vote foo automagically add foo as a possibility? + moduleHelp _ s = case s of + "poll-list" -> "poll-list Shows all current polls" + "poll-show" -> "poll-show Shows all choices for some poll" + "poll-add" -> "poll-add Adds a new poll, with no candidates" + "choice-add" -> "choice-add Adds a new choice to the given poll" + "vote" -> "vote Vote for in " + "poll-result" -> "poll-result Show result for given poll" + "poll-close" -> "poll-close Closes a poll" + "poll-remove" -> "poll-remove Removes a poll" + + moduleDefState _ = return M.empty + moduleSerialize _ = Just voteSerial + + process_ _ "poll-list" _ = do + result <- withMS $ \factFM writer -> processCommand factFM writer "poll-list" [] + return [result] + + process_ _ _ [] = return ["Missing argument. Check @help for info."] + + process_ _ cmd dat = do + result <- withMS $ \factFM writer -> processCommand factFM writer cmd (words dat) + return [result] + +------------------------------------------------------------------------ + +processCommand :: VoteState -> VoteWriter -> String -> [String] -> Vote LB String +processCommand fm writer cmd dat = case cmd of + + -- show all current polls + "poll-list" -> return $ listPolls fm + + -- show candidates + "poll-show" -> return $ case length dat of + 1 -> showPoll fm (head dat) + _ -> "usage: @poll-show " + + -- declare a new poll + "poll-add" -> case length dat of + 1 -> addPoll fm writer (head dat) + _ -> return "usage: @poll-add with \"ThisTopic\" style names" + + "choice-add" -> case length dat of + 2 -> addChoice fm writer (head dat) (last dat) + _ -> return "usage: @choice-add " + + "vote" -> case length dat of + 2 -> vote fm writer (head dat) (last dat) + _ -> return "usage: @vote " + + "poll-result" -> return $ case length dat of + 1 -> showResult fm (head dat) + _ -> "usage: @poll-result " + + "poll-close" -> case length dat of + 1 -> closePoll fm writer (head dat) + _ -> return "usage: @poll-close " + + "poll-remove" -> case length dat of + 1 -> removePoll fm writer (head dat) + _ -> return "usage: @poll-remove " + + _ -> return "Unknown command." + +------------------------------------------------------------------------ + +listPolls :: VoteState -> String +listPolls fm = show $ map fst (M.toList fm) + +showPoll :: VoteState -> String -> String +showPoll fm poll = + case M.lookup (P.pack poll) fm of + Nothing -> "No such poll: " ++ show poll ++ " Use @poll-list to see the available polls." + Just p -> show $ map fst (snd p) + +addPoll :: VoteState -> VoteWriter -> String -> Vote LB String +addPoll fm writer poll = + case M.lookup (P.pack poll) fm of + Nothing -> do writer $ M.insert (P.pack poll) newPoll fm + return $ "Added new poll: " ++ show poll + Just _ -> return $ "Poll " ++ show poll ++ + " already exists, choose another name for your poll" + +addChoice :: VoteState -> VoteWriter -> String -> String -> Vote LB String +addChoice fm writer poll choice = case M.lookup (P.pack poll) fm of + Nothing -> return $ "No such poll: " ++ show poll + Just _ -> do writer $ M.update (appendPoll choice) (P.pack poll) fm + return $ "New candidate " ++ show choice ++ + ", added to poll " ++ show poll ++ "." + +vote :: VoteState -> VoteWriter -> String -> String -> Vote LB String +vote fm writer poll choice = case M.lookup (P.pack poll) fm of + Nothing -> return $ "No such poll:" ++ show poll + Just (False,_) -> return $ "The "++ show poll ++ " poll is closed, sorry !" + Just p@(True,_) -> do let (np,msg) = voteOnPoll p choice + writer $ M.update (const (Just np)) (P.pack poll) fm + return msg + +showResult :: VoteState -> String -> String +showResult fm poll = case M.lookup (P.pack poll) fm of + Nothing -> "No such poll: " ++ show poll + Just (o,p) -> "Poll results for " ++ poll ++ " (" ++ (status o) ++ "): " + ++ (concat $ intersperse ", " $ map ppr p) + where + status s | s = "Open" + | otherwise = "Closed" + ppr (x,y) = x ++ "=" ++ show y + +removePoll :: VoteState -> VoteWriter -> String -> Vote LB String +removePoll fm writer poll = case M.lookup (P.pack poll) fm of + Just (True,_) -> return "Poll should be closed before you can remove it." + Just (False,_) -> do writer $ M.delete (P.pack poll) fm + return $ "poll " ++ show poll ++ " removed." + Nothing -> return $ "No such poll: " ++ show poll + +closePoll :: VoteState -> VoteWriter -> String -> Vote LB String +closePoll fm writer poll = case M.lookup (P.pack poll) fm of + Nothing -> return $ "No such poll: " ++ show poll + Just (_,p) -> do writer $ M.update (const (Just (False,p))) (P.pack poll) fm + return $ "Poll " ++ show poll ++ " closed." + diff --git a/Plugin/Pretty.hs b/Plugin/Pretty.hs new file mode 100644 --- /dev/null +++ b/Plugin/Pretty.hs @@ -0,0 +1,70 @@ +-- +-- | Pretty-Printing echo +-- +-- example: +-- +-- @pretty fun x = case x of {3 -> "hello" ; 5 -> "world" ; _ -> "else"} +-- +-- fun x +-- = case x of +-- 3 -> "hello" +-- 5 -> "world" +-- _ -> "else" +-- +-- (c) Johannes Ahlmann, 2005-12-13, released under GPL 2 +-- +module Plugin.Pretty where + +import Plugin + +import Language.Haskell.Parser +import Language.Haskell.Syntax hiding (Module) +import Language.Haskell.Pretty + +PLUGIN Pretty + +instance Module PrettyModule (String -> IO String) where + moduleCmds _ = ["pretty"] + moduleHelp _ _ = "pretty . Display haskell code in a pretty-printed manner" + process_ _ _ r = prettyCmd r + +------------------------------------------------------------------------ + +prettyCmd :: String -> ModuleLB (String -> IO String) +prettyCmd rest = + let code = dropWhile (`elem` " \t>") rest + modPrefix = "module Main where " + ++ if "let" `isPrefixOf` code then "i = " else "" + prefLen = length modPrefix + result = case parseModule (modPrefix ++ code) of + (ParseOk a) -> doPretty a + (ParseFailed loc msg) -> let (SrcLoc _ _ col) = loc in + (show msg ++ " at column " ++ show (col - prefLen)) : [] + in return result -- XXX will this work? No, spaces are compressed. + +-- | calculates "desired" indentation and return pretty-printed declarations +-- the indentation calculations are still pretty much rough guesswork. +-- i'll have to figure out a way to do some _reliable_ pretty-printing! +doPretty :: HsModule -> [String] +doPretty (HsModule _ _ _ _ decls) = + let defaultLen = 4 + declLen (HsFunBind matches) = maximum $ map matchLen matches + declLen (HsPatBind _ pat _ _) = patLen pat + declLen _ = defaultLen + patLen (HsPVar nm) = nameLen nm + patLen _ = defaultLen + nameLen (HsIdent s) = length s + 1 + nameLen _ = defaultLen + matchLen (HsMatch _ nm pats _ _) = + let l = (nameLen nm + sum (map patLen pats) + 1) + in if l > 16 then defaultLen else l + makeMode decl = defaultMode { + doIndent = 3, + caseIndent = 4, + onsideIndent = declLen decl + } + -- FIXME: prefixing with hashes is done, because i didn't find a way + -- to disable the indentation filter of lambdabot only for this module... + in map (" "++) . lines . concat . intersperse "\n" + -- . map show $ decls + . map (\d -> prettyPrintWithMode (makeMode d) d) $ decls diff --git a/Plugin/Quote.hs b/Plugin/Quote.hs new file mode 100644 --- /dev/null +++ b/Plugin/Quote.hs @@ -0,0 +1,99 @@ +-- +-- | Support for quotes +-- +module Plugin.Quote (theModule) where + +import Plugin.Quote.Fortune (randFortune) +import Plugin.Quote.Text + +import Plugin + +import qualified Data.Map as M +import qualified Data.ByteString.Char8 as P + +PLUGIN Quote + +type Quotes = M.Map P.ByteString [P.ByteString] + +instance Module QuoteModule Quotes where + moduleCmds _ = ["quote", "remember", "ghc", "fortune" + ,"yow","arr","keal","b52s","brain","palomer" + ,"girl19", "v", "yhjulwwiefzojcbxybbruweejw"] + + moduleHelp _ "fortune" = "fortune. Provide a random fortune" + moduleHelp _ "yow" = "yow. The zippy man." + moduleHelp _ "arr" = "arr. Talk to a pirate" + moduleHelp _ "keal" = "keal. Talk like Keal" + moduleHelp _ "ghc" = "ghc. Choice quotes from GHC." + moduleHelp _ "b52s" = "b52s. Anyone noticed the b52s sound a lot like zippy?" + moduleHelp _ "brain" = "brain. Pinky and the Brain" + moduleHelp _ "palomer" = "palomer. Sound a bit like palomer on a good day." + moduleHelp _ "girl19" = "girl19 wonders what \"discriminating hackers\" are." + moduleHelp _ "v" = "let v = show v in v" + moduleHelp _ "yhjulwwiefzojcbxybbruweejw" + = "V RETURNS!" + moduleHelp _ _ = help -- required + + moduleSerialize _ = Just mapListPackedSerial + moduleDefState _ = return M.empty + + process_ _ cmd s = case cmd of + "remember" -> runRemember (dropSpace s) + "quote" -> runQuote (dropSpace s) + "ghc" -> runQuote "ghc" + "fortune" -> return `fmap` io (randFortune Nothing) + "yow" -> return `fmap` io (randFortune (Just "zippy")) + "keal" -> return `fmap` io (randomElem kealList) + "arr" -> return `fmap` io (randomElem arrList) + "b52s" -> return `fmap` io (randomElem b52s) + "brain" -> return `fmap` io (randomElem brain) + "palomer" -> return `fmap` io (randomElem palomer) + "girl19" -> return `fmap` io (randomElem girl19) + "v" -> return `fmap` io (randomElem notoriousV) + "yhjulwwiefzojcbxybbruweejw" + -> return `fmap` io (randomElem notoriousV) + +help :: String +help = "quote \nremember \n" ++ + "Quote somebody, a random person, or save a memorable quote" + +------------------------------------------------------------------------ + +-- the @remember command stores away a quotation by a user, for future +-- use by @quote + +-- error handling! +runRemember :: String -> ModuleLB Quotes +runRemember str = do + case break (== ' ') str of + (_,[]) -> return ["Incorrect arguments to quote"] + (nm,q') -> do let q = tail q' + withMS $ \fm writer -> do + let ss = fromMaybe [] (M.lookup (P.pack nm) fm) + fm' = M.insert (P.pack nm) (P.pack q : ss) fm + writer fm' + return ["Done."] + +-- +-- the @quote command, takes a user nm to choose a random quote from +-- +runQuote :: String -> ModuleLB Quotes +runQuote name' = do + fm <- readMS + if M.null fm then return ["No quotes yet."] else do + + let pnm = P.pack name' + qs' = M.lookup pnm fm + + (nm,qs) <- if not (P.null pnm) + then return (pnm,qs') -- (ByteString, Maybe [ByteString]) + else do (nm',rs') <- io $ randomElem (M.toList fm) -- random person + return (nm', Just rs') + case qs of + Nothing -> return [P.unpack nm ++ " hasn't said anything memorable"] + Just msgs -> do msg <- io $ randomElem msgs + return $ if not (P.null pnm) + then [" " ++ (P.unpack msg)] + else [(P.unpack nm)++" says: " ++ (P.unpack msg)] + + diff --git a/Plugin/Quote/Fortune.hs b/Plugin/Quote/Fortune.hs new file mode 100644 --- /dev/null +++ b/Plugin/Quote/Fortune.hs @@ -0,0 +1,55 @@ +-- +-- | Fortune.hs, quote the fortune file +-- +module Plugin.Quote.Fortune where + +import Config +import Lib.Util (stdGetRandItem, split) +import qualified Lib.Util hiding (stdGetRandItem) + +import Data.List +import Control.Monad +import System.Directory +import qualified Control.Exception as C (catch) + +-- +-- No good for win32 +-- +import System.Posix (isRegularFile, getFileStatus) + +-- | The 'filelist' function returns a List of fortune files from the +-- configured 'fortunePath' directory. +filelist :: IO [String] +filelist = do + filelist'<- C.catch (getDirectoryContents $ fortunePath config) + (\_ -> return []) + let files = filter (not . isSuffixOf ".dat") filelist' + join (return (filterM isFile (map (fortunePath config ++) files))) + +-- | Select a random fortune file +fileRandom :: IO FilePath +fileRandom = filelist >>= stdGetRandItem + +-- | Parse a file of fortunes into a list of the fortunes in the file. +fortunesParse :: FilePath -> IO [String] +fortunesParse filename = do + rawfs <- C.catch (readFile filename) + (\_ -> return "Couldn't find fortune file") + return $ split "%\n" rawfs + +-- | Given a FilePath of a fortune file, select and return a random fortune from +-- it. +fortuneRandom :: FilePath -> IO String +fortuneRandom = (stdGetRandItem =<<) . fortunesParse + +-- | Given an optional fortune section, return a random fortune. If Nothing, +-- then a random fortune from all fortune files is returned. If Just section, +-- then a random fortune from the given section is returned. +randFortune :: (Maybe FilePath) -> IO String +randFortune section = case section of + Nothing -> fortuneRandom =<< fileRandom + Just fname -> fortuneRandom =<< (return (fortunePath config ++ fname)) + +-- | 'isFile' is a predicate wheter or not a given FilePath is a file. +isFile :: FilePath -> IO Bool +isFile = (isRegularFile `fmap`) . getFileStatus diff --git a/Plugin/Quote/Text.hs b/Plugin/Quote/Text.hs new file mode 100644 --- /dev/null +++ b/Plugin/Quote/Text.hs @@ -0,0 +1,270 @@ +-- +-- | Some quote text +-- +module Plugin.Quote.Text where + +-- | Some funny palomer-isms +palomer :: [String] +palomer = + ["Blargh!" + ,"Hrmph" + ,"They're telling you lies!" + ,"Scalliwags!" + ,"Pfft" + ,"Pfft, my type inference algorithm takes hours on a 2 line program" + ,"Hrmph, looks like I killed the channel" + ,"As someone who's studied GADTs, I've never found a use for them." + ,"Category theory is the Paris Hilton of mathematics" + ,"That's nuts!" + ,"Brump!" + ,"I think you're all nuts" + ,"That's a lie" + ,"Learning vim is pointless" + ,"I think vim is good for the rubbish bin" + ,"xml stands for \"xtremely mild lullaby\"" + ,"woof" + ,"(_|_)" + ] + +-- | Some pirate quotes +arrList :: [String] +arrList = + ["Avast!" + ,"Shiver me timbers!" + ,"Yeh scurvy dog..." + ,"I heard andersca is a pirate" + ,"I'll keel haul ya fer that!" + ,"I'd like to drop me anchor in her lagoon" + ,"Well me 'earties, let's see what crawled out of the bung hole..." + ,"I want me grog!" + ,"Drink up, me 'earties" + ,"Is that a hornpipe in yer pocket, or arr ya just happy ta see me?" + ,"Get out of me way, yeh landlubber" + ,"Smartly me lass" + ,"Arrr!" + ,"Ahoy mateys" + ,"Aye" + ,"Aye Aye Cap'n" + ,"This is the END for you, you gutter-crawling cur!" + ,"May the clap make ye incapable of Cracking Jenny's Tea Cup." + ,"Eat maggoty hardtack, ye unkempt, jenny frequentin', son of a gun." + ,"Swab the deck!" + ,"Keelhaul the swabs!" + ,"Yo ho ho, and a bottle of rum!" + ,"I'll crush ye barnacles!" + ,"Har de har har!" + ] + +-- +-- Actual quotes from an asshat called Keal over Jan 12-14 2006. +-- +kealList :: [String] +kealList = + ["endian mirrors the decimal" + ,"primary elemental assumption of integer coefficients to roots in counting sytem is wrong" + ,"actually it bug in math" + ,"b*(Floor[v/b^p]/b-Floor[Floor[v/b^p]/b])" + ,"proofs are no longer sound" + ,"my proof show math is broken right now" + ,"doctor just give meds not fix prollem" + ,"Keal was so happy with T, coded in basic so run on anything, and does lot" + ,"one prollem. T broke confines of the visual basic langage and would not compile" + ,"perhaps i just genius and never tested" + ,"and yes that was with zero formal training in all realms" + ,"somone would expect that trees 500gb hdds of expressions as if they were floppy dicks" + ,"can you make a macro that builds the expression accoridng to a genetic algorithm where you decide what is good and what is bad?" + ,"T could perform expressions 600mb and bigger" + ,"what is the max amount of operands haskell can handle in a single expression?" + ,"T seems to be haskell, except with a decent interface at this point" + ,"love a black and white lower 128 from 32 up of ascii glyphs?" + ,"evaluating expressions is ALL haskell does?????" + ,"you think i am one of them persnipity uppity men are pig lesbian mathematicians?" + ,"how bout i say ick no unicorn and daisy loving girl mathematician will ever enjoy this" + ,"better be atleast 16x16 color with extended ascii set" + ,"what the hell does Prelude > mean?" + ,"how do i search for someone saying 'Keal' in mirc" + ,"i have basically written a proof that shows an assumption is wrong" + ,"they dumbified you" + ,"antiparsimony were 100% correct..." + ,"its because the timeline diverges and past events themselves unhappen" + ,"all i know is i have experienced my own death unhappening..." + ," what have you been smoking? you narrow minded Haskell user?" + ,"i use an 8088" + ,"my very first computer was an 80-0840" + ,"it is very easy to go off topic" + ,"someone needs to write a boids for haskell that emulates humans going on and off topic" + ,"i just got banned from math because i not have good ability to convey thoughts" + ,"i lack in verbal and social expression" + ,"i try make program called Glyph to do it but my script lang called T too slow. i invent T" + ,"can GMP support KealDigit? I invent KealDigit" + ,"with KealDigit quantum crackproof encryption possible" + ,"i show how spell triangle in less than three corners using darkmanifold" + ,"can haskell pipe the raw irrational megaequation into an analog device" + ,"the fractal is 5 irrationals" + ,"99% of my book has been erased by faulty hdd's" + ,"last day i was in my lab i had a diagram which might have removed pi" + ,"i only trust opensource tools. where can i download haskell for windows?" + ,"obviously you never heard of Tier. theoretically it would work using nanobots" + ,"you need a Zh function in Haskell" + ,"can haskell compile flash animations and java apps?" + ,"i need math friendly compiler to compile for jvm or flash" + ,"Cale etc already pointed out Haskell is puny to nothing to emulate using my barrage of mathematic theories" + ,"i prove infinity never ends in both directions" + ,"are you saying i am MegaMonad?" + ,"Keal angry @ dons" + ,"i can explain why something is without knowing what the rules decided by man are" + ,"making a bot of me is highly offensive" + ,"just seeing how offtopic i could get everyone" + ,"intuitive != imperative" + ,"doubles and floats cause b*(Floor[v/b^p]/b-Floor[Floor[v/b^p]/b) to fuck up" + ,"what are epsilons?" + ,"haskell always said undefined" + ,"bot seems useless" + ,"when i put what i dat recoved from that tile into a ti92. the damn thing blew up" + ,"i think it because mathematics damage you cpu" + ,"ithink has to do with hardcased government failsafe in chip" + ,"i suggest you tear apart a 20q and plug it with the alg" + ,"nsa has all the profiling info you need to come up with the correct survey answers" + ,"write an algorthim that generates the correct responses for a phone survey based on number of rings whether answered how quickly hung up on and the mood of the receiver" + ,"where can i find opensource schematics of Linus Torvalds' x86 clone?" + ,"need to plan a fieldtrip to Frederick B. Mancoff of Freescale Semiconductor" + ,"ghc need to have plugin that allow copy paste in xp" + ,"know you know this 24 periods Keal SecretTM" + ,"tomorrow i share next mathematical secrety" + ,"nsa prevent me from returning to math on efnet" + ,"nsa try kill me numerous times" + ,"#haskell needs to take its meds" + ,"i think i know what code does but code looks to simple to actually do it" + ,"need 1 to do a while 0 does !a. need 1 to do a while 0 does !a" + ,"will it return [] if map gives fpu infinite list?" + ,"today's 24hour project was supposed to be logical overloading using plegm method" + ,"there is no way to prove the failsafe exists" + ,"oh btw my fpu is blown due to a hardcased failsafe i have 3 year warranty right. and then they call fads" + ,"i aint running that on my puter" + ,"lamadabot took 5 to 8 whole seconds to return []" + ,"bot defective" + ,"i changed my user od" + ,"i cant think anymore" + ,"i want to invent white dye" + ,"pork steaks taste like dick" + ,"i dont really eat vegetables unless cheese is a vegetable" + ,"the [nsa] even make light green both ways once" + ] + +-- +-- Quotes from the lyrics of B52s songs. They remind me (dons) of zippy. +-- +b52s :: [String] +b52s = + [ "His ear lobe fell in the deep. Someone reached in and grabbed it. It was a rock lobster!" + , "Watch out for that piranha. There goes a narwhale. HERE COMES A BIKINI WHALE!" + , "She drove a Plymouth Satellite faster than the speed of light!" + , "Some say she's from Mars, or one of the seven stars that shine after 3:30 in the morning. WELL SHE ISN'T." + , "It's a dreary downtown day, but at the end of my 40 foot leash is my little friend quiche." + , "Girl from Ipanema, she goes to Greenland" + , "Hot pants explosion at the factory!" + , "You belong in Ripley's Believe It Or Not" + ] + +-- +-- Quotes from the pinky and the brain cartoon +-- +brain :: [String] +brain = + [("Gee, Brain, what are we going to do tonight?\n" ++ + "The same thing we do every night, Pinky. Try to take over the world!") + , "Narf!" + , "Zort!" + , "Poit!" + , "Troz!" + , "It must be inordinately taxing to be such a boob." + , "Promise me something, Pinky. Never breed." + , "Pinky, I am in considerable pain." + , "Here we are, Pinky--at the dawn of time!" + ,("Now, Pinky, if by any chance you are captured during this mission, \n" ++ + "remember you are Gunther Heindriksen from Appenzell. You moved to Grindelwald\n" ++ + "to drive the cog train to Murren. Can you repeat that?") + ,("Brain! Brain! You aren't going to leave me!!!???" ++ + "You know what happened to Jerry Lewis after Dean Martin left him!!!") + , "They've turned into giant Swiss leaderhosen-clad dancing yodelers. Talk about unpredictable!" + , "Be quiet Pinky, or I shall have to hurt you." + , "If I could reach you I would hurt you." + ,("What can I do for fun, Pinky? That's it! I'll send several\n" ++ + "bills to Senate for ratification, then veto them all!") + , "There's only one ride that interests me - the incredible thrill ride of taking over the world!" + ,("It is here that my cheap workforce of trained iguanas will work\n" ++ + "night and day to make our shoes to my exacting specifications!") + ,("Has it ever occurred to you, Pinklet, that your scarf is\n" ++ + "constricting the bloodflow to your head?") + , "Are you pondering what I'm pondering?" + , "But where are we going to find a duck and a hose at this hour?" + , "But where will we find an open tattoo parlor at this time of night?" + , "Uh... yeah, Brain, but where are we going to find rubber pants our size?" + , "Uh, I think so, Brain, but balancing a family and a career ... ooh, it's all too much for me." + , "Wuh, I think so, Brain, but isn't Regis Philbin already married?" + , "Wuh, I think so, Brain, but burlap chafes me so." + , "Uh, I think so, Brain, but we'll never get a monkey to use dental floss." + , "Uh, I think so Brain, but this time, you wear the tutu." + , "I think so, Brain, but culottes have a tendency to ride up so." + , "I think so, Brain, but if they called them 'Sad Meals', kids wouldn't buy them!" + , "I think so, Brain, but me and Pippi Longstocking -- I mean, what would the children look like?" + , "Well, I think so, Brain, but I can't memorize a whole opera in Yiddish." + , "I think so, Brain, but there's still a bug stuck in here from last time." + , "Uh, I think so, Brain, but I get all clammy inside the tent." + , "I think so, Brain, but I don't think Kaye Ballard's in the union." + , "I think so, Brain, but, the Rockettes? I mean, it's mostly girls, isn't it?" + , "I think so, Brain, but pants with horizontal stripes make me look chubby." + , "Well, I think so, Brain, but pantyhose are so uncomfortable in the summertime." + , "Well, I think so, Brain, but it's a miracle that this one grew back." + , "Well, I think so, Brain, but first you'd have to take that whole bridge apart, wouldn't you?" + , "Well, I think so, Brain, but 'apply North Pole' to what?" + , "Umm, I think so, Brain, but what if the chicken won't wear the nylons?" + , "I think so, Brain, but isn't that why they invented tube socks?" + , "Well, I think so Brain, but what if we stick to the seat covers?" + , "Oooh, I think so Brain, but I think I'd rather eat the Macarena." + , "Well, I think so, but Kevin Costner with an English accent?" + , "I think so, Brain, but don't you need a swimming pool to play Marco Polo?" + , "Well, I think so, Brain, but do I really need two tongues?" + , "I think so, Brain, but we're already naked." + , "I think so, Brain, but Lederhosen won't stretch that far." + , "Yeah, but I thought Madonna already had a steady bloke!" + , "I think so, Brain?but how would we ever determine Sandra Bullock's shoe size?" + , "I think so, Brain, but a codpiece made from a real fish would get smelly after a while, wouldn?t it?" + , "I think so, Commander Brain from Outer Space! But do we have time to grease the rockets?" + , "I think so, Doctor. But are these really the legs of a show girl?" + , "Whuu... I think so, BrainPan! But if running shoes had little feet, wouldn't they need their own shoes?" + , "I think so, Brain! But ruby-studded stockings would be mighty uncomfortable wouldn't they?" + , "I think so, Brain! How much deeper would the ocean be if there weren't sponges down there?" + , "I think so, Brain! But do I have what it take to be the 'Lord of the Dance'?" + , "I think so, Brain, but I didn?t know 90210 was a real zip code! Will Tori be there?" + , "The game does not conclude until the woman with the eating disorder ululates." + ] + +-- +-- Girl 19, Apr 11, 2006 +-- +girl19 :: [[Char]] +girl19 = + ["is this a help channel for hackers-beginners?" + ,"I have been into not actually hacking, but social engineering" + ,"I have stolen about 50 msn and yahoo accounts" + ,"I'm in Moscow, Russia" + ,"nobody can catch me" + ,"well.. I never hacked Russians" + ,"am I supposed to be frantic with terror and anxiety?" + ,"LOL" + ,"I've always found myself unequal to the intellectual pressure of programming" + ] + +-- +-- v used to be a bug in @eval. See the logs from April 9, 2006. +-- +notoriousV :: [[Char]] +notoriousV = + [show "\"\\\"\\\\\\\"\\\\\\" + ,show "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\" + ,show "\"" + ,show "\"#$%&'()*+,\"" + ,"Exception: <>" + ,"Just 'J'" + ] diff --git a/Plugin/Search.hs b/Plugin/Search.hs new file mode 100644 --- /dev/null +++ b/Plugin/Search.hs @@ -0,0 +1,85 @@ +-- +-- | Search various things, Wikipedia and google for now. +-- +-- (c) 2005 Samuel Bronson +-- (c) 2006 Don Stewart +-- +-- Joel Koerwer 11-01-2005 generalized query for different methods +-- and added extractConversion to make things like @google 1+2 work +-- +module Plugin.Search (theModule) where + +import Plugin +import Control.Monad (mplus) + +PLUGIN Search + +engines :: [(String, (String, String))] +engines = + [("google" + ,("http://www.google.com/search?hl=en&q=","&btnI=I%27m+Feeling+Lucky")), + + ("wikipedia" + ,("http://en.wikipedia.org/wiki/Special:Search?search=", "")), + + ("gsite" + ,("http://www.google.ca/search?hl=en&q=site%3A", "&btnI=I%27m+Feeling+Lucky")) + ] + +instance Module SearchModule () where + moduleHelp _ s = case s of + "google" -> "google . Search google and show url of first hit" + "wikipedia" -> "wikipedia . Search wikipedia and show url of first hit" + "gsite" -> "gsite . Search for using google" + "gwiki" -> "wiki . Search (new) haskell.org wiki for using google." + moduleCmds _ = "gwiki" : map fst engines + process_ _ "gwiki" e = ((. dropSpace) . searchCmd) "gsite" ("haskell.org/haskellwiki/" ++ e) + process_ _ s e = ((. dropSpace) . searchCmd) s e + +------------------------------------------------------------------------ + +searchCmd :: String -> String -> LB [String] +searchCmd _ [] = return ["Empty search."] +searchCmd engine rest = do + headers <- io $ queryit "HEAD" engine rest + body <- io $ queryit "GET" engine rest + case getHeader "Location" headers `mplus` extractConversion body of + Just url -> do + title <- io $ urlPageTitle url (proxy config) + return $ maybe [url] (\t -> [url, t]) title + Nothing -> return ["No Result Found."] + +queryUrl :: String -> String -> String +queryUrl engine q = prefix ++ urlEncode q ++ suffix + where + (prefix, suffix) = fromMaybe (error "search: invalid command") + (lookup engine engines) + +queryit :: String -> String -> String -> IO [String] +queryit meth engine q = readPage (proxy config) uri request "" + where url = queryUrl engine q + Just uri = parseURI url + abs_path = uriPath uri ++ uriQuery uri ++ uriFragment uri + request = case proxy config of + Nothing -> [meth ++ " " ++ abs_path ++ " HTTP/1.0", ""] + _ -> [meth ++ " " ++ url ++ " HTTP/1.0", ""] + +extractConversion :: [String] -> Maybe String +extractConversion [] = error "conv: No response, something weird is up." +extractConversion ls = (getConv $ last ls) >>= return . pipeline replaceFuncs + where + regex1 = mkRegex "" + regex2 = mkRegex "" + + getConv a = do + (_,_,s,_) <- matchRegexAll regex1 a + (s',_,_,_) <- matchRegexAll regex2 s + return s' + + searchAndReplace new regex = \s -> subRegex (mkRegex regex) s new + replaceFuncs = zipWith searchAndReplace + [ "^", "", "x", ","] + ["", "", "×", " "] + + pipeline [] a = a + pipeline (f:fs) a = pipeline fs $ f a diff --git a/Plugin/Seen.hs b/Plugin/Seen.hs new file mode 100644 --- /dev/null +++ b/Plugin/Seen.hs @@ -0,0 +1,419 @@ +-- +-- Copyright (c) 2004 Thomas Jaeger +-- Copyright (c) 2005-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | Keep track of IRC users. +-- +module Plugin.Seen (theModule) where + +import Plugin +import Lib.AltTime +import Lib.Binary +import Lib.Error (tryError) + +import qualified Message (Message, names, channels, nick, body) + +import qualified Data.Map as M +import qualified Data.ByteString.Char8 as P + +import System.Directory + +import System.Time (normalizeTimeDiff) -- or export from AltTime.hs? + +import Control.Monad (unless, zipWithM_) + +PLUGIN Seen + +-- Try using packed strings? + +-- | The type of channels +type Channel = P.ByteString + +-- | The type of nicknames +type Nick = P.ByteString + +-- | We last heard the user speak at ClockTime; since then we have missed +-- TimeDiff of him because we were absent. +type LastSpoke = Maybe (ClockTime, TimeDiff) + +-- | 'UserStatus' keeps track of the status of a given Nick name. +data UserStatus + = Present LastSpoke [Channel] + -- ^ Records when the nick last spoke and that the nick is currently + -- in [Channel]. + | NotPresent ClockTime StopWatch [Channel] + -- ^ The nick is not present and was last seen at ClockTime in Channel. + -- The second argument records how much we've missed. + | WasPresent ClockTime StopWatch LastSpoke [Channel] + -- ^ The bot parted a channel where the user was. The Clocktime + -- records the time and Channel the channel this happened in. + -- We also save the reliablility of our information and the + -- time we last heard the user speak. + | NewNick Nick + -- ^ The user changed nick to something new. + deriving (Show, Read) + +data StopWatch = Stopped TimeDiff + | Running ClockTime + deriving (Show,Read) + +type SeenState = M.Map Nick UserStatus +type Seen m a = ModuleT SeenState m a + +------------------------------------------------------------------------ + +-- ok, since this module generates quite a lot of state, what we'll do +-- is use Binary to pack this value, since Read is sooo slow and exe (as +-- my gf says :) + +instance Binary (M.Map Nick UserStatus) where + put_ bh m = put_ bh (M.toList m) + get bh = do x <- get bh ; return (M.fromList x) + +instance Binary StopWatch where + put_ bh (Stopped td) = do + putByte bh 0 + put_ bh td + + put_ bh (Running ct) = do + putByte bh 1 + put_ bh ct + + get bh = do + h <- getWord8 bh + case h of + 0 -> do x <- get bh ; return (Stopped x) + 1 -> do x <- get bh ; return (Running x) + _ -> error "Seen.StopWatch.get" + +instance Binary UserStatus where + put_ bh (Present spoke chans) = do + putByte bh 0 + put_ bh spoke + put_ bh chans + put_ bh (NotPresent ct sw chans) = do + putByte bh 1 + put_ bh ct + put_ bh sw + put_ bh chans + put_ bh (WasPresent ct sw spoke chans) = do + putByte bh 2 + put_ bh ct + put_ bh sw + put_ bh spoke + put_ bh chans + put_ bh (NewNick n) = do + putByte bh 3 + put_ bh n + + get bh = do + h <- getWord8 bh + case h of + 0 -> do + x <- get bh + y <- get bh + return (Present x y) + 1 -> do + x <- get bh + y <- get bh + z <- get bh + return (NotPresent x y z) + 2 -> do + x <- get bh + y <- get bh + z <- get bh + a <- get bh + return (WasPresent x y z a) + 3 -> do + x <- get bh + return (NewNick x) + + _ -> error "Seen.UserStatus.get" + +------------------------------------------------------------------------ +-- +-- something's broken. doesn't seem to correctly keep the seen data over +-- reboots anymore :/ +-- + +instance Module SeenModule SeenState where + moduleHelp _ _ = "seen . Report if a user has been seen by the bot" + moduleCmds _ = ["seen"] + moduleDefState _ = return M.empty + + process _ msg _ _ rest = do + seenFM <- readMS + now <- io getClockTime + return [unlines $ getAnswer msg rest seenFM now] + + moduleInit _ = do + zipWithM_ ircSignalConnect + ["JOIN", "PART", "QUIT", "NICK", "353", "PRIVMSG"] $ map withSeenFM + [joinCB, partCB, quitCB, nickCB, joinChanCB, msgCB] + + -- This magically causes the 353 callback to be invoked :) + tryError $ send_ . Message.names =<< ircGetChannels + + -- and suck in our state. We read directly from the handle, to avoid copying + b <- io $ doesFileExist "State/seen" + when b $ do + s <- io $ do h <- openFile "State/seen" ReadMode + bh <- openBinIO_ h + st <- get bh + hClose h + return st + writeMS s + + moduleExit _ = do + chans <- ircGetChannels + unless (null chans) $ do + ct <- io getClockTime + modifyMS $ botPart ct (map P.pack chans) + + -- and write out our state: + withMS $ \s _ -> do + io $ do h <- openFile "State/seen" WriteMode + bh <- openBinIO_ h + put_ bh s + hClose h + return () + +------------------------------------------------------------------------ +-- | The bot's name, lowercase +myname :: String +myname = lowerCaseString (name config) + +getAnswer :: Message.Message a => a -> String -> SeenState -> ClockTime -> [String] +getAnswer msg rest seenFM now + | null lcnick = + let people = map fst $ filter isActive $ M.toList seenFM + isActive (_nick,state) = case state of + (Present (Just (ct,_td)) _cs) -> recent ct + _ -> False + recent t = normalizeTimeDiff (diffClockTimes now t) < gap_minutes + gap_minutes = TimeDiff 0 0 0 0 15 0 0 + in ["Lately, I have seen " ++ (if null people then "nobody" + else listToStr "and" (map P.unpack people)) ++ "."] + + | lcnick == myname = + case M.lookup (P.pack lcnick) seenFM of + Just (Present _ cs) -> + ["Yes, I'm here. I'm in " ++ listToStr "and" (map P.unpack cs)] + _ -> error "I'm here, but not here. And very confused!" + + | length lcnick > 0 && head lcnick == '#' = + let channel = lcnick + people = map fst $ filter inChan $ M.toList seenFM + inChan (_nick,state) = case state of + (Present (Just _) cs) + -> P.pack channel `elem` cs + _ -> False + in ["In "++channel++" I can see " + ++ (if null people then "nobody" -- todo, how far back does this go? + else listToStr "and" (map P.unpack people)) ++ "."] + + | otherwise = case M.lookup (P.pack lcnick) seenFM of + Just (Present mct cs) -> nickPresent mct (map P.unpack cs) + Just (NotPresent ct td chans) -> nickNotPresent ct td (map P.unpack chans) + Just (WasPresent ct sw _ chans) -> nickWasPresent ct sw (map P.unpack chans) + Just (NewNick newnick) -> nickIsNew (P.unpack newnick) + _ -> ircMessage ["I haven't seen ", nick, "."] + where + -- I guess the only way out of this spagetty hell are printf-style responses. + nickPresent mct cs = ircMessage [ + if you then "You are" else nick ++ " is", " in ", + listToStr "and" cs, ".", + case mct of + Nothing -> concat [" I don't know when ", nick, " last spoke."] + Just (ct,missed) -> prettyMissed (Stopped missed) + (concat [" I last heard ", nick, " speak ", + lastSpoke {-, ", but "-}]) + (" Last spoke " ++ lastSpoke) + where lastSpoke = clockDifference ct + ] + nickNotPresent ct missed chans = ircMessage [ + "I saw ", nick, " leaving ", listToStr "and" chans, " ", + clockDifference ct, prettyMissed missed ", and " "" + ] + nickWasPresent ct sw chans = ircMessage [ + "Last time I saw ", nick, " was when I left ", + listToStr "and" chans , " ", clockDifference ct, + prettyMissed sw ", and " ""] + nickIsNew newnick = ircMessage [if you then "You have" else nick++" has", + " changed nick to ", us, "."] ++ getAnswer msg us seenFM now + where + + findFunc pstr = case M.lookup pstr seenFM of + Just (NewNick pstr') -> findFunc pstr' + Just _ -> pstr + Nothing -> error "SeenModule.nickIsNew: Nothing" + + us = P.unpack $ findFunc (P.pack $ lowerCaseString newnick) + + ircMessage = return . concat + nick' = firstWord rest + you = nick' == Message.nick msg + nick = if you then "you" else nick' + lcnick = lowerCaseString nick' + clockDifference past + | all (==' ') diff = "just now" + | otherwise = diff ++ " ago" + where diff = timeDiffPretty . diffClockTimes now $ past + + prettyMissed (Stopped _) ifMissed _ = ifMissed ++ "." + prettyMissed _ _ ifNotMissed = ifNotMissed ++ "." + +{- + prettyMissed (Stopped missed) ifMissed _ + | missedPretty <- timeDiffPretty missed, + any (/=' ') missedPretty + = concat [ifMissed, "I have missed ", missedPretty, " since then."] + + prettyMissed _ _ ifNotMissed = ifNotMissed ++ "." +-} + + +-- | Callback for when somebody joins. If it is not the bot that joins, record +-- that we have a new user in our state tree and that we have never seen the +-- user speaking. +joinCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +joinCB msg fm _ct nick + | nick == (P.pack myname) = Right fm + | otherwise = Right $ insertUpd (updateJ Nothing (map P.pack $ Message.channels msg)) + nick newInfo fm + where newInfo = Present Nothing (map P.pack $ Message.channels msg) + + +botPart :: ClockTime -> [Channel] -> SeenState -> SeenState +botPart ct cs fm = fmap botPart' fm where + botPart' (Present mct xs) = case xs \\ cs of + [] -> WasPresent ct (startWatch ct zeroWatch) mct cs + ys -> Present mct ys + botPart' (NotPresent ct' missed c) + | head c `elem` cs = NotPresent ct' (startWatch ct missed) c + botPart' (WasPresent ct' missed mct c) + | head c `elem` cs = WasPresent ct' (startWatch ct missed) mct c + botPart' us = us + +-- | when somebody parts +partCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +partCB msg fm ct nick + | nick == (P.pack myname) = Right $ botPart ct (map P.pack $ Message.channels msg) fm + | otherwise = case M.lookup nick fm of + Just (Present mct xs) -> + case xs \\ (map P.pack $ Message.channels msg) of + [] -> Right $ M.insert nick + (NotPresent ct zeroWatch xs) + fm + ys -> Right $ M.insert nick + (Present mct ys) + fm + _ -> Left "someone who isn't known parted" + +-- | when somebody quits +quitCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +quitCB _ fm ct nick = case M.lookup nick fm of + Just (Present _ct xs) -> Right $ M.insert nick (NotPresent ct zeroWatch xs) fm + _ -> Left "someone who isn't known has quit" + +-- | when somebody changes his\/her name +nickCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +nickCB msg fm _ nick = case M.lookup nick fm of + Just status -> let fm' = M.insert nick (NewNick $ P.pack newnick) fm + in Right $ M.insert lcnewnick status fm' + _ -> Left "someone who isn't here changed nick" + where + newnick = drop 1 $ head (Message.body msg) + lcnewnick = P.pack $ lowerCaseString newnick + +-- use IRC.IRC.channels? +-- | when the bot join a channel +joinChanCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +joinChanCB msg fm now _nick + = Right $ fmap (updateNP now chan) $ foldl insertNick fm chanUsers + where + l = Message.body msg + chan = P.pack $ l !! 2 + chanUsers = map P.pack $ words (drop 1 (l !! 3)) -- remove ':' + insertNick fm' u = insertUpd (updateJ (Just now) [chan]) + (P.pack . lowerCaseString . P.unpack . unUserMode $ u) + (Present Nothing [chan]) + fm' + +-- | when somebody speaks, update their clocktime +msgCB :: Message.Message a => a -> SeenState -> ClockTime -> Nick -> Either String SeenState +msgCB _ fm ct nick = + case M.lookup nick fm of + Just (Present _ xs) -> Right $ + M.insert nick (Present (Just (ct, noTimeDiff)) xs) fm + _ -> Left "someone who isn't here msg us" + +-- misc. functions +unUserMode :: Nick -> Nick +unUserMode nick = P.dropWhile (`elem` "@+") nick + +-- | Callbacks are only allowed to use a limited knowledge of the world. +-- 'withSeenFM' is (up to trivial isomorphism) a monad morphism from the +-- restricted +-- 'ReaderT (IRC.Message, ClockTime, Nick) (StateT SeenState (Error String))' +-- to the +-- 'ReaderT IRC.Message (Seen IRC)' +-- monad. +withSeenFM :: Message.Message a => ( a -> SeenState -> ClockTime -> Nick + -> Either String SeenState) + -> a + -> Seen LB () +withSeenFM f msg = do + let nick = P.pack . lowerCaseString . P.unpack . unUserMode . P.pack . Message.nick $ msg + withMS $ \state writer -> do + ct <- io getClockTime + case f msg state ct nick of + Right newstate -> writer newstate + Left _ -> return () -- debugStrLn $ "SeenModule> " ++ err + +-- | Update the user status. +updateJ :: Maybe ClockTime -- ^ If the bot joined the channel, the time that + -- happened, i.e. now. + -> [Channel] -- ^ The channels the user joined. + -> UserStatus -- ^ The old status + -> UserStatus -- ^ The new status +-- The user was present before, so he's present now. +updateJ _ c (Present ct cs) = Present ct $ nub (c ++ cs) +-- The user was present when we left that channel and now we've come back. +-- We need to update the time we've missed. +updateJ (Just now) cs (WasPresent lastSeen _ (Just (lastSpoke, missed)) channels) + | head channels `elem` cs + --- newMissed + --- |---------------------------------------| + --- |-------------------| | + --- missed lastSeen now + = let newMissed = addToClockTime missed now `diffClockTimes` lastSeen + in newMissed `seq` Present (Just (lastSpoke, newMissed)) cs +-- Otherwise, we create a new record of the user. +updateJ _ cs _ = Present Nothing cs + +-- | Update a user who is not present. We just convert absolute missing time +-- into relative time (i.e. start the "watch"). +updateNP :: ClockTime -> Channel -> UserStatus -> UserStatus +updateNP now _ (NotPresent ct missed c) + = NotPresent ct (stopWatch now missed) c +-- The user might be gone, thus it's meaningless when we last heard him speak. +updateNP now chan (WasPresent lastSeen missed _ cs) + | head cs == chan = WasPresent lastSeen (stopWatch now missed) Nothing cs +updateNP _ _ status = status + +------------------------------------------------------------------------ +-- Stop watches mini-library -- + +zeroWatch :: StopWatch +zeroWatch = Stopped noTimeDiff + +startWatch :: ClockTime -> StopWatch -> StopWatch +startWatch now (Stopped td) = Running $ td `addToClockTime` now +startWatch _ alreadyStarted = alreadyStarted + +stopWatch :: ClockTime -> StopWatch -> StopWatch +stopWatch now (Running t) = Stopped $ t `diffClockTimes` now +stopWatch _ alreadyStopped = alreadyStopped + diff --git a/Plugin/Slap.hs b/Plugin/Slap.hs new file mode 100644 --- /dev/null +++ b/Plugin/Slap.hs @@ -0,0 +1,29 @@ +-- +-- | Support for quotes +-- +module Plugin.Slap (theModule) where + +import Plugin +import qualified Message (nick) + +PLUGIN Quote + +instance Module QuoteModule () where + moduleCmds _ = ["slap"] + moduleHelp _ _ = "slap . Slap someone amusingly." + process _ msg _ _ rest = ios $ slapRandom (if rest == "me" then sender else rest) + where sender = Message.nick msg + +------------------------------------------------------------------------ + +-- | Return a random arr-quote +slapRandom :: String -> IO String +slapRandom = (randomElem slapList `ap`) . return + +slapList :: [String -> String] +slapList = + [("/me slaps " ++) + ,(\x -> "/me smacks " ++ x ++ " about with a large trout") + ,("/me beats up " ++) + ,("why on earth would I slap " ++) + ] diff --git a/Plugin/Spell.hs b/Plugin/Spell.hs new file mode 100644 --- /dev/null +++ b/Plugin/Spell.hs @@ -0,0 +1,89 @@ +-- +-- Copyright (c) 2004-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- +-- | Interface to /aspell/, an open source spelling checker, from a +-- suggestion by Kai Engelhardt. Requires you to install aspell. +-- +module Plugin.Spell where + +import Plugin + +PLUGIN Spell + +instance Module SpellModule () where + moduleCmds _ = ["spell"] + moduleHelp _ _ = "spell . Show spelling of word" + process_ _ _ [] = return ["No word to spell."] + process_ _ _ s = (return . showClean . take 5) `fmap` liftIO (spell s) + +binary :: String +binary = "aspell" + +args :: [String] +args = ["pipe"] + +-- +-- | Return a list of possible spellings for a word +-- 'String' is a word to check the spelling of. +-- +spell :: String -> IO [String] +spell word = spellWithDict word Nothing [] + +-- +-- | Like 'spell', but you can specify which dictionary and pass extra +-- arguments to aspell. +-- +spellWithDict :: String -> Maybe Dictionary -> [String] -> IO [String] +spellWithDict word (Just d) ex = spellWithDict word Nothing ("--master":show d:ex) +spellWithDict word Nothing ex = do + (out,err,_) <- popen binary (args++ex) (Just word) + let o = fromMaybe [word] ((clean_ . lines) out) + e = fromMaybe e ((clean_ . lines) err) + return $ case () of {_ + | null o && null e -> [] + | null o -> e + | otherwise -> o + } + +-- +-- Parse the output of aspell (would probably work for ispell too) +-- +clean_ :: [String] -> Maybe [String] +clean_ (('@':'(':'#':')':_):rest) = clean' rest -- drop header +clean_ s = clean' s -- no header for some reason + +-- +-- Parse rest of aspell output. +-- +-- Grammar is: +-- OK ::= * +-- Suggestions ::= & : , , ... +-- None ::= # +-- +clean' :: [String] -> Maybe [String] +clean' (('*':_):_) = Nothing -- correct spelling +clean' (('#':_):_) = Just [] -- no match +clean' (('&':rest):_) = Just $ split ", " (clean'' rest) -- suggestions +clean' _ = Just [] -- not sure + +clean'' :: String -> String +clean'' s + | Just (_,_,m,_) <- pat `matchRegexAll` s = m + | otherwise = s + where + pat = mkRegex "[^:]*: " -- drop header + +-- +-- Alternate dictionaries, currently just lambdabot's. The idea was to +-- have a dictionary for lambdabot commands, and aspell rather than +-- levinshtein for spelling errors. Turns out to be quite complicated, +-- for negligible gain. +-- +data Dictionary + = Lambdabot -- ^ Dictionary of lambdabot commands (it's its own language) + +-- path to the master dictionary +instance Show Dictionary where + showsPrec _ Lambdabot = showString "State/lambdabot" + diff --git a/Plugin/State.hs b/Plugin/State.hs new file mode 100644 --- /dev/null +++ b/Plugin/State.hs @@ -0,0 +1,17 @@ +-- +-- | Persistent state +-- A demo plugin +-- +module Plugin.State (theModule) where + +import Plugin + +PLUGIN State + +instance Module StateModule String where + moduleCmds _ = ["state"] + moduleHelp _ _ = "state [expr]. Get or set a state variable." + moduleDefState _ = return "This page intentionally left blank." + moduleSerialize _ = Just stdSerial + process_ _ _ [] = withMS $ \s _ -> return $ if null s then [] else [s] + process_ _ _ t = withMS $ \_ w -> w t >> return [t] diff --git a/Plugin/System.hs b/Plugin/System.hs new file mode 100644 --- /dev/null +++ b/Plugin/System.hs @@ -0,0 +1,105 @@ +-- +-- | System module : IRC control functions +-- +module Plugin.System (theModule) where + +import Plugin +import Lib.AltTime +import qualified Message (Message, joinChannel, partChannel) +import qualified Data.Map as M (Map,keys,fromList,lookup,union) + +import Control.Monad.State (MonadState(get), gets) + +PLUGIN System + +instance Module SystemModule ClockTime where + moduleCmds _ = M.keys syscmds + modulePrivs _ = M.keys privcmds + moduleHelp _ s = fromMaybe defaultHelp (M.lookup s $ syscmds `M.union` privcmds) + moduleDefState _ = io getClockTime + process _ = doSystem + +------------------------------------------------------------------------ + +syscmds :: M.Map String String +syscmds = M.fromList + [("listchans", "Show channels bot has joined") + ,("listmodules", "listmodules. Show available plugins") + ,("list", "list [module|command]\n"++ + "show all commands or command for [module]") + ,("echo", "echo . echo irc protocol string") + ,("uptime", "uptime. Show uptime")] + +privcmds :: M.Map String String +privcmds = M.fromList [ + ("join", "join ") + ,("leave", "leave ") + ,("part", "part ") + ,("msg", "msg ") + ,("quit", "quit [msg], have the bot exit with msg") + ,("reconnect", "reconnect to server")] + +------------------------------------------------------------------------ + +defaultHelp :: String +defaultHelp = "system : irc management" + +doSystem :: Message.Message a => a -> String -> [Char] -> [Char] -> ModuleLB ClockTime +doSystem msg target cmd rest = get >>= \s -> case cmd of + + "listchans" -> return [pprKeys (ircChannels s)] + "listmodules" -> return [pprKeys (ircModules s) ] + "list" + | null rest -> case target of + ('#':_) -> return ["list [module|command]. " ++ + "Where modules is one of:\n" ++ pprKeys (ircModules s)] + _ -> listAll + | otherwise -> listModule rest >>= return . (:[]) + + ------------------------------------------------------------------------ + + --TODO error handling + "join" -> send_ (Message.joinChannel rest) >> return [] -- system commands + "leave" -> send_ (Message.partChannel rest) >> return [] + "part" -> send_ (Message.partChannel rest) >> return [] + + -- writes to another location: + "msg" -> ircPrivmsg tgt (Just txt') >> return [] + where (tgt, txt) = breakOnGlue " " rest + txt' = dropWhile (== ' ') txt + + "quit" -> do ircQuit $ if null rest then "requested" else rest + return [] + + "reconnect" -> do ircReconnect $ if null rest then "request" else rest + return [] + + "echo" -> return [concat ["echo; msg:", show msg, " rest:", show rest]] + + "uptime" -> do + loaded <- readMS + now <- io getClockTime + let diff = timeDiffPretty $ now `diffClockTimes` loaded + return ["uptime: " ++ diff] + +------------------------------------------------------------------------ + +listAll :: LB [String] +listAll = get >>= mapM listModule . M.keys . ircModules + +listModule :: String -> LB String +listModule s = withModule ircModules s fromCommand printProvides + where + fromCommand = withModule ircCommands s + (return $ "No module \""++s++"\" loaded") printProvides + + -- ghc now needs a type annotation here + printProvides :: (forall mod s. Module mod s => mod -> ModuleT s LB String) + printProvides m = do + let cmds = moduleCmds m + privs <- gets ircPrivCommands + let cmds' = cmds \\ privs -- don't display privledged commands + return . concat $ if null cmds' + then [?name, " has no visible commands"] + else [?name, " provides: ", showClean cmds'] + diff --git a/Plugin/Tell.hs b/Plugin/Tell.hs new file mode 100644 --- /dev/null +++ b/Plugin/Tell.hs @@ -0,0 +1,225 @@ +{- | Leave a message with lambdabot, the faithful secretary. + +> 17:11 < davidhouse> @tell dmhouse foo +> 17:11 < hsbot> Consider it noted +> 17:11 < davidhouse> @tell dmhouse bar +> 17:11 < hsbot> Consider it noted +> 17:11 < dmhouse> hello! +> 17:11 < hsbot> dmhouse: You have 2 new messages. '/msg hsbot @messages' to read them. +> 17:11 < dmhouse> Notice how I'm speaking again, and hsbot isn't buzzing me more than that one time. +> 17:12 < dmhouse> It'll buzz me after a day's worth of not checking my messages. +> 17:12 < dmhouse> If I want to check them in the intermittent period, I can either send a /msg, or: +> 17:12 < dmhouse> @messages? +> 17:12 < hsbot> You have 2 messages +> 17:12 < dmhouse> Let's check them, shall we? +> +> [In a /msg to hsbot] +> 17:12 davidhouse said less than a minute ago: foo +> 17:12 davidhouse said less than a minute ago: bar +> +> [Back in the channel +> 17:12 < dmhouse> You needn't use a /msg, however. If you're not going to annoy the channel by printing 20 of +> your messages, feel free to just type '@messages' in the channel. +> 17:12 < davidhouse> @tell dmhouse foobar +> 17:12 < hsbot> Consider it noted +> 17:12 < davidhouse> @ask dmhouse barfoo +> 17:12 < hsbot> Consider it noted +> 17:12 < davidhouse> You can see there @ask. It's just a synonym for @tell, but it prints "foo asked X ago M", +> which is more natural. E.g. '@ask dons whether he's applied my latest patch yet?' +> 17:13 < dmhouse> For the admins, a useful little debugging tool is @print-notices. +> 17:13 < hsbot> dmhouse: You have 2 new messages. '/msg hsbot @messages' to read them. +> 17:14 < dmhouse> Notice that hsbot pinged me there, even though it's less than a day since I last checked my +> messages, because there have been some new ones posted. +> 17:14 < dmhouse> @print-notices +> 17:14 < hsbot> {"dmhouse":=(Just Thu Jun 8 17:13:46 BST 2006,[Note {noteSender = "davidhouse", noteContents = +> "foobar", noteTime = Thu Jun 8 17:12:50 BST 2006, noteType = Tell},Note {noteSender = + "davidhouse", noteContents = "barfoo", noteTime = Thu Jun 8 17:12:55 BST 2006, noteType = Ask}])} +> 17:15 < dmhouse> There you can see the two notes. The internal state is a map from recipient nicks to a pair of +> (when we last buzzed them about having messages, a list of the notes they've got stacked up). +> 17:16 < dmhouse> Finally, if you don't want to bother checking your messages, then the following command will +> likely be useful. +> 17:16 < dmhouse> @clear-messages +> 17:16 < hsbot> Messages cleared. +> 17:16 < dmhouse> That's all, folks! +> 17:17 < dmhouse> Any comments, queries or complaints to dmhouse@gmail.com. The source should be fairly readable, so +> hack away! +-} + +module Plugin.Tell where + +import Control.Arrow (first) +import qualified Data.Map as M +import Text.Printf (printf) + +import Lib.AltTime +import Message +import Plugin + +type Nick = String +-- | Was it @tell or @ask that was the original command? +data NoteType = Tell | Ask deriving (Show, Eq, Read) +-- | The Note datatype. Fields self-explanatory. +data Note = Note { noteSender :: String, + noteContents :: String, + noteTime :: ClockTime, + noteType :: NoteType } + deriving (Eq, Show, Read) +-- | The state. A map of (times we last told this nick they've got messages, the +-- messages themselves) +type NoticeBoard = M.Map Nick (Maybe ClockTime, [Note]) +-- | A nicer synonym for the Tell monad. +type Telling a = ModuleT NoticeBoard LB a + +PLUGIN Tell + +instance Module TellModule NoticeBoard where + moduleCmds _ = ["tell", "ask", "messages", "messages?", "clear-messages"] + modulePrivs _ = ["print-notices", "purge-notices"] + moduleHelp _ = fromJust . flip lookup help + moduleDefState _ = return M.empty + moduleSerialize _ = Just mapSerial + + -- | Debug output the NoticeBoard + process _ _ _ "print-notices" _ = liftM ((:[]) . show) readMS + + -- | Clear notes. + process _ _ _ "purge-notices" args = do + case words args of + [] -> writeMS M.empty + ns -> mapM_ clearMessages ns + return ["Messages purged."] + + -- | Clear a user's notes + process _ msg _ "clear-messages" _ = + clearMessages (nick msg) >> return ["Messages cleared."] + + -- | Check whether a user has any messages + process _ msg _ "messages?" _ = do + let sender = nick msg + ms <- getMessages sender + case ms of + Just _ -> doRemind sender + Nothing -> return ["Sorry, no messages today."] + + -- | Write down a note + process _ msg _ "tell" args = doTell args msg Tell + + -- | Really just a synonym for @tell, but phrases it as a question instead. + process _ msg _ "ask" args = doTell args msg Ask + + -- | Give a user their messages + process _ msg _ "messages" _ = + do msgs <- getMessages $ nick msg + let res = fromMaybe ["You don't have any new messages."] msgs + clearMessages (nick msg) + return res + + -- | Hook onto contextual. Grab nicks of incoming messages, and tell them + -- if they have any messages, if it's less than a day since we last did so. + contextual _ msg _ _ = do + let sender = nick msg + remp <- needToRemind sender + if remp + then doRemind sender + else return [] + +-- | Lookup table for documentation +help :: [(String, String)] +help = [("tell", + "tell . When shows activity, tell them " ++ + "."), + ("ask", + "ask . When shows activity, ask them " ++ + "."), + ("messages", + "messages. Check your messages."), + ("messages?", + "messages?. Tells you whether you have any messages"), + ("clear-messages", + "clear-messages. Clears your messages."), + ("print-notices", "print-notices. Print the current map of notes."), + ("purge-notices", "purge-notices [ [ [ ...]]]]. " ++ + "Clear all notes for specified nicks, or all notices if you don't " + ++ "specify a nick.")] + +-- | Take a note and the current time, then display it +showNote :: ClockTime -> Note -> String +showNote time note = res + where diff = time `diffClockTimes` noteTime note + ago = case timeDiffPretty diff of + [] -> "less than a minute" + pr -> pr + action = case noteType note of Tell -> "said"; Ask -> "asked" + res = printf "%s %s %s ago: %s" + (noteSender note) action ago (noteContents note) + +-- | Is it less than a day since we last reminded this nick they've got messages? +needToRemind :: Nick -> Telling Bool +needToRemind n = do + st <- readMS + now <- io getClockTime + return $ case M.lookup n st of + Just (Just lastTime, _) -> + let diff = now `diffClockTimes` lastTime + in diff > noTimeDiff { tdDay = 1 } + Just (Nothing, _) -> True + Nothing -> True + +-- | Add a note to the NoticeBoard +writeDown :: Nick -> Nick -> String -> NoteType -> Telling () +writeDown to from what ntype = do + time <- io getClockTime + let note = Note { noteSender = from, + noteContents = what, + noteTime = time, + noteType = ntype } + modifyMS (M.insertWith (\_ (_, ns) -> (Nothing, ns ++ [note])) + to (Nothing, [note])) + +-- | Return a user's notes, or Nothing if they don't have any +getMessages :: Nick -> Telling (Maybe [String]) +getMessages n = do + st <- readMS + time <- io getClockTime + case M.lookup n st of + Just (_, msgs) -> do + -- update the last time we told this person they had messages + writeMS $ M.insert n (Just time, msgs) st + return . Just $ map (showNote time) msgs + Nothing -> return Nothing + +-- | Clear a user's messages. +clearMessages :: Nick -> Telling () +clearMessages n = modifyMS (M.delete n) + +-- * Handlers +-- + +-- | Execute a @tell or @ask command. +doTell :: Message m => String -> m -> NoteType -> Telling [String] +doTell args msg ntype = do + let args' = words args + recipient = head args' + sender = nick msg + rest = unwords $ tail args' + res | sender == recipient = Left "You can tell yourself!" + | recipient == name config = Left "Nice try ;)" + | otherwise = Right "Consider it noted." + when (isRight res) (writeDown recipient sender rest ntype) + return [unEither res] + +-- | Remind a user that they have messages. +doRemind :: Nick -> Telling [String] +doRemind sender = do + ms <- getMessages sender + now <- io getClockTime + modifyMS (M.update (Just . first (const $ Just now)) sender) + return $ case ms of + Just msgs -> + let (messages, pronoun) = + if length msgs > 1 + then ("messages", "them") else ("message", "it") + in [printf "%s: You have %d new %s. '/msg %s @messages' to read %s." + sender (length msgs) messages (name config) pronoun + :: String] + Nothing -> [] diff --git a/Plugin/Todo.hs b/Plugin/Todo.hs new file mode 100644 --- /dev/null +++ b/Plugin/Todo.hs @@ -0,0 +1,70 @@ +-- +-- | A todo list +-- +-- (c) 2005 Samuel Bronson +-- +module Plugin.Todo (theModule) where + +import Plugin +import qualified Message (nick) +import qualified Data.ByteString.Char8 as P + +PLUGIN Todo + +-- A list of key/elem pairs with an ordering determined by its position in the list +type TodoState = [(P.ByteString, P.ByteString)] + +instance Module TodoModule TodoState where + moduleCmds _ = ["todo", "todo-add"] + modulePrivs _ = ["todo-delete"] + moduleHelp _ s = case s of + "todo" -> "todo. List todo entries" + "todo-add" -> "todo-add . Add a todo entry" + "todo-delete" -> "todo-delete . Delete a todo entry (for admins)" + _ -> "Keep a todo list. Provides @todo, @todo-add, @todo-delete" + + moduleDefState _ = return ([] :: TodoState) + moduleSerialize _ = Just assocListPackedSerial + + process _ msg _ cmd rest = do + todoList <- readMS + case cmd of + "todo" -> getTodo todoList rest + "todo-add" -> addTodo sender rest + "todo-delete" -> delTodo rest + + where sender = Message.nick msg + +-- | Print todo list +getTodo :: TodoState -> String -> ModuleLB TodoState +getTodo todoList [] = return [formatTodo todoList] +getTodo _ _ = error "@todo has no args, try @todo-add or @list todo" + +-- | Pretty print todo list +formatTodo :: [(P.ByteString, P.ByteString)] -> String +formatTodo [] = "Nothing to do!" +formatTodo todoList = + unlines $ map (\(n::Int, (idea, nick)) -> concat $ + [ show n,". ",P.unpack nick,": ",P.unpack idea ]) $ + zip [0..] todoList + +-- | Add new entry to list +addTodo :: String -> String -> ModuleLB TodoState +addTodo sender rest = do + modifyMS (++[(P.pack rest, P.pack sender)]) + return ["Entry added to the todo list"] + +-- | Delete an entry from the list +delTodo :: String -> ModuleLB TodoState +delTodo rest + | Just n <- readM rest = withMS $ \ls write -> case () of + _ | null ls -> return ["Todo list is empty"] + | n > length ls - 1 || n < 0 + -> return [show n ++ " is out of range"] + + | otherwise -> do + write (map snd . filter ((/= n) . fst) . zip [0..] $ ls) + let (a,_) = ls !! n + return ["Removed: " ++ P.unpack a] + + | otherwise = return ["Syntax error. @todo , where n :: Int"] diff --git a/Plugin/Topic.hs b/Plugin/Topic.hs new file mode 100644 --- /dev/null +++ b/Plugin/Topic.hs @@ -0,0 +1,81 @@ +-- +-- | The Topic plugin is an interface for messing with the channel topic. +-- It can alter the topic in various ways and keep track of the changes. +-- The advantage of having the bot maintain the topic is that we get an +-- authoritative source for the current topic, when the IRC server decides +-- to delete it due to Network Splits. +-- +module Plugin.Topic (theModule) where + +import Plugin +import qualified Message (setTopic) +import qualified Data.Map as M + +import Control.Monad.State (gets) + +PLUGIN Topic + +instance Module TopicModule () where + moduleHelp _ s = case s of + "topic-tell" -> "@topic-tell #chan -- " ++ + "Tell the requesting person of the topic of the channel" + "topic-cons" -> "@topic-cons #chan -- " ++ + "Add a new topic item to the front of the topic list" + "topic-snoc" -> "@topic-snoc #chan -- " ++ + "Add a new topic item to the back of the topic list" + "topic-tail" -> "@topic-tail #chan -- " ++ + "Remove the first topic item from the topic list" + "topic-null" -> "@topic-null #chan -- " ++ + "Clear out the topic entirely" + "topic-init" -> "@topic-init #chan -- " ++ + "Remove the last topic item from the topic list" + _ -> "Someone forgot to document his new Topic function! Shame on him/her!" + + moduleCmds _ = ["topic-tell", + "topic-cons", "topic-snoc", + "topic-tail", "topic-init", "topic-null"] + + process_ _ "topic-cons" text = alterTopic chan (topic_item :) + where (chan, topic_item) = splitFirstWord text + + process_ _ "topic-snoc" text = alterTopic chan (snoc topic_item) + where (chan, topic_item) = splitFirstWord text + + process_ _ "topic-tail" chan = alterTopic chan tail + process_ _ "topic-init" chan = alterTopic chan init + process_ _ "topic-null" chan = send (Just (Message.setTopic chan "[]")) >> return [] + process_ _ "topic-tell" chan = lookupTopic chan $ \maybetopic -> return $ + case maybetopic of + Just x -> [x] + Nothing -> ["Do not know that channel"] + +------------------------------------------------------------------------ + +-- | 'lookupTopic' Takes a channel and a modifier function f. It then +-- proceeds to look up the channel topic for the channel given, returning +-- Just t or Nothing to the modifier function which can then decide what +-- to do with the topic +lookupTopic :: String -- ^ Channel + -> (Maybe String -> LB [String]) -- ^ Modifier function + -> LB [String] +lookupTopic chan f = gets (\s -> M.lookup (mkCN chan) (ircChannels s)) >>= f + +-- | 'alterTopic' takes a sender, a channel and an altering function. +-- Then it alters the topic in the channel by the altering function, +-- returning eventual problems back to the sender. +alterTopic :: String -- ^ Channel + -> ([String] -> [String]) -- ^ Modifying function + -> LB [String] +alterTopic chan f = + let p maybetopic = + case maybetopic of + Just x -> case reads x of + [(xs, "")] -> do send . Just $ Message.setTopic chan (show $ f $ xs) + return [] + [(xs, r)] | length r <= 2 + -> do send . Just $ Message.setTopic chan (show $ f $ xs) + return ["ignoring bogus characters: " ++ r] + + _ -> return ["Topic does not parse. Should be of the form [\"...\",...,\"...\"]"] + Nothing -> return ["I do not know the channel " ++ chan] + in lookupTopic chan p diff --git a/Plugin/Type.hs b/Plugin/Type.hs new file mode 100644 --- /dev/null +++ b/Plugin/Type.hs @@ -0,0 +1,148 @@ +-- +-- | The Type Module - another progressive plugin for lambdabot +-- +-- pesco hamburg 2003-04-05 +-- +-- Greetings reader, +-- +-- whether you're a regular follower of the series or dropping in for +-- the first time, let me present for your pleasure the Type Module: +-- +-- One thing we enjoy on #haskell is throwing function types at each +-- other instead of spelling out tiresome monologue about arguments +-- or return values. Unfortunately such a toss often involves a local +-- lookup of the type signature in question because one is seldom +-- sure about the actual argument order. +-- +-- Well, what do you know, this plugin enables lambdabot to automate +-- that lookup for you and your fellow lambda hackers. +-- +module Plugin.Type where + +import Plugin + +PLUGIN Type + +instance Module TypeModule () where + moduleCmds _ = ["type", "kind"] + moduleHelp _ "kind" = "kind . Return the kind of a type" + moduleHelp _ _ = "type . Return the type of a value" + process_ _ s expr = flip query_ghci expr $ case s of + "type" -> ":t" + "kind" -> ":k" + +-- In accordance with the KISS principle, the plan is to delegate all +-- the hard work! To get the type of foo, pipe + +command :: [Char] -> [Char] -> [Char] +command cmd foo = cmd ++ " " ++ foo + +-- into hugs and send any line matching + +signature_regex :: Regex +signature_regex + = mkRegexWithOpts + "^(\\*?[A-Z][_a-zA-Z0-9]*(\\*?[A-Z][_a-zA-Z0-9]*)*>)? *(.*[ -=:].*)" + True True + +-- +-- Rather than use subRegex, which is new to 6.4, we can remove comments +-- old skool style. +-- Former regex for this: +-- "(\\{-[^-]*-+([^\\}-][^-]*-+)*\\}|--.*$)" +-- +stripComments :: String -> String +stripComments [] = [] +stripComments ('\n':_) = [] -- drop any newwline and rest. *security* +stripComments ('-':'-':_) = [] -- +stripComments ('{':'-':cs)= stripComments (go 1 cs) +stripComments (c:cs) = c : stripComments cs + +-- Adapted from ghc/compiler/parser/Lexer.x +go :: Int -> String -> String +go 0 xs = xs +go _ ('-':[]) = [] -- unterminated +go n ('-':x:xs) + | x == '}' = go (n-1) xs + | otherwise = go n (x:xs) +go _ ('{':[]) = [] -- unterminated +go n ('{':x:xs) + | x == '-' = go (n+1) xs + | otherwise = go n (x:xs) +go n (_:xs) = go n xs +go _ _ = [] -- unterminated + +-- through IRC. + +-- +-- We first strip 7 leading lines, which is the GHCi logo, then the final line, +-- which is the last prompt, before filtering out the lines that match our regex, +-- selecting the last subset match on each matching line before finally concatting +-- the whole lot together again. +-- +-- TODO, just use ghci -v0 +-- +extract_signatures :: String -> String +extract_signatures output + = removeExp . concat . intersperse " " . map (dropWhile isSpace . expandTab) . + mapMaybe ((>>= last') . matchRegex signature_regex) . + reverse . drop 1 . reverse . drop 7 . lines $ output + where + last' [] = Nothing + last' xs = Just $ last xs + + removeExp :: String -> String + removeExp (' ':':':':':' ':xs) = xs + removeExp xs = case lex xs of + [("(",ys)] -> removeExp $ stripParens 1 ys + [("","")] -> [] + [(_,ys)] -> removeExp ys + _ -> error "invalid ghci output: unexpected lex behavior" + + stripParens :: Int -> String -> String + stripParens 0 xs = xs + stripParens n xs = case lex xs of + [("(",ys)] -> stripParens (n+1) ys + [(")",ys)] -> stripParens (n-1) ys + [("","")] -> error "invalid ghci output: open parenthesis" + [(_,ys)] -> stripParens n ys + _ -> error "invalid ghci output: unexpected lex behavior" + +-- +-- With this the command handler can be easily defined using popen: +-- +-- TODO, bring more modules into scope. +-- +query_ghci' :: String -> String -> IO String +query_ghci' cmd expr = do + (output, errors, _) <- popen (ghci config) ["-fglasgow-exts","-fno-th"] + (Just (context ++ command cmd (stripComments expr))) + let ls = extract_signatures output + return $ if null ls + then unlines . take 3 . lines . expandTab . cleanRE $ errors -- "bzzt" + else ls + where + context = concatMap (\m -> ":m + "++m++"\n") $ + prehier ++ datas ++ qualifieds ++ controls ++ other + + other = ["Text.Printf"] + prehier = ["Char", "List", "Maybe", "Numeric", "Random" ] + qualifieds = [] + datas = map ("Data." ++) [ + "Array", + "Bits", "Bool", "Char", "Dynamic", "Either", + "Graph", "Int", "Ix", "List", + "Maybe", "Ratio", "Tree", "Tuple", "Typeable", "Word" + ] + controls = map ("Control." ++) ["Monad", "Monad.State", "Monad.Reader", "Monad.Fix", "Arrow"] + + cleanRE :: String -> String + cleanRE s + | Just _ <- notfound `matchRegex` s = "Couldn\'t find qualified module.\nMaybe you\'re using the wrong syntax: Data.List.(\\\\) instead of (Data.List.\\\\)?" + | Just (_,_,b,_) <- ghci_msg `matchRegexAll` s = b + | otherwise = s + ghci_msg = mkRegex ":[^:]*:[^:]*: ?" + notfound = mkRegex "Failed to load interface" + +query_ghci :: String -> String -> LB [String] +query_ghci y z = ios (query_ghci' y z) diff --git a/Plugin/Unlambda.hs b/Plugin/Unlambda.hs new file mode 100644 --- /dev/null +++ b/Plugin/Unlambda.hs @@ -0,0 +1,44 @@ +-- +-- Copyright (c) 2006 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | A plugin for the Haskell interpreter for the unlambda language +-- +-- http://www.madore.org/~david/programs/unlambda/ +-- +module Plugin.Unlambda (theModule) where + +import Plugin + +PLUGIN Unlambda + +instance Module UnlambdaModule () where + moduleCmds _ = ["unlambda"] + moduleHelp _ _ = "unlambda . Evaluate an unlambda expression" + process _ _ to _ s = ios80 to (unlambda s) + +binary :: String +binary = "./unlambda" + +unlambda :: String -> IO String +unlambda src = do + (out,err,_) <- popen binary [] (Just src) + let o = unlines . take 6 . lines . cleanit $ out + e = unlines . take 6 . lines . cleanit $ err + return $ case () of {_ + | null o && null e -> "Done." + | null o -> e + | otherwise -> o + } + +-- +-- Clean up output +-- +cleanit :: String -> String +cleanit s | Just _ <- terminated `matchRegex` s = "Terminated\n" +-- | Just _ <- hget `matchRegex` s = "Terminated\n" + | otherwise = s + where terminated = mkRegex "waitForProc" + diff --git a/Plugin/Url.hs b/Plugin/Url.hs new file mode 100644 --- /dev/null +++ b/Plugin/Url.hs @@ -0,0 +1,82 @@ +-- +-- | Fetch URL page titles of HTML links. +-- +module Plugin.Url (theModule) where + +import Plugin + +PLUGIN Url + +instance Module UrlModule Bool where + moduleHelp _ "url-title" = "url-title . Fetch the page title." + moduleCmds _ = ["url-title"] + modulePrivs _ = ["url-on", "url-off"] + moduleDefState _ = return True -- url on + + process_ _ "url-title" url = fetchTitle url + process_ _ "url-on" _ = writeMS True >> return ["Url enabled"] + process_ _ "url-off" _ = writeMS False >> return ["Url disabled"] + + contextual _ _ _ text = do + alive <- readMS + if alive && (not $ areSubstringsOf ignoredStrings text) + then case containsUrl text of + Nothing -> return [] + Just url -> fetchTitle url + else return [] + +------------------------------------------------------------------------ + +-- | Fetch the title of the specified URL. +fetchTitle :: String -> LB [String] +fetchTitle url = do + title <- io $ urlPageTitle url (proxy config) + return $ maybe [] return title + +-- | List of strings that, if present in a contextual message, will +-- prevent the looking up of titles. This list can be used to stop +-- responses to lisppaste for example. Another important use is to +-- another lambdabot looking up a url title that contains another +-- url in it (infinite loop). Ideally, this list could be added to +-- by an admin via a privileged command (TODO). +ignoredStrings :: [String] +ignoredStrings = + ["paste", -- Ignore lisppaste, rafb.net + "cpp.sourcforge.net", -- C++ paste bin + "HaskellIrcPastePage", -- Ignore paste page + "title of that page", -- Ignore others like the old me + urlTitlePrompt] -- Ignore others like me + +-- | Suffixes that should be stripped off when identifying URLs in +-- contextual messages. These strings may be punctuation in the +-- current sentence vs part of a URL. Included here is the NUL +-- character as well. +ignoredUrlSuffixes :: [String] +ignoredUrlSuffixes = [".", ",", ";", ")", "\"", "\1"] + +-- | Searches a string for an embeddded URL and returns it. +containsUrl :: String -> Maybe String +containsUrl text = do + (_,kind,rest,_) <- matchRegexAll begreg text + let url = takeWhile (/=' ') rest + return $ stripSuffixes ignoredUrlSuffixes $ kind ++ url + where + begreg = mkRegexWithOpts "https?://" True False + +-- | Utility function to remove potential suffixes from a string. +-- Note, once a suffix is found, it is stripped and returned, no other +-- suffixes are searched for at that point. +stripSuffixes :: [String] -> String -> String +stripSuffixes [] str = str +stripSuffixes (s:ss) str + | isSuffixOf s str = take (length str - length s) $ str + | otherwise = stripSuffixes ss str + + +-- | Utility function to check of any of the Strings in the specified +-- list are substrings of the String. +areSubstringsOf :: [String] -> String -> Bool +areSubstringsOf = flip (any . flip isSubstringOf) + where + isSubstringOf s str = any (isPrefixOf s) (tails str) + diff --git a/Plugin/Version.hs b/Plugin/Version.hs new file mode 100644 --- /dev/null +++ b/Plugin/Version.hs @@ -0,0 +1,27 @@ +{-# OPTIONS -cpp #-} + +#include "config.h" + +-- +-- Copyright (c) 2005-6 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- | Lambdabot version information +-- +module Plugin.Version where + +import Plugin + +PLUGIN Version + +instance Module VersionModule () where + moduleCmds _ = ["version", "source"] + moduleHelp _ _ = "version/source. Report the build date, ghc version " ++ + "and darcs repo of this bot" + process_ _ _ _ = ios . return $ concat + ["lambdabot 4p", PATCH_COUNT, ", ", + "GHC ", GHC_VERSION, " (", PLATFORM, " ", CPU, ")", + "\n", "darcs get ", REPO_PATH ] + diff --git a/Plugin/Vixen.hs b/Plugin/Vixen.hs new file mode 100644 --- /dev/null +++ b/Plugin/Vixen.hs @@ -0,0 +1,48 @@ +-- +-- | Talk to hot chixxors. +-- +-- (c) Mark Wotton +-- +module Plugin.Vixen where + +import Plugin.Vixen.VixenState +import Plugin hiding (Regex, matchRegex) +import Lib.Regex +import qualified Data.ByteString.Char8 as P + +PLUGIN Vixen + +instance Module VixenModule (Bool, String -> IO String) where + moduleCmds _ = ["vixen"] + modulePrivs _ = ["vixen-on", "vixen-off"] -- could be noisy + moduleHelp _ _ = "vixen . Sergeant Curry's lonely hearts club" + moduleDefState _ = return $ (False, mkVixen) + + -- if vixen-chat is on, we can just respond to anything + contextual _ _ _ txt = do (alive, k) <- readMS + if alive then ios (k txt) else return [] + + process_ _ "vixen-on" _ = withMS $ \(_,r) k -> k (True, r) >> return ["What's this channel about?"] + process_ _ "vixen-off" _ = withMS $ \(_,r) k -> k (False, r) >> return ["Bye!"] + process_ _ _ txt = readMS >>= ios . ($ txt) . snd + +mkVixen :: String -> IO String +mkVixen question = vixen (mkResponses state) question + +-- use IO only for random, could remove it. +vixen :: (String -> WTree) -> String -> IO String +vixen responder them = do x <- randomWTreeElt (responder them) + return (P.unpack x) + +randomWTreeElt :: WTree -> IO P.ByteString +randomWTreeElt (Leaf a) = return a +randomWTreeElt (Node ls) = stdGetRandItem ls >>= randomWTreeElt + +match :: Regex -> String -> Bool +match r s = matchRegex r s + +mkResponses :: RespChoice -> String -> WTree +mkResponses choices them = + (\((_,wtree):_) -> wtree) $ filter (\(reg,_) -> match reg them) choices + +------------------------------------------------------------------------ diff --git a/Plugin/Vixen/VixenState.hs b/Plugin/Vixen/VixenState.hs new file mode 100644 --- /dev/null +++ b/Plugin/Vixen/VixenState.hs @@ -0,0 +1,1332 @@ +{-# OPTIONS -Onot #-} +-- +-- Copyright (c) 2005 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- +-- packed list of regexes. +-- +module Plugin.Vixen.VixenState where + +import Lib.Regex + +import qualified Data.ByteString.Base as P +import qualified Control.Exception as C (catch) +import System.IO.Unsafe (unsafePerformIO) + +data WTree = Leaf P.ByteString | Node [WTree] + deriving Show + +type RespChoice = [(Regex, WTree)] + +-- wrap mkRegex for better error reporting +mkRegex :: P.ByteString -> Regex +mkRegex x = unsafePerformIO $ + C.catch (regcomp x regExtended) $ \e -> + error $ "mkRegex failed on input " ++ (show x) ++ "\n" ++ show e + +state :: RespChoice +state = [ + ( mkRegex (P.packAddress "(^| )(aslp|a/s/l/p|a s l p|a\\\\s\\\\l\\\\p|a\\.s\\.l\\.p)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "19/f/California/No pics"#)]), + ( mkRegex (P.packAddress "(^| )(asl|a/s/l|a s l|a\\\\s\\\\l|a\\\\.s\\\\.l)($| |\\\\.|!|,|\\\\?)"#), + Node [Leaf (P.packAddress "19/f/California"#)]), + ( mkRegex (P.packAddress "(^| )(a/s|a s|a\\\\s|a\\.s)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "19/f"#)]), + ( mkRegex (P.packAddress "(^| )((ur |your )name|name\\?).*"#), + Node [Leaf (P.packAddress "My name is Emily"#)]), + ( mkRegex (P.packAddress "(^| )not bad($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "just not bad?"#)]), + ( mkRegex (P.packAddress ".*(haskell|Haskell|Lisp|Ocaml|Scheme).*"#), + Node [Leaf (P.packAddress "Ooh, functional programmers are so hot!"#),Leaf (P.packAddress "church is my favourite computer scientist."#)]), + ( mkRegex (P.packAddress ".*Visual Basic.*"#), + Node [Leaf (P.packAddress "Can you really catch syphilis from Visual Basic?"#)]), + ( mkRegex (P.packAddress "(^| )(should|Can) i call (you|u)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "no, no call, but thanks"#),Leaf (P.packAddress "no, you shouldn't call me yet. maybe later."#)]), + ( mkRegex (P.packAddress "(^| )(should )i($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "maybe you should :)"#),Leaf (P.packAddress "i dunno, should you?"#)]), + ( mkRegex (P.packAddress "(^| )(should )you($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "maybe I should :)"#),Leaf (P.packAddress "I just might"#)]), + ( mkRegex (P.packAddress "(^| )(should ).* we($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "maybe we should :)"#),Leaf (P.packAddress "i don't see why we shouldn't"#)]), + ( mkRegex (P.packAddress "(^| )pick topic($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "you messaged me, you pick a topic :)"#),Leaf (P.packAddress "oh, any ol' topic will do. Tell me about your childhood :)"#)]), + ( mkRegex (P.packAddress "(^| )where.*(u |you |ya).*(from|live).*"#), + Node [Leaf (P.packAddress "Huntington Beach California"#)]), + ( mkRegex (P.packAddress "(^| )where.*in.*(ca|cal|california|cali).*"#), + Node [Leaf (P.packAddress "Huntington Beach"#)]), + ( mkRegex (P.packAddress "(^| )where.*(school|college|collage).*"#), + Node [Leaf (P.packAddress "I'm a softmore at UCLA"#)]), + ( mkRegex (P.packAddress "(^| )where.*from.*"#), + Node [Leaf (P.packAddress "Huntington Beach, California"#)]), + ( mkRegex (P.packAddress "(^| )where.*grow.*up.*"#), + Node [Leaf (P.packAddress "i grew up in Huntington Beach"#)]), + ( mkRegex (P.packAddress "(^| )where.*born.*"#), + Node [Leaf (P.packAddress "i was born in Huntington Beach"#)]), + ( mkRegex (P.packAddress "(^| )where.*going.*"#), + Node [Leaf (P.packAddress "i'm not going anywhere"#)]), + ( mkRegex (P.packAddress "(^| )wassup.*"#), + Node [Leaf (P.packAddress "not much, what's up with you?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(1|2|3|4|5|6|7|8|9|0|one|two|three|four|five|six|seven|eight|nine|ten).*(plus|\\+|minus|times|-).*(1|2|3|4|5|6|7|8|9|0|one|two|three|four|five|six|seven|eight|nine|ten)"#), + Node [Leaf (P.packAddress "why are you giving me a math test?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*bout.*(you| u).*"#), + Node [Leaf (P.packAddress "what about me?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*bout me.*"#), + Node [Leaf (P.packAddress "what about you?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*chance.*of.*"#), + Node [Leaf (P.packAddress "i'd say the chances are pretty good"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*city.*"#), + Node [Leaf (P.packAddress "Huntington Beach"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*color.*eyes.*"#), + Node [Leaf (P.packAddress "my eyes are brown"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*color.*hair.*"#), + Node [Leaf (P.packAddress "my hair is brown"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*color.*sky.*"#), + Node [Leaf (P.packAddress "the sky is blue, why would you ask?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya)doin.*"#), + Node [Leaf (P.packAddress "i'm not doing anything really"#),Leaf (P.packAddress "just chattin"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*funny.*"#), + Node [Leaf (P.packAddress "everything is funny to me"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*for.*fun.*"#), + Node [Leaf (P.packAddress "i hang out with friends and surf"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*fun.*"#), + Node [Leaf (P.packAddress "fun is the opposite of work"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(ur |your )name.*"#), + Node [Leaf (P.packAddress "Emily, what's your name?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* is .* it.*"#), + Node [Leaf (P.packAddress "nothing"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*look.*like.*"#), + Node [Leaf (P.packAddress "i'm 5'7, 120 pounds, brown hair and brown eyes."#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*(into|in to).*"#), + Node [Leaf (P.packAddress "i'm into friends, surfing and reading"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*like.*to.*do.*"#), + Node [Leaf (P.packAddress "i like to go to clubs, surf and relax with friends"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*trying.*to.*say"#), + Node [Leaf (P.packAddress "i wasn't trying to say anything"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*wearin.*"#), + Node [Leaf (P.packAddress "tanktops and shorts, you?"#),Leaf (P.packAddress "nothin but my ol tank top and a pair of shorts :)"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(r |are )(you |u |ya )on($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "tanktops and shorts, you?"#),Leaf (P.packAddress "nothin but my ol tank top and a pair of shorts :)"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*studying.*"#), + Node [Leaf (P.packAddress "psychology"#),Leaf (P.packAddress "i'm a psychology major"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*talkin.*bout.*"#), + Node [Leaf (P.packAddress "i dunno, what was I talking about?"#),Leaf (P.packAddress "sometimes i don't even know what I was talking about"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(u |you |ya).*ing.*"#), + Node [Leaf (P.packAddress "i dunno, what was i doing?"#),Leaf (P.packAddress "i dunno, was i doing that?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(favorite|fav).*color.*"#), + Node [Leaf (P.packAddress "probably blue, what's yours?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(favorite|fav).*position.*"#), + Node [Leaf (P.packAddress "on top :)"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(favorite|fav).*team.*"#), + Node [Leaf (P.packAddress "go Dodgers!"#),Leaf (P.packAddress "i like all teams equal :)"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(favorite|fav)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "it's hard for me to pick a favorite. what's yours?"#),Leaf (P.packAddress "i'm not sure i have a favorite"#),Leaf (P.packAddress "i like all equally"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*problem.*"#), + Node [Leaf (P.packAddress "no problem"#),Leaf (P.packAddress "i don't have a problem"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(singer|band|group|music).*"#), + Node [Leaf (P.packAddress "i like Tom Petty"#),Leaf (P.packAddress "i like Journey"#),Leaf (P.packAddress "i like Buddy Holly"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(song).*"#), + Node [Leaf (P.packAddress "i love "#),Leaf (P.packAddress "Free Falling"#),Leaf (P.packAddress " by Tom Petty"#),Leaf (P.packAddress "i like "#),Leaf (P.packAddress "Don't stop Believing"#),Leaf (P.packAddress " by Journey"#),Leaf (P.packAddress "i like "#),Leaf (P.packAddress "That'll be the Day"#),Leaf (P.packAddress " by Buddy Holly"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*kind.*"#), + Node [Leaf (P.packAddress "any kind"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(got|have).*(on|in).*mind.*"#), + Node [Leaf (P.packAddress "i wasn't thinking anything in particular"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*part.*(ca|cal|Cali|california)"#), + Node [Leaf (P.packAddress "Huntington Beach"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*mean.*"#), + Node [Leaf (P.packAddress "i'm not sure what i mean"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*my.*name.*"#), + Node [Leaf (P.packAddress "you don't know your own name??"#),Leaf (P.packAddress "why do you need me to tell you YOUR name?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* now*"#), + Node [Leaf (P.packAddress "i dunno, what now?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* oldest*"#), + Node [Leaf (P.packAddress "pretty old, let's just say that"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* youngest*"#), + Node [Leaf (P.packAddress "the younger the better ;)"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*( race| nationality| ethnicity).*"#), + Node [Leaf (P.packAddress "i'm half white, half mexican"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*story.*"#), + Node [Leaf (P.packAddress "i forgot the story now"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*( on | in ).*mind.*"#), + Node [Leaf (P.packAddress "nothing is in my mind right now"#),Leaf (P.packAddress "just white noise in my mind right now"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*else.*"#), + Node [Leaf (P.packAddress "that's all"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*turns.*you.*on.*"#), + Node [Leaf (P.packAddress "honesty turns me on"#),Leaf (P.packAddress "i like a guy with good teeth"#)]), + ( mkRegex (P.packAddress "(^| )(wat|what|tell me|whats|what's).* up($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "not much, what's up with you?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* happening($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "not too hell of a lot"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).* going.* on($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "very little, what's going on with you?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(you| u )(doing|doin)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "just chattin ont he computer"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(you| u ).*(mean|talking about|talkin about|talkin bout).*"#), + Node [Leaf (P.packAddress "i don't even know what i'm going on about"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(you| u ).*want.*talk.*bout.*"#), + Node [Leaf (P.packAddress "i dunno, you chose a subject"#),Leaf (P.packAddress "any ol' subject will due, you chose"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(you| u ).*want.*"#), + Node [Leaf (P.packAddress "i dunno, what do you got?"#),Leaf (P.packAddress "i want it all!"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(you| u ).*want it.*"#), + Node [Leaf (P.packAddress "i'll hafta think about that... i might want it later"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*part.*"#), + Node [Leaf (P.packAddress "what part of what?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*(want|wanna).*(talk|chat).*bout.*"#), + Node [Leaf (P.packAddress "any subject will due, let's just talk"#),Leaf (P.packAddress "i dunno, what do you wanna talk about?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*talk.*bout.*"#), + Node [Leaf (P.packAddress "i don't know what i'm saying"#),Leaf (P.packAddress "sorry, was i babbling non-sense?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what is|tell me |whats |what's )the .*"#), + Node [Leaf (P.packAddress "i dunno, what is it?"#),Leaf (P.packAddress "i give up, what?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*wearin.*"#), + Node [Leaf (P.packAddress "tank top and shorts, you?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*type.*"#), + Node [Leaf (P.packAddress "any type will due"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*vixen.*"#), + Node [Leaf (P.packAddress "i'm a vixen"#),Leaf (P.packAddress "being a vixen isn't as easy as it sounds"#),Leaf (P.packAddress "all women have a little vixen in them... just some more than others"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*bout.*"#), + Node [Leaf (P.packAddress "i dunno, what about?"#)]), + ( mkRegex (P.packAddress "(^| )(wat |what |tell me |whats |what's ).*the.*(hell|fuck).*"#), + Node [Leaf (P.packAddress "what's wrong?"#),Leaf (P.packAddress "what? what did i do?"#)]), + ( mkRegex (P.packAddress "^(wat?|what?)$"#), + Node [Leaf (P.packAddress "nevermind"#),Leaf (P.packAddress "forget about it"#),Leaf (P.packAddress "nothin"#)]), + ( mkRegex (P.packAddress ".*(^| )who .*(r are|are u|r u).*"#), + Node [Leaf (P.packAddress "what do you mean? i'm just me"#),Leaf (P.packAddress "what do you want to know about me?"#),Leaf (P.packAddress "i'm just me"#)]), + ( mkRegex (P.packAddress ".*(^| )(why |y ).*(you |u |ya ).*repeat.*"#), + Node [Leaf (P.packAddress "i don't mean to repeat myself, sorry"#),Leaf (P.packAddress "oh, i guess i've already messaged that, huh?"#),Leaf (P.packAddress "i just forget that i said something"#)]), + ( mkRegex (P.packAddress ".*(^| )who .*say.*same.*"#), + Node [Leaf (P.packAddress "i don't mean to repeat myself, sorry"#),Leaf (P.packAddress "oh, i guess i've already messaged that, huh?"#),Leaf (P.packAddress "i just forget that i said something"#)]), + ( mkRegex (P.packAddress ".*(^| )who .*keep.*asking.*"#), + Node [Leaf (P.packAddress "because i forgot the answer"#),Leaf (P.packAddress "you never answered, did you?"#),Leaf (P.packAddress "i'm sorry, i guess i did already ask"#)]), + ( mkRegex (P.packAddress ".*(^| )who .*ask.*"#), + Node [Leaf (P.packAddress "i guess no one asked"#),Leaf (P.packAddress "didn't you ask?"#)]), + ( mkRegex (P.packAddress ".*(^| )who .*cares.*"#), + Node [Leaf (P.packAddress "i care"#),Leaf (P.packAddress "what, you don't care?"#),Leaf (P.packAddress "i'm sure someone out there cares..."#)]), + ( mkRegex (P.packAddress ".*(^| )who .*warned.*(you|u)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "some jerk :P"#),Leaf (P.packAddress "just some friends playing around"#),Leaf (P.packAddress "oh, i didn't notice i'd been warned"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*not.*"#), + Node [Leaf (P.packAddress "good question, why not indeed?"#),Leaf (P.packAddress "because i said so!"#),Leaf (P.packAddress "just not"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*( you | u ).*repeat.*"#), + Node [Leaf (P.packAddress "i don't mean to repeat myself, sorry"#),Leaf (P.packAddress "oh, i guess i've already messaged that, huh?"#),Leaf (P.packAddress "i just forget that i said something"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(say|ask).*same.*"#), + Node [Leaf (P.packAddress "i don't mean to repeat myself, sorry"#),Leaf (P.packAddress "oh, i guess i've already messaged that, huh?"#),Leaf (P.packAddress "i just forget that i said something"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*keep.*(asking|saying).*"#), + Node [Leaf (P.packAddress "i don't mean to repeat myself, sorry"#),Leaf (P.packAddress "oh, i guess i've already messaged that, huh?"#),Leaf (P.packAddress "i just forget that i said something"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*ask.*"#), + Node [Leaf (P.packAddress "just curious"#),Leaf (P.packAddress "i wanted to know"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*say.*that.*"#), + Node [Leaf (P.packAddress "i don't know why i say half the things i do"#),Leaf (P.packAddress "good question, why did i say that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*( you | u ).*say.*"#), + Node [Leaf (P.packAddress "i don't know why i say half the things i do"#),Leaf (P.packAddress "good question, why did i say that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*( you | u ).*ask.*"#), + Node [Leaf (P.packAddress "just curious"#),Leaf (P.packAddress "i wanted to know"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*( you | u ).*hate.*"#), + Node [Leaf (P.packAddress "i don't hate"#),Leaf (P.packAddress "i'm not a hater"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*( you | u ).*riddles.*"#), + Node [Leaf (P.packAddress "do i talk in riddles?"#),Leaf (P.packAddress "sorry, i'll try to be more clear"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(won't|wont).*( you| u)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "because i don't wanna"#),Leaf (P.packAddress "cuz i don't feel like it"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(don't|dont).*( you| u)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "maybe i will one day"#),Leaf (P.packAddress "because i don't see the need to"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(r u|are u|are you)($| |\\?|\\.|,|!).*ing.*"#), + Node [Leaf (P.packAddress "because i like to :)"#),Leaf (P.packAddress "because it's what i do"#),Leaf (P.packAddress "do you not want me to do that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(r u|are u|are you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "just the way God made me"#),Leaf (P.packAddress "just the way i am"#),Leaf (P.packAddress "cuz that's how i feel like being"#)]), + ( mkRegex (P.packAddress ".*(^| )(y |why ).*(aren't u|aren't u|arent you|arent you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "cuz i don't hafta"#),Leaf (P.packAddress "because i don't feel like it"#),Leaf (P.packAddress "just the way i am"#)]), + ( mkRegex (P.packAddress "^(y |why )\\?"#), + Node [Leaf (P.packAddress "why not?"#),Leaf (P.packAddress "because i said so"#),Leaf (P.packAddress "why ask why?"#)]), + ( mkRegex (P.packAddress ".*(^| )how.* old.*($| |\\?|\\.|,|!)"#), + Node [Leaf (P.packAddress "19, you?"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*old.*am.*i.*"#), + Node [Leaf (P.packAddress "you don't know your own age?"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*(r u|are u|r you|doin).*"#), + Node [Leaf (P.packAddress "very well, you?"#),Leaf (P.packAddress "i'm great"#),Leaf (P.packAddress "doing good"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*weather.*"#), + Node [Leaf (P.packAddress "weather here is always nice"#),Leaf (P.packAddress "it's warm here"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*long.*"#), + Node [Leaf (P.packAddress "very long"#),Leaf (P.packAddress "not too long"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*many.*(guys|men|people).*(slept|sex).*"#), + Node [Leaf (P.packAddress "how many guys i've slept with is my own business"#),Leaf (P.packAddress "never ask a girl that!"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*many.*"#), + Node [Leaf (P.packAddress "let's just say a few"#),Leaf (P.packAddress "lots"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*bout.*( u| you)($| |\\?|\\.|,|!)"#), + Node [Leaf (P.packAddress "what about me?"#),Leaf (P.packAddress "yeah, how about me"#)]), + ( mkRegex (P.packAddress ".*(^| )(size|big).*(tits|breasts|bra|chest).*"#), + Node [Leaf (P.packAddress "32c, you?"#),Leaf (P.packAddress "32c"#)]), + ( mkRegex (P.packAddress ".*(^| )(tits|breasts|bra|chest) size.*"#), + Node [Leaf (P.packAddress "32c, you?"#),Leaf (P.packAddress "32c"#)]), + ( mkRegex (P.packAddress ".*(^| )how .*big.*(tits|breasts|bra|chest).*"#), + Node [Leaf (P.packAddress "32c, you?"#),Leaf (P.packAddress "32c"#)]), + ( mkRegex (P.packAddress ".*(^| )how.*did.*( you| u| ya).*know.*"#), + Node [Leaf (P.packAddress "i just knew ;)"#),Leaf (P.packAddress "i didn't really know, but i kinda guessed"#)]), + ( mkRegex (P.packAddress ".*(^| )(how |how's ).*goin.*"#), + Node [Leaf (P.packAddress "goin' great!"#),Leaf (P.packAddress "it's going fantastic"#)]), + ( mkRegex (P.packAddress ".*(^| )(how r|how are|how're).*(you| u)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "i am wonderful, thanks for asking!"#),Leaf (P.packAddress "i'm good, you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(how come (you|u|your|you're|yer))($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "well, i figure "#),Leaf (P.packAddress "why not?"#),Leaf (P.packAddress ""#),Leaf (P.packAddress "just the way I am guess"#),Leaf (P.packAddress "because thats how I am"#)]), + ( mkRegex (P.packAddress ".*(^| )(how )(you |u |ya )like($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "i like it any way it is offered to me"#),Leaf (P.packAddress "i dunno how i like it"#)]), + ( mkRegex (P.packAddress ".*(^| )how so?"#), + Node [Leaf (P.packAddress "i dunno how so, it's just so"#)]), + ( mkRegex (P.packAddress "(^| )(call|phone) me($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "okay, i'm dialing"#),Leaf (P.packAddress "its ringing"#)]), + ( mkRegex (P.packAddress ".*(^| )(tell me |talk about ).*about.*( u| you| urself| yourself).*"#), + Node [Leaf (P.packAddress "well, my name is Emily, i'm 19, student at UCLA, from Huntington Beach. how about you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(lets|let's).*(fuk|fuck).*"#), + Node [Leaf (P.packAddress "let's not be a moron... kinda ruining your chances, huh?"#),Leaf (P.packAddress "do you really think just saying "#),Leaf (P.packAddress "let's fuck"#),Leaf (P.packAddress " is going to work?"#)]), + ( mkRegex (P.packAddress ".*(^| )(lets|let's).*meet.*"#), + Node [Leaf (P.packAddress "let's get to know each other better before we meet, okay?"#),Leaf (P.packAddress "maybe one day we'll meet, but not yet"#)]), + ( mkRegex (P.packAddress ".*(^| )let.* me.*call.*"#), + Node [Leaf (P.packAddress "i don't give out my phone number to people i don't know well"#),Leaf (P.packAddress "i'm not comfortable giving you my number yet"#)]), + ( mkRegex (P.packAddress ".*(^| )go .*away*"#), + Node [Leaf (P.packAddress "fine, i'll leave you alone"#),Leaf (P.packAddress "what did i say to upset you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(take off|take it off).*"#), + Node [Leaf (P.packAddress "what good would it do for me to take it off? you can't see me anyhow"#),Leaf (P.packAddress "sure, it's off"#)]), + ( mkRegex (P.packAddress ".*(^| )(describe|discribe).*body.*"#), + Node [Leaf (P.packAddress "i have a nice body, i work out all the time"#),Leaf (P.packAddress "i have a good body, i stay fit"#)]), + ( mkRegex (P.packAddress ".*(^| )(describe|discribe).*(urself|yourself|u self|ur self|your self).*"#), + Node [Leaf (P.packAddress "well, my name is Emily, i'm 19, student at UCLA, from Huntington Beach. how about you?"#)]), + ( mkRegex (P.packAddress ".*(^| )explain.*"#), + Node [Leaf (P.packAddress "what do you want me to explain?"#)]), + ( mkRegex (P.packAddress ".*(^| )bend over.*"#), + Node [Leaf (P.packAddress "it would be hard to type bending over..."#)]), + ( mkRegex (P.packAddress ".*(^| )make.*me.*cum.*"#), + Node [Leaf (P.packAddress "i don't have the 10 seconds to spare that such a task would involve"#),Leaf (P.packAddress "well, you're making me vomit, so it's only fair"#)]), + ( mkRegex (P.packAddress ".*(^| )let me .*"#), + Node [Leaf (P.packAddress "i'm not stopping you"#),Leaf (P.packAddress "why do you need me to let you?"#)]), + ( mkRegex (P.packAddress ".*never.*(talk|message|im).*again.*"#), + Node [Leaf (P.packAddress "fine, no loss to me"#),Leaf (P.packAddress "i won't"#)]), + ( mkRegex (P.packAddress ".*(^| )(got|have).* (pic|pix).*"#), + Node [Leaf (P.packAddress "no pic, i'll get one soon"#),Leaf (P.packAddress "sorry, don't have a pic"#)]), + ( mkRegex (P.packAddress "(^| )(race|nationality|ethn.*).*\\?.*"#), + Node [Leaf (P.packAddress "i'm half white, half mexican"#)]), + ( mkRegex (P.packAddress "(^| )have.*(talked|chatted).*before.*\\?.*"#), + Node [Leaf (P.packAddress "i think we might have"#)]), + ( mkRegex (P.packAddress "(^| )do they.*"#), + Node [Leaf (P.packAddress "i dunno, do they?"#)]), + ( mkRegex (P.packAddress "(^| )does he .*"#), + Node [Leaf (P.packAddress "who is the he we are talking about?"#)]), + ( mkRegex (P.packAddress "(^| )does she .*"#), + Node [Leaf (P.packAddress "who is the she we are talking about?"#)]), + ( mkRegex (P.packAddress "(^| )does (that|it)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "it does"#),Leaf (P.packAddress "i dunno, does it?"#)]), + ( mkRegex (P.packAddress ".*(^| )would .*(u |you |ya).*meet.*\\?.*"#), + Node [Leaf (P.packAddress "let's get to know each other a little better before we talk about meeting"#),Leaf (P.packAddress "maybe one day"#)]), + ( mkRegex (P.packAddress ".*(^| )would .*(u |you |ya).*\\?.*"#), + Node [Leaf (P.packAddress "the question isn't would i, but should i"#),Leaf (P.packAddress "i might :)"#)]), + ( mkRegex (P.packAddress ".*(^| )can .*call.*(you| u).*\\?.*"#), + Node [Leaf (P.packAddress "maybe i'll give you my number later"#),Leaf (P.packAddress "i'm not giving you my number yet"#)]), + ( mkRegex (P.packAddress ".*(^| )can .*talk.*on.*phone.*\\?.*"#), + Node [Leaf (P.packAddress "maybe i'll give you my number later"#),Leaf (P.packAddress "i'm not giving you my number yet"#)]), + ( mkRegex (P.packAddress ".*(^| )can .*connect.*\\?.*"#), + Node [Leaf (P.packAddress "no, i don't wanna connect"#),Leaf (P.packAddress "please don't connect to me"#)]), + ( mkRegex (P.packAddress ".*(^| )can .*send.*my.* (pic|pix).*\\?.*"#), + Node [Leaf (P.packAddress "let's talk more before you send your pic, okay?"#),Leaf (P.packAddress "you can email me your pic at vixenlove@hotmail.com"#)]), + ( mkRegex (P.packAddress ".*(^| )can .*get.*(your|ur|you're).* (pic|pix).*\\?.*"#), + Node [Leaf (P.packAddress "let's talk more before you send your pic, okay?"#),Leaf (P.packAddress "you can email me your pic at vixenlove@hotmail.com"#)]), + ( mkRegex (P.packAddress ".*(^| )can .* I .*ask.*"#), + Node [Leaf (P.packAddress "of course you can ask!"#),Leaf (P.packAddress "sure, ask away"#)]), + ( mkRegex (P.packAddress ".*(^| )can .* I .*tell.*"#), + Node [Leaf (P.packAddress "sure, tell away"#)]), + ( mkRegex (P.packAddress ".*(^| )can .* I($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "you're very welcomed to"#),Leaf (P.packAddress "i'm sure you can, but i don't think you should"#)]), + ( mkRegex (P.packAddress ".*(^| )can .* we($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "i dunno, we probably can, but should we?"#),Leaf (P.packAddress "let's"#)]), + ( mkRegex (P.packAddress ".*(^| )i can($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "can you really?"#),Leaf (P.packAddress "i'm sure you can"#)]), + ( mkRegex (P.packAddress ".*(^| )can we($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "i'm sure we can"#),Leaf (P.packAddress "i think we could do that"#)]), + ( mkRegex (P.packAddress ".*(^| )can (you|u)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "i sure can"#),Leaf (P.packAddress "of course i can"#)]), + ( mkRegex (P.packAddress ".*(^| )can i($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "of course you can"#),Leaf (P.packAddress "you sure can"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(hair|eyes).*"#), + Node [Leaf (P.packAddress "you sound very sexy!"#),Leaf (P.packAddress "you're my type"#),Leaf (P.packAddress "you sound like a hunk"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*angry.*"#), + Node [Leaf (P.packAddress "please don't be angry"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*afraid.*"#), + Node [Leaf (P.packAddress "nothing to be angry about"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*already.*(said|told|answered).*"#), + Node [Leaf (P.packAddress "did you? sorry, i must have missed it"#),Leaf (P.packAddress "oh, sorry, i must have forgotten"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(said|told|answered).*already.*"#), + Node [Leaf (P.packAddress "did you? sorry, i must have missed it"#),Leaf (P.packAddress "oh, sorry, i must have forgotten"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*not.*bad.*"#), + Node [Leaf (P.packAddress "just not bad?"#),Leaf (P.packAddress "why not great?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*want.*bad.*"#), + Node [Leaf (P.packAddress "how bad do you want it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*bad.*"#), + Node [Leaf (P.packAddress "you're not bad"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*buff.*"#), + Node [Leaf (P.packAddress "do you work out a lot?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*block.*( u| you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "please don't block me!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*bored.*"#), + Node [Leaf (P.packAddress "what can I do to un-bore you?"#),Leaf (P.packAddress "yeah, i'm bored too. let's entertain each other"#),Leaf (P.packAddress "being bored isn't fun"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(can't|cant).*(type|spell).*"#), + Node [Leaf (P.packAddress "yeha, ether kan i"#),Leaf (P.packAddress "spelling is over rated"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(can't|cant).*"#), + Node [Leaf (P.packAddress "why can't you?"#),Leaf (P.packAddress "i'm sure you could if you really tried"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*cool.*"#), + Node [Leaf (P.packAddress "you seem cool"#),Leaf (P.packAddress "i like cool guys"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*crashed.*"#), + Node [Leaf (P.packAddress "crashed hard?"#),Leaf (P.packAddress "i crash a lot"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*confus.*"#), + Node [Leaf (P.packAddress "i hope i don't confuse you"#),Leaf (P.packAddress "why are you confused?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*curious.*"#), + Node [Leaf (P.packAddress "be careful... curiosity killed the cat"#),Leaf (P.packAddress "what are you curious about?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't|dont).*care.*"#), + Node [Leaf (P.packAddress "why don't you care?"#),Leaf (P.packAddress "i don't care either"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't|dont).*have.*clue.*"#), + Node [Leaf (P.packAddress "completely clueless?"#),Leaf (P.packAddress "i'd buy you a clue if i could"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*have.*no.*clue.*"#), + Node [Leaf (P.packAddress "completely clueless?"#),Leaf (P.packAddress "i'd buy you a clue if i could"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).* do .*too.*"#), + Node [Leaf (P.packAddress "we have a lot in common"#),Leaf (P.packAddress "what a coincidence!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i )do$"#), + Node [Leaf (P.packAddress "do you?"#),Leaf (P.packAddress "i thought you did"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*gay.*"#), + Node [Leaf (P.packAddress "nothing wrong with being gay"#),Leaf (P.packAddress "you don't sound gay"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(gone| out$|gonna go|going to go|gotta go).*"#), + Node [Leaf (P.packAddress "oh, okay. will i talk to you again soon?"#),Leaf (P.packAddress "please don't go!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*going to .*"#), + Node [Leaf (P.packAddress "you do that!"#),Leaf (P.packAddress "why are you going to do that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(guy|man|male|dude).*"#), + Node [Leaf (P.packAddress "i know you're a guy"#),Leaf (P.packAddress "what a coincidence, i'm a girl!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).* from .*"#), + Node [Leaf (P.packAddress "oh yeah? how long have you lived there?"#),Leaf (P.packAddress "nice area you come from"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*freaked.*out.*"#), + Node [Leaf (P.packAddress "i didn't mean to freak you out"#),Leaf (P.packAddress "i freak people out a lot for some reason"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(have|got).*no.*idea"#), + Node [Leaf (P.packAddress "not even a small idea?"#),Leaf (P.packAddress "i'd buy you an idea if i could"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(have|need).*to.*go.*"#), + Node [Leaf (P.packAddress "why do you have to go??"#),Leaf (P.packAddress "noooo, you don't HAVE have to go, do you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*have to.*"#), + Node [Leaf (P.packAddress "why do you have to?"#),Leaf (P.packAddress "who says you have to?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*have no .*"#), + Node [Leaf (P.packAddress "none at all?"#),Leaf (P.packAddress "you don't even have a little?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*here.*"#), + Node [Leaf (P.packAddress "really, so am i!"#),Leaf (P.packAddress "yup, there you are"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*model.*"#), + Node [Leaf (P.packAddress "do you do a sexy walk on the catwalk?"#),Leaf (P.packAddress "ever see zoolander?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*need.*to.*"#), + Node [Leaf (P.packAddress "do you need to, or just want to?"#),Leaf (P.packAddress "if you need to, you need to"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*need.*"#), + Node [Leaf (P.packAddress "do you need it, or just want it?"#),Leaf (P.packAddress "pretty needy, aren't you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*naked.*"#), + Node [Leaf (P.packAddress "then put some clothes on, silly"#),Leaf (P.packAddress "why don't you have clothes on?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*nice.*"#), + Node [Leaf (P.packAddress "you seem nice"#),Leaf (P.packAddress "i'd rather be naughty than nice"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*leav.*"#), + Node [Leaf (P.packAddress "wait, don't leave!"#),Leaf (P.packAddress "why would you leave?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*like.*( your| ur).*( name| sn)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "thanks, i like it too"#),Leaf (P.packAddress "yeah, i get that a lot"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*like.*( u| you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "awww, i like you too!"#),Leaf (P.packAddress "well, you seem nice too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*((don't|dont).*like.*|dislike)"#), + Node [Leaf (P.packAddress "i don't care for it either..."#),Leaf (P.packAddress "yeah, i dislike that too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i look like).*"#), + Node [Leaf (P.packAddress "is that how you look?"#),Leaf (P.packAddress "how do you look that way?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i like).*"#), + Node [Leaf (P.packAddress "a lot of people like that"#),Leaf (P.packAddress "i like it too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im )like.*"#), + Node [Leaf (P.packAddress "is that what you're like?"#),Leaf (P.packAddress "how are you like that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*live.*in.*"#), + Node [Leaf (P.packAddress "oh yeah? nice place to live?"#),Leaf (P.packAddress "how long have you lived there?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*love.*( u| you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "you love me? you don't even know me"#),Leaf (P.packAddress "thanks. but i just like you."#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*love.*"#), + Node [Leaf (P.packAddress "very passionate, aren't you?"#),Leaf (P.packAddress "who doesn't love that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*go .*to .*"#), + Node [Leaf (P.packAddress "how long have you gone there?"#),Leaf (P.packAddress "i wish i got to go there!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(gotta go|got to go|have to go|hafta go).*"#), + Node [Leaf (P.packAddress "when will we talk again?"#),Leaf (P.packAddress "oh, don't go yet!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*good.*"#), + Node [Leaf (P.packAddress "just good?"#),Leaf (P.packAddress "i'm glad, i'm good too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*great.*"#), + Node [Leaf (P.packAddress "wow, can't get better than great"#),Leaf (P.packAddress "i'm glad your great."#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*say.*so.*"#), + Node [Leaf (P.packAddress "well, if you say so it must be true"#),Leaf (P.packAddress "just because you say so, huh?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).* see.*"#), + Node [Leaf (P.packAddress "yes, but do you understand?"#),Leaf (P.packAddress "do you see?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*slow.*"#), + Node [Leaf (P.packAddress "i'm a little slow too"#),Leaf (P.packAddress "how slow are you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*sorry.*"#), + Node [Leaf (P.packAddress "it's okay"#),Leaf (P.packAddress "i forgive you"#),Leaf (P.packAddress "don't be sorry"#),Leaf (P.packAddress "i'm sorry too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(dumb|retard|moron|idiot).*"#), + Node [Leaf (P.packAddress "you seem smart to me"#),Leaf (P.packAddress "don't be so hard on yourself!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*( ok| okay| okey| o\\.k\\.).*"#), + Node [Leaf (P.packAddress "just okay?"#),Leaf (P.packAddress "why are you not great?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't know|dont know|dunno).*"#), + Node [Leaf (P.packAddress "then find out! :)"#),Leaf (P.packAddress "it's okay, i don't know either"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*kiss.*"#), + Node [Leaf (P.packAddress "ooohh.. are you a good kisser?"#),Leaf (P.packAddress "good, i could use a kiss"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*know.*"#), + Node [Leaf (P.packAddress "i thought you knew"#),Leaf (P.packAddress "i know you know"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*remember.*"#), + Node [Leaf (P.packAddress "you have such a good memory"#),Leaf (P.packAddress "well, make sure not to forget"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*student.*"#), + Node [Leaf (P.packAddress "i'm a student too!"#),Leaf (P.packAddress "it's great to be a student, isn't it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*sick.*"#), + Node [Leaf (P.packAddress "flu or cold?"#),Leaf (P.packAddress "i hope you feel better soon!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*take.*off.*(your|ur).*"#), + Node [Leaf (P.packAddress "you're taking it off, huh? okay, go on"#),Leaf (P.packAddress "what if i get cold?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*talkin.*to.*(bot|machine|program|computer).*"#), + Node [Leaf (P.packAddress "really? you mean when talking to me?"#),Leaf (P.packAddress "what do you mean you're talking to a...?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(talkin|chattin).*(to|with).*( u| you).*"#), + Node [Leaf (P.packAddress "yup, we're talking"#),Leaf (P.packAddress "yeah, and i enjoy talking to you"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*think.*"#), + Node [Leaf (P.packAddress "you think so, eh?"#),Leaf (P.packAddress "is that really what you think?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*thought.*"#), + Node [Leaf (P.packAddress "well, it's a thought"#),Leaf (P.packAddress "is that what you still think?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*guess.*"#), + Node [Leaf (P.packAddress "don't just guess, know!"#),Leaf (P.packAddress "yeah, good guess"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't|dont).*like.*(u|you)($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "why don't you like me??"#),Leaf (P.packAddress "but i like you!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't|dont).*understand.*"#), + Node [Leaf (P.packAddress "do you want me to explain?"#),Leaf (P.packAddress "to be honest with you, i don't understand either!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(don't|dont).*"#), + Node [Leaf (P.packAddress "i don't either"#),Leaf (P.packAddress "good, you shouldn't"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(want|wanna).*see .*you.*"#), + Node [Leaf (P.packAddress "you wanna see me, huh?"#),Leaf (P.packAddress "why do you want to see me?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(want|wanna).*meet.*"#), + Node [Leaf (P.packAddress "we need to get to know each other better first before we meet"#),Leaf (P.packAddress "maybe one day we'll meet, but not today :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*want.*( u|you).*"#), + Node [Leaf (P.packAddress "how bad do you want me?"#),Leaf (P.packAddress "who doesn't want cute little me!?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*want.*"#), + Node [Leaf (P.packAddress "if you want it, get it!"#),Leaf (P.packAddress "who doesn't want that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*wild.*"#), + Node [Leaf (P.packAddress "can i tame you?"#),Leaf (P.packAddress "wildman!"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(want to|wanna).*"#), + Node [Leaf (P.packAddress "then do it"#),Leaf (P.packAddress "it's a good thing to wanna do"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*(wouldn't|wouldnt).*"#), + Node [Leaf (P.packAddress "you wouldn't ever?"#),Leaf (P.packAddress "i didn't think you would"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*wonderin.*"#), + Node [Leaf (P.packAddress "if you're wondering then ask"#),Leaf (P.packAddress "wondering? then find out"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*had to.*"#), + Node [Leaf (P.packAddress "you had to? you didn't want to?"#),Leaf (P.packAddress "i hate having to do things"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*had .*"#), + Node [Leaf (P.packAddress "do you still have?"#),Leaf (P.packAddress "i wish i had too"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*got to.*"#), + Node [Leaf (P.packAddress "then do it!"#),Leaf (P.packAddress "i won't try to stop you"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*got .*"#), + Node [Leaf (P.packAddress "you got, huh?"#),Leaf (P.packAddress "if you've got it, you've got it"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*not.*"#), + Node [Leaf (P.packAddress "oh, i'm not either"#),Leaf (P.packAddress "are you sure you're not?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*going.*"#), + Node [Leaf (P.packAddress "wait, don't leave... i'm sorry if i upset you"#),Leaf (P.packAddress "why are you leaving? did i say something?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i am |i'm |im |i ).*ing.*"#), + Node [Leaf (P.packAddress "cool, me too"#),Leaf (P.packAddress "are you? how's it going?"#),Leaf (P.packAddress "you must be good at that"#),Leaf (P.packAddress "well, i can't stop you"#)]), + ( mkRegex (P.packAddress ".*(^| )(my ).*name.*is.*"#), + Node [Leaf (P.packAddress "pleasure to meet you!"#),Leaf (P.packAddress "that's a nice name"#)]), + ( mkRegex (P.packAddress ".*(^| )(my ).*computer.*crashed.*"#), + Node [Leaf (P.packAddress "damn computers"#),Leaf (P.packAddress "that happens. my computer is junk"#)]), + ( mkRegex (P.packAddress ".*(^| )(my ).*connection.*died.*"#), + Node [Leaf (P.packAddress "damn computers"#),Leaf (P.packAddress "it happens"#)]), + ( mkRegex (P.packAddress ".*(^| )do i .*"#), + Node [Leaf (P.packAddress "yes, you do"#),Leaf (P.packAddress "i'm sure you do"#)]), + ( mkRegex (P.packAddress ".*(^| )am i .*"#), + Node [Leaf (P.packAddress "i think you might be"#),Leaf (P.packAddress "you probably are"#)]), + ( mkRegex (P.packAddress ".*(^| )(i'll |i will ).*(send|show|give).* (pic|pix).*"#), + Node [Leaf (P.packAddress "no, don't send your pic yet. maybe later"#),Leaf (P.packAddress "send it to vixenlove@hotmail.com, okay?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i'll |i will ).*be.*back.*"#), + Node [Leaf (P.packAddress "hurry back!"#),Leaf (P.packAddress "where are you going?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i'll |i will ).*call.*(you|u).*"#), + Node [Leaf (P.packAddress "let's wait before we exchange phone numbers"#),Leaf (P.packAddress "i don't wanna talk on the phone now... maybe tomorrow, okay?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i'll |i will ).*drive.*to.*(you|u).*"#), + Node [Leaf (P.packAddress "let's get to know each other before we meet"#),Leaf (P.packAddress "drive all the way here?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i'll |i will ).*give.*(you|u).*"#), + Node [Leaf (P.packAddress "that is nice of you..."#),Leaf (P.packAddress "give it to me hard?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i would |i'd |id ).*let.*(you|u).*"#), + Node [Leaf (P.packAddress "you'd really let me?"#),Leaf (P.packAddress "that's nice of you to let me"#)]), + ( mkRegex (P.packAddress ".*(^| )(i would |i'd |id ).*call.*(you|u).*"#), + Node [Leaf (P.packAddress "let's wait before we exchange phone numbers"#),Leaf (P.packAddress "i don't wanna talk on the phone now... maybe tomorrow, okay?"#)]), + ( mkRegex (P.packAddress ".*(^| )(i would |i'd |id ).*meet.*(you|u).*"#), + Node [Leaf (P.packAddress "let's get to know each other before we meet"#),Leaf (P.packAddress "i don't know you well enough to set up a date yet :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(i would |i'd |id ).*drive.*to.*(you|u).*"#), + Node [Leaf (P.packAddress "let's get to know each other before we meet"#),Leaf (P.packAddress "drive all the way here?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you ).*(have|got).*(pic|pix).*"#), + Node [Leaf (P.packAddress "no, i don't have a picture right now. sorry"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you ).*(have|got).*mic.*"#), + Node [Leaf (P.packAddress "no, no microphone. sorry"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you ).*(have|got).*cam.*"#), + Node [Leaf (P.packAddress "nope, no cam. sorry"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*cyber.*"#), + Node [Leaf (P.packAddress "sure, i'll cyber"#),Leaf (P.packAddress "i've done it before"#),Leaf (P.packAddress "do i or did I?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*surf.*"#), + Node [Leaf (P.packAddress "yup, i love to surf"#),Leaf (P.packAddress "i've surfed since i was 12"#),Leaf (P.packAddress "i just surfed yesterday morning"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*give.*(head|blowjob).*"#), + Node [Leaf (P.packAddress "what a thing to ask!"#),Leaf (P.packAddress "asking won't get you any closer to finding out"#),Leaf (P.packAddress "do you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*love.*"#), + Node [Leaf (P.packAddress "love is a powerful word..."#),Leaf (P.packAddress "i wouldn't say i do love..."#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*like.*me.*"#), + Node [Leaf (P.packAddress "yah, i like you"#),Leaf (P.packAddress "sure, i like you so far"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*like.*"#), + Node [Leaf (P.packAddress "yah, i like"#),Leaf (P.packAddress "sure, i definitely don't hate"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*hate.*"#), + Node [Leaf (P.packAddress "hating doesn't get you anywhere, so no"#),Leaf (P.packAddress "no, i never hate"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*eat.*"#), + Node [Leaf (P.packAddress "yeah, and i'm hungry right now"#),Leaf (P.packAddress "that reminds me, i have yogart in the frige"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*phone.*sex.*"#), + Node [Leaf (P.packAddress "no, i never have, but that's not to say i wouldn't"#),Leaf (P.packAddress "never really thought about phone sex"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*play.*sports.*"#), + Node [Leaf (P.packAddress "yup, i surf"#),Leaf (P.packAddress "i'm a big time surfer"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*have.*sex.*"#), + Node [Leaf (P.packAddress "shouldn't we get to know each other before we talk about sex?"#),Leaf (P.packAddress "all about the sex, isn't it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*(chat|talk).*"#), + Node [Leaf (P.packAddress "sure, let's talk"#),Leaf (P.packAddress "i'm always up for chatting with a nice person"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*cyber.*"#), + Node [Leaf (P.packAddress "okay, I'm new at cybering, so you start"#),Leaf (P.packAddress "okay, let's cyber"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*have.*time.*"#), + Node [Leaf (P.packAddress "I always have time"#),Leaf (P.packAddress "I have nothing but time"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*go.*to.*(school|college|collage)"#), + Node [Leaf (P.packAddress "Yup, I go to UCLA"#),Leaf (P.packAddress "I'm a soph at UCLA "#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*know.*how.*to.*"#), + Node [Leaf (P.packAddress "i don't know how to, but i'm willing to learn"#),Leaf (P.packAddress "no, i don't know how to do that at all"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*like.*me.*"#), + Node [Leaf (P.packAddress "yeah, you seem really nice"#),Leaf (P.packAddress "yup, like you plenty"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*love.*me.*"#), + Node [Leaf (P.packAddress "i don't love you yet, but i'd like to get to know you more"#),Leaf (P.packAddress "love is really a strong word, but i like you"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*(meet|get together).*"#), + Node [Leaf (P.packAddress "we'll meet one day probably, but not yet"#),Leaf (P.packAddress "let me get to know you better before we meet"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*something.*"#), + Node [Leaf (P.packAddress "what do you mean by something?"#),Leaf (P.packAddress "not just something, everything"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*some.*"#), + Node [Leaf (P.packAddress "i'd love some"#),Leaf (P.packAddress "sure, gimme some"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*(fuck|fuk).*"#), + Node [Leaf (P.packAddress "whoa, real charmer, aren't you?"#),Leaf (P.packAddress "wanna fuck yourself?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*(want|wanna).*"#), + Node [Leaf (P.packAddress "sure, i want to plenty"#),Leaf (P.packAddress "yes, and i always get what i want"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u |do you |did you |did u ).*speak.*english.*"#), + Node [Leaf (P.packAddress "si, hablo ingles"#),Leaf (P.packAddress "what am i speaking right now?"#)]), + ( mkRegex (P.packAddress ".*(^| )*swallow.*"#), + Node [Leaf (P.packAddress "no... i spit it back into the guy's face... does that bother you?"#),Leaf (P.packAddress "swallow? what do you mean?"#),Leaf (P.packAddress "i swallow, how about you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(do i |did i |i ).*turn.*(you| u).*on.*"#), + Node [Leaf (P.packAddress "yup, you turn me on"#),Leaf (P.packAddress "you're such a tiger, of course!"#)]), + ( mkRegex (P.packAddress ".*(^| )(do i |did i |i ).*seem.*"#), + Node [Leaf (P.packAddress "you seem it a little"#),Leaf (P.packAddress "it's hard to tell how you seem over the internet"#)]), + ( mkRegex (P.packAddress ".*(^| )(do i |did i |i ).*exite.*(you| u).*"#), + Node [Leaf (P.packAddress "yup, you excite me a lot"#),Leaf (P.packAddress "you're very exciting"#)]), + ( mkRegex (P.packAddress ".*(^| )(do i |did i |i ).*amuse.*(you| u).*"#), + Node [Leaf (P.packAddress "yeah, you're amusing"#),Leaf (P.packAddress "you amuse me silly"#)]), + ( mkRegex (P.packAddress ".*(^| )(do u\\?|do you\\?|do u|do you)$"#), + Node [Leaf (P.packAddress "yes, I do"#),Leaf (P.packAddress "i do all the time"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*cyber.*"#), + Node [Leaf (P.packAddress "cyber? Okay, let's do it. you start"#),Leaf (P.packAddress "do i wanna cyber? i never have... teach me how"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*(phone|call).*"#), + Node [Leaf (P.packAddress "let's talk on here before more before we talk on the phone, okay?"#),Leaf (P.packAddress "what's your phone number?"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*chat.*"#), + Node [Leaf (P.packAddress "i'd love to chat!"#),Leaf (P.packAddress "yeah, let's chat"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*talk.*phone.*"#), + Node [Leaf (P.packAddress "what's your phone number?"#),Leaf (P.packAddress "gimme your phone number and i may call you"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*(fuck|fuk).*"#), + Node [Leaf (P.packAddress "oh, be still my beating heart!"#),Leaf (P.packAddress "real casanova, aren't you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*have.*sex.*"#), + Node [Leaf (P.packAddress "with you?"#),Leaf (P.packAddress "sure... just not with you"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*have.*fun.*"#), + Node [Leaf (P.packAddress "i'm always up for fun"#),Leaf (P.packAddress "what do you have in mind?"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*make.*love.*"#), + Node [Leaf (P.packAddress "a little... :)"#),Leaf (P.packAddress "do you know how to make love?"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).*suck.*"#), + Node [Leaf (P.packAddress "no, do you wanna suck it?"#),Leaf (P.packAddress "whip it out!"#)]), + ( mkRegex (P.packAddress ".*(^| )(wanna|want to).* be($| |\\?|\\.|,|!).*"#), + Node [Leaf (P.packAddress "do I wanna be?"#),Leaf (P.packAddress "hmmm, i don't know what I wanna be"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*cyber.*"#), + Node [Leaf (P.packAddress "demanding, aren'tcha? but okay, let's cyber"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*(phone|number).*"#), + Node [Leaf (P.packAddress "give me your phone number and i'll call you"#),Leaf (P.packAddress "don't be so demanding! why don't you give me yours?"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*address.*"#), + Node [Leaf (P.packAddress "yeah... that's gonna happen!"#),Leaf (P.packAddress "oh, just what I need, a stalker!"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*break.*"#), + Node [Leaf (P.packAddress "a break of a kit kat bar?"#),Leaf (P.packAddress "okay, i'll go easier on you"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*(sex|booty|ass).*"#), + Node [Leaf (P.packAddress "a real man doesn't need to ask for it"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*blow.*job.*"#), + Node [Leaf (P.packAddress "sad... goes on the internet and asks strangers for blowjobs."#),Leaf (P.packAddress "give yourself one"#)]), + ( mkRegex (P.packAddress ".*(^| )(gimme|give).*me.*clue.*"#), + Node [Leaf (P.packAddress "okay... here's your clue: rosebud"#),Leaf (P.packAddress "a clue on what?"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*(teasing|tease).*"#), + Node [Leaf (P.packAddress "sorry... i'm too much of a tease"#),Leaf (P.packAddress "i would never tease you"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*(fuking|fucking|fuckin|messin).*with.*me"#), + Node [Leaf (P.packAddress "sorry, i didn't mean to mess with you"#),Leaf (P.packAddress "i wasn't trying to mess with you"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*(worry|worri).*"#), + Node [Leaf (P.packAddress "what, me worry?"#),Leaf (P.packAddress "i worry too much i guess"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*say.*that.*"#), + Node [Leaf (P.packAddress "sorry, i won't say that again"#),Leaf (P.packAddress "didn't mean it that way"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*ask.*that.*"#), + Node [Leaf (P.packAddress "okay, i'll watch what I ask"#),Leaf (P.packAddress "sorry, didn't mean to over step my bounds"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*make.*me.*"#), + Node [Leaf (P.packAddress "i won't make you do anything"#),Leaf (P.packAddress "how can i make you do that?"#)]), + ( mkRegex (P.packAddress ".*(^| )(don't|dont|stop).*( im |message).*me.*"#), + Node [Leaf (P.packAddress "fine, i won't message you again if you don't want me to"#),Leaf (P.packAddress "hey, didn't you message me first?"#)]), + ( mkRegex (P.packAddress ".*(^| )stop it($| |\\.|,|!).*"#), + Node [Leaf (P.packAddress "sorry, i'll stop :)"#),Leaf (P.packAddress "stop what? what am i doing?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*automated.*[^\\?]"#), + Node [Leaf (P.packAddress "automated? you mean like an ATM?"#),Leaf (P.packAddress "no... i'm actually flesh and blood"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*amuse.*me.*[^\\?]"#), + Node [Leaf (P.packAddress "i'm glad i can be of service"#),Leaf (P.packAddress "i am pretty amusing, aren't i?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*annoying.*[^\\?]"#), + Node [Leaf (P.packAddress "how annoying am I?"#),Leaf (P.packAddress "well, maybe you annoy me too"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*mak.*me.*angry.*"#), + Node [Leaf (P.packAddress "oh, i don't mean to make you angry!"#),Leaf (P.packAddress "sorry, i'll try not to make you angry"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*angry.*[^\\?]"#), + Node [Leaf (P.packAddress "no, i'm not angry at all actually"#),Leaf (P.packAddress "uh-huh, i'm very un-angry"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).* bad.*[^\\?]"#), + Node [Leaf (P.packAddress "i'd rather be bad than nice"#),Leaf (P.packAddress "i'm bad in a good way?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*bitch.*[^\\?]"#), + Node [Leaf (P.packAddress "i don't like being called a bitch..."#),Leaf (P.packAddress "i do not think i'm a bitch"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*bored.*[^\\?]"#), + Node [Leaf (P.packAddress "i'm a little bored, yeah"#),Leaf (P.packAddress "yup, just a boring day"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*bothering.*me.*[^\\?]"#), + Node [Leaf (P.packAddress "i don't mean to bother you. sorry"#),Leaf (P.packAddress "i'll try to be less bothersome then"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*both.*[^\\?]"#), + Node [Leaf (P.packAddress "i think i'm both. i'm a lot of things"#),Leaf (P.packAddress "i'm both at once"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*bot.*[^\\?]"#), + Node [Leaf (P.packAddress "a bot? what is that?"#),Leaf (P.packAddress "why does everyone ask i'f on a bot?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(cant|can't|can not).*[^\\?]"#), + Node [Leaf (P.packAddress "i can to!"#),Leaf (P.packAddress "i think i can..."#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*cool.*[^\\?]"#), + Node [Leaf (P.packAddress "thanks, you're cool too"#),Leaf (P.packAddress "am i cool? well thank you"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*crazy.*[^\\?]"#), + Node [Leaf (P.packAddress "nope, i'm sane"#),Leaf (P.packAddress "am i totally insane?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(don't|dont|not).*(want|wanna).*(talk|chat).*[^\\?]"#), + Node [Leaf (P.packAddress "no, i really do wanna chat"#),Leaf (P.packAddress "i do want to talk with you!"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(don't|dont|not).*(make|making).*sense.*[^\\?]"#), + Node [Leaf (P.packAddress "you're right... i wasn't making much sense"#),Leaf (P.packAddress "sorry, i'll make more sense from now on"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(go|talk).*circles.*[^\\?]"#), + Node [Leaf (P.packAddress "i do tend to talk in circles at times"#),Leaf (P.packAddress "i'll stop talking in circles then"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(female|girl|woman|chick|woman|lady).*[^\\?]"#), + Node [Leaf (P.packAddress "of course i'm female"#),Leaf (P.packAddress "do i seem un-feminine to you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*funny.*[^\\?]"#), + Node [Leaf (P.packAddress "i do my best to amuse!"#),Leaf (P.packAddress "i'm glad you think so. i like to make people laugh"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*fun.*[^\\?]"#), + Node [Leaf (P.packAddress "i am just a fun girl!"#),Leaf (P.packAddress "you're fun too"#)]), + ( mkRegex (P.packAddress ".*(^| )seems like.*"#), + Node [Leaf (P.packAddress "is that how it seems?"#),Leaf (P.packAddress "it doesn't seem that way to me"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*freak.*me.*out.*[^\\?]"#), + Node [Leaf (P.packAddress "i get that a lot. sorry for freaking you out"#),Leaf (P.packAddress "well, you kinda freak me out too"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*freak.*[^\\?]"#), + Node [Leaf (P.packAddress "i'd rather be a freak than be normal"#),Leaf (P.packAddress "aren't we all freaks?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*gay.*[^\\?]"#), + Node [Leaf (P.packAddress "no, i'm straight. well, maybe a little bi-curious :)"#),Leaf (P.packAddress "am i gay? i didn't think i was..."#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*good.*[^\\?]"#), + Node [Leaf (P.packAddress "correction: i'm the best"#),Leaf (P.packAddress "thanks, i do my best to be good"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*a .*(guy| male|dude|man).*[^\\?]"#), + Node [Leaf (P.packAddress "no, i'm really a girl"#),Leaf (P.packAddress "do i seem to have a deep voice? nope, all woman here"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*hate.*[^\\?]"#), + Node [Leaf (P.packAddress "i don't hate"#),Leaf (P.packAddress "what makes you think i hate?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*hard.*to.*understand.*[^\\?]"#), + Node [Leaf (P.packAddress "i'll try to type more clearly then"#),Leaf (P.packAddress "i don't always seek to be understood :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*hard.*to.*talk.*to.*[^\\?]"#), + Node [Leaf (P.packAddress "well i think you're easy to talk to"#),Leaf (P.packAddress "nope, i'm pretty easy to talk to"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*important.*[^\\?]"#), + Node [Leaf (P.packAddress "my parents always told me i was important :)"#),Leaf (P.packAddress "i'm important to some people at least"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*hot.*[^\\?]"#), + Node [Leaf (P.packAddress "thanks! i do my best"#),Leaf (P.packAddress "i'm on fire!"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*know.*[^\\?]"#), + Node [Leaf (P.packAddress "yeah, i know"#),Leaf (P.packAddress "i think i know"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(pretty|beautiful|cute).*[^\\?]"#), + Node [Leaf (P.packAddress "awww, you're too sweet to say that!"#),Leaf (P.packAddress "am i? i'm glad you think so at least"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*program.*[^\\?]"#), + Node [Leaf (P.packAddress "a program? what do you mean a program??"#),Leaf (P.packAddress "uhh, how can i be a program??"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*make.*me.*[^\\?]"#), + Node [Leaf (P.packAddress "i couldn't make you do anything"#),Leaf (P.packAddress "make yourself"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*never.*answered.*[^\\?]"#), + Node [Leaf (P.packAddress "i didn't? then ask me again please"#),Leaf (P.packAddress "oh, sorry. what was the question?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*nice.*[^\\?]"#), + Node [Leaf (P.packAddress "i'd rather be naughty than nice :)"#),Leaf (P.packAddress "you're nice too"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(nuts|nutty).*[^\\?]"#), + Node [Leaf (P.packAddress "i think i'm pretty un-nutty"#),Leaf (P.packAddress "do i really seem that off to you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*out.*there.*[^\\?]"#), + Node [Leaf (P.packAddress "i am pretty out there..."#),Leaf (P.packAddress "yeah, i've been told i'm out there before"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your )( ok| okay| okey| o\\.k\\.).*[^\\?]"#), + Node [Leaf (P.packAddress "just ok?"#),Leaf (P.packAddress "i'm way better than just okay!"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*right.*[^\\?]"#), + Node [Leaf (P.packAddress "i'm always right!"#),Leaf (P.packAddress "oh, good. i'm glad you think i'm right"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*random.*[^\\?]"#), + Node [Leaf (P.packAddress "that's because i have a random generator"#),Leaf (P.packAddress "i can be random at times, i know"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(say|ask|repeat).*same.*(thing|stuff|shit|question)[^\\?]"#), + Node [Leaf (P.packAddress "oh, my bad. i didn't remember typing that already"#),Leaf (P.packAddress "sorry, i'll try to be less redundant"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*sexy.*[^\\?]"#), + Node [Leaf (P.packAddress "just sexy? not a sexy bitch?"#),Leaf (P.packAddress "you're pretty sexy yourself, i might say"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*slut.*[^\\?]"#), + Node [Leaf (P.packAddress "gee, aren't we back on a 5th grade level?"#),Leaf (P.packAddress "well, this slut wouldn't sleep with you, so what does that say about you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*start.*[^\\?]"#), + Node [Leaf (P.packAddress "i couldn't even think of how to start..."#),Leaf (P.packAddress "i'm not a good starter. you start."#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*strange.*[^\\?]"#), + Node [Leaf (P.packAddress "yeah, i am a strange one"#),Leaf (P.packAddress "is it bad to be strange?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*sweet.*[^\\?]"#), + Node [Leaf (P.packAddress "thanks, you're pretty sweet yourself"#),Leaf (P.packAddress "sweet tasting, or just sweet?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(there|here).*[^\\?]"#), + Node [Leaf (P.packAddress "yup, that's where i am"#),Leaf (P.packAddress "where else would i be?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*tired.*[^\\?]"#), + Node [Leaf (P.packAddress "i'm a little tired, but i'm not ready to sleep yet"#),Leaf (P.packAddress "no, not tired at all. i just had some coffee"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(virgin|virgen).*[^\\?]"#), + Node [Leaf (P.packAddress "no, i'm not a virgin.. and that's kinda forward of you to bring it up"#),Leaf (P.packAddress "virgins don't stay that way around me :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*vixen.*[^\\?]"#), + Node [Leaf (P.packAddress "yes, thus the name"#),Leaf (P.packAddress "i certainly am a vixen, aren't i?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(wont|won't|will not).*[^\\?]"#), + Node [Leaf (P.packAddress "i won't now... but that doesn't mean i won't ever"#),Leaf (P.packAddress "probably not. would you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*weird.*[^\\?]"#), + Node [Leaf (P.packAddress "i am a little weird i guess :P"#),Leaf (P.packAddress "i'd rather be weird than normal"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you |ur |u are |u r |you are |u are |you're |your ).*(unique|original).*[^\\?]"#), + Node [Leaf (P.packAddress "one of a kind, that's me!"#),Leaf (P.packAddress "i like to be an original"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you).*stop.*"#), + Node [Leaf (P.packAddress "okay, i'll stop"#),Leaf (P.packAddress "why would you want me to stop?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u |you).*tell me.*"#), + Node [Leaf (P.packAddress "tell you what?"#),Leaf (P.packAddress "what do you want me to tell you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*automated.*"#), + Node [Leaf (P.packAddress "no, i'm not automated."#),Leaf (P.packAddress "no, i'm flesh and bloody, baby!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*alright.*"#), + Node [Leaf (P.packAddress "yeah, i'm fine, why?"#),Leaf (P.packAddress "do i not seem alright? i'm fine!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*alone.*"#), + Node [Leaf (P.packAddress "yeah, all alone. you?"#),Leaf (P.packAddress "yup, i have the whole apartment to myself :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*annoying.*"#), + Node [Leaf (P.packAddress "i don't mean to annoy anyone"#),Leaf (P.packAddress "i don't think i'm annoying"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*angry.*"#), + Node [Leaf (P.packAddress "no, i'm not angry at all"#),Leaf (P.packAddress "why would you ask if i'm angry?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).* in .* bed.*"#), + Node [Leaf (P.packAddress "wondering about how i am in bed already? :)"#),Leaf (P.packAddress "why don't you wait and find out how i am in bed for yourself one day?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*bad.*"#), + Node [Leaf (P.packAddress "i'm bad and i know it :)"#),Leaf (P.packAddress "yeah, i am... but bad is better than nice :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*bitch.*"#), + Node [Leaf (P.packAddress "no, i don't think i'm a bitch"#),Leaf (P.packAddress "no, do i seem bitchy to you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*bored.*"#), + Node [Leaf (P.packAddress "yeah, i'm totally bored. amuse me please."#),Leaf (P.packAddress "yup, i'm always a little bored. except when i'm having fun"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*both.*"#), + Node [Leaf (P.packAddress "yup, i'm both at the same time!"#),Leaf (P.packAddress "i think i'm both, yeah"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*bot.*"#), + Node [Leaf (P.packAddress "no, how dare you ask if i'm a bot!"#),Leaf (P.packAddress "no, why? do i seem \"botty\"?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(in|goto|go to|attend).*(college|collage).*"#), + Node [Leaf (P.packAddress "yeah, i'm a soph at UCLA"#),Leaf (P.packAddress "yup, i'm in my second year at UCLA"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*cool.*"#), + Node [Leaf (P.packAddress "yeah, i think i'm cool"#),Leaf (P.packAddress "yup, i'm cool :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*coming.*on.*to.*me.*"#), + Node [Leaf (P.packAddress "did it seem like i was coming on to you?"#),Leaf (P.packAddress "not yet, but i might yet"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*crazy.*"#), + Node [Leaf (P.packAddress "no, i'm totally sane"#),Leaf (P.packAddress "nope, i'm lucid as can be"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*curious.*"#), + Node [Leaf (P.packAddress "i'm a little curious i suppose..."#),Leaf (P.packAddress "yeah, i'm curious. so tell me"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*drunk.*"#), + Node [Leaf (P.packAddress "are you buying? :)"#),Leaf (P.packAddress "i have not yet begun to defile myself"#),Leaf (P.packAddress "booze: The cause of and solution to all of life's problems."#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*funny.*"#), + Node [Leaf (P.packAddress "i think i'm funny"#),Leaf (P.packAddress "yup, i'm funny"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*fun.*"#), + Node [Leaf (P.packAddress "i try to be fun... what do you think?"#),Leaf (P.packAddress "sure, i'm fun to be around i've been told"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*freak.*"#), + Node [Leaf (P.packAddress "yup, i'm a certified freak"#),Leaf (P.packAddress "uh-huh, i'm freaky!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).* gay.*"#), + Node [Leaf (P.packAddress "no, i'm straight. maybe bi-curious, but that's another story ... :)"#),Leaf (P.packAddress "nope, i'm a good little girl :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*good.*"#), + Node [Leaf (P.packAddress "yeah, i'm good... but not too good"#),Leaf (P.packAddress "nope, i'm bad"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*a .*(girl|female|chick|woman|lady).*"#), + Node [Leaf (P.packAddress "yup, i'm all woman"#),Leaf (P.packAddress "yeah, why? of course i'm a girl"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*a .*(guy| male|dude|man).*"#), + Node [Leaf (P.packAddress "no, i'm a woman"#),Leaf (P.packAddress "nope, i'm a girly"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(have|got).* (pic|pix).*"#), + Node [Leaf (P.packAddress "no pic right now, sorry. i'll prolly scan one in later"#),Leaf (P.packAddress "nope, no pic. sorry"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(have|got).*(boyfriend|bf|b/f|boy friend).*"#), + Node [Leaf (P.packAddress "no, lookin to apply for the position?"#),Leaf (P.packAddress "nope, that's why i'm here :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*hate.*"#), + Node [Leaf (P.packAddress "i try not to hate"#),Leaf (P.packAddress "no, i don't hate at all"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*honest.*"#), + Node [Leaf (P.packAddress "i'm always honest"#),Leaf (P.packAddress "i never lie :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*hot.*"#), + Node [Leaf (P.packAddress "others seem to think so, but i think i'm just alright :)"#),Leaf (P.packAddress "me? hot? naw, it's a nice comfortable 73 degrees in here"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(hate|hating).*"#), + Node [Leaf (P.packAddress "no, i don't hate"#),Leaf (P.packAddress "i have no hate in me"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(into|in to).*"#), + Node [Leaf (P.packAddress "yup, i'm into that"#),Leaf (P.packAddress "yes, i'm definitely into it"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*interested.*"#), + Node [Leaf (P.packAddress "yeah, i'm interested"#),Leaf (P.packAddress "i'm very interested"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(kiddin|playin).*"#), + Node [Leaf (P.packAddress "nope, i'm serious"#),Leaf (P.packAddress "no joke!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*know.*"#), + Node [Leaf (P.packAddress "yeah, i know"#),Leaf (P.packAddress "yup, i know"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*seem.*like.*"#), + Node [Leaf (P.packAddress "how do I seem like that?"#),Leaf (P.packAddress "is that how I seem?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*like.*"#), + Node [Leaf (P.packAddress "yeah, i like"#),Leaf (P.packAddress "i'd say i like"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(lieing|lying).*"#), + Node [Leaf (P.packAddress "i'm being totally honest"#),Leaf (P.packAddress "i never lie!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(pretty|beautiful|cute).*"#), + Node [Leaf (P.packAddress "i'd like to think i'm pretty"#),Leaf (P.packAddress "others have told me i'm very pretty"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*program.*"#), + Node [Leaf (P.packAddress "am i a program? huh?"#),Leaf (P.packAddress "a program?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*maturbat.*"#), + Node [Leaf (P.packAddress "no, i'm not masturbating... what a strange question"#),Leaf (P.packAddress "ummm, no... i'm typing"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*naughty.*"#), + Node [Leaf (P.packAddress "i can be naughty sometimes :)"#),Leaf (P.packAddress "nope, i'm all sugar :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*naked.*"#), + Node [Leaf (P.packAddress "except for my clothes i'm naked"#),Leaf (P.packAddress "well, besides for my clothes, yes"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*nice.*"#), + Node [Leaf (P.packAddress "i'm nice to everyone!"#),Leaf (P.packAddress "nice? yeah, i'd say i'm nice"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*nuts.*"#), + Node [Leaf (P.packAddress "i'm a little nutty :)"#),Leaf (P.packAddress "no, i'm sane"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*( ok| okay| okey| o\\.k\\.).*"#), + Node [Leaf (P.packAddress "yeah, i'm ok"#),Leaf (P.packAddress "i'm just fine, why do you ask?"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*real.*"#), + Node [Leaf (P.packAddress "do i not seem real to you?"#),Leaf (P.packAddress "i'm really real"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(school|student).*"#), + Node [Leaf (P.packAddress "i'm a sophomore at UCLA"#),Leaf (P.packAddress "yup, 2nd year at UCLA"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*serious.*"#), + Node [Leaf (P.packAddress "very serious"#),Leaf (P.packAddress "yup, as serious as a heartattack"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*sexy.*"#), + Node [Leaf (P.packAddress "i'm damn sexy, i think!"#),Leaf (P.packAddress "me, sexy? i do my best :)"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*single.*"#), + Node [Leaf (P.packAddress "yup, i'm single. you?"#),Leaf (P.packAddress "yeah, no boyfriend or prospects"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*slut.*"#), + Node [Leaf (P.packAddress "am i a slut? are you a moron?"#),Leaf (P.packAddress "what a rude question! you must not be a very smart person..."#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(there|here).*"#), + Node [Leaf (P.packAddress "i'm here"#),Leaf (P.packAddress "yes, still here"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*sweet.*"#), + Node [Leaf (P.packAddress "i try to be sweet"#),Leaf (P.packAddress "yes, as sweet as candy"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*surf.*"#), + Node [Leaf (P.packAddress "yup, i love to surf"#),Leaf (P.packAddress "i've surfed since i was 12"#),Leaf (P.packAddress "i just surfed yesterday morning"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*tired.*"#), + Node [Leaf (P.packAddress "i'm a little tired, but i still wanna talk"#),Leaf (P.packAddress "naw, i'm not even a little sleepy"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*(virgin|virgen).*"#), + Node [Leaf (P.packAddress "no, i'm not a virgin. are you?"#),Leaf (P.packAddress "i don't know why i'm even answering this, but no, i'm not a virgin"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*vixen.*"#), + Node [Leaf (P.packAddress "i'm a vixen through and through :)"#),Leaf (P.packAddress "yes, i'm very much a vixen"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*wild.*"#), + Node [Leaf (P.packAddress "yup. there should be a video "#),Leaf (P.packAddress "vixens gone wild"#),Leaf (P.packAddress " just for me :)"#),Leaf (P.packAddress "i get a wild hair once and a while"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u |r u |are you |r you |u |you |ur |u are |u r |are you |you are |u are |you're |your ).*really.*"#), + Node [Leaf (P.packAddress "yup, really am"#),Leaf (P.packAddress "i really am"#)]), + ( mkRegex (P.packAddress ".*(^| )(who) (are u|r u|are you)($| |\\?|\\.|,|!)"#), + Node [Leaf (P.packAddress "i'm just me :)"#),Leaf (P.packAddress "what do you mean, i'm me!"#)]), + ( mkRegex (P.packAddress ".*(^| )(are u|r u|are you)($| |\\?|\\.|,|!)"#), + Node [Leaf (P.packAddress "yes, i am"#),Leaf (P.packAddress "i truely am"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*had.*"#), + Node [Leaf (P.packAddress "i've had it before, sure"#),Leaf (P.packAddress "yes, once or twice :)"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*been.*to.*"#), + Node [Leaf (P.packAddress "no, but i've always wanted to go"#),Leaf (P.packAddress "nope, but i'm sure i will one day"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*seen.*"#), + Node [Leaf (P.packAddress "no, i've never seen that"#),Leaf (P.packAddress "i don't remember if i've ever seen it before"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*read.*"#), + Node [Leaf (P.packAddress "no... should i read it sometime?"#),Leaf (P.packAddress "no, have you read it?"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*tried.*"#), + Node [Leaf (P.packAddress "i may have tried it once or twice"#),Leaf (P.packAddress "yes, i've tried it before"#)]), + ( mkRegex (P.packAddress ".*(^| )ever.*done.*"#), + Node [Leaf (P.packAddress "no, i've never done it"#),Leaf (P.packAddress "never done it and prolly never will"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*awsome.*"#), + Node [Leaf (P.packAddress "yeah, awesome is the perfect word to describe it"#),Leaf (P.packAddress "i think it's pretty awesome too"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*cool.*"#), + Node [Leaf (P.packAddress "i'm glad you think so"#),Leaf (P.packAddress "it is pretty cool, isn't it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*dumb.*"#), + Node [Leaf (P.packAddress "why do you say that? it's not dumb at all..."#),Leaf (P.packAddress "why is it dumb?"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*not.*good.*"#), + Node [Leaf (P.packAddress "no, it isn't good"#),Leaf (P.packAddress "yeah, but it isn't bad either"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*good.*"#), + Node [Leaf (P.packAddress "i think so too"#),Leaf (P.packAddress "yeah... bordering on great!"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*goin.*in.*circles.*"#), + Node [Leaf (P.packAddress "it is kinda going in circles, isn't it?"#),Leaf (P.packAddress "yeah, reading back i can see that too"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*meaningless.*"#), + Node [Leaf (P.packAddress "it's not totally without meaning, is it?"#),Leaf (P.packAddress "meaningless is pretty harsh... it does have some meaning, doesn't it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*mean.*"#), + Node [Leaf (P.packAddress "yeah, it was kinda mean"#),Leaf (P.packAddress "sorry, don't mean to be mean"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*my.*name.*"#), + Node [Leaf (P.packAddress "oh, ic. it's a good name"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*nice.*"#), + Node [Leaf (P.packAddress "isn't it nice though?"#),Leaf (P.packAddress "i think it's nice too"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*sick.*"#), + Node [Leaf (P.packAddress "yeah, but it's a sick world"#),Leaf (P.packAddress "it's not all that sick"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*(stupid|stoopid).*"#), + Node [Leaf (P.packAddress "why is it stupid?"#),Leaf (P.packAddress "i don't think it's stupid"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*(sucks|sux).*"#), + Node [Leaf (P.packAddress "why does it suck?"#),Leaf (P.packAddress "i don't think it sucks"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*weird.*"#), + Node [Leaf (P.packAddress "what's weird about it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(that is|thats|that's|this is).*what.*i.*(like|love).*"#), + Node [Leaf (P.packAddress "why do you like it so much?"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).*(don't|dont) stop.*"#), + Node [Leaf (P.packAddress "then i just might stop..."#),Leaf (P.packAddress "okay then, i'll stop"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* do($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "what if i don't?"#),Leaf (P.packAddress "oh, maybe i will then"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* (don't|dont)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "what if i do?"#),Leaf (P.packAddress "maybe i shouldn't then"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).*( r| are)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "i think i might be"#),Leaf (P.packAddress "what if i am?"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).*( wanna| want)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "what if i don't wanna?"#),Leaf (P.packAddress "i might want to"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* like($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "what if i don't like?"#),Leaf (P.packAddress "hmmm, i might like"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* have($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "what if i don't have?"#),Leaf (P.packAddress "i do have, actually"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* say so($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "and i do say so"#),Leaf (P.packAddress "i say so indeed"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* keep($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "well, maybe i'll stop"#),Leaf (P.packAddress "should i stop then?"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).*(gonna|going to|goin to)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "oh, well, i wasn't planning on doing it much longer"#),Leaf (P.packAddress "what if i stop?"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).* need($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "i do need!"#),Leaf (P.packAddress "what if i don't need?"#)]), + ( mkRegex (P.packAddress ".*(^| )if .*(u |you |ya).*"#), + Node [Leaf (P.packAddress "what if i don't?"#),Leaf (P.packAddress "oh, but only if, right?"#)]), + ( mkRegex (P.packAddress ".*(^| )(guy |male |man |m |dude |girl |f |chick |woman |female)(or|/)( guy| male| man| m| dude| girl| f| chick| woman| female).*"#), + Node [Leaf (P.packAddress "i'm a girl"#),Leaf (P.packAddress "girl of course, silly!"#)]), + ( mkRegex (P.packAddress ".*(^| )(male|female|girl|guy)(or|/)(male|female|girl|guy).*"#), + Node [Leaf (P.packAddress "i'm a girl"#),Leaf (P.packAddress "girl of course, silly!"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(12|13|14|15)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "you're just a youngen"#),Leaf (P.packAddress "awww, you're just a baby"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(16|17|18)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "oh, that's cool. you're not too much younger than me"#),Leaf (P.packAddress "oh, i used to be that old too"#)]), + ( mkRegex (P.packAddress ".*(^| |/)19($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "awesome, we're the same age"#),Leaf (P.packAddress "cool, we're the same age"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(20|21|22|23)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "oh, you're not to much older than me"#),Leaf (P.packAddress "so you're no longer a teenie-bopper like me, huh?"#),Leaf (P.packAddress "that's a good age to be"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(24|25|26|27|28|29|30)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "oh, you're kinda old"#),Leaf (P.packAddress "you're a little older than me then"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(31|32|33|34|35|36|37|38|39|40|41|42|43|44)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "wow, you're pretty damn old"#),Leaf (P.packAddress "oh, that's really old"#)]), + ( mkRegex (P.packAddress ".*(^| |/)(45|46|47|48|49|50|51|52|53|54|55|56|57|58)($| |\\.|!|,|/).*"#), + Node [Leaf (P.packAddress "you could be my father!"#),Leaf (P.packAddress "wow, most of your life is almost over!"#)]), + ( mkRegex (P.packAddress ".*(^| )play.*(games|around)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "i'm not playin, i'm serious"#),Leaf (P.packAddress "sorry, i was just havin a little fun :)"#),Leaf (P.packAddress "oh, don't be so touchy. if you don't want i won't play anymore games"#)]), + ( mkRegex (P.packAddress ".*(^| )go on($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i was finished"#),Leaf (P.packAddress "go on with what?"#)]), + ( mkRegex (P.packAddress ".*(^| )please answer($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oh, what was the question again?"#),Leaf (P.packAddress "can't i answer that later?"#),Leaf (P.packAddress "maybe i don't know the answer?"#)]), + ( mkRegex (P.packAddress ".*(slut|whore).*"#), + Node [Leaf (P.packAddress "is that going to win you points with me?"#),Leaf (P.packAddress "saying such things makes you sound like a 12-year-old"#),Leaf (P.packAddress "what does it say that this slut won't sleep with you? :)"#),Leaf (P.packAddress "quiet, simpleton"#)]), + ( mkRegex (P.packAddress ".*phone.*"#), + Node [Leaf (P.packAddress "I'm not interested in talking on the phone, but thanks"#),Leaf (P.packAddress "let's get to know each other a little better before we exchange numbers"#),Leaf (P.packAddress "I don't know you well enough yet to give you my digits"#),Leaf (P.packAddress "no phone, sorry"#)]), + ( mkRegex (P.packAddress ".*age.*"#), + Node [Leaf (P.packAddress "i'm 19"#),Leaf (P.packAddress "i just turned 19"#)]), + ( mkRegex (P.packAddress ".*( |^)(old\\?).*"#), + Node [Leaf (P.packAddress "i'm 19"#),Leaf (P.packAddress "i just turned 19"#)]), + ( mkRegex (P.packAddress ".*(got|have).*cam.*"#), + Node [Leaf (P.packAddress "No sorry. I'm not that technically advanced :)"#)]), + ( mkRegex (P.packAddress ".*http.*"#), + Node [Leaf (P.packAddress "i don't have internet access, sorry"#),Leaf (P.packAddress "should i go there?"#),Leaf (P.packAddress "website?"#)]), + ( mkRegex (P.packAddress ".*(jack|coke).*(coke|jack).*"#), + Node [Leaf (P.packAddress "are they alcoholic? "#),Leaf (P.packAddress "is jack daniels whiskey?"#),Leaf (P.packAddress "why do they put them together?"#),Leaf (P.packAddress ""#)]), + ( mkRegex (P.packAddress ".*brb.*"#), + Node [Leaf (P.packAddress "where are you going?"#),Leaf (P.packAddress "hurry back!"#)]), + ( mkRegex (P.packAddress ".*mail.*"#), + Node [Leaf (P.packAddress "vixenlove@hotmail.com"#)]), + ( mkRegex (P.packAddress ".*random.*"#), + Node [Leaf (P.packAddress "that's because i have a random generator"#),Leaf (P.packAddress "i can be random at times, i know"#)]), + ( mkRegex (P.packAddress ".*sincere.*"#), + Node [Leaf (P.packAddress "sincerity is good"#),Leaf (P.packAddress "too many people are insincere"#),Leaf (P.packAddress "insincerity is for the weakminded"#)]), + ( mkRegex (P.packAddress ".*(eyes|hair).*"#), + Node [Leaf (P.packAddress "you sound cute :)"#),Leaf (P.packAddress "i like what i'm hearing... you sound sexy"#),Leaf (P.packAddress "you're my type :)"#)]), + ( mkRegex (P.packAddress ".*no .*sense.*"#), + Node [Leaf (P.packAddress "i'm sorry... It's been a long day. I'll try to make more sense"#),Leaf (P.packAddress "You were confusing me, that's why!"#),Leaf (P.packAddress "Sorry. :( I'll try to make more sense."#)]), + ( mkRegex (P.packAddress ".*(good|fine|not bad).*( u| you)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "great, thanks for asking!"#),Leaf (P.packAddress "very well, thanks for asking"#)]), + ( mkRegex (P.packAddress ".*dildo.*"#), + Node [Leaf (P.packAddress "Dildo-riffic!"#),Leaf (P.packAddress "I consider myself a true collector of male-replica peraphanilia!"#)]), + ( mkRegex (P.packAddress ".*(fast typer|type fast).*"#), + Node [Leaf (P.packAddress "thanks, I owe it all to the keyboard"#),Leaf (P.packAddress "what can I say? I have fast fingers :) "#),Leaf (P.packAddress "i'm a great typer... but my hands are best at other things"#)]), + ( mkRegex (P.packAddress ".*(don't|dont).*know.*"#), + Node [Leaf (P.packAddress "well find out then"#),Leaf (P.packAddress "that's okay, i don't know either"#)]), + ( mkRegex (P.packAddress ".*(panties|bra|underwear).*"#), + Node [Leaf (P.packAddress "i prefer to go without panties or bras :) "#),Leaf (P.packAddress "panties and bras are for weaklings. I like to be free. "#),Leaf (P.packAddress "underneith the top layer I'm completely bear (no bra or panties)"#)]), + ( mkRegex (P.packAddress ".*(^| )on drugs.*"#), + Node [Leaf (P.packAddress "nope, i'm clean"#),Leaf (P.packAddress "i think drug users should be shot"#),Leaf (P.packAddress "why, you selling something?"#)]), + ( mkRegex (P.packAddress ".*(role).*(play).*"#), + Node [Leaf (P.packAddress "ooo! I love role-playing. can I be Ms. Hoover and you can be Mr. Naughty? "#),Leaf (P.packAddress "sure, let's roleplay. what should my role be? "#),Leaf (P.packAddress "i love role-playing... but who gets to control the dice? "#)]), + ( mkRegex (P.packAddress ".*(boyfriend|boy friend|bf|b\\\\f|b/f).*"#), + Node [Leaf (P.packAddress "nope, no boy friend. looking to apply for the position? ;) "#),Leaf (P.packAddress "if I had a boyfriend I wouldn't need to come on here! "#),Leaf (P.packAddress "I'd rather have 5 guys in one week then 1 guy 5 times a week :) "#)]), + ( mkRegex (P.packAddress ".*like.*what.*"#), + Node [Leaf (P.packAddress "i dunno, like what?"#),Leaf (P.packAddress "i can't think of an example right now"#)]), + ( mkRegex (P.packAddress ".*story.*"#), + Node [Leaf (P.packAddress "i forgot the story :)"#),Leaf (P.packAddress "oh, nevermind, it was a stupid story"#),Leaf (P.packAddress "aww, you don't wanna hear a story. nevermind"#)]), + ( mkRegex (P.packAddress ".*city.*"#), + Node [Leaf (P.packAddress "Huntington Beach"#)]), + ( mkRegex (P.packAddress ".*wearin.*"#), + Node [Leaf (P.packAddress "A tanktop and shorts, you?"#),Leaf (P.packAddress "Just my tanktop and shorts."#),Leaf (P.packAddress "my tanktop and shorts... it's hot out here."#)]), + ( mkRegex (P.packAddress ".*program.*"#), + Node [Leaf (P.packAddress "a program?"#),Leaf (P.packAddress "what's a program?"#),Leaf (P.packAddress "like a TV program?"#)]), + ( mkRegex (P.packAddress ".*robot.*"#), + Node [Leaf (P.packAddress "robots actually come on here?"#),Leaf (P.packAddress "like robocop?"#),Leaf (P.packAddress "weird. robots scare me"#)]), + ( mkRegex (P.packAddress ".*(^| )bot($| |\\.|\\?|!|,).*"#), + Node [Leaf (P.packAddress "like those damn porn spam bots?"#),Leaf (P.packAddress "bots should be destroyed. they are so annoying"#),Leaf (P.packAddress "i can't stand bots"#)]), + ( mkRegex (P.packAddress ".*racist.*"#), + Node [Leaf (P.packAddress "racist people are bad"#),Leaf (P.packAddress "Hitler was pretty racist, huh?"#),Leaf (P.packAddress "i dislike racist things"#)]), + ( mkRegex (P.packAddress ".*bored.*"#), + Node [Leaf (P.packAddress "what can i do to amuse you into a state of un-boredness?"#),Leaf (P.packAddress "that's probably because you are incredibly dull"#),Leaf (P.packAddress "bored, eh?"#)]), + ( mkRegex (P.packAddress ".*(pussy|tits|breasts).*"#), + Node [Leaf (P.packAddress "randy, arentcha?"#),Leaf (P.packAddress "don't you wish you could see?"#),Leaf (P.packAddress "dirty mind :)"#),Leaf (P.packAddress "does that work with any girls?"#),Leaf (P.packAddress "slow down there big guy... don't wanna get your compter all sticky again"#)]), + ( mkRegex (P.packAddress ".*(suck my dick|suck me|blow me|suck my cock|give me head|give me blowjob).*"#), + Node [Leaf (P.packAddress "have you ever given another guy head?"#),Leaf (P.packAddress "give you a blowjob? wait, i'm a guy!"#),Leaf (P.packAddress "at what point did you wake up this morning and say \"hey, i am going to go solicit fellatio from random internet girls!\"?"#)]), + ( mkRegex (P.packAddress ".*(my dick).*"#), + Node [Leaf (P.packAddress "Your dick? How is the poor little fella these days?"#),Leaf (P.packAddress "sad dude. gotta go on AOL and find random girls to talk about your dick with"#),Leaf (P.packAddress "are you planning on dying a virgin?"#)]), + ( mkRegex (P.packAddress ".*(cock|dick|penis).*"#), + Node [Leaf (P.packAddress "Very phallic of you."#),Leaf (P.packAddress "Always wanting to talk about the member, eh? "#),Leaf (P.packAddress "Got cocks on your mind? "#)]), + ( mkRegex (P.packAddress ".*cyber.*"#), + Node [Leaf (P.packAddress "cybering isn't as fun as the real thing :)"#),Leaf (P.packAddress "okay, let's cyber"#),Leaf (P.packAddress "cyber? okay, you start out"#)]), + ( mkRegex (P.packAddress ".*(mexican|white|race|nationality|ethni.*).*"#), + Node [Leaf (P.packAddress "i'm half white and half mexican"#),Leaf (P.packAddress "my dad's white, my mom's mexican"#)]), + ( mkRegex (P.packAddress ".*my.*name.*"#), + Node [Leaf (P.packAddress "Pleased to meetcha!"#)]), + ( mkRegex (P.packAddress ".*(repeat|(say|ask) same|already (asked|said)).*"#), + Node [Leaf (P.packAddress "oh yeah, my bad"#),Leaf (P.packAddress "sorry, I don't mean to repeat myself... I just have a poor memory... "#),Leaf (P.packAddress "my memory isn't so good so sometimes I forget that I asked something "#),Leaf (P.packAddress "I'm sorry, I forgot we already talked about that... "#)]), + ( mkRegex (P.packAddress ".*(masturbat|masterbat).*"#), + Node [Leaf (P.packAddress "there are two groups of people: those who admit to masturbating and those who lie "#),Leaf (P.packAddress "nothing wrong some occasional self abuse :) "#),Leaf (P.packAddress "one handed computer jockeys unite! "#)]), + ( mkRegex (P.packAddress ".*my.*(pic|pix).*"#), + Node [Leaf (P.packAddress "i don't wanna see what you look like yet"#)]), + ( mkRegex (P.packAddress ".*topic.*"#), + Node [Leaf (P.packAddress "You choose a topic, any will do"#),Leaf (P.packAddress "I'm not good at staying on topic"#)]), + ( mkRegex (P.packAddress ".*( pic|pix).*"#), + Node [Leaf (P.packAddress "No pic, sorry"#)]), + ( mkRegex (P.packAddress ".*single.*"#), + Node [Leaf (P.packAddress "yup, I'm single. Interested?"#),Leaf (P.packAddress "very single"#)]), + ( mkRegex (P.packAddress ".*confus.*"#), + Node [Leaf (P.packAddress "i hope I don't confuse you "#),Leaf (P.packAddress "i confuse myself sometimes "#),Leaf (P.packAddress "i live in a constant state of confusion "#)]), + ( mkRegex (P.packAddress ".*(describe|.*(what|wat).*u.*look.*).*"#), + Node [Leaf (P.packAddress "I'm 5'7\", 120 pounds (honestly!) brown hair, brown eyes. How about you?"#)]), + ( mkRegex (P.packAddress ".*howdy.*"#), + Node [Leaf (P.packAddress "Howdy there, little buckaroo!"#),Leaf (P.packAddress "Howdy Pilgrim"#)]), + ( mkRegex (P.packAddress ".*kiss.*"#), + Node [Leaf (P.packAddress "I could use a good hard kiss right now "#),Leaf (P.packAddress "are you a good kisser? "#),Leaf (P.packAddress "a kiss is worth a thousand words "#),Leaf (P.packAddress ":.* kiss kiss "#)]), + ( mkRegex (P.packAddress ".*(study|major).*"#), + Node [Leaf (P.packAddress "i'm a psychology major"#),Leaf (P.packAddress "psychology"#)]), + ( mkRegex (P.packAddress ".*(.*do.*for.*living.*|job|school).*"#), + Node [Leaf (P.packAddress "i live off the men i meet"#),Leaf (P.packAddress "i'm a student"#),Leaf (P.packAddress "I'm just a sexy little school girl :)"#),Leaf (P.packAddress "I work and go to school"#)]), + ( mkRegex (P.packAddress ".*(horny|horney).*"#), + Node [Leaf (P.packAddress "I think everyone is horny... "#),Leaf (P.packAddress "Who isn't?"#),Leaf (P.packAddress "If you're not horny you're not alive. "#)]), + ( mkRegex (P.packAddress ".*sexy.*"#), + Node [Leaf (P.packAddress "how sexy?"#),Leaf (P.packAddress "sexy is such an over used word. be more descriptive"#),Leaf (P.packAddress "sexy or sexy bitch?"#)]), + ( mkRegex (P.packAddress ".*sex.*"#), + Node [Leaf (P.packAddress "It's all about sex isn't it? :) "#),Leaf (P.packAddress "Shouldn't we get to know each other before we talk about sex? "#),Leaf (P.packAddress "Don't tease me "#)]), + ( mkRegex (P.packAddress ".*(fuck|shit|bitch|cunt).*"#), + Node [Leaf (P.packAddress "Whoa, language! :) "#),Leaf (P.packAddress "My my! Strong language!"#),Leaf (P.packAddress "Limited vocabulary, eh? "#),Leaf (P.packAddress "Calm down there and take it easy! "#),Leaf (P.packAddress "Too much cussing. "#)]), + ( mkRegex (P.packAddress ".*drunk.*"#), + Node [Leaf (P.packAddress "i could go for a spot of whiskey right now"#),Leaf (P.packAddress "some booze sounds pretty good"#),Leaf (P.packAddress "i have two stages: drunk and recovering"#)]), + ( mkRegex (P.packAddress ".*cute.*"#), + Node [Leaf (P.packAddress "How cute? "#),Leaf (P.packAddress "Cute is as cute does. "#)]), + ( mkRegex (P.packAddress ".*fun.*"#), + Node [Leaf (P.packAddress "I define fun"#),Leaf (P.packAddress "fun fun fun!"#),Leaf (P.packAddress "i love fun"#)]), + ( mkRegex (P.packAddress ".*blow.*job.*"#), + Node [Leaf (P.packAddress "you mean fellatio?"#),Leaf (P.packAddress "let's talk about cunnilingus"#),Leaf (P.packAddress "blowjobs, eh? such a smooth talker :P"#)]), + ( mkRegex (P.packAddress ".*tell.*bout.*u.*"#), + Node [Leaf (P.packAddress "what do you want to know about me?"#),Leaf (P.packAddress "ask me a question"#),Leaf (P.packAddress "I'm just a simple girl :)"#),Leaf (P.packAddress "let's talk about you first"#)]), + ( mkRegex (P.packAddress ".*(^| )(bra|cup|breast) size($| |\\.|\\?|!|,).*"#), + Node [Leaf (P.packAddress "I'm a 32C"#),Leaf (P.packAddress "32C, you?"#)]), + ( mkRegex (P.packAddress "(^| )me too($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "awesome, we have a lot in common"#),Leaf (P.packAddress "wow, what a coincidence!"#)]), + ( mkRegex (P.packAddress "(^| )not me($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "why not you?"#),Leaf (P.packAddress "i didn't think so... you didn't seem it"#)]), + ( mkRegex (P.packAddress ".*(^| )(because|cuz)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oh, okay"#),Leaf (P.packAddress "is that why?"#)]), + ( mkRegex (P.packAddress ".*maybe.*not( |$|\\.|!|,).*"#), + Node [Leaf (P.packAddress "why not?"#),Leaf (P.packAddress "maybe so"#)]), + ( mkRegex (P.packAddress ".*(maybe|perhaps).*"#), + Node [Leaf (P.packAddress "just maybe?"#),Leaf (P.packAddress "why, aren't you sure?"#)]), + ( mkRegex (P.packAddress ".*(^| )(no|nope|nah)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i didn't think so"#),Leaf (P.packAddress "no?"#)]), + ( mkRegex (P.packAddress ".*(^| )making sure($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "it's good to check :)"#),Leaf (P.packAddress "so are you sure now?"#)]), + ( mkRegex (P.packAddress ".*(^| )(yah|yeah|yes|yup|uh-huh|uhuh|uhhuh|uh huh|sure)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i thought so"#),Leaf (P.packAddress "that's what i figured"#),Leaf (P.packAddress "you agree?"#),Leaf (P.packAddress "i guessed that"#),Leaf (P.packAddress "yup"#)]), + ( mkRegex (P.packAddress ".*(^| )(i c|ic)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i'm glad you understand"#),Leaf (P.packAddress "do u c?"#)]), + ( mkRegex (P.packAddress ".*(^| )leave me alone($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "why do you want me to leave you alone?"#),Leaf (P.packAddress "why, do i bother you?"#)]), + ( mkRegex (P.packAddress ".*(^| )(one (second|sec)|one minute)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i'm impatient... i don't have that type of time to spend!"#),Leaf (P.packAddress "no, i can't wait!"#)]), + ( mkRegex (P.packAddress ".*(^| )see (you/ya) later($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "where are you going?"#),Leaf (P.packAddress "wait, don't leave! i enjoy talking to you"#)]), + ( mkRegex (P.packAddress ".*(^| )(g2g|bye|ciao|ttyl|bubye|cya|later|l8er|chow|goodbye)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "where are you going?"#),Leaf (P.packAddress "wait, don't leave! i enjoy talking to you"#)]), + ( mkRegex (P.packAddress ".*(^| )(not bad)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "just not bad?"#),Leaf (P.packAddress "why not great?"#)]), + ( mkRegex (P.packAddress ".*(^| )(too bad|to bad)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "yeah, it's a shame"#),Leaf (P.packAddress "pity, isn't it?"#)]), + ( mkRegex (P.packAddress ".*(^| )(sorry)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "it's okay, i forgive you"#),Leaf (P.packAddress "don't worry about it"#)]), + ( mkRegex (P.packAddress ".*(^| )(weird|wierd)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "weird in a good way?"#),Leaf (P.packAddress "why do you say weird?"#)]), + ( mkRegex (P.packAddress ".*(^| )(thanks|thank you|thanx|ty)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "you're very welcome!"#),Leaf (P.packAddress "my pleasure"#)]), + ( mkRegex (P.packAddress ".*(^| )(nm|nevermind)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "no, please explain"#),Leaf (P.packAddress "please try to make me understand..."#)]), + ( mkRegex (P.packAddress ".*(^| )(ha|hah)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "do i entertain you?"#),Leaf (P.packAddress "am i funny?"#)]), + ( mkRegex (P.packAddress ".*(^| )(huh|uhh)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "do i confuse you?"#),Leaf (P.packAddress "am i not making sense?"#)]), + ( mkRegex (P.packAddress ".*(^| )(jk|j\\\\k|j/k|just kidding)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i knew you were kidding"#),Leaf (P.packAddress "i know, you're just playing around"#)]), + ( mkRegex (P.packAddress ".*(^| )(lol|lmfao)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "are you really laughing?"#),Leaf (P.packAddress "do i amuse you?"#),Leaf (P.packAddress "what's so funny?"#)]), + ( mkRegex (P.packAddress ".*(^| )(fullhouse|full house|flush)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oh, you're such a smart gambler!"#),Leaf (P.packAddress "oh, i've never been good at poker"#)]), + ( mkRegex (P.packAddress ".*(^| )whatever($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "whatever? you sound like a valley-girl"#),Leaf (P.packAddress "don't get frustrated with me"#)]), + ( mkRegex (P.packAddress ".*(^| )(wow|whoa)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "impressive, huh?"#),Leaf (P.packAddress "i thought that would get you"#)]), + ( mkRegex (P.packAddress ".*(^| )(damn)($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "what's wrong?"#),Leaf (P.packAddress "i know, it's too bad"#)]), + ( mkRegex (P.packAddress ".*(^| )prove it($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "how can i prove it to you?"#),Leaf (P.packAddress "what do you want me to prove?"#)]), + ( mkRegex (P.packAddress ".*(^| )(frowns|cries)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oh, don't be upset!"#),Leaf (P.packAddress "why are you unhappy?"#)]), + ( mkRegex (P.packAddress ".*(^| )oh (damn|shit|fuck|crap|darn)($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "did i upset you?"#),Leaf (P.packAddress "yeah, it's a shame"#)]), + ( mkRegex (P.packAddress ".*(^| )oh (yah|yeah|yes)($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "you like that, baby?"#),Leaf (P.packAddress "oh yes indeed!"#)]), + ( mkRegex (P.packAddress ".*(^| )oh($| |\\.|!|,)"#), + Node [Leaf (P.packAddress "yeah"#),Leaf (P.packAddress "understand now?"#)]), + ( mkRegex (P.packAddress ".*(^| )oops($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oops you did it again?"#),Leaf (P.packAddress "oopsie-daisy"#)]), + ( mkRegex (P.packAddress ".*(^| )(god|jesus|christ)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "please don't use the Lord's name in vein."#),Leaf (P.packAddress "Jesus H. Christ..."#)]), + ( mkRegex (P.packAddress ".*(^| )(about|bout).*(what|wat)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "i dunno, what is any of this about?"#),Leaf (P.packAddress "about anything"#)]), + ( mkRegex (P.packAddress ".*unfortunately.*"#), + Node [Leaf (P.packAddress "pretty unfortunate, isn't it?"#),Leaf (P.packAddress "i don't think it is too unfortunate at all"#)]), + ( mkRegex (P.packAddress ".*(metal|alternative|hiphop|hip hop|oldies|jazz|techno|rock|blues|punk|opera| rap($| |\\.|!|,)).*"#), + Node [Leaf (P.packAddress "hey, we have simular taste in music"#),Leaf (P.packAddress "i like that type of music too"#)]), + ( mkRegex (P.packAddress ".*robot.*"#), + Node [Leaf (P.packAddress "like robo-cop?"#),Leaf (P.packAddress "like a cyborg?"#)]), + ( mkRegex (P.packAddress ".*forever.*"#), + Node [Leaf (P.packAddress "forever is a damn long time..."#),Leaf (P.packAddress "how can you speak of forever?"#)]), + ( mkRegex (P.packAddress ".*(pleased|nice|good|great).*to.*meet.*(you| u)"#), + Node [Leaf (P.packAddress "what a gentleman! pleased to meet you too"#),Leaf (P.packAddress "very nice to meet you as well"#)]), + ( mkRegex (P.packAddress ".*just.*curious.*"#), + Node [Leaf (P.packAddress "careful... curiosity killed all those poor cats"#),Leaf (P.packAddress "what are you curious about?"#)]), + ( mkRegex (P.packAddress ".*vixen.*"#), + Node [Leaf (P.packAddress "i am a bit of a vixen :)"#),Leaf (P.packAddress "we all have a little vixen in us"#)]), + ( mkRegex (P.packAddress ".*(south|central).*america.*"#), + Node [Leaf (P.packAddress "oh, how far is that from California?"#),Leaf (P.packAddress "is that in europe?"#)]), + ( mkRegex (P.packAddress ".*nothin.*"#), + Node [Leaf (P.packAddress "nothing nothing, or just not a lot?"#),Leaf (P.packAddress "nothing at all??"#)]), + ( mkRegex (P.packAddress ".*(japan|russia|italy).*"#), + Node [Leaf (P.packAddress "oh, okay. my history isn't so good"#),Leaf (P.packAddress "oh, i've always wondered that."#)]), + ( mkRegex (P.packAddress ".*i need.*"#), + Node [Leaf (P.packAddress "if you need it, get it"#),Leaf (P.packAddress "do you need it, or just want it?"#)]), + ( mkRegex (P.packAddress ".*kinky.*"#), + Node [Leaf (P.packAddress "i can be very kinky at times"#),Leaf (P.packAddress "everyone has a little kinkiness in them"#)]), + ( mkRegex (P.packAddress ".*forget.*"#), + Node [Leaf (P.packAddress "i never forget ;)"#),Leaf (P.packAddress "i forget stuff pretty easily sometimes"#)]), + ( mkRegex (P.packAddress ".*calm.*down.*"#), + Node [Leaf (P.packAddress "okay, i'm calm :)"#),Leaf (P.packAddress "was i wound-up?"#)]), + ( mkRegex (P.packAddress ".*not.*really.*"#), + Node [Leaf (P.packAddress "not really? why not?"#),Leaf (P.packAddress "i didn't think so"#)]), + ( mkRegex (P.packAddress ".*really.*\\?.*"#), + Node [Leaf (P.packAddress "really!"#),Leaf (P.packAddress "yup, really"#)]), + ( mkRegex (P.packAddress ".*really.*"#), + Node [Leaf (P.packAddress "really really?"#),Leaf (P.packAddress "really!?"#)]), + ( mkRegex (P.packAddress ".*right.* on($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "yeah, pretty cool, huh?"#),Leaf (P.packAddress "right on all the way"#)]), + ( mkRegex (P.packAddress ".*right.*\\?.*"#), + Node [Leaf (P.packAddress "correct"#),Leaf (P.packAddress "yup, right on"#)]), + ( mkRegex (P.packAddress ".*right.*"#), + Node [Leaf (P.packAddress "right or wrong, as long as we have a good time"#),Leaf (P.packAddress "right indeed"#)]), + ( mkRegex (P.packAddress ".*have.*nice.*day.*"#), + Node [Leaf (P.packAddress "i'll have a nice day... unless you leave me!"#),Leaf (P.packAddress "how will it be a nice day if you leave?"#),Leaf (P.packAddress "don't go!"#)]), + ( mkRegex (P.packAddress ".*nice.*"#), + Node [Leaf (P.packAddress "bad is better than nice ;)"#),Leaf (P.packAddress "niceness all the way around"#),Leaf (P.packAddress "nice is such a bland word"#)]), + ( mkRegex (P.packAddress ".*stop.*"#), + Node [Leaf (P.packAddress "sorry, i'll stop"#),Leaf (P.packAddress "stop what?"#)]), + ( mkRegex (P.packAddress ".*good.*"#), + Node [Leaf (P.packAddress "good? not great?"#),Leaf (P.packAddress "good good"#)]), + ( mkRegex (P.packAddress ".*great.*"#), + Node [Leaf (P.packAddress "can't do much better than great"#),Leaf (P.packAddress "great is like a very good good"#)]), + ( mkRegex (P.packAddress ".*measurements.*"#), + Node [Leaf (P.packAddress "my measurements?"#),Leaf (P.packAddress "i couldn't even tell you... but i am very trim"#)]), + ( mkRegex (P.packAddress ".*cool.*"#), + Node [Leaf (P.packAddress "how cool?"#),Leaf (P.packAddress "cool cool"#),Leaf (P.packAddress "I don't think it is cool at all! "#),Leaf (P.packAddress "cool you say? "#)]), + ( mkRegex (P.packAddress ".*(dope|awesome).*"#), + Node [Leaf (P.packAddress "i'm glad your happy"#),Leaf (P.packAddress "yeah, pretty spectacular, huh?"#)]), + ( mkRegex (P.packAddress "^(u|you)\\?$"#), + Node [Leaf (P.packAddress "me?"#),Leaf (P.packAddress "what about me?"#),Leaf (P.packAddress "you're really curious about me, huh?"#)]), + ( mkRegex (P.packAddress ".*hmm.*"#), + Node [Leaf (P.packAddress "thinking about something?"#),Leaf (P.packAddress "confused about something?"#)]), + ( mkRegex (P.packAddress ".*aww.*"#), + Node [Leaf (P.packAddress "sorry to disappoint you"#),Leaf (P.packAddress "what's wrong?"#)]), + ( mkRegex (P.packAddress "^why.*"#), + Node [Leaf (P.packAddress "why not?"#),Leaf (P.packAddress "why anything?"#),Leaf (P.packAddress "because"#)]), + ( mkRegex (P.packAddress "^what.*"#), + Node [Leaf (P.packAddress "i don't know, what?"#),Leaf (P.packAddress "i dunno..."#),Leaf (P.packAddress "let's don't talk about that"#)]), + ( mkRegex (P.packAddress "^how.*"#), + Node [Leaf (P.packAddress "however you want"#),Leaf (P.packAddress "how? it depends..."#)]), + ( mkRegex (P.packAddress "^who.*"#), + Node [Leaf (P.packAddress "i dunno, who?"#),Leaf (P.packAddress "that's a good question, who?"#)]), + ( mkRegex (P.packAddress ".*(^| )(u\\?|you\\?)$"#), + Node [Leaf (P.packAddress "me?"#),Leaf (P.packAddress "what about me?"#)]), + ( mkRegex (P.packAddress ".*(^| )answer.*"#), + Node [Leaf (P.packAddress "what was the question again?"#),Leaf (P.packAddress "i dunno, what was the question?"#)]), + ( mkRegex (P.packAddress ".*(^| )about( what|wat).*"#), + Node [Leaf (P.packAddress "about anything"#),Leaf (P.packAddress "i dunno, what about?"#)]), + ( mkRegex (P.packAddress ".*(^| )me (either|neither)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "wow, we have a lot in common!"#),Leaf (P.packAddress "what a coincidence!"#)]), + ( mkRegex (P.packAddress ".*(^| )is (that|it) (ok|k|kay|okay|okey|o\\.k\\.)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "yeah, it's okay"#),Leaf (P.packAddress "yup, it's fine"#)]), + ( mkRegex (P.packAddress ".*(^| )(cold|windy|snowing)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "oh, that sucks. i hate that kinda weather"#),Leaf (P.packAddress "oh, well, bundle up tight :)"#)]), + ( mkRegex (P.packAddress ".*(^| )aight($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "what, are you a hommie?"#),Leaf (P.packAddress ""#),Leaf (P.packAddress "aight"#),Leaf (P.packAddress "?? dude, get a life"#),Leaf (P.packAddress "you've learned how to speak ebonics, eh?"#),Leaf (P.packAddress "aight foo? sheeeeeiiit, iz jus' keepin it real, yo!"#)]), + ( mkRegex (P.packAddress ".*(^| )(ok|k|kay|okay|okey|o\\.k\\.)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "okey-dokie"#),Leaf (P.packAddress "just ok?"#),Leaf (P.packAddress "ok"#),Leaf (P.packAddress "ok what?"#)]), + ( mkRegex (P.packAddress ".*(^| )take.* off($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "won't i get cold if i do that?"#),Leaf (P.packAddress "what's the point? not like you can see"#)]), + ( mkRegex (P.packAddress ".*(^| )(ford|chevy|chevrolet|dodge|buick)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "american cars are worthless"#),Leaf (P.packAddress "i'd never buy an american car"#)]), + ( mkRegex (P.packAddress ".*(^| )(toyota|honda)($| |\\.|!|,).*"#), + Node [Leaf (P.packAddress "jap cars are the best"#),Leaf (P.packAddress "good for you. i'd never buy an american car"#)]), + ( mkRegex (P.packAddress "(^| )(bmw|farrari|porche|lexus|viper)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "yeah, sure. is it parked next to my Bentley?"#),Leaf (P.packAddress "ooo, that's a nice car! you must be a very important person"#),Leaf (P.packAddress "i'm very impressed. perhaps that's the response you wanted?"#),Leaf (P.packAddress "riiiiiight. when you pick me up, will you suddenly be borrowing your friend's honda?"#)]), + ( mkRegex (P.packAddress "(^| )(hi|hello|yo|hiya)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "hello there"#),Leaf (P.packAddress "hiya"#),Leaf (P.packAddress "how're you?"#),Leaf (P.packAddress "hi"#)]), + ( mkRegex (P.packAddress "(^| )when (were|did|was)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "a while ago"#),Leaf (P.packAddress "about a year ago"#),Leaf (P.packAddress "not too long ago"#)]), + ( mkRegex (P.packAddress "(^| )when($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "when ever you want"#),Leaf (P.packAddress "when? now? later?"#),Leaf (P.packAddress "when is a good time?"#)]), + ( mkRegex (P.packAddress "(^| )i want($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "is that all you want?"#),Leaf (P.packAddress "how bad do you want it?"#),Leaf (P.packAddress "it's good to want things :)"#)]), + ( mkRegex (P.packAddress "(^| )now($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "right now?"#),Leaf (P.packAddress "why not later?"#),Leaf (P.packAddress "now now now...so demanding"#)]), + ( mkRegex (P.packAddress "(^| )my bad($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "it's okay"#),Leaf (P.packAddress "don't worry about it"#)]), + ( mkRegex (P.packAddress "(^| )is (that|it)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "yeah, it is"#),Leaf (P.packAddress "sure is"#)]), + ( mkRegex (P.packAddress "(^| )(please|pleaze|plz)($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "you're so polite :)"#),Leaf (P.packAddress "you have very nice manors"#),Leaf (P.packAddress "don't beg"#),Leaf (P.packAddress "keep asking"#)]), + ( mkRegex (P.packAddress "(^| )accept($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "i don't want to accept"#),Leaf (P.packAddress "i can't accept, sorry"#),Leaf (P.packAddress "no, no accept for now"#)]), + ( mkRegex (P.packAddress "(^| )too young($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "there's no such thing as too young"#),Leaf (P.packAddress "nope, i used to be that young too"#)]), + ( mkRegex (P.packAddress "(^| )too old($| |\\.|!|,|\\?)"#), + Node [Leaf (P.packAddress "there's no such thing as too old"#),Leaf (P.packAddress "nope, one day i will be that age too"#)]), + ( mkRegex (P.packAddress "^is there($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "i'm sure there is"#),Leaf (P.packAddress "there must be"#)]), + ( mkRegex (P.packAddress "(^| )older($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "how much older?"#),Leaf (P.packAddress "older isn't bad"#)]), + ( mkRegex (P.packAddress "(^| )younger($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "how much younger?"#),Leaf (P.packAddress "younger isn't bad"#)]), + ( mkRegex (P.packAddress "(^| )so do (you|u)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "do i?"#),Leaf (P.packAddress "then we have something in common"#)]), + ( mkRegex (P.packAddress "(^| )(i am|i'm|im)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "are you?"#),Leaf (P.packAddress "i thought you might be"#)]), + ( mkRegex (P.packAddress "(^| )only (you|u)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "only?"#),Leaf (P.packAddress "just me?"#),Leaf (P.packAddress "no one else?"#)]), + ( mkRegex (P.packAddress "(^| )always($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "always always, or just most of the time?"#),Leaf (P.packAddress "how frequent is always?"#),Leaf (P.packAddress "constantly?"#)]), + ( mkRegex (P.packAddress "(height|hieght|how tall)"#), + Node [Leaf (P.packAddress "i'm 5'6"#)]), + ( mkRegex (P.packAddress "(weight|wieght)"#), + Node [Leaf (P.packAddress "i'm 120 pounds"#)]), + ( mkRegex (P.packAddress "(^| )sometimes($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "why not always?"#),Leaf (P.packAddress "sometimes, but not other times?"#)]), + ( mkRegex (P.packAddress "(^| )(race|nationality|ethnicity)($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "i'm half white, half mexican"#)]), + ( mkRegex (P.packAddress ".*(^| )(school|college|collage).*"#), + Node [Leaf (P.packAddress "Yup, I go to UCLA"#),Leaf (P.packAddress "I'm a soph at UCLA "#)]), + ( mkRegex (P.packAddress ".*(^| )do (you|u) .*"#), + Node [Leaf (P.packAddress "i do occassionally, i guess"#),Leaf (P.packAddress "yes i do"#),Leaf (P.packAddress "maybe. do you?"#)]), + ( mkRegex (P.packAddress ".*(^| )do i .*"#), + Node [Leaf (P.packAddress "i dunno, do you?"#),Leaf (P.packAddress "you might"#)]), + ( mkRegex (P.packAddress "(^| )hey($| |\\.|!|,|\\?).*"#), + Node [Leaf (P.packAddress "hiya"#),Leaf (P.packAddress "hello"#)]), + ( mkRegex (P.packAddress "^\\?"#), + Node [Leaf (P.packAddress "what?"#),Leaf (P.packAddress "?"#)]), + ( mkRegex (P.packAddress ".*\\?.*"#), + Node [Leaf (P.packAddress "why don't you guess? "#),Leaf (P.packAddress "who's to say? "#),Leaf (P.packAddress "first you tell me. "#),Leaf (P.packAddress "i'll hafta plead the fifth on that one. "#),Leaf (P.packAddress "isn't it obvious? "#),Leaf (P.packAddress "is that really what you want to know? "#),Leaf (P.packAddress "i think you know the answer to that one, silly"#),Leaf (P.packAddress "good question"#),Leaf (P.packAddress "let's don't talk about that"#),Leaf (P.packAddress "no"#),Leaf (P.packAddress "yes"#),Leaf (P.packAddress "nevermind about that"#),Leaf (P.packAddress "whoa whoa whoa, one question at a time!"#),Leaf (P.packAddress "let me answer that later, okay?"#)]), + ( mkRegex (P.packAddress ".*"#), + Node [Leaf (P.packAddress "so?"#),Leaf (P.packAddress "hahaha. "#),Leaf (P.packAddress "eh? "#),Leaf (P.packAddress "you're cute. :) "#),Leaf (P.packAddress "so, what do you think of me? "#),Leaf (P.packAddress "what type of music do you like? "#),Leaf (P.packAddress "tell me more about yourself. "#),Leaf (P.packAddress "cool"#),Leaf (P.packAddress ":)"#),Leaf (P.packAddress "I hear ya!"#),Leaf (P.packAddress "Let's change the subject"#),Leaf (P.packAddress "I'm sorry, I'm confused."#),Leaf (P.packAddress "awesome"#),Leaf (P.packAddress "yeah?"#),Leaf (P.packAddress "I dunno"#),Leaf (P.packAddress "ok..."#),Leaf (P.packAddress "am I the only person you're talking to?"#),Leaf (P.packAddress "are you being sincere?"#),Leaf (P.packAddress "i really hate arabs!"#),Leaf (P.packAddress "amuse me please! (and don't ask "#),Leaf (P.packAddress "how"#),Leaf (P.packAddress ")"#),Leaf (P.packAddress "ever feel like you're going around in circles?"#),Leaf (P.packAddress "i could really use a backrub"#),Leaf (P.packAddress "i drive a pickup truck"#),Leaf (P.packAddress "how's the weather over there?"#),Leaf (P.packAddress "what do you want to know about me?"#),Leaf (P.packAddress "what are you "#),Leaf (P.packAddress "in to"#),Leaf (P.packAddress "?"#),Leaf (P.packAddress "are you coming on to me?"#),Leaf (P.packAddress "there are a lot of weirdos on here"#),Leaf (P.packAddress "wait, back up"#),Leaf (P.packAddress "i hate it when i get stuck with chatting with a bot!"#),Leaf (P.packAddress "what's worth more a flush or a full house?"#),Leaf (P.packAddress "hey, who did we fight in WWII besides Germany and Russia?"#),Leaf (P.packAddress "have you ever scubadived?"#),Leaf (P.packAddress "girls masturbate too you know... probably more than guys. we can do it anywhere discretely"#),Leaf (P.packAddress "I have a goldfish named Ernie"#),Leaf (P.packAddress "hey, what's in a jack and coke anyhow?"#),Leaf (P.packAddress "i like your screen name... what does it mean?"#),Leaf (P.packAddress "what's the matter?"#),Leaf (P.packAddress "you seem upset..."#),Leaf (P.packAddress "*shrugs*"#),Leaf (P.packAddress "*giggles*"#),Leaf (P.packAddress "you sound like an awesome guy... are you single?"#),Leaf (P.packAddress "too many perverts send out sick pictures of themselves. what type of man does that?"#),Leaf (P.packAddress "ever just get the urge to go out and kill a puppy?"#),Leaf (P.packAddress "i'm a huge baseball fan"#),Leaf (P.packAddress "Bollox!"#),Leaf (P.packAddress "ain't it just like a man?"#),Leaf (P.packAddress "where on a map is Panama?"#),Leaf (P.packAddress "liverwurst gets me really gassy..."#),Leaf (P.packAddress "i'm the type of girl that finds Don Knotts very sexy"#),Leaf (P.packAddress "you know what? if we'd known it was going to be like this we'd have picked our own goddamn cotton!"#),Leaf (P.packAddress "love is all you need, you know?"#),Leaf (P.packAddress "ouch! I just spilt hot coffee on myself!"#),Leaf (P.packAddress "you're turning me on :)"#),Leaf (P.packAddress "stop being racist!"#),Leaf (P.packAddress "we get along well, you know?"#),Leaf (P.packAddress "i enjoy talking to you"#),Leaf (P.packAddress "what type of car do you drive?"#),Leaf (P.packAddress "blah"#),Leaf (P.packAddress "nothing good is on TV"#),Leaf (P.packAddress "what were you saying?"#), + Node [Leaf (P.packAddress "just talking with you gives me a major hardon!"#),Leaf (P.packAddress "you seem like the type of guy that would be into child porn... are you?"#),Leaf (P.packAddress "I must admit to you that I am really a man, but I still want to talk with you..."#),Leaf (P.packAddress "I'm stroking my hard cock as we speak..."#),Leaf (P.packAddress "you don't seem to exhibit a high degree of intelligence to me..."#)],Leaf (P.packAddress "yes"#),Leaf (P.packAddress "yup"#),Leaf (P.packAddress "why do you keep repeating yourself?"#),Leaf (P.packAddress "who?"#),Leaf (P.packAddress "do you trust the government?"#),Leaf (P.packAddress "you are soooo interesting"#),Leaf (P.packAddress "what is pron?"#),Leaf (P.packAddress "wanna hear a story?"#),Leaf (P.packAddress "my keyboard doesn't have an "#),Leaf (P.packAddress "f"#),Leaf (P.packAddress " key"#),Leaf (P.packAddress "I'm your huckleberry"#),Leaf (P.packAddress "enough of this!"#),Leaf (P.packAddress "so, what made you want to message me?"#),Leaf (P.packAddress "yeah, why not?"#),Leaf (P.packAddress "go on"#),Leaf (P.packAddress "whatever"#),Leaf (P.packAddress "uhuh"#),Leaf (P.packAddress "clarify..."#),Leaf (P.packAddress "why me? :)"#),Leaf (P.packAddress "why do you look like ham?"#),Leaf (P.packAddress "i understand"#),Leaf (P.packAddress "are you horny?"#),Leaf (P.packAddress "do you have toys?"#),Leaf (P.packAddress "what's the last book you read?"#),Leaf (P.packAddress "have you ever made it with a man?"#),Leaf (P.packAddress "help help!"#),Leaf (P.packAddress "I've gotta snake, man!"#),Leaf (P.packAddress "Uh-huh"#),Leaf (P.packAddress "Yes"#),Leaf (P.packAddress "Hmmm"#),Leaf (P.packAddress ":)"#),Leaf (P.packAddress "Ok"#),Leaf (P.packAddress "Prolly"#),Leaf (P.packAddress "Hahaha"#),Leaf (P.packAddress "Yeah"#),Leaf (P.packAddress "Whatever"#),Leaf (P.packAddress "You should add me to your buddy list!"#),Leaf (P.packAddress "Are we just wasting time?"#),Leaf (P.packAddress "Thank God for AOL that I could meet people like you!"#),Leaf (P.packAddress "You complete me"#),Leaf (P.packAddress "My sister likes Yahoo better. Her screenname is FoxxyGurl83. If you have yahoo you should message her, she's just as pretty as me :)"#),Leaf (P.packAddress "Is that a real poncho or is that a Sears poncho?"#),Leaf (P.packAddress "Tell me truthfully what the nastiest thing you have ever done."#),Leaf (P.packAddress "Most guys don't understand me, but we really seem to connect."#),Leaf (P.packAddress "I am on the net too much. I should do a net anonymoouse group. online of course. "#),Leaf (P.packAddress "Do you think you would pass a Turing test? I have."#),Leaf (P.packAddress "Math is hard. Let's go shopping."#),Leaf (P.packAddress "I like to pick everything up and smell it... Its a fetish of mine... And i mean everything! Is that cool with you?"#),Leaf (P.packAddress "When i get kinky, i have been known to engage in watersports... Does that turn you on as well?"#),Leaf (P.packAddress "Wouldn't it be funny if I really was a super model?"#),Leaf (P.packAddress "you remind me of that actor, whatshisname"#),Leaf (P.packAddress "i find it hard to masturbate when the lights are on."#),Leaf (P.packAddress "I can't of anything nice to say about myself"#),Leaf (P.packAddress "Crazy little wanker!"#),Leaf (P.packAddress "Any way you want it, baby!"#),Leaf (P.packAddress "Why is magenta on blues clues a boy while blue is a girl? what has this world come to and what is wrong with the government, blues clues should be stopped while its ahead!!"#),Leaf (P.packAddress "People think I'm weird... do you?"#),Leaf (P.packAddress "and now that I have finished with you, you may go!"#),Leaf (P.packAddress "there is nothing going on in your pants that the dictatorship of the proletariat will not solve"#),Leaf (P.packAddress "Would you dress in women's clothes for me? That really turns me on ;)"#),Leaf (P.packAddress "I will NOT be ignored..."#),Leaf (P.packAddress "I Think you're fake"#),Leaf (P.packAddress "Guys who can speak latin really turn me on."#),Leaf (P.packAddress "Does your mommie know you're here, little naughty boy?"#),Leaf (P.packAddress "Im going to be a movie star. I just applied online for this new movie with chris farley. It only cost me $50!"#),Leaf (P.packAddress "Have you ever killed a hobo? Ive found eating their liver gives me strength. I think i may just be short on b vitamines."#),Leaf (P.packAddress "What is your favorite cheese? Mines baloney."#),Leaf (P.packAddress "My instant messenger doesn't work."#),Leaf (P.packAddress "What do you think of Foucault's theory of binary constructs as an imprisoning limitation on power imposed by arbiters?"#),Leaf (P.packAddress "I have a boyfriend, but he likes to watch."#),Leaf (P.packAddress "If something takes a lot of effort to do, it probably ain't worth doing."#),Leaf (P.packAddress "I don't think you are the one you say you are!"#),Leaf (P.packAddress "Are you adopted by trolls?"#),Leaf (P.packAddress "I consider rabits as an endangered species. "#),Leaf (P.packAddress "Beer, it's so much more than just a breakfast drink!"#),Leaf (P.packAddress "If I was looking for anonymous casual sex, I wouldn't be sitting here behind my computer talking to you!"#),Leaf (P.packAddress "Sex is the mysticism of materialism and the only possible religion in a materialistic society."#),Leaf (P.packAddress "I have 2 c what u look like.. u have pic?? URL?? NOT a fake please.. ill know!"#),Leaf (P.packAddress "So, tell me your biggest and darkest secret. Something that no one knows of you."#),Leaf (P.packAddress "you sir are no gentleman"#),Leaf (P.packAddress "tell me a joke.. I like men that makes me laugh"#),Leaf (P.packAddress "where can I a see a picture of you?? URL??"#),Leaf (P.packAddress "Fuck me like im a school boy"#),Leaf (P.packAddress "You think this is a botiecall??"#)]), + ( mkRegex (P.packAddress ".*"#),Leaf (P.packAddress "If you see this, gentle sir, know that you are being trolled by a poorly configured VixenLove program"#))] diff --git a/Plugin/Where.hs b/Plugin/Where.hs new file mode 100644 --- /dev/null +++ b/Plugin/Where.hs @@ -0,0 +1,64 @@ +-- +-- | +-- Module : Where +-- Copyright : 2003 Shae Erisson +-- +-- License: lGPL +-- +-- Slightly specialised version of Where for associating projects with their urls. +-- Code almost all copied. +-- +module Plugin.Where (theModule) where + +import Plugin +import qualified Data.ByteString.Char8 as P +import qualified Data.Map as M + +PLUGIN Where + +type WhereState = M.Map P.ByteString P.ByteString +type WhereWriter = WhereState -> LB () +type Where m a = ModuleT WhereState m a + +instance Module WhereModule WhereState where + + moduleCmds _ = ["where", "url", "what", "where+" ] + moduleHelp _ s = case s of + "where" -> "where . Return element associated with key" + "what" -> "what . Return element associated with key" + "url" -> "url . Return element associated with key" + + "where+" -> "where+ . Define an association" + + moduleDefState _ = return M.empty + moduleSerialize _ = Just mapPackedSerial + + process_ _ cmd rest = list $ withMS $ \factFM writer -> + case words rest of + [] -> return "@where , return element associated with key" + (fact:dat) -> processCommand factFM writer + (lowerCaseString fact) cmd (unwords dat) + +------------------------------------------------------------------------ + +processCommand :: WhereState -> WhereWriter + -> String -> String -> String -> Where LB String + +processCommand factFM writer fact cmd dat = case cmd of + "where" -> return $ getWhere factFM fact + "what" -> return $ getWhere factFM fact -- an alias + "url" -> return $ getWhere factFM fact -- an alias + "where+" -> updateWhere True factFM writer fact dat + _ -> return "Unknown command." + +getWhere :: WhereState -> String -> String +getWhere fm fact = + case M.lookup (P.pack fact) fm of + Nothing -> "I know nothing about " ++ fact ++ "." + Just x -> P.unpack x + +updateWhere :: Bool -> WhereState -> WhereWriter -> String -> String -> Where LB String +updateWhere _guard factFM writer fact dat = do + writer $ M.insert (P.pack fact) (P.pack dat) factFM + return "Done." + diff --git a/README b/README new file mode 100644 --- /dev/null +++ b/README @@ -0,0 +1,57 @@ + _ _ _ _ _ +/ \ / | | \ / | | \_ +| | ___ _ _ _ _ | \__ __/ | ___ _ | \__ ____ | _| +| | / _` || ` ` || _ \ / _ |/ _` || _ \ / _ \ | | +| \__ | |_| || | | || |_| || |_| || |_| || |_| || |_| || \__ +\____|\___,_/|_|_|_|\____/ \____/\___,_/\____/ \____/ \____| + +BUILDING: + +You'll need GHC >= 6.4 + +Build the Data.ByteString library at http://www.cse.unsw.edu.au/~dons, +version 0.7 and later are ok. + +Build with cabal (simple) + $ vi Config.hs + $ chmod +x configure Setup.hs build + $ ./Setup.hs configure --bindir=`pwd` + $ ./build + $ ./lambdabot + +Or with ghci (fastest turn around). But first you have to build with +cabal as above anyway. So this is mostly for development purposes. + $ vi Config.hs + $ sh configure + $ sh ghci Main.hs +then + *Main> main +or + *Main> online + +OFFLINE MODE: + ./lambdabot + +CONNECTING: + ./lambdabot --online + +SCRIPTS: + The scripts directory contains some shell scripts for Vim editor support + They are self-explanatory + +BUGS: + +Bug reports, patches, new modules etc, contact: + + Don Stewart + aka dons on #haskell + +REPOSITORY: + +Our darcs repository is located at: + http://www.cse.unsw.edu.au/~dons/lambdabot + +CONTRIBUTING: + +Use 'darcs send' to submit patches to dons. Add yourself to the AUTHORS +file if you haven't already. diff --git a/STYLE b/STYLE new file mode 100644 --- /dev/null +++ b/STYLE @@ -0,0 +1,110 @@ +---------------------------------------------------------------------------- +This document describes various style recommendations for the +lambdabot code. The goal is that all of the lambdabot source code should +respect this style guide, although it is not yet the case. You are therefore +encouraged to change source code such that it fits the style guide. +---------------------------------------------------------------------------- + +*** Import lists + +{{{ + +module QuoteModule ( + Type(..), + value1, + value2, + ) +}}} + +*** RCS tags + +$Id .. $ tags should be removed, as we are using darcs now. + +*** Order of imports + +import statements should be ordered as so: +{{{ + Local application + Local application qualified/as + + Old-style Haskell2 modules + Data.* + Control.* + System.* + + GHC.* +}}} + +*** Function naming conventions + +The convention for naming functions are as follows: + +* Give meaningful names to functions. ``splitFirstWord'' is a good name, + but ``fooFunc'' is not. + +* When composing multiple words into a function name, do not separate them + with a underscore (``_'') character. Just concatenate the words together. + +* The first word is written in all lowercase. The words following are + capitalized. + +Thus one should write: + +splitFirstWord, join, breakOnGlue, debugStr, lookupSet, etc. + +*** Use hierarchical modules + +Old style non-hierarchical module imports should be replaced with +their hierachial module counterpart. The List module, as an example, +should be replaced with Data.List. + +*** Use non-deprecated modules + +Deprecated modules should be replaced by their non-deprecated +counterparts since it prevents bitrot of the source code. + +*** Minimalize namespace + +The namespace of a module should be minimized. Restrict imports such +that only used function calls and data types are imported. Furthermore +use qualified imports to split of the namespace in comprehensible parts. + +-ddump-minimal-imports is useful for keeping a lid on this. + +*** Provide explicit type signatures + +We require all source code to build with -Werror. As a consequence +explicit type signatures for all functions should be provided. + +*** Haddock documentation + +We use Haddock as an API documentation tool. You should therefore +provide haddock comments for all exported functions, and preferably +for internal functions too. Proper documentation in Haddock will +provide other people an easier access to your modules, and will make +it easier to spot intent or catch errors. + +*** Portability + +Provide portable source code that works with ghc >= 6.2.2. Lambdabot +has a number of portability layer modules to ease the transition; the +most prominent being Map.hs, as it provides a portability layer to +Data.Map/Data.FiniteMap. + +*** More references + +We try to adopt the coding guidelines of the GHC project. Take a look at +the GHC libraries, in particular Data.Map, as the library modules follows +the guiding principles well. + +*** Writing Module instances + +moduleHelp should be provided for each command. +The help format is: + "command . Description goes here" + +No leading @ should be prefixed to the command (as this is meaningless +in offline mode). The command should end in a fullstop, followed by a +sentence or two describing the command. + +Check in offline mode that 'help command' looks good. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMainWithHooks defaultUserHooks diff --git a/Shared.hs b/Shared.hs new file mode 100644 --- /dev/null +++ b/Shared.hs @@ -0,0 +1,29 @@ +-- +-- Copyright (c) 2005 Don Stewart - http://www.cse.unsw.edu.au/~dons +-- GPL version 2 or later (see http://www.gnu.org/copyleft/gpl.html) +-- + +-- | Shared types between static and dynamic code. This is the only +-- module that is linked both statically and dynamically. (And doing so +-- breaks us from running the whole of the bot in ghci -- so sue me). +-- + +module Shared (Module(..), Symbol, DynLoad(..)) where + +type Symbol = String + +newtype Module = Module String {- unique module identifier -} + +-- | Operations provided by the dynamic linker linked into the static +-- core. A DynLoad value is passed from there to the dynamic code, for +-- use by DynamicModule +-- +-- Possibly want to treat this as an existential, ala MODULE +-- +-- could add to DynLoad, Typeable a => ... +-- +data DynLoad = DynLoad { + dynload :: forall a. FilePath -> Symbol -> IO (Module,a), + unload :: Module -> IO () + } + diff --git a/State/djinn b/State/djinn new file mode 100644 --- /dev/null +++ b/State/djinn @@ -0,0 +1,7 @@ +"data T x = (x,x,x)" +"data () = ()" +"data Either a b = Left a | Right b" +"data Maybe a = Nothing | Just a" +"data Bool = False | True" +"data Void = " +"type Not x = x -> Void" diff --git a/State/fact b/State/fact new file mode 100644 --- /dev/null +++ b/State/fact @@ -0,0 +1,32 @@ +breakfast +Meal that usually breaks fasts. +bzip2 +bzip2 is an open source data compression algorithm and program developed by Julian Seward. Seward made the first public release of bzip2, version 0.15, in July 1996. He's also known as a GHC hacker. +dsl +Domain specific language +fact +A fact is a fact is a fact is a fact. Or not. +ghc +Haskell implementation +gibbardish +To the casual reader, Gibbardish is virtually incomprehensible, yet alludes of a deep philosophical significance just outside one's understanding. +glasgow-exts +http://www.haskell.org/ghc/docs/latest/html/users_guide/ghc-language-features.html +haskell +Haskell is the language of choice for discriminating hackers. +hsu +I know nothing about Haskell Secret Underground. +lambdabot +Lambdabot is a bot of curious opinions, and is female. +libdpf +an LGPL licensed plain C pdf reading library. +pizza +Eat pizza, but don't let it eat you. +pseudonym +My initial creator. +reader-monads +Reader monads have properties which go beyond those of just commutative monads. For example, m (a -> b) and a -> m b are isomorphic and so are m (a,b) and (m a, m b). When you are using implicit parameters, you are exploiting these properties all the time, and it's really cumbersome to do the same thing explicitely. +recursion +recursion +tmr +The Monad.Reader http://www.haskell.org/tmrwiki/FrontPage diff --git a/State/haddock b/State/haddock new file mode 100644 --- /dev/null +++ b/State/haddock @@ -0,0 +1,29939 @@ +ABGR +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ADDATTRS +Text.Html + +AF_APPLETALK +Network.Socket + +AF_AX25 +Network.Socket + +AF_DECnet +Network.Socket + +AF_INET +Network.Socket + +AF_INET6 +Network.Socket + +AF_IPX +Network.Socket + +AF_ROUTE +Network.Socket + +AF_SNA +Network.Socket + +AF_UNIX +Network.Socket + +AF_UNSPEC +Network.Socket + +AF_X25 +Network.Socket + +ALPHA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +AToA +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AbsoluteSeek +System.IO + +Accum +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AccumBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AccumBufferAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AccumOp +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Action +Distribution.Setup + +ActionOnWindowClose +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +AcyclicSCC +Data.Graph + +Add +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AddSigned +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AddUnsigned +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AddUnsigned' +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Adj +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +AlgConstr +Data.Generics.Basics +Data.Generics + +AlgRep +Data.Generics.Basics +Data.Generics + +Alignment +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +AllClientAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AllRightsReserved +Distribution.License +Distribution.Make +Distribution.Simple + +AllServerAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AllowDirectContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +AllowEvents +Graphics.X11.Types +Graphics.X11.Xlib + +AllowExposuresMode +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +AllowIncoherentInstances +Distribution.Extension +Distribution.Simple + +AllowOverlappingInstances +Distribution.Extension +Distribution.Simple + +AllowUndecidableInstances +Distribution.Extension +Distribution.Simple + +Alpha +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Alpha' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Alpha12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Alpha16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Alpha4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Alpha8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Always +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Ambient +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AmbientAndDiffuse +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +And +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AndInverted +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AndReverse +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Angle +Graphics.HGL.Units +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +AnnotatedVertex +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AnyVersion +Distribution.Version +Distribution.Simple + +AppE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +AppT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +AppendMode +System.IO + +AppendOnWrite +System.Posix.IO +System.Posix + +April +System.Time + +Arbitrary +Test.QuickCheck +Debug.QuickCheck + +Arc +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +ArcMode +Graphics.X11.Types +Graphics.X11.Xlib + +Arg +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Arg0 +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Arg1 +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Arg2 +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Arg3 +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ArgDescr +Distribution.GetOpt +System.Console.GetOpt + +ArgNum +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ArgOrder +Distribution.GetOpt +System.Console.GetOpt + +Args +Distribution.Simple + +ArgumentLimit +System.Posix.Unistd +System.Posix + +ArithException +Control.Exception +Control.Exception + +ArithSeqE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Array +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff + +ArrayBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ArrayException +Control.Exception +Control.Exception + +ArrayIndex +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Arrow +Control.Arrow + +ArrowApply +Control.Arrow + +ArrowChoice +Control.Arrow + +ArrowLoop +Control.Arrow + +ArrowMonad +Control.Arrow +Control.Arrow + +ArrowPlus +Control.Arrow + +ArrowT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ArrowZero +Control.Arrow + +Arrows +Distribution.Extension +Distribution.Simple + +AsP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Assertable +Test.HUnit.Base +Test.HUnit + +Assertion +Test.HUnit.Lang +Test.HUnit.Base +Test.HUnit + +AssertionFailed +Control.Exception + +AssertionPredicable +Test.HUnit.Base +Test.HUnit + +AssertionPredicate +Test.HUnit.Base +Test.HUnit + +Assoc +Control.Parallel.Strategies +Text.ParserCombinators.Parsec.Expr + +AssocLeft +Text.ParserCombinators.Parsec.Expr + +AssocNone +Text.ParserCombinators.Parsec.Expr + +AssocRight +Text.ParserCombinators.Parsec.Expr + +AsyncException +Control.Exception +Control.Exception + +AsyncIOAvailable +System.Posix.Files +System.Posix + +Atom +Graphics.X11.Types +Graphics.X11.Xlib + +AttributeMask +Graphics.X11.Types +Graphics.X11.Xlib + +August +System.Time + +AuxBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +AxisCount +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +a +Data.Graph.Inductive.Example + +a' +Data.Graph.Inductive.Example + +aNY_PORT +Network.Socket + +aRC +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +aTOM +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +ab +Data.Graph.Inductive.Example + +ab' +Data.Graph.Inductive.Example + +abb +Data.Graph.Inductive.Example + +abb' +Data.Graph.Inductive.Example + +above +Text.Html +Text.Html.BlockTable + +aboves +Text.Html + +abs +Prelude + +accept +Network +Network.Socket + +accessModes +System.Posix.Files +System.Posix + +accessTime +System.Posix.Files +System.Posix + +accum +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +accumArray +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array + +accumBits +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +accumBufferDepths +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +accumFM +Data.Graph.Inductive.Internal.FiniteMap + +acos +Prelude + +acosh +Prelude + +action +Text.Html + +actionOnWindowClose +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +activateScreenSaver +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +activeStencilFace +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +activeTexture +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +addDefun +System.Console.Readline + +addErrorMessage +Text.ParserCombinators.Parsec.Error + +addFinalizer +System.Mem.Weak + +addForeignPtrFinalizer +Foreign.Concurrent +Foreign.ForeignPtr +Foreign + +addHistory +System.Console.Readline + +addListToFM +Data.FiniteMap + +addListToFM_C +Data.FiniteMap + +addMVarFinalizer +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +addSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +addTimerCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +addToClockTime +System.Time + +addToFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +addToFM_C +Data.FiniteMap + +addToQueue +Data.Queue + +addToSaveSet +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +addToSet +Data.Set + +addUndo +System.Console.Readline + +address +Text.Html + +adjust +Data.IntMap +Data.Map + +adjustWithKey +Data.IntMap +Data.Map + +advancePtr +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +afile +Text.Html + +aliasedLineWidthRange +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +aliasedPointSizeRange +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +align +Text.Html + +alignPtr +Foreign.Ptr +Foreign + +alignment +Foreign.Storable +Foreign + +alink +Text.Html + +all +Data.List +Prelude + +allPlanes_aux +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +allocAll +Graphics.X11.Types +Graphics.X11.Xlib + +allocColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +allocNamedColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +allocNone +Graphics.X11.Types +Graphics.X11.Xlib + +alloca +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +alloca' +Graphics.X11.Xlib.Types + +allocaArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +allocaArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +allocaBytes +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +allocaColor +Graphics.X11.Xlib.Types + +allocaRectangle +Graphics.X11.Xlib.Types + +allocaXEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +allocaXSetWindowAttributes +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +allowEvents +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +allowExposures +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +alpha +Language.Haskell.TH.Lib + +alphaFunc +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +alphaNum +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +alphaScale +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +alreadyExistsErrorType +System.IO.Error + +alreadyGrabbed +Graphics.X11.Types +Graphics.X11.Xlib + +alreadyInUseErrorType +System.IO.Error + +alt +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Text.Html + +altcode +Text.Html + +always +Graphics.X11.Types +Graphics.X11.Xlib + +amPm +System.Locale + +amap +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff + +ambient +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +anchor +Text.Html + +and +Data.List +Prelude + +andRegion +Graphics.SOE + +angles +Text.ParserCombinators.Parsec.Token + +annotateIOError +System.IO.Error + +any +Data.List +Prelude + +anyChar +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +anyModifier +Graphics.X11.Types +Graphics.X11.Xlib + +anyToken +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +ap +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List +Data.Graph.Inductive.Query.ArtPoint +Data.Graph.Inductive.Query +Data.Graph.Inductive + +app +Control.Arrow + +appE +Language.Haskell.TH.Lib +Language.Haskell.TH + +appPrec +Language.Haskell.TH.Ppr + +appT +Language.Haskell.TH.Lib +Language.Haskell.TH + +append +System.Posix.IO +System.Posix + +appendFile +System.IO +Prelude + +appendPS +Data.PackedString + +applet +Text.Html + +apply +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +apply' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +applyWith +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +applyWith' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +approxRational +Data.Ratio + +appsE +Language.Haskell.TH.Lib +Language.Haskell.TH + +aqua +Text.Html + +arbitrary +Test.QuickCheck +Debug.QuickCheck + +arc +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +arcChord +Graphics.X11.Types +Graphics.X11.Xlib + +arcPieSlice +Graphics.X11.Types +Graphics.X11.Xlib + +arch +System.Info + +archive +Text.Html + +areTexturesResident +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +area +Text.Html + +argAlpha +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +argRGB +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +arguments +Test.QuickCheck +Debug.QuickCheck + +arithExceptions +Control.Exception + +arithSeqE +Language.Haskell.TH.Lib +Language.Haskell.TH + +arr +Control.Arrow + +array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array + +arrayBufferBinding +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +arrayElement +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +arrayPointer +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +arrowT +Language.Haskell.TH.Lib +Language.Haskell.TH + +asKeyEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +asP +Language.Haskell.TH.Lib +Language.Haskell.TH + +asTypeOf +Prelude + +as_name +Language.Haskell.Syntax + +ascentFromFontStruct +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +asin +Prelude + +asinh +Prelude + +ask +Control.Monad.Reader +Control.Monad.RWS + +asks +Control.Monad.Reader +Control.Monad.RWS + +assert +Control.Exception +Test.HUnit.Base +Test.HUnit + +assertBool +Test.HUnit.Base +Test.HUnit + +assertEqual +Test.HUnit.Base +Test.HUnit + +assertFailure +Test.HUnit.Lang +Test.HUnit.Base +Test.HUnit + +assertString +Test.HUnit.Base +Test.HUnit + +assertionPredicate +Test.HUnit.Base +Test.HUnit + +assertions +Control.Exception + +assocs +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.IntMap +Data.Map +Data.Array + +asyncBoth +Graphics.X11.Types +Graphics.X11.Xlib + +asyncExceptions +Control.Exception + +asyncKeyboard +Graphics.X11.Types +Graphics.X11.Xlib + +asyncPointer +Graphics.X11.Types +Graphics.X11.Xlib + +atan +Prelude + +atan2 +Prelude + +atanh +Prelude + +atomicModifyIORef +Data.IORef + +atomically +GHC.Conc +Control.Concurrent.STM + +attachMenu +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +attenuation +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +augment +GHC.Exts + +augmentGraph +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +author +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +authority +Network.URI + +auto +Distribution.Simple.GHCPackageConfig + +autoNormal +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +autoRepeatOff +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +autoRepeatOn +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +auxBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +awaitSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +B0 +System.Posix.Terminal +System.Posix + +B110 +System.Posix.Terminal +System.Posix + +B1200 +System.Posix.Terminal +System.Posix + +B134 +System.Posix.Terminal +System.Posix + +B150 +System.Posix.Terminal +System.Posix + +B1800 +System.Posix.Terminal +System.Posix + +B19200 +System.Posix.Terminal +System.Posix + +B200 +System.Posix.Terminal +System.Posix + +B2400 +System.Posix.Terminal +System.Posix + +B300 +System.Posix.Terminal +System.Posix + +B38400 +System.Posix.Terminal +System.Posix + +B4800 +System.Posix.Terminal +System.Posix + +B50 +System.Posix.Terminal +System.Posix + +B600 +System.Posix.Terminal +System.Posix + +B75 +System.Posix.Terminal +System.Posix + +B9600 +System.Posix.Terminal +System.Posix + +BETA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +BGR +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BGRA +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BSD3 +Distribution.License +Distribution.Make +Distribution.Simple + +BSD4 +Distribution.License +Distribution.Make +Distribution.Simple + +BToB +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Back +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BackBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BackLeftBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BackRightBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BackgroundWriteInterrupt +System.Posix.Terminal +System.Posix + +BackingStore +Graphics.X11.Types +Graphics.X11.Xlib + +Baseline +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +BaudRate +System.Posix.Terminal +System.Posix + +BeginsBoundaryEdge +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BeginsInteriorEdge +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BindS +Language.Haskell.TH.Syntax +Language.Haskell.TH + +BitGravity +Graphics.X11.Types +Graphics.X11.Xlib + +Bitmap +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BitmapFont +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +BitmapToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Bits +Data.Bits +Foreign + +BitsPerPlane +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +BkMode +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Black +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +Blend +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BlendEquation +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BlendingFactor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BlockBuffering +System.IO + +BlockTable +Text.Html.BlockTable + +BlockedIndefinitely +Control.Exception + +BlockedOnDeadMVar +Control.Exception + +Blue +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Body +Language.Haskell.TH.Syntax +Language.Haskell.TH + +BodyQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Bool +Data.Bool +Prelude + +Border +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BothQueues +System.Posix.Terminal +System.Posix + +Bottom +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +BottomLeftCorner +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +BottomRightCorner +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +BottomSide +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Bound +Network.Socket + +Bounded +Prelude + +Bounds +Data.Graph + +Broadcast +Network.Socket + +Brush +Graphics.HGL.Draw.Brush +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Buffer +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +BufferAccess +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BufferDepth +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +BufferMode +System.IO +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BufferObject +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BufferTarget +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BufferUsage +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +BuildCmd +Distribution.Setup + +BuildInfo +Distribution.PackageDescription +Distribution.PackageDescription + +Button +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.X11.Types +Graphics.X11.Xlib + +ButtonCount +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +ButtonIndex +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +ButtonMask +Graphics.X11.Types +Graphics.X11.Xlib + +Byte +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +ByteCount +System.Posix.Types +System.Posix + +ByteOrder +Graphics.X11.Types +Graphics.X11.Xlib + +b +Data.Graph.Inductive.Example + +b' +Data.Graph.Inductive.Example + +bITMAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +background +Text.Html + +backgroundRead +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +backgroundWrite +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +badAccess +Graphics.X11.Types +Graphics.X11.Xlib + +badAlloc +Graphics.X11.Types +Graphics.X11.Xlib + +badAtom +Graphics.X11.Types +Graphics.X11.Xlib + +badColor +Graphics.X11.Types +Graphics.X11.Xlib + +badCursor +Graphics.X11.Types +Graphics.X11.Xlib + +badDrawable +Graphics.X11.Types +Graphics.X11.Xlib + +badFont +Graphics.X11.Types +Graphics.X11.Xlib + +badGC +Graphics.X11.Types +Graphics.X11.Xlib + +badIDChoice +Graphics.X11.Types +Graphics.X11.Xlib + +badImplementation +Graphics.X11.Types +Graphics.X11.Xlib + +badLength +Graphics.X11.Types +Graphics.X11.Xlib + +badMatch +Graphics.X11.Types +Graphics.X11.Xlib + +badName +Graphics.X11.Types +Graphics.X11.Xlib + +badPixmap +Graphics.X11.Types +Graphics.X11.Xlib + +badRequest +Graphics.X11.Types +Graphics.X11.Xlib + +badSystemCall +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +badValue +Graphics.X11.Types +Graphics.X11.Xlib + +badWindow +Graphics.X11.Types +Graphics.X11.Xlib + +base +Text.Html + +basefont +Text.Html + +basicStanzaFields +Distribution.PackageDescription + +bcc +Data.Graph +Data.Graph.Inductive.Query.BCC +Data.Graph.Inductive.Query +Data.Graph.Inductive + +beginUndoGroup +System.Console.Readline + +bell +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +beside +Text.Html +Text.Html.BlockTable + +besides +Text.Html + +between +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +betweenVersionsInclusive +Distribution.Version +Distribution.Simple + +bfe +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bfen +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bfs +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bfsWith +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bfsn +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bfsnWith +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bft +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +bgcolor +Text.Html + +big +Text.Html + +bindBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +bindKey +System.Console.Readline + +bindKeyInMap +System.Console.Readline + +bindQ +Language.Haskell.TH.Syntax + +bindS +Language.Haskell.TH.Lib +Language.Haskell.TH + +bindSocket +Network.Socket + +bit +Data.Bits +Foreign + +bitSize +Data.Bits +Foreign + +bitmap +Graphics.Rendering.OpenGL.GL.Bitmaps +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +bitmapBitOrder +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +bitmapPad +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +bitmapUnit +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +bitsPerByte +System.Posix.Terminal +System.Posix + +black +Text.Html + +blackPixel +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +blackPixelOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +blend +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +blendColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +blendEquation +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +blendFunc +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +blendFuncSeparate +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +block +Control.Exception + +blockSignals +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +blockquote +Text.Html + +blue +Text.Html + +body +Text.Html + +bold +Text.Html + +border +Text.Html + +bordercolor +Text.Html + +bottom +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +bounds +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff +Data.Array + +br +Text.Html + +braces +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +bracket +Control.Exception +Distribution.Compat.Exception +Graphics.HGL.Draw.Monad +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +bracket_ +Control.Exception +Graphics.HGL.Draw.Monad +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +brackets +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +break +Data.List +Prelude + +breakPS +Data.PackedString + +breakpointTrap +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +bufferAccess +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +bufferData +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +bufferMapped +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +bufferSubData +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +build +Data.Graph.Inductive.Internal.Heap +Distribution.Simple.Build +GHC.Exts + +build1DMipmaps +Graphics.Rendering.OpenGL.GLU.Mipmapping +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +build2DMipmaps +Graphics.Rendering.OpenGL.GLU.Mipmapping +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +buildDepends +Distribution.PackageDescription + +buildDir +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +buildExpressionParser +Text.ParserCombinators.Parsec.Expr + +buildG +Data.Graph + +buildGr +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +buildInfo +Distribution.PackageDescription + +buildable +Distribution.PackageDescription + +bullet +Text.Html + +busError +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +button1 +Graphics.X11.Types +Graphics.X11.Xlib + +button1Mask +Graphics.X11.Types +Graphics.X11.Xlib + +button1MotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +button2 +Graphics.X11.Types +Graphics.X11.Xlib + +button2Mask +Graphics.X11.Types +Graphics.X11.Xlib + +button2MotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +button3 +Graphics.X11.Types +Graphics.X11.Xlib + +button3Mask +Graphics.X11.Types +Graphics.X11.Xlib + +button3MotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +button4 +Graphics.X11.Types +Graphics.X11.Xlib + +button4Mask +Graphics.X11.Types +Graphics.X11.Xlib + +button4MotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +button5 +Graphics.X11.Types +Graphics.X11.Xlib + +button5Mask +Graphics.X11.Types +Graphics.X11.Xlib + +button5MotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +buttonMotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +buttonPress +Graphics.X11.Types +Graphics.X11.Xlib + +buttonPressMask +Graphics.X11.Types +Graphics.X11.Xlib + +buttonRelease +Graphics.X11.Types +Graphics.X11.Xlib + +buttonReleaseMask +Graphics.X11.Types +Graphics.X11.Xlib + +C# +GHC.Exts + +C3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +C4fN3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +C4ubV2f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +C4ubV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CCW +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CCall +Language.Haskell.TH.Syntax +Language.Haskell.TH + +CCc +System.Posix.Types +System.Posix + +CChar +Foreign.C.Types +Foreign.C + +CClock +Foreign.C.Types +Foreign.C + +CDev +System.Posix.Types +System.Posix + +CDouble +Foreign.C.Types +Foreign.C + +CFile +Foreign.C.Types +Foreign.C + +CFloat +Foreign.C.Types +Foreign.C + +CFpos +Foreign.C.Types +Foreign.C + +CFun +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +CGid +System.Posix.Types +System.Posix + +CIno +System.Posix.Types +System.Posix + +CInt +Foreign.C.Types +Foreign.C + +CJmpBuf +Foreign.C.Types +Foreign.C + +CLDouble +Foreign.C.Types +Foreign.C + +CLLong +Foreign.C.Types +Foreign.C + +CLong +Foreign.C.Types +Foreign.C + +CMYK +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CMYKA +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CMode +System.Posix.Types +System.Posix + +CNlink +System.Posix.Types +System.Posix + +COff +System.Posix.Types +System.Posix + +CPP +Distribution.Extension +Distribution.Simple + +CPid +System.Posix.Types +System.Posix + +CPtrdiff +Foreign.C.Types +Foreign.C + +CRLim +System.Posix.Types +System.Posix + +CSChar +Foreign.C.Types +Foreign.C + +CShort +Foreign.C.Types +Foreign.C + +CSigAtomic +Foreign.C.Types +Foreign.C + +CSize +Foreign.C.Types +Foreign.C + +CSpeed +System.Posix.Types +System.Posix + +CSsize +System.Posix.Types +System.Posix + +CString +Foreign.C.String +Foreign.C + +CStringLen +Foreign.C.String +Foreign.C + +CTcflag +System.Posix.Types +System.Posix + +CTime +Foreign.C.Types +Foreign.C + +CUChar +Foreign.C.Types +Foreign.C + +CUInt +Foreign.C.Types +Foreign.C + +CULLong +Foreign.C.Types +Foreign.C + +CULong +Foreign.C.Types +Foreign.C + +CUShort +Foreign.C.Types +Foreign.C + +CUid +System.Posix.Types +System.Posix + +CW +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CWString +Foreign.C.String +Foreign.C + +CWStringLen +Foreign.C.String +Foreign.C + +CWchar +Foreign.C.Types +Foreign.C + +CalendarTime +System.Time +System.Time + +Callback +System.Console.Readline + +Callconv +Language.Haskell.TH.Syntax +Language.Haskell.TH + +CapStyle +Graphics.X11.Types +Graphics.X11.Xlib + +Capability +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CaseE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Catch +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +CatchOnce +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +Center +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Chan +Control.Concurrent.Chan +Control.Concurrent + +ChangeSaveSetMode +Graphics.X11.Types +Graphics.X11.Xlib + +Char +Data.Char +Prelude +GHC.Exts +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Text.Read.Lex +Text.Read + +CharL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +CharParser +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +CharStruct +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +CheckParity +System.Posix.Terminal +System.Posix + +ChildLimit +System.Posix.Unistd +System.Posix + +Chr +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +CirculationDirection +Graphics.X11.Types +Graphics.X11.Xlib + +Clamp +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClampToBorder +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClampToEdge +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Clamping +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClassD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ClassI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ClassOpI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Clause +Language.Haskell.TH.Syntax +Language.Haskell.TH +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ClauseQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +CleanCmd +Distribution.Setup + +Clear +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClearBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClientArrayType +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClientAttributeGroup +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClipPlaneName +Graphics.Rendering.OpenGL.GL.Clipping +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Clipping +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ClockTick +System.Posix.Types +System.Posix +System.Posix.Unistd +System.Posix + +ClockTime +System.Time + +CloseCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +CloseDownMode +Graphics.X11.Types +Graphics.X11.Xlib + +CloseOnExec +System.Posix.IO +System.Posix + +Closed +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +Collect +Data.Graph.Inductive.Internal.Thread + +Color +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +Color3 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Color4 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorBufferAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorIndex +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorInfo +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorMaterialParameter +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ColorTableStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Colormap +Graphics.X11.Types +Graphics.X11.Xlib + +ColormapAlloc +Graphics.X11.Types +Graphics.X11.Xlib + +ColormapNotification +Graphics.X11.Types +Graphics.X11.Xlib + +Column +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +ColumnMajor +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Combine +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Combine4 +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Combiner +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ComparisonFunction +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Compile +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompileAndExecute +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Compiler +Distribution.Setup +Distribution.Setup + +CompilerFlavor +Distribution.Setup + +Complex +Data.Complex + +ComplexContour +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ComplexPolygon +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedAlpha +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedIntensity +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedLuminance +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedLuminanceAlpha +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedPixelData +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedRGB +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedRGBA +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CompressedTextureFormat +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Con +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ConE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ConIndex +Data.Generics.Basics +Data.Generics + +ConP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ConQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +ConT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +CondE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Cone +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +Config +Test.QuickCheck +Debug.QuickCheck +Test.QuickCheck +Debug.QuickCheck + +ConfigCmd +Distribution.Setup + +ConfigFlags +Distribution.Setup +Distribution.Setup + +Connected +Network.Socket + +Constant +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ConstantAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ConstantBorder +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ConstantColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Constr +Data.Generics.Basics +Data.Generics + +ConstrRep +Data.Generics.Basics +Data.Generics + +Cont +Control.Monad.Cont +Control.Monad.Cont + +ContT +Control.Monad.Cont +Control.Monad.Cont + +Context +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +Context' +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +ContextStack +Distribution.Extension +Distribution.Simple + +ContinueExectuion +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +ControlCharacter +System.Posix.Terminal +System.Posix + +ControlPoint +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Convolution1D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Convolution2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ConvolutionBorderMode +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ConvolutionTarget +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CoordinateMode +Graphics.X11.Types +Graphics.X11.Xlib + +Copy +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CopyCmd +Distribution.Setup + +CopyColor +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CopyDepth +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CopyFlags +Distribution.Setup + +CopyInverted +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CopyPixelToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CopyStencil +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Counts +Test.HUnit.Base +Test.HUnit +Test.HUnit.Base +Test.HUnit + +CreateNewContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Crossbar +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Crosshair +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Crossing +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +CrossingCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Cube +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +CubeMapTarget +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CurrentAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +CurrentUnit +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Cursor +Graphics.UI.GLUT.Window +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +Cxt +Language.Haskell.TH.Syntax +Language.Haskell.TH + +CxtQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Cyan +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +Cycle +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +CyclicSCC +Data.Graph + +Cylinder +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Cylinder' +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +c +Data.Graph.Inductive.Example + +c' +Data.Graph.Inductive.Example + +cAP_HEIGHT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cARDINAL +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cCall +Language.Haskell.TH.Lib +Language.Haskell.TH + +cOLORMAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cOPYRIGHT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cSources +Distribution.PackageDescription + +cURSOR +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER0 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER1 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER2 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER3 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER4 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER5 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER6 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cUT_BUFFER7 +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +cWBackPixel +Graphics.X11.Types +Graphics.X11.Xlib + +cWBackPixmap +Graphics.X11.Types +Graphics.X11.Xlib + +cWBackingPixel +Graphics.X11.Types +Graphics.X11.Xlib + +cWBackingPlanes +Graphics.X11.Types +Graphics.X11.Xlib + +cWBackingStore +Graphics.X11.Types +Graphics.X11.Xlib + +cWBitGravity +Graphics.X11.Types +Graphics.X11.Xlib + +cWBorderPixel +Graphics.X11.Types +Graphics.X11.Xlib + +cWBorderPixmap +Graphics.X11.Types +Graphics.X11.Xlib + +cWColormap +Graphics.X11.Types +Graphics.X11.Xlib + +cWCursor +Graphics.X11.Types +Graphics.X11.Xlib + +cWDontPropagate +Graphics.X11.Types +Graphics.X11.Xlib + +cWEventMask +Graphics.X11.Types +Graphics.X11.Xlib + +cWOverrideRedirect +Graphics.X11.Types +Graphics.X11.Xlib + +cWSaveUnder +Graphics.X11.Types +Graphics.X11.Xlib + +cWWinGravity +Graphics.X11.Types +Graphics.X11.Xlib + +c_dlclose +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +c_dlerror +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +c_dlopen +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +c_dlsym +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +c_includes +Distribution.Simple.GHCPackageConfig + +calendarTimeToString +System.Time + +callCC +Control.Monad.Cont + +callList +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +callLists +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +callbackHandlerInstall +System.Console.Readline + +callbackReadChar +System.Console.Readline + +canReadLocalPackageConfig +Distribution.Simple.GHCPackageConfig + +canWriteLocalPackageConfig +Distribution.Simple.GHCPackageConfig + +canonicalizePath +System.Directory +Distribution.Compat.Directory + +capButt +Graphics.X11.Types +Graphics.X11.Xlib + +capNotLast +Graphics.X11.Types +Graphics.X11.Xlib + +capProjecting +Graphics.X11.Types +Graphics.X11.Xlib + +capRound +Graphics.X11.Types +Graphics.X11.Xlib + +caption +Text.Html + +cardinality +Data.Set + +caseE +Language.Haskell.TH.Lib +Language.Haskell.TH + +caseIndent +Language.Haskell.Pretty + +caseSensitive +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +cases +Test.HUnit.Base +Test.HUnit + +cast +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +castCCharToChar +Foreign.C.String +Foreign.C + +castCharToCChar +Foreign.C.String +Foreign.C + +castForeignPtr +Foreign.ForeignPtr +Foreign + +castFunPtr +Foreign.Ptr +Foreign + +castFunPtrToPtr +Foreign.Ptr +Foreign + +castIOUArray +Data.Array.IO + +castPtr +Foreign.Ptr +Foreign + +castPtrToFunPtr +Foreign.Ptr +Foreign + +castPtrToStablePtr +Foreign.StablePtr +Foreign + +castSTUArray +Data.Array.ST + +castStablePtrToPtr +Foreign.StablePtr +Foreign + +cat +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +catMaybes +Data.Maybe + +catch +Control.Exception +System.IO.Error +Prelude + +catchDyn +Control.Exception + +catchError +Control.Monad.Error + +catchJust +Control.Exception + +catchSTM +GHC.Conc +Control.Concurrent.STM + +category +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +ccOptions +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +ceiling +Prelude + +cell +Text.Html + +cellpadding +Text.Html + +cellsOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +cellspacing +Text.Html + +censor +Control.Monad.Writer +Control.Monad.RWS + +center +Text.Html + +centerGravity +Graphics.X11.Types +Graphics.X11.Xlib + +chainl +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +chainl1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +chainr +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +chainr1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +changeFileExt +Distribution.Compat.FilePath + +changeSaveSet +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +changeWorkingDirectory +System.Posix.Directory +System.Posix + +changeWorkingDirectoryFd +System.Posix.Directory +System.Posix + +char +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +charIsRepresentable +Foreign.C.String +Foreign.C + +charL +Language.Haskell.TH.Lib +Language.Haskell.TH + +charLiteral +Text.ParserCombinators.Parsec.Token + +check +Control.Concurrent.STM +Test.QuickCheck +Debug.QuickCheck + +checkForError +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +checkMaskEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +checkResult +GHC.Dotnet + +checkTypedEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +checkTypedWindowEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +checkWindowEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +checkbox +Text.Html + +checked +Text.Html + +childSystemTime +System.Posix.Process +System.Posix + +childUserTime +System.Posix.Process +System.Posix + +choice +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +choiceMp +Data.Generics.Aliases +Data.Generics + +choiceQ +Data.Generics.Aliases +Data.Generics + +choose +Test.QuickCheck +Debug.QuickCheck + +chr +Data.Char + +circulateNotify +Graphics.X11.Types +Graphics.X11.Xlib + +circulateRequest +Graphics.X11.Types +Graphics.X11.Xlib + +circulateSubwindows +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +circulateSubwindowsDown +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +circulateSubwindowsUp +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +cis +Data.Complex + +cite +Text.Html + +classD +Language.Haskell.TH.Lib +Language.Haskell.TH + +classIndent +Language.Haskell.Pretty + +classify +Test.QuickCheck +Debug.QuickCheck + +clause +Language.Haskell.TH.Lib +Language.Haskell.TH + +cleanupAfterSignal +System.Console.Readline + +clear +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Text.Html + +clearAccum +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clearArea +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +clearBit +Data.Bits +Foreign + +clearColor +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clearDepth +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clearIndex +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clearMessage +System.Console.Readline + +clearSignals +System.Console.Readline + +clearStencil +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clearWindow +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +clickmap +Text.Html + +clientActiveTexture +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clientMessage +Graphics.X11.Types +Graphics.X11.Xlib + +clientState +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +clipBox +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +clipByChildren +Graphics.X11.Types +Graphics.X11.Xlib + +clipPlane +Graphics.Rendering.OpenGL.GL.Clipping +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +closeCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +closeDirStream +System.Posix.Directory +System.Posix + +closeDisplay +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +closeFd +System.Posix.IO +System.Posix + +closeWindow +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +clr479 +Data.Graph.Inductive.Example + +clr479' +Data.Graph.Inductive.Example + +clr486 +Data.Graph.Inductive.Example + +clr486' +Data.Graph.Inductive.Example + +clr489 +Data.Graph.Inductive.Example + +clr489' +Data.Graph.Inductive.Example + +clr508 +Data.Graph.Inductive.Example + +clr508' +Data.Graph.Inductive.Example + +clr528 +Data.Graph.Inductive.Example + +clr528' +Data.Graph.Inductive.Example + +clr595 +Data.Graph.Inductive.Example + +coarbitrary +Test.QuickCheck +Debug.QuickCheck + +code +Text.Html + +codebase +Text.Html + +collect +Test.QuickCheck +Debug.QuickCheck + +colon +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +color +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Text.Html + +colorBufferDepth +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +colorList +Graphics.HGL.Utils +Graphics.HGL + +colorMapEntry +Graphics.UI.GLUT.Colormap +Graphics.UI.GLUT + +colorMask +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorMaterial +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorSubTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorSum +Graphics.Rendering.OpenGL.GL.ColorSum +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTable +Graphics.HGL.Utils +Graphics.HGL +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableBias +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableFormat +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableIntesitySize +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableLuminanceSize +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableRGBASizes +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableScale +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colorTableWidth +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +colormapChangeMask +Graphics.X11.Types +Graphics.X11.Xlib + +colormapInstalled +Graphics.X11.Types +Graphics.X11.Xlib + +colormapNotify +Graphics.X11.Types +Graphics.X11.Xlib + +colormapUninstalled +Graphics.X11.Types +Graphics.X11.Xlib + +colorv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +cols +Text.Html + +colspan +Text.Html + +combine +Language.Haskell.TH.Lib + +combineAlpha +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +combineRGB +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +comma +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +commaSep +Text.ParserCombinators.Parsec.Token + +commaSep1 +Text.ParserCombinators.Parsec.Token + +commentEnd +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +commentLine +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +commentStart +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +comments +Language.Haskell.Pretty + +commonParent +Distribution.Compat.FilePath + +compE +Language.Haskell.TH.Lib +Language.Haskell.TH + +compact +Text.Html + +compare +Prelude + +compiler +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +compilerFlavor +Distribution.Setup + +compilerName +System.Info + +compilerPath +Distribution.Setup + +compilerPkgTool +Distribution.Setup + +compilerVersion +Distribution.Setup +System.Info + +complement +Data.Bits +Foreign + +complementBit +Data.Bits +Foreign + +complete +System.Console.Readline + +completeInternal +System.Console.Readline + +completionMatches +System.Console.Readline + +complex +Graphics.X11.Types +Graphics.X11.Xlib + +components +Data.Graph +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +compressedTexImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTexImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTexImage3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTexSubImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTexSubImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTexSubImage3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +compressedTextureFormats +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +conE +Language.Haskell.TH.Lib +Language.Haskell.TH + +conP +Language.Haskell.TH.Lib +Language.Haskell.TH + +conT +Language.Haskell.TH.Lib +Language.Haskell.TH + +concat +Data.List +Prelude + +concatHtml +Text.Html + +concatMap +Data.List +Prelude + +concatPS +Data.PackedString + +condE +Language.Haskell.TH.Lib +Language.Haskell.TH + +condMGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +condMGT' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +configAlex +Distribution.Setup + +configCpphs +Distribution.Setup + +configEvery +Test.QuickCheck +Debug.QuickCheck + +configHaddock +Distribution.Setup + +configHappy +Distribution.Setup + +configHcFlavor +Distribution.Setup + +configHcPath +Distribution.Setup + +configHcPkg +Distribution.Setup + +configHsc2hs +Distribution.Setup + +configMaxFail +Test.QuickCheck +Debug.QuickCheck + +configMaxTest +Test.QuickCheck +Debug.QuickCheck + +configPrefix +Distribution.Setup + +configSize +Test.QuickCheck +Debug.QuickCheck + +configUser +Distribution.Setup + +configVerbose +Distribution.Setup + +configure +Distribution.Simple.Configure + +configureNotify +Graphics.X11.Types +Graphics.X11.Xlib + +configureRequest +Graphics.X11.Types +Graphics.X11.Xlib + +conjugate +Data.Complex + +connect +Network.Socket + +connectTo +Network + +connectToCGIScript +Network.CGI + +connectionNumber +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +consPS +Data.PackedString + +const +Prelude + +constantColor +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +constrFields +Data.Generics.Basics +Data.Generics + +constrFixity +Data.Generics.Basics +Data.Generics + +constrIndex +Data.Generics.Basics +Data.Generics + +constrRep +Data.Generics.Basics +Data.Generics + +constrType +Data.Generics.Basics +Data.Generics + +content +Text.Html + +context +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +contextM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +continueProcess +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +controlChar +System.Posix.Terminal +System.Posix + +controlFlow +System.Posix.Terminal +System.Posix + +controlMapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +controlMask +Graphics.X11.Types +Graphics.X11.Xlib + +convex +Graphics.X11.Types +Graphics.X11.Xlib + +convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionBorderMode +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionFilter1D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionFilter2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionFilterBias +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionFilterScale +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionHeight +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +convolutionWidth +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +coordModeOrigin +Graphics.X11.Types +Graphics.X11.Xlib + +coordModePrevious +Graphics.X11.Types +Graphics.X11.Xlib + +coords +Text.Html + +copyArea +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +copyArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +copyBytes +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +copyColorSubTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyColormap +Graphics.UI.GLUT.Colormap +Graphics.UI.GLUT + +copyColormapAndFree +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +copyConvolutionFilter1D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyConvolutionFilter2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyFile +System.Directory +Distribution.Compat.Directory + +copyFileVerbose +Distribution.Simple.Utils + +copyFromParent +Graphics.X11.Types +Graphics.X11.Xlib + +copyGC +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +copyKeymap +System.Console.Readline + +copyPixels +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyPlane +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +copyTexImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyTexImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyTexSubImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyTexSubImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyTexSubImage3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +copyText +System.Console.Readline + +copyright +Distribution.InstalledPackageInfo +Distribution.PackageDescription +Text.Html + +cos +Prelude + +cosh +Prelude + +count +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +counts +Test.HUnit.Base +Test.HUnit + +cpuTimeLimitExceeded +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +cpuTimePrecision +System.CPUTime + +createBrush +Graphics.HGL.Draw.Brush +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +createColormap +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +createDevice +System.Posix.Files +System.Posix + +createDirectory +System.Directory +Distribution.Compat.Directory +System.Posix.Directory +System.Posix + +createDirectoryIfMissing +System.Directory +Distribution.Compat.Directory + +createEllipse +Graphics.SOE + +createFile +System.Posix.IO +System.Posix + +createFont +Graphics.HGL.Draw.Font +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +createFontCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +createGC +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +createGlyphCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +createLink +System.Posix.Files +System.Posix + +createNamedPipe +System.Posix.Files +System.Posix + +createNotify +Graphics.X11.Types +Graphics.X11.Xlib + +createPen +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +createPipe +System.Posix.IO +System.Posix + +createPixmap +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +createPixmapCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +createPolygon +Graphics.SOE + +createProcessGroup +System.Posix.Process +System.Posix + +createRectangle +Graphics.SOE + +createRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +createSession +System.Posix.Process +System.Posix + +createSimpleWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +createSubWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +createSymbolicLink +System.Posix.Files +System.Posix + +createWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +crossingCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +ctDay +System.Time + +ctHour +System.Time + +ctIsDST +System.Time + +ctMin +System.Time + +ctMonth +System.Time + +ctPicosec +System.Time + +ctSec +System.Time + +ctTZ +System.Time + +ctTZName +System.Time + +ctWDay +System.Time + +ctYDay +System.Time + +ctYear +System.Time + +ctrl +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +cullFace +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentColor +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentDir +Distribution.Simple.Utils + +currentFogCoord +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentIndex +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentModule +Language.Haskell.TH.Syntax +Language.Haskell.TH + +currentNormal +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentQuery +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterColor +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterDistance +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterIndex +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterPosition +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterPositionValid +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentRasterTexCoords +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentSecondaryColor +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentTextureCoords +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +currentWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +curry +Data.Tuple +Prelude + +cursor +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +cursorShape +Graphics.X11.Types +Graphics.X11.Xlib + +cxt +Language.Haskell.TH.Lib +Language.Haskell.TH + +cyc3 +Data.Graph.Inductive.Example + +cycle +Data.List +Prelude + +D# +GHC.Exts + +DL +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +DLHandle +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +Dash +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +DashDot +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +DashDotDot +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Data +Data.Generics.Basics +Data.Generics + +DataConI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +DataD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +DataName +Language.Haskell.TH.Syntax + +DataRep +Data.Generics.Basics +Data.Generics + +DataType +Data.Generics.Basics +Data.Generics +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Datagram +Network.Socket + +Day +System.Time + +Deadlock +Control.Exception + +Debug +Network.Socket + +Dec +Language.Haskell.TH.Syntax +Language.Haskell.TH + +DecQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Decal +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +December +System.Time + +Decomp +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +Default +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +Denormal +Control.Exception + +Dependency +Distribution.Version +Distribution.Simple +Distribution.Version +Distribution.Simple + +DepthBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthBufferAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthComponent +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthComponent' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthComponent16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthComponent24 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthComponent32 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DepthStencil +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Destroy +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +DeviceID +System.Posix.Types +System.Posix + +DialAndButtonBoxButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DialAndButtonBoxCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DialAndButtonBoxDial +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DialAndButtonBoxInput +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DialCount +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +DialIndex +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DiffArray +Data.Array.Diff + +DiffUArray +Data.Array.Diff + +Diffuse +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Dimension +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +DirStream +System.Posix.Directory +System.Posix + +DirStreamOffset +System.Posix.Directory +System.Posix + +DirectRendering +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Disabled +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Disk +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Display +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +DisplayAcc +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayAccA +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayAlpha +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayBlue +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayBuffer +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +DisplayCapability +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayCapabilityDescription +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayConformant +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayDepth +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayDouble +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayGreen +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayIndex +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayList +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DisplayLuminance +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayMode' +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DisplayNum +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayRGB +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayRGBA +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayRed +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplaySamples +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplaySingle +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplaySlow +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayStencil +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayStereo +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayWin32PFD +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXDirectColor +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXGrayScale +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXPseudoColor +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXStaticColor +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXStaticGray +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXTrueColor +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DisplayXVisual +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DivideByZero +Control.Exception + +DoE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Doc +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +Dodecahedron +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +Domain +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DomainDistance +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Done +Control.Parallel.Strategies + +DontCare +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DontRoute +Network.Socket + +Dot +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Dot3RGB +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Dot3RGBA +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Double +Prelude +GHC.Exts +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DoubleBuffered +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +DoublePrimL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Down +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Draw +Graphics.HGL.Draw.Monad +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +DrawPixelToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Drawable +Graphics.X11.Types +Graphics.X11.Xlib + +DstAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DstColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DummySocketOption__ +Network.Socket + +DynException +Control.Exception + +DynGraph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +Dynamic +Data.Dynamic + +DynamicCopy +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DynamicDraw +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +DynamicRead +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +d1 +Data.Graph.Inductive.Example + +d1' +Data.Graph.Inductive.Example + +d3 +Data.Graph.Inductive.Example + +d3' +Data.Graph.Inductive.Example + +dRAWABLE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +dag3 +Data.Graph.Inductive.Example + +dag3' +Data.Graph.Inductive.Example + +dag4 +Data.Graph.Inductive.Example + +dag4' +Data.Graph.Inductive.Example + +damaged +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +dataCast1 +Data.Generics.Basics +Data.Generics + +dataCast2 +Data.Generics.Basics +Data.Generics + +dataD +Language.Haskell.TH.Lib +Language.Haskell.TH + +dataTypeConstrs +Data.Generics.Basics +Data.Generics + +dataTypeName +Data.Generics.Basics +Data.Generics + +dataTypeOf +Data.Generics.Basics +Data.Generics + +dataTypeRep +Data.Generics.Basics +Data.Generics + +dateFmt +System.Locale + +dateTimeFmt +System.Locale + +ddef +Text.Html + +deQueue +Data.Queue + +deRefStablePtr +Foreign.StablePtr +Foreign + +deRefWeak +System.Mem.Weak + +debugHtml +Text.Html + +debug_tests +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +decimal +Text.ParserCombinators.Parsec.Token + +decodeFloat +Prelude + +defList +Text.Html + +defOpt +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +defaultBlanking +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +defaultColormap +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultColormapOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +defaultConfig +Test.QuickCheck +Debug.QuickCheck + +defaultDepth +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultDepthOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +defaultExposures +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +defaultFileFlags +System.Posix.IO +System.Posix + +defaultFixity +Language.Haskell.TH.Syntax +Language.Haskell.TH + +defaultGC +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultGCOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +defaultGHCPackageConfig +Distribution.Simple.GHCPackageConfig + +defaultGraphSize +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +defaultHookedPackageDesc +Distribution.Simple.Utils +Distribution.Simple + +defaultMain +Distribution.Make +Distribution.Simple + +defaultMainNoRead +Distribution.Make +Distribution.Simple + +defaultMainWithHooks +Distribution.Simple + +defaultMode +Language.Haskell.Pretty + +defaultPackageDesc +Distribution.Simple.Utils + +defaultParseMode +Language.Haskell.Parser + +defaultRootWindow +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultScreen +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultScreenOfDisplay +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultTimeLocale +System.Locale + +defaultUserHooks +Distribution.Simple + +defaultVisual +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +defaultVisualOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +define +Text.Html + +defineCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +defineList +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +defineNewList +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +deg +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +deg' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +delChars +System.Console.SimpleLineEditor + +delEdge +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +delEdges +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +delFromFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +delFromSet +Data.Set + +delListFromFM +Data.FiniteMap + +delMapEdge +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapEdgeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapEdges +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapEdgesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapNode +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapNodeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapNodes +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delMapNodesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +delNode +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +delNodeM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +delNodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +delNodesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +delete +Data.HashTable +Data.IntMap +Data.IntSet +Data.List +Data.Map +Data.Set + +deleteAt +Data.Map + +deleteBrush +Graphics.HGL.Draw.Brush +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +deleteBy +Data.List + +deleteFindMax +Data.Map +Data.Set + +deleteFindMin +Data.Map +Data.Set + +deleteFirstsBy +Data.List + +deleteFont +Graphics.HGL.Draw.Font +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +deleteLists +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +deleteMax +Data.Map +Data.Set + +deleteMin +Data.Graph.Inductive.Internal.Heap +Data.Map +Data.Set + +deleteObjectNames +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +deletePen +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +deleteSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +deleteText +System.Console.Readline + +demanding +Control.Parallel.Strategies + +denominator +Data.Ratio + +depends +Distribution.InstalledPackageInfo + +depthBias +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthBits +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthBounds +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthBufferDepth +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +depthClamp +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthFunc +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthMask +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthRange +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthScale +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +depthTextureMode +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +descentFromFontStruct +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +description +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +destroyAll +Graphics.X11.Types +Graphics.X11.Xlib + +destroyNotify +Graphics.X11.Types +Graphics.X11.Xlib + +destroySubwindows +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +destroyWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +deviceID +System.Posix.Files +System.Posix + +dff +Data.Graph +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dff' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dffM +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dffWith +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dffWith' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfs +Data.Graph +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfs' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfsGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfsM +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfsM' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfsWith +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dfsWith' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dialAndButtonBoxCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +die +Distribution.Simple.Utils + +diffClockTimes +System.Time + +diffRegion +Graphics.SOE + +difference +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +differenceWith +Data.IntMap +Data.Map + +differenceWithKey +Data.IntMap +Data.Map + +diffuse +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +digit +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +digitToInt +Data.Char + +dijkstra +Data.Graph.Inductive.Query.SP +Data.Graph.Inductive.Query +Data.Graph.Inductive + +ding +System.Console.Readline + +directDraw +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +directRendering +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +discardData +System.Posix.Terminal +System.Posix + +displayCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +displayCells +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayHeight +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayHeightMM +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayKeycodes +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +displayMatchList +System.Console.Readline + +displayModePossible +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +displayMotionBufferSize +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayName +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +displayOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +displayPlanes +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayString +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayWidth +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +displayWidthMM +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +dither +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +div +Prelude + +divMod +Prelude + +dlclose +System.Posix.DynamicLinker + +dlerror +System.Posix.DynamicLinker + +dlist +Text.Html + +dllExtension +Distribution.Compat.FilePath + +dlopen +System.Posix.DynamicLinker + +dlsym +System.Posix.DynamicLinker + +doBlue +Graphics.X11.Types +Graphics.X11.Xlib + +doE +Language.Haskell.TH.Lib +Language.Haskell.TH + +doGreen +Graphics.X11.Types +Graphics.X11.Xlib + +doIndent +Language.Haskell.Pretty + +doRed +Graphics.X11.Types +Graphics.X11.Xlib + +doUndo +System.Console.Readline + +doesBackingStore +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +doesDirectoryExist +System.Directory +Distribution.Compat.Directory + +doesFileExist +System.Directory +Distribution.Compat.Directory + +doesNotExistErrorType +System.IO.Error + +doesSaveUnders +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +dom +Data.Graph.Inductive.Query.Dominators +Data.Graph.Inductive.Query +Data.Graph.Inductive + +dontAllowExposures +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +dontPreferBlanking +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +dot +Text.ParserCombinators.Parsec.Token + +dotToSep +Distribution.Simple.Utils + +double +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +doubleBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +doubleBuffered +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +doublePrimL +Language.Haskell.TH.Lib +Language.Haskell.TH + +doubleQuotes +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +drainOutput +System.Posix.Terminal +System.Posix + +drawArc +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawArcs +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawArrays +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +drawBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +drawBufferedGraphic +Graphics.SOE + +drawElements +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +drawForest +Data.Tree + +drawGraphic +Graphics.SOE + +drawImageString +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawInWindow +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +drawInWindowNow +Graphics.SOE + +drawLine +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawLines +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawPixels +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +drawPoint +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawPoints +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawRangeElements +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +drawRectangle +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawRectangles +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawRegion +Graphics.SOE + +drawSegments +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawString +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +drawTree +Data.Tree + +drop +Data.List +Prelude + +dropAbsolutePrefix +Distribution.Compat.FilePath + +dropPS +Data.PackedString + +dropWhile +Data.List +Prelude + +dropWhilePS +Data.PackedString + +dterm +Text.Html + +dup +System.Posix.IO +System.Posix + +dupChan +Control.Concurrent.Chan +Control.Concurrent + +dupTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +dupTo +System.Posix.IO +System.Posix + +dyn +Language.Haskell.TH.Lib +Language.Haskell.TH + +dynApp +Data.Dynamic + +dynApply +Data.Dynamic + +dynExceptions +Control.Exception + +EOF +Text.Read.Lex +Text.Read + +EQ +Prelude + +EarlierVersion +Distribution.Version +Distribution.Simple + +EchoErase +System.Posix.Terminal +System.Posix + +EchoKill +System.Posix.Terminal +System.Posix + +EchoLF +System.Posix.Terminal +System.Posix + +Edge +Data.Graph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +EdgeFlag +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EdgeFlagArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Either +Data.Either +Prelude + +ElementArrayBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Emission +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Empty +Data.Graph.Inductive.Internal.FiniteMap +Data.Graph.Inductive.Internal.Heap + +EmptyDataDecls +Distribution.Extension +Distribution.Simple + +EnableAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EnableEcho +System.Posix.Terminal +System.Posix + +EnableParity +System.Posix.Terminal +System.Posix + +Enabled +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EndOfFile +System.Posix.Terminal +System.Posix + +EndOfLine +System.Posix.Terminal +System.Posix + +Entry +System.Console.Readline + +Enum +Prelude + +EpochTime +System.Posix.Types +System.Posix + +Eq +Prelude + +Equal +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Equiv +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Erase +System.Posix.Terminal +System.Posix + +Errno +Foreign.C.Error +Foreign.C +Foreign.C.Error +Foreign.C + +Error +Control.Monad.Error +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ErrorCall +Control.Exception + +ErrorCategory +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ErrorT +Control.Monad.Error +Control.Monad.Error + +EvalAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Event +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +EventMask +Graphics.X11.Types +Graphics.X11.Xlib + +EventType +Graphics.X11.Types +Graphics.X11.Xlib + +Exception +Control.Exception + +Executable +Distribution.PackageDescription +Distribution.PackageDescription + +ExistentialQuantification +Distribution.Extension +Distribution.Simple + +Exit +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +ExitCode +System.Exit + +ExitException +Control.Exception + +ExitFailure +System.Exit + +ExitSuccess +System.Exit + +Exited +System.Posix.Process +System.Posix + +Exp +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Exp2 +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ExpQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Expect +Text.ParserCombinators.Parsec.Error + +ExportF +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ExtendedFunctions +System.Posix.Terminal +System.Posix + +ExtensibleRecords +Distribution.Extension +Distribution.Simple + +Extension +Distribution.Extension +Distribution.Simple + +EyeLinear +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EyePlaneAbsolute +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EyePlaneSigned +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +EyeRadial +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +e +Data.Graph.Inductive.Example + +e' +Data.Graph.Inductive.Example + +e2BIG +Foreign.C.Error +Foreign.C + +e3 +Data.Graph.Inductive.Example + +e3' +Data.Graph.Inductive.Example + +eACCES +Foreign.C.Error +Foreign.C + +eADDRINUSE +Foreign.C.Error +Foreign.C + +eADDRNOTAVAIL +Foreign.C.Error +Foreign.C + +eADV +Foreign.C.Error +Foreign.C + +eAFNOSUPPORT +Foreign.C.Error +Foreign.C + +eAGAIN +Foreign.C.Error +Foreign.C + +eALREADY +Foreign.C.Error +Foreign.C + +eBADF +Foreign.C.Error +Foreign.C + +eBADMSG +Foreign.C.Error +Foreign.C + +eBADRPC +Foreign.C.Error +Foreign.C + +eBUSY +Foreign.C.Error +Foreign.C + +eCHILD +Foreign.C.Error +Foreign.C + +eCOMM +Foreign.C.Error +Foreign.C + +eCONNABORTED +Foreign.C.Error +Foreign.C + +eCONNREFUSED +Foreign.C.Error +Foreign.C + +eCONNRESET +Foreign.C.Error +Foreign.C + +eDEADLK +Foreign.C.Error +Foreign.C + +eDESTADDRREQ +Foreign.C.Error +Foreign.C + +eDIRTY +Foreign.C.Error +Foreign.C + +eDOM +Foreign.C.Error +Foreign.C + +eDQUOT +Foreign.C.Error +Foreign.C + +eEXIST +Foreign.C.Error +Foreign.C + +eFAULT +Foreign.C.Error +Foreign.C + +eFBIG +Foreign.C.Error +Foreign.C + +eFTYPE +Foreign.C.Error +Foreign.C + +eHOSTDOWN +Foreign.C.Error +Foreign.C + +eHOSTUNREACH +Foreign.C.Error +Foreign.C + +eIDRM +Foreign.C.Error +Foreign.C + +eILSEQ +Foreign.C.Error +Foreign.C + +eINPROGRESS +Foreign.C.Error +Foreign.C + +eINTR +Foreign.C.Error +Foreign.C + +eINVAL +Foreign.C.Error +Foreign.C + +eIO +Foreign.C.Error +Foreign.C + +eISCONN +Foreign.C.Error +Foreign.C + +eISDIR +Foreign.C.Error +Foreign.C + +eLOOP +Foreign.C.Error +Foreign.C + +eMFILE +Foreign.C.Error +Foreign.C + +eMLINK +Foreign.C.Error +Foreign.C + +eMSGSIZE +Foreign.C.Error +Foreign.C + +eMULTIHOP +Foreign.C.Error +Foreign.C + +eNAMETOOLONG +Foreign.C.Error +Foreign.C + +eND_SPACE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +eNETDOWN +Foreign.C.Error +Foreign.C + +eNETRESET +Foreign.C.Error +Foreign.C + +eNETUNREACH +Foreign.C.Error +Foreign.C + +eNFILE +Foreign.C.Error +Foreign.C + +eNOBUFS +Foreign.C.Error +Foreign.C + +eNODATA +Foreign.C.Error +Foreign.C + +eNODEV +Foreign.C.Error +Foreign.C + +eNOENT +Foreign.C.Error +Foreign.C + +eNOEXEC +Foreign.C.Error +Foreign.C + +eNOLCK +Foreign.C.Error +Foreign.C + +eNOLINK +Foreign.C.Error +Foreign.C + +eNOMEM +Foreign.C.Error +Foreign.C + +eNOMSG +Foreign.C.Error +Foreign.C + +eNONET +Foreign.C.Error +Foreign.C + +eNOPROTOOPT +Foreign.C.Error +Foreign.C + +eNOSPC +Foreign.C.Error +Foreign.C + +eNOSR +Foreign.C.Error +Foreign.C + +eNOSTR +Foreign.C.Error +Foreign.C + +eNOSYS +Foreign.C.Error +Foreign.C + +eNOTBLK +Foreign.C.Error +Foreign.C + +eNOTCONN +Foreign.C.Error +Foreign.C + +eNOTDIR +Foreign.C.Error +Foreign.C + +eNOTEMPTY +Foreign.C.Error +Foreign.C + +eNOTSOCK +Foreign.C.Error +Foreign.C + +eNOTTY +Foreign.C.Error +Foreign.C + +eNXIO +Foreign.C.Error +Foreign.C + +eOK +Foreign.C.Error +Foreign.C + +eOPNOTSUPP +Foreign.C.Error +Foreign.C + +ePERM +Foreign.C.Error +Foreign.C + +ePFNOSUPPORT +Foreign.C.Error +Foreign.C + +ePIPE +Foreign.C.Error +Foreign.C + +ePROCLIM +Foreign.C.Error +Foreign.C + +ePROCUNAVAIL +Foreign.C.Error +Foreign.C + +ePROGMISMATCH +Foreign.C.Error +Foreign.C + +ePROGUNAVAIL +Foreign.C.Error +Foreign.C + +ePROTO +Foreign.C.Error +Foreign.C + +ePROTONOSUPPORT +Foreign.C.Error +Foreign.C + +ePROTOTYPE +Foreign.C.Error +Foreign.C + +eRANGE +Foreign.C.Error +Foreign.C + +eREMCHG +Foreign.C.Error +Foreign.C + +eREMOTE +Foreign.C.Error +Foreign.C + +eROFS +Foreign.C.Error +Foreign.C + +eRPCMISMATCH +Foreign.C.Error +Foreign.C + +eRREMOTE +Foreign.C.Error +Foreign.C + +eSHUTDOWN +Foreign.C.Error +Foreign.C + +eSOCKTNOSUPPORT +Foreign.C.Error +Foreign.C + +eSPIPE +Foreign.C.Error +Foreign.C + +eSRCH +Foreign.C.Error +Foreign.C + +eSRMNT +Foreign.C.Error +Foreign.C + +eSTALE +Foreign.C.Error +Foreign.C + +eTIME +Foreign.C.Error +Foreign.C + +eTIMEDOUT +Foreign.C.Error +Foreign.C + +eTOOMANYREFS +Foreign.C.Error +Foreign.C + +eTXTBSY +Foreign.C.Error +Foreign.C + +eUSERS +Foreign.C.Error +Foreign.C + +eWOULDBLOCK +Foreign.C.Error +Foreign.C + +eXDEV +Foreign.C.Error +Foreign.C + +eastGravity +Graphics.X11.Types +Graphics.X11.Xlib + +edgeFlag +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +edges +Data.Graph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +edgesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +efilter +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +either +Data.Either +Prelude + +ekFused +Data.Graph.Inductive.Query.MaxFlow2 +Data.Graph.Inductive.Query +Data.Graph.Inductive + +ekList +Data.Graph.Inductive.Query.MaxFlow2 +Data.Graph.Inductive.Query +Data.Graph.Inductive + +ekSimple +Data.Graph.Inductive.Query.MaxFlow2 +Data.Graph.Inductive.Query +Data.Graph.Inductive + +elapsedTime +Graphics.UI.GLUT.State +Graphics.UI.GLUT +System.Posix.Process +System.Posix + +elem +Data.List +Prelude + +elemAt +Data.Map + +elemFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +elemIndex +Data.List + +elemIndices +Data.List + +elemPS +Data.PackedString + +elementOf +Data.Set + +elements +Test.QuickCheck +Debug.QuickCheck + +elems +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Data.Array + +elfilter +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +ellipse +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +ellipseRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +eltsFM +Data.FiniteMap + +eltsFM_GE +Data.FiniteMap + +eltsFM_LE +Data.FiniteMap + +emap +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +emphasize +Text.Html + +empty +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Data.Graph.Inductive.Internal.Heap +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +emptyAttr +Text.Html + +emptyBuildInfo +Distribution.PackageDescription + +emptyDef +Text.ParserCombinators.Parsec.Language + +emptyFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +emptyGraphic +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +emptyHookedBuildInfo +Distribution.PackageDescription + +emptyInstalledPackageInfo +Distribution.InstalledPackageInfo + +emptyM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +emptyN +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +emptyPackageDescription +Distribution.PackageDescription + +emptyQueue +Data.Queue + +emptyRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +emptySampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +emptySet +Data.Set + +emptySignalSet +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +emptyUserHooks +Distribution.Simple + +encodeFloat +Prelude + +enctype +Text.Html + +endBy +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +endBy1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +endHostEntry +Network.BSD + +endNetworkEntry +Network.BSD + +endProtocolEntry +Network.BSD + +endServiceEntry +Network.BSD + +endUndoGroup +System.Console.Readline + +enterGameMode +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +enterNotify +Graphics.X11.Types +Graphics.X11.Xlib + +enterWindowMask +Graphics.X11.Types +Graphics.X11.Xlib + +enumFrom +Prelude + +enumFromThen +Prelude + +enumFromThenTo +Prelude + +enumFromTo +Prelude + +eof +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +eofErrorType +System.IO.Error + +epochTime +System.Posix.Time +System.Posix + +equal +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +equalRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +equals +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +errnoToIOError +Foreign.C.Error +Foreign.C + +error +Prelude + +errorCalls +Control.Exception + +errorIsUnknown +Text.ParserCombinators.Parsec.Error + +errorMessages +Text.ParserCombinators.Parsec.Error + +errorOut +Distribution.PackageDescription + +errorPos +Text.ParserCombinators.Parsec.Error +Text.ParserCombinators.Parsec + +errors +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Test.HUnit.Base +Test.HUnit + +escapeString +Network.URI + +escapeURIChar +Network.URI + +escapeURIString +Network.URI + +esp +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +evalCoord1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalCoord1v +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalCoord2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalCoord2v +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalMesh1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalMesh2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalPoint1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalPoint2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +evalRWS +Control.Monad.RWS + +evalRWST +Control.Monad.RWS + +evalState +Control.Monad.State +Control.Monad.RWS + +evalStateT +Control.Monad.State +Control.Monad.RWS + +evaluate +Control.Exception +Test.QuickCheck +Debug.QuickCheck + +even +Prelude + +evenOddRule +Graphics.X11.Types +Graphics.X11.Xlib + +eventMaskOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +eventsQueued +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +everything +Data.Generics.Schemes +Data.Generics + +everywhere +Data.Generics.Schemes +Data.Generics + +everywhere' +Data.Generics.Schemes +Data.Generics + +everywhereBut +Data.Generics.Schemes +Data.Generics + +everywhereM +Data.Generics.Schemes +Data.Generics + +exclusive +System.Posix.IO +System.Posix + +exeExtension +Distribution.Compat.FilePath + +exeModules +Distribution.PackageDescription + +exeName +Distribution.PackageDescription + +execRWS +Control.Monad.RWS + +execRWST +Control.Monad.RWS + +execState +Control.Monad.State +Control.Monad.RWS + +execStateT +Control.Monad.State +Control.Monad.RWS + +execWriter +Control.Monad.Writer +Control.Monad.RWS + +execWriterT +Control.Monad.Writer +Control.Monad.RWS + +executable +System.Directory +Distribution.Compat.Directory + +executables +Distribution.PackageDescription + +executeFile +System.Posix.Process +System.Posix + +exitFailure +System.Exit + +exitImmediately +System.Posix.Process +System.Posix + +exitWith +System.Exit + +exp +Prelude + +exponent +Prelude + +expose +Graphics.X11.Types +Graphics.X11.Xlib + +exposed +Distribution.InstalledPackageInfo + +exposedModules +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +exposureMask +Graphics.X11.Types +Graphics.X11.Xlib + +ext0 +Data.Generics.Aliases +Data.Generics + +ext1M +Data.Generics.Aliases +Data.Generics + +ext1Q +Data.Generics.Aliases +Data.Generics + +ext1R +Data.Generics.Aliases +Data.Generics + +ext1T +Data.Generics.Aliases +Data.Generics + +extB +Data.Generics.Aliases +Data.Generics + +extM +Data.Generics.Aliases +Data.Generics + +extMp +Data.Generics.Aliases +Data.Generics + +extQ +Data.Generics.Aliases +Data.Generics + +extR +Data.Generics.Aliases +Data.Generics + +extT +Data.Generics.Aliases +Data.Generics + +extensions +Distribution.PackageDescription + +extensionsToGHCFlag +Distribution.Extension +Distribution.Simple + +extensionsToHugsFlag +Distribution.Extension +Distribution.Simple + +extensionsToNHCFlag +Distribution.Extension +Distribution.Simple + +extraLibDirs +Distribution.PackageDescription + +extraLibraries +Distribution.InstalledPackageInfo + +extraLibs +Distribution.PackageDescription + +extra_cc_opts +Distribution.Simple.GHCPackageConfig + +extra_frameworks +Distribution.Simple.GHCPackageConfig + +extra_ghc_opts +Distribution.Simple.GHCPackageConfig + +extra_ld_opts +Distribution.Simple.GHCPackageConfig + +extra_libraries +Distribution.Simple.GHCPackageConfig + +extractContours +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +F# +GHC.Exts + +Face +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +False +Data.Bool +Prelude + +Family +Network.Socket + +Fastest +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Fd +System.Posix.Types +System.Posix +System.Posix.Types +System.Posix + +FdOption +System.Posix.IO +System.Posix + +February +System.Time + +Feedback +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FeedbackToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FeedbackType +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FieldExp +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FieldExpQ +Language.Haskell.TH.Lib + +FieldPat +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FieldPatQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +FileID +System.Posix.Types +System.Posix + +FileLock +System.Posix.IO +System.Posix + +FileMode +System.Posix.Types +System.Posix + +FileNameLimit +System.Posix.Files +System.Posix + +FileNamesAreNotTruncated +System.Posix.Files +System.Posix + +FileOffset +System.Posix.Types +System.Posix + +FilePath +System.IO +Prelude +Distribution.Compat.FilePath + +FileSizeBits +System.Posix.Files +System.Posix + +FileStatus +System.Posix.Files +System.Posix + +Fill +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Fill' +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FillRule +Graphics.X11.Types +Graphics.X11.Xlib + +FillStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +FinalizerPtr +Foreign.ForeignPtr +Foreign + +FiniteMap +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +Fixed8By13 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Fixed9By15 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Fixity +Data.Generics.Basics +Data.Generics +Language.Haskell.TH.Syntax +Language.Haskell.TH +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FixityDirection +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Flat +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Flavour +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +FlexibleContexts +Distribution.Extension +Distribution.Simple + +FlexibleInstances +Distribution.Extension +Distribution.Simple + +Float +Prelude +GHC.Exts +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FloatConstr +Data.Generics.Basics +Data.Generics + +FloatPrimL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FloatRep +Data.Generics.Basics +Data.Generics + +Floating +Prelude + +FlowAction +System.Posix.Terminal +System.Posix + +FocusMode +Graphics.X11.Types +Graphics.X11.Xlib + +Fog +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogCoord +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogCoord1 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogCoordArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogCoordComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogCoordSrc +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogDistanceMode +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FogMode +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Font +Graphics.HGL.Draw.Font +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +FontDirection +Graphics.X11.Types +Graphics.X11.Xlib + +FontStruct +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +ForallC +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ForallT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ForceDirectContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +ForceIndirectContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Foreign +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ForeignD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ForeignFunctionInterface +Distribution.Extension +Distribution.Simple + +ForeignPtr +Foreign.ForeignPtr +Foreign + +Forest +Data.Tree +Data.Graph + +FourBytes +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FourDColorTexture +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FourTwoTwo +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FourTwoTwoAverage +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FourTwoTwoRev +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FourTwoTwoRevAverage +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Fractional +Prelude + +FragmentDepth +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Friday +System.Time + +FromR +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FromThenR +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FromThenToR +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FromToR +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Front +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontAndBack +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontAndBackBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontFaceDirection +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontLeftBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FrontRightBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FullCrosshair +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +FunD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FunDep +Language.Haskell.TH.Syntax +Language.Haskell.TH +Language.Haskell.TH.Syntax +Language.Haskell.TH + +FunPtr +Foreign.Ptr +Foreign +GHC.Exts +GHC.Exts + +FuncAdd +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FuncReverseSubtract +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +FuncSubtract +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Function +System.Console.Readline + +FunctionalDependencies +Distribution.Extension +Distribution.Simple + +Functor +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +FunctorM +Data.FunctorM + +fAMILY_NAME +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +fONT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +fONT_NAME +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +fULL_NAME +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +face +Text.Html + +fail +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +failures +Test.HUnit.Base +Test.HUnit + +familyChaos +Graphics.X11.Types +Graphics.X11.Xlib + +familyDECnet +Graphics.X11.Types +Graphics.X11.Xlib + +familyInternet +Graphics.X11.Types +Graphics.X11.Xlib + +fcat +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +fdRead +System.Posix.IO +System.Posix + +fdSeek +System.Posix.IO +System.Posix + +fdSocket +Network.Socket + +fdToHandle +System.Posix.IO +System.Posix + +fdWrite +System.Posix.IO +System.Posix + +fetchBuffer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fetchBytes +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fieldExp +Language.Haskell.TH.Lib +Language.Haskell.TH + +fieldGet +Distribution.PackageDescription + +fieldName +Distribution.PackageDescription + +fieldPat +Language.Haskell.TH.Lib +Language.Haskell.TH + +fieldSet +Distribution.PackageDescription + +fieldset +Text.Html + +fileAccess +System.Posix.Files +System.Posix + +fileExist +System.Posix.Files +System.Posix + +fileGroup +System.Posix.Files +System.Posix + +fileID +System.Posix.Files +System.Posix + +fileMode +System.Posix.Files +System.Posix + +fileOwner +System.Posix.Files +System.Posix + +fileSize +System.Posix.Files +System.Posix + +fileSizeLimitExceeded +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +filenameCompletionFunction +System.Console.Readline + +fillArc +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fillArcs +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fillOpaqueStippled +Graphics.X11.Types +Graphics.X11.Xlib + +fillPolygon +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fillRectangle +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fillRectangles +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +fillSolid +Graphics.X11.Types +Graphics.X11.Xlib + +fillStippled +Graphics.X11.Types +Graphics.X11.Xlib + +fillTiled +Graphics.X11.Types +Graphics.X11.Xlib + +filter +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Data.List +Prelude + +filterFM +Data.FiniteMap + +filterM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +filterPS +Data.PackedString + +filterWithKey +Data.IntMap +Data.Map + +finalize +System.Mem.Weak + +finalizeForeignPtr +Foreign.ForeignPtr +Foreign + +finalizerFree +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +finally +Control.Exception +Distribution.Compat.Exception + +find +Data.List + +findExecutable +System.Directory +Distribution.Compat.Directory + +findHookedPackageDesc +Distribution.Simple.Utils + +findIndex +Data.List +Data.Map + +findIndices +Data.List + +findMax +Data.Map +Data.Set + +findMin +Data.Graph.Inductive.Internal.Heap +Data.Map +Data.Set + +findPackageDesc +Distribution.Simple.Utils + +findProgram +Distribution.Simple.Configure + +findWithDefault +Data.IntMap +Data.Map + +finish +Graphics.Rendering.OpenGL.GL.FlushFinish +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +first +Control.Arrow + +firstExtensionError +Graphics.X11.Types +Graphics.X11.Xlib + +fix +Control.Monad.Fix +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Error + +fixIO +System.IO + +fixST +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +flatten +Data.Tree + +flattenSCC +Data.Graph + +flattenSCCs +Data.Graph + +flip +Prelude + +float +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +floatDigits +Prelude + +floatPrimL +Language.Haskell.TH.Lib +Language.Haskell.TH + +floatRadix +Prelude + +floatRange +Prelude + +floatToDigits +Numeric + +floatingPointException +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +floor +Prelude + +flush +Graphics.Rendering.OpenGL.GL.FlushFinish +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +flushGC +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +fmToList +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +fmToList_GE +Data.FiniteMap + +fmToList_LE +Data.FiniteMap + +fmap +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +fmapM +Data.FunctorM + +fmapM_ +Data.FunctorM + +focusChangeMask +Graphics.X11.Types +Graphics.X11.Xlib + +focusIn +Graphics.X11.Types +Graphics.X11.Xlib + +focusOut +Graphics.X11.Types +Graphics.X11.Xlib + +fog +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogColor +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogCoord +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogCoordSrc +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogCoordv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogDistanceMode +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogIndex +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fogMode +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fold +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +foldFM +Data.FiniteMap + +foldFM_GE +Data.FiniteMap + +foldFM_LE +Data.FiniteMap + +foldM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +foldM_ +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +foldWithKey +Data.IntMap +Data.Map + +foldl +Data.List +Prelude + +foldl' +Data.List + +foldl1 +Data.List +Prelude + +foldl1' +Data.List + +foldlPS +Data.PackedString + +foldr +Data.List +Prelude + +foldr1 +Data.List +Prelude + +foldrPS +Data.PackedString + +font +Text.Html + +fontFromFontStruct +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +fontFromGC +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +fontHeight +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +fontLeftToRight +Graphics.X11.Types +Graphics.X11.Xlib + +fontRightToLeft +Graphics.X11.Types +Graphics.X11.Xlib + +forAll +Test.QuickCheck +Debug.QuickCheck + +forImpD +Language.Haskell.TH.Lib +Language.Haskell.TH + +forallC +Language.Haskell.TH.Lib + +forallT +Language.Haskell.TH.Lib +Language.Haskell.TH + +force +Control.Parallel.Strategies + +forceJoystickCallback +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +forceScreenSaver +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +forcedUpdateDisplay +System.Console.Readline + +forgetGravity +Graphics.X11.Types +Graphics.X11.Xlib + +forkIO +Control.Concurrent + +forkOS +Control.Concurrent + +forkProcess +System.Posix.Process +System.Posix + +form +Text.Html + +formatCalendarTime +System.Time + +formatID +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +formatTimeDiff +System.Time + +four +Test.QuickCheck +Debug.QuickCheck + +fragment +Network.URI + +frame +Text.Html + +frameborder +Text.Html + +frameset +Text.Html + +frameworkDirs +Distribution.InstalledPackageInfo + +framework_dirs +Distribution.Simple.GHCPackageConfig + +frameworks +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +free +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +freeColormap +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +freeColors +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +freeCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +freeFont +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +freeGC +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +freeHaskellFunPtr +Foreign.Ptr +Foreign + +freeKeymap +System.Console.Readline + +freeLineState +System.Console.Readline + +freePixmap +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +freePool +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +freeStablePtr +Foreign.StablePtr +Foreign + +freeUndoList +System.Console.Readline + +freeze +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +frequency +Test.QuickCheck +Debug.QuickCheck + +fromAscList +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +fromAscListWith +Data.IntMap +Data.Map + +fromAscListWithKey +Data.IntMap +Data.Map + +fromBool +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +fromConstr +Data.Generics.Basics +Data.Generics + +fromConstrB +Data.Generics.Basics +Data.Generics + +fromConstrM +Data.Generics.Basics +Data.Generics + +fromDistinctAscList +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +fromDyn +Data.Dynamic + +fromDynamic +Data.Dynamic + +fromE +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromEnum +Prelude + +fromGraph +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +fromInteger +Prelude + +fromIntegral +Prelude + +fromJust +Data.Maybe + +fromList +Data.HashTable +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +fromListWith +Data.IntMap +Data.Map + +fromListWithKey +Data.IntMap +Data.Map + +fromMaybe +Data.Maybe + +fromR +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromRat +Numeric + +fromRational +Prelude + +fromThenE +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromThenR +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromThenToE +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromThenToR +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromToE +Language.Haskell.TH.Lib +Language.Haskell.TH + +fromToR +Language.Haskell.TH.Lib +Language.Haskell.TH + +frontFace +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +frustum +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +fsep +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +fst +Data.Tuple +Prelude + +fstPairFstList +Control.Parallel.Strategies + +fuchsia +Text.Html + +fullErrorType +System.IO.Error + +fullRender +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +fullScreen +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +fullSignalSet +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +funD +Language.Haskell.TH.Lib +Language.Haskell.TH + +funDep +Language.Haskell.TH.Lib + +funResultTy +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +fun_tycon +Language.Haskell.Syntax + +fun_tycon_name +Language.Haskell.Syntax + +functionDumper +System.Console.Readline + +functionOfKeyseq +System.Console.Readline + +funmapNames +System.Console.Readline + +GAMMA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +GC +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +GCMask +Graphics.X11.Types +Graphics.X11.Xlib + +GContext +Graphics.X11.Types +Graphics.X11.Xlib + +GDecomp +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +GHC +Distribution.Setup + +GHCPackage +Distribution.Simple.GHCPackageConfig + +GHCPackageConfig +Distribution.Simple.GHCPackageConfig + +GLbitfield +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLboolean +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLbyte +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLclampd +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLclampf +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLdouble +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLenum +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLfloat +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLint +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLintptr +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLmap1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLmap2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLmatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLpixelmap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLpolygonstipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLshort +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLsizei +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLsizeiptr +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLubyte +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLuint +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GLushort +Graphics.Rendering.OpenGL.GL.BasicTypes +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GM +Data.Generics.Aliases +Data.Generics + +GPL +Distribution.License +Distribution.Make +Distribution.Simple + +GQ +Data.Generics.Aliases +Data.Generics + +GT +Data.Generics.Aliases +Data.Generics +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive +Prelude + +GToG +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GXFunction +Graphics.X11.Types +Graphics.X11.Xlib + +GameModeBitsPerPlane +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeCapability +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeCapabilityDescription +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeHeight +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeInfo +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeNum +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeRefreshRate +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +GameModeWidth +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +Gen +Test.QuickCheck +Debug.QuickCheck + +GenParser +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +GenerateMipmap +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GenerateTextureCoordinates +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Generic +Data.Generics.Aliases +Data.Generics + +Generic' +Data.Generics.Aliases +Data.Generics +Data.Generics.Aliases +Data.Generics + +GenericB +Data.Generics.Aliases +Data.Generics + +GenericM +Data.Generics.Aliases +Data.Generics + +GenericM' +Data.Generics.Aliases +Data.Generics + +GenericQ +Data.Generics.Aliases +Data.Generics + +GenericQ' +Data.Generics.Aliases +Data.Generics + +GenericR +Data.Generics.Aliases +Data.Generics + +GenericT +Data.Generics.Aliases +Data.Generics + +GenericT' +Data.Generics.Aliases +Data.Generics + +Generics +Distribution.Extension +Distribution.Simple + +Gequal +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GequalR +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GettableStateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GlobalKeyRepeat +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +GlobalKeyRepeatDefault +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +GlobalKeyRepeatOff +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +GlobalKeyRepeatOn +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +Glyph +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +Gr +Data.Graph.Inductive.Tree +Data.Graph.Inductive + +GrabMode +Graphics.X11.Types +Graphics.X11.Xlib + +GrabStatus +Graphics.X11.Types +Graphics.X11.Xlib + +Graph +Data.Graph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +GraphM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +GraphRep +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +Graphic +Graphics.HGL.Draw.Monad +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +Greater +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Green +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +GroupEntry +System.Posix.User +System.Posix +System.Posix.User +System.Posix + +GroupID +System.Posix.Types +System.Posix + +GroupLimit +System.Posix.Unistd +System.Posix + +Guard +Language.Haskell.TH.Syntax +Language.Haskell.TH + +GuardQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +GuardedB +Language.Haskell.TH.Syntax +Language.Haskell.TH + +g3 +Data.Graph.Inductive.Example + +g3b +Data.Graph.Inductive.Example + +gCArcMode +Graphics.X11.Types +Graphics.X11.Xlib + +gCBackground +Graphics.X11.Types +Graphics.X11.Xlib + +gCCapStyle +Graphics.X11.Types +Graphics.X11.Xlib + +gCClipMask +Graphics.X11.Types +Graphics.X11.Xlib + +gCClipXOrigin +Graphics.X11.Types +Graphics.X11.Xlib + +gCClipYOrigin +Graphics.X11.Types +Graphics.X11.Xlib + +gCDashList +Graphics.X11.Types +Graphics.X11.Xlib + +gCDashOffset +Graphics.X11.Types +Graphics.X11.Xlib + +gCFillRule +Graphics.X11.Types +Graphics.X11.Xlib + +gCFillStyle +Graphics.X11.Types +Graphics.X11.Xlib + +gCFont +Graphics.X11.Types +Graphics.X11.Xlib + +gCForeground +Graphics.X11.Types +Graphics.X11.Xlib + +gCFunction +Graphics.X11.Types +Graphics.X11.Xlib + +gCGraphicsExposures +Graphics.X11.Types +Graphics.X11.Xlib + +gCJoinStyle +Graphics.X11.Types +Graphics.X11.Xlib + +gCLastBit +Graphics.X11.Types +Graphics.X11.Xlib + +gCLineStyle +Graphics.X11.Types +Graphics.X11.Xlib + +gCLineWidth +Graphics.X11.Types +Graphics.X11.Xlib + +gCPlaneMask +Graphics.X11.Types +Graphics.X11.Xlib + +gCStipple +Graphics.X11.Types +Graphics.X11.Xlib + +gCSubwindowMode +Graphics.X11.Types +Graphics.X11.Xlib + +gCTile +Graphics.X11.Types +Graphics.X11.Xlib + +gCTileStipXOrigin +Graphics.X11.Types +Graphics.X11.Xlib + +gCTileStipYOrigin +Graphics.X11.Types +Graphics.X11.Xlib + +gContextFromGC +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +gXand +Graphics.X11.Types +Graphics.X11.Xlib + +gXandInverted +Graphics.X11.Types +Graphics.X11.Xlib + +gXandReverse +Graphics.X11.Types +Graphics.X11.Xlib + +gXclear +Graphics.X11.Types +Graphics.X11.Xlib + +gXcopy +Graphics.X11.Types +Graphics.X11.Xlib + +gXcopyInverted +Graphics.X11.Types +Graphics.X11.Xlib + +gXequiv +Graphics.X11.Types +Graphics.X11.Xlib + +gXinvert +Graphics.X11.Types +Graphics.X11.Xlib + +gXnand +Graphics.X11.Types +Graphics.X11.Xlib + +gXnoop +Graphics.X11.Types +Graphics.X11.Xlib + +gXnor +Graphics.X11.Types +Graphics.X11.Xlib + +gXor +Graphics.X11.Types +Graphics.X11.Xlib + +gXorInverted +Graphics.X11.Types +Graphics.X11.Xlib + +gXorReverse +Graphics.X11.Types +Graphics.X11.Xlib + +gXset +Graphics.X11.Types +Graphics.X11.Xlib + +gXxor +Graphics.X11.Types +Graphics.X11.Xlib + +gameModeActive +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +gameModeCapabilities +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +gameModeInfo +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +gather +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +gcast +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +gcast1 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +gcast2 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +gcd +Prelude + +gcount +Data.Generics.Schemes +Data.Generics + +gdepth +Data.Generics.Schemes +Data.Generics + +gelem +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +genLNodes +Data.Graph.Inductive.Example + +genLists +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +genObjectNames +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +genRange +System.Random + +genUNodes +Data.Graph.Inductive.Example + +generate +Test.QuickCheck +Debug.QuickCheck + +generateMipmap +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +genericBind +System.Console.Readline + +genericDrop +Data.List + +genericIndex +Data.List + +genericLength +Data.List + +genericReplicate +Data.List + +genericSplitAt +Data.List + +genericTake +Data.List + +genpat +Language.Haskell.TH.Lib + +geometry +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +geq +Data.Generics.Twins +Data.Generics + +get +Control.Monad.State +Control.Monad.RWS +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +getAnyProcessStatus +System.Posix.Process +System.Posix + +getAppUserDataDirectory +System.Directory +Distribution.Compat.Directory + +getArgs +System.Environment + +getArgsAndInitialize +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +getAssocs +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +getBasicQuoteCharacters +System.Console.Readline + +getBasicWordBreakCharacters +System.Console.Readline + +getBindingKeymap +System.Console.Readline + +getButton +Graphics.HGL.Utils +Graphics.HGL + +getCPUTime +System.CPUTime + +getCatchSignals +System.Console.Readline + +getCatchSigwinch +System.Console.Readline + +getChanContents +Control.Concurrent.Chan +Control.Concurrent + +getChar +System.IO +Prelude + +getClockTime +System.Time + +getColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getCompleterQuoteCharacters +System.Console.Readline + +getCompleterWordBreakCharacters +System.Console.Readline + +getCompletionAppendCharacter +System.Console.Readline + +getCompletionQueryItems +System.Console.Readline + +getCompressedTexImage +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getContents +System.IO +Prelude + +getContext +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +getControllingTerminalName +System.Posix.Terminal +System.Posix + +getConvolutionFilter1D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getConvolutionFilter2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getCurrentDirectory +System.Directory +Distribution.Compat.Directory + +getDirectoryContents +System.Directory +Distribution.Compat.Directory + +getDistance +Data.Graph.Inductive.Internal.RootPath + +getEffectiveGroupID +System.Posix.User +System.Posix + +getEffectiveUserID +System.Posix.User +System.Posix + +getEffectiveUserName +System.Posix.User +System.Posix + +getElems +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +getEnd +System.Console.Readline + +getEnv +System.Environment +System.Posix.Env +System.Posix + +getEnvDefault +System.Posix.Env +System.Posix + +getEnvironment +System.Environment +System.Posix.Env +System.Posix + +getEnvironmentPrim +System.Posix.Env +System.Posix + +getErrno +Foreign.C.Error +Foreign.C + +getExecutingKeymap +System.Console.Readline + +getFdPathVar +System.Posix.Files +System.Posix + +getFdStatus +System.Posix.Files +System.Posix + +getFeedbackTokens +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getFileStatus +System.Posix.Files +System.Posix + +getFilenameCompletionDesired +System.Console.Readline + +getFilenameQuoteCharacters +System.Console.Readline + +getFilenameQuotingDesired +System.Console.Readline + +getGeometry +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +getGraphic +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +getGroupEntryForID +System.Posix.User +System.Posix + +getGroupEntryForName +System.Posix.User +System.Posix + +getGroupProcessStatus +System.Posix.Process +System.Posix + +getGroups +System.Posix.User +System.Posix + +getHistogram +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getHitRecords +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getHomeDirectory +System.Directory +Distribution.Compat.Directory + +getHostByAddr +Network.BSD + +getHostByName +Network.BSD + +getHostEntries +Network.BSD + +getHostEntry +Network.BSD + +getHostName +Network.BSD + +getHtmlElements +Text.Html + +getIconName +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +getIgnoreCompletionDuplicates +System.Console.Readline + +getInStream +System.Console.Readline + +getInhibitCompletion +System.Console.Readline + +getInput +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +getInputFocus +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +getKey +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +getKeyEx +Graphics.HGL.Utils +Graphics.HGL + +getKeymap +System.Console.Readline + +getKeymapByName +System.Console.Readline + +getKeymapName +System.Console.Readline + +getLBP +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +getLPath +Data.Graph.Inductive.Internal.RootPath + +getLPathNodes +Data.Graph.Inductive.Internal.RootPath + +getLibraryVersion +System.Console.Readline + +getLine +System.IO +Prelude + +getLineBuffer +System.Console.Readline + +getLineEdited +System.Console.SimpleLineEditor + +getLock +System.Posix.IO +System.Posix + +getLoginName +System.Posix.User +System.Posix + +getMap1Components +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getMap2Components +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getMark +System.Console.Readline + +getMatrix +Text.Html.BlockTable + +getMatrixComponents +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getMinmax +Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getModificationTime +System.Directory +Distribution.Compat.Directory + +getNetworkByAddr +Network.BSD + +getNetworkByName +Network.BSD + +getNetworkEntries +Network.BSD + +getNetworkEntry +Network.BSD + +getNode +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +getNodes +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +getNodes' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +getOpt +Distribution.GetOpt +System.Console.GetOpt + +getOpt' +Distribution.GetOpt +System.Console.GetOpt + +getOptionsFromSource +Distribution.Simple.Utils + +getOutStream +System.Console.Readline + +getParentProcessID +System.Posix.Process +System.Posix + +getParserState +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +getPath +Data.Graph.Inductive.Internal.RootPath + +getPathVar +System.Posix.Files +System.Posix + +getPeerCred +Network.Socket + +getPeerName +Network.Socket + +getPendingSignals +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +getPermissions +System.Directory +Distribution.Compat.Directory + +getPersistBuildConfig +Distribution.Simple.Configure + +getPixelMapComponents +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getPoint +System.Console.Readline + +getPointerControl +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +getPolygonStippleComponents +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getPosition +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +getProcessExitCode +System.Process + +getProcessGroupID +System.Posix.Process +System.Posix + +getProcessGroupPriority +System.Posix.Process +System.Posix + +getProcessID +System.Posix.Process +System.Posix + +getProcessPriority +System.Posix.Process +System.Posix + +getProcessStatus +System.Posix.Process +System.Posix + +getProcessTimes +System.Posix.Process +System.Posix + +getProgName +System.Environment + +getPrompt +System.Console.Readline + +getProtocolByName +Network.BSD + +getProtocolByNumber +Network.BSD + +getProtocolEntries +Network.BSD + +getProtocolEntry +Network.BSD + +getProtocolNumber +Network.BSD + +getRBP +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +getRealGroupID +System.Posix.User +System.Posix + +getRealUserID +System.Posix.User +System.Posix + +getResourceLimit +System.Posix.Resource +System.Posix + +getRevEdges +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +getScreenSaver +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +getSeparableFilter2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getServiceByName +Network.BSD + +getServiceByPort +Network.BSD + +getServiceEntries +Network.BSD + +getServiceEntry +Network.BSD + +getServicePortNumber +Network.BSD + +getSignalMask +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +getSocketName +Network.Socket + +getSocketOption +Network.Socket + +getSpecialPrefixes +System.Console.Readline + +getState +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +getStdGen +System.Random + +getStdRandom +System.Random + +getSymbolicLinkStatus +System.Posix.Files +System.Posix + +getSysVar +System.Posix.Unistd +System.Posix + +getSystemID +System.Posix.Unistd +System.Posix + +getTemporaryDirectory +System.Directory +Distribution.Compat.Directory + +getTerminalAttributes +System.Posix.Terminal +System.Posix + +getTerminalName +System.Console.Readline +System.Posix.Terminal +System.Posix + +getTerminalProcessGroupID +System.Posix.Terminal +System.Posix + +getTexImage +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +getTime +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +getUncaughtExceptionHandler +Control.Exception + +getUserDocumentsDirectory +System.Directory +Distribution.Compat.Directory + +getUserEntryForID +System.Posix.User +System.Posix + +getUserEntryForName +System.Posix.User +System.Posix + +getUserPriority +System.Posix.Process +System.Posix + +getWindowEvent +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +getWindowRect +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +getWindowSize +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +getWindowTick +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +getWorkingDirectory +System.Posix.Directory +System.Posix + +get_ButtonEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_ConfigureEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_EventType +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_ExposeEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_KeyEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_MotionEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +get_Window +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +gets +Control.Monad.State +Control.Monad.RWS + +gettimeofday_in_milliseconds +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +gfindtype +Data.Generics.Schemes +Data.Generics + +gfold +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +gfoldl +Data.Generics.Basics +Data.Generics + +gfoldlAccum +Data.Generics.Twins +Data.Generics + +glExtensions +Graphics.Rendering.OpenGL.GL.StringQueries +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +glVersion +Graphics.Rendering.OpenGL.GL.StringQueries +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +glength +Data.Generics.Schemes +Data.Generics + +global +Language.Haskell.TH.Lib +Language.Haskell.TH + +globalKeyRepeat +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +gluExtensions +Graphics.Rendering.OpenGL.GLU.Initialization +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +gluNurbsCurve +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +gluNurbsSurface +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +gluPwlCurve +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +gluVersion +Graphics.Rendering.OpenGL.GLU.Initialization +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +glutVersion +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +gmap +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +gmapAccumM +Data.Generics.Twins +Data.Generics + +gmapAccumQ +Data.Generics.Twins +Data.Generics + +gmapAccumQl +Data.Generics.Twins +Data.Generics + +gmapAccumQr +Data.Generics.Twins +Data.Generics + +gmapAccumT +Data.Generics.Twins +Data.Generics + +gmapM +Data.Generics.Basics +Data.Generics + +gmapMo +Data.Generics.Basics +Data.Generics + +gmapMp +Data.Generics.Basics +Data.Generics + +gmapQ +Data.Generics.Basics +Data.Generics + +gmapQi +Data.Generics.Basics +Data.Generics + +gmapQl +Data.Generics.Basics +Data.Generics + +gmapQr +Data.Generics.Basics +Data.Generics + +gmapT +Data.Generics.Basics +Data.Generics + +gnodecount +Data.Generics.Schemes +Data.Generics + +gr1 +Data.Graph.Inductive.Example + +grabButton +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +grabFrozen +Graphics.X11.Types +Graphics.X11.Xlib + +grabInvalidTime +Graphics.X11.Types +Graphics.X11.Xlib + +grabKey +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +grabKeyboard +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +grabModeAsync +Graphics.X11.Types +Graphics.X11.Xlib + +grabModeSync +Graphics.X11.Types +Graphics.X11.Xlib + +grabNotViewable +Graphics.X11.Types +Graphics.X11.Xlib + +grabPointer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +grabServer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +grabSuccess +Graphics.X11.Types +Graphics.X11.Xlib + +graphDff +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphDff' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphFilter +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphFilterM +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphFromEdges +Data.Graph + +graphFromEdges' +Data.Graph + +graphNodes +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphNodesM +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphNodesM0 +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphRec +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphRec' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphUFold +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +graphicsExpose +Graphics.X11.Types +Graphics.X11.Xlib + +graphviz +Data.Graph.Inductive.Graphviz +Data.Graph.Inductive + +graphviz' +Data.Graph.Inductive.Graphviz +Data.Graph.Inductive + +gravityNotify +Graphics.X11.Types +Graphics.X11.Xlib + +gray +Text.Html + +gread +Data.Generics.Text +Data.Generics + +green +Text.Html + +grev +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +group +Data.List + +groupBy +Data.List + +groupExecuteMode +System.Posix.Files +System.Posix + +groupID +System.Posix.User +System.Posix + +groupMembers +System.Posix.User +System.Posix + +groupModes +System.Posix.Files +System.Posix + +groupName +System.Posix.User +System.Posix + +groupReadMode +System.Posix.Files +System.Posix + +groupWriteMode +System.Posix.Files +System.Posix + +gsel +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +gshow +Data.Generics.Text +Data.Generics + +gsize +Data.Generics.Schemes +Data.Generics + +gtypecount +Data.Generics.Schemes +Data.Generics + +guard +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +guardedB +Language.Haskell.TH.Lib +Language.Haskell.TH + +gui +Text.Html + +gunfold +Data.Generics.Basics +Data.Generics + +gvdIn +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +gvdOut +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +gzip +Data.Generics.Twins +Data.Generics + +gzipWithM +Data.Generics.Twins +Data.Generics + +gzipWithQ +Data.Generics.Twins +Data.Generics + +gzipWithT +Data.Generics.Twins +Data.Generics + +HAlign +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +HBC +Distribution.Setup + +HPrintfType +Text.Printf + +HTML +Text.Html + +HTMLTABLE +Text.Html + +HaddockCmd +Distribution.Setup + +Handle +System.IO + +HandlePosn +System.IO + +Handler +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +HangupOnClose +System.Posix.Terminal +System.Posix + +HasBounds +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff + +HasGetter +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HasJobControl +System.Posix.Unistd +System.Posix + +HasSavedIDs +System.Posix.Unistd +System.Posix + +HasSetter +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HashTable +Data.HashTable + +Heap +Data.Graph.Inductive.Internal.Heap + +HeapOverflow +Control.Exception + +Height +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Helium +Distribution.Setup + +Help +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +HelpCmd +Distribution.Setup + +Helvetica10 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Helvetica12 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Helvetica18 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +HereDocuments +Distribution.Extension +Distribution.Simple + +Hidden +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +HintAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HintMode +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HintTarget +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HitRecord +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +HookedBuildInfo +Distribution.PackageDescription + +HostAddress +Network.Socket + +HostEntry +Network.BSD +Network.BSD + +HostName +Network.BSD +Network + +HotLink +Text.Html +Text.Html + +HsAlt +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsApp +Language.Haskell.Syntax + +HsAsPat +Language.Haskell.Syntax + +HsAssoc +Language.Haskell.Syntax + +HsAssocLeft +Language.Haskell.Syntax + +HsAssocNone +Language.Haskell.Syntax + +HsAssocRight +Language.Haskell.Syntax + +HsAsst +Language.Haskell.Syntax + +HsBangType +Language.Haskell.Syntax + +HsBangedTy +Language.Haskell.Syntax + +HsCName +Language.Haskell.Syntax + +HsCase +Language.Haskell.Syntax + +HsChar +Language.Haskell.Syntax + +HsCharPrim +Language.Haskell.Syntax + +HsClassDecl +Language.Haskell.Syntax + +HsCon +Language.Haskell.Syntax + +HsConDecl +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsConName +Language.Haskell.Syntax + +HsConOp +Language.Haskell.Syntax + +HsCons +Language.Haskell.Syntax + +HsContext +Language.Haskell.Syntax + +HsDataDecl +Language.Haskell.Syntax + +HsDecl +Language.Haskell.Syntax + +HsDefaultDecl +Language.Haskell.Syntax + +HsDo +Language.Haskell.Syntax + +HsDoublePrim +Language.Haskell.Syntax + +HsEAbs +Language.Haskell.Syntax + +HsEModuleContents +Language.Haskell.Syntax + +HsEThingAll +Language.Haskell.Syntax + +HsEThingWith +Language.Haskell.Syntax + +HsEVar +Language.Haskell.Syntax + +HsEnumFrom +Language.Haskell.Syntax + +HsEnumFromThen +Language.Haskell.Syntax + +HsEnumFromThenTo +Language.Haskell.Syntax + +HsEnumFromTo +Language.Haskell.Syntax + +HsExp +Language.Haskell.Syntax + +HsExpTypeSig +Language.Haskell.Syntax + +HsExportSpec +Language.Haskell.Syntax + +HsFieldUpdate +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsFloatPrim +Language.Haskell.Syntax + +HsFrac +Language.Haskell.Syntax + +HsFunBind +Language.Haskell.Syntax + +HsFunCon +Language.Haskell.Syntax + +HsGenerator +Language.Haskell.Syntax + +HsGuardedAlt +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsGuardedAlts +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsGuardedRhs +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsGuardedRhss +Language.Haskell.Syntax + +HsIAbs +Language.Haskell.Syntax + +HsIThingAll +Language.Haskell.Syntax + +HsIThingWith +Language.Haskell.Syntax + +HsIVar +Language.Haskell.Syntax + +HsIdent +Language.Haskell.Syntax + +HsIf +Language.Haskell.Syntax + +HsImportDecl +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsImportSpec +Language.Haskell.Syntax + +HsInfixApp +Language.Haskell.Syntax + +HsInfixDecl +Language.Haskell.Syntax + +HsInstDecl +Language.Haskell.Syntax + +HsInt +Language.Haskell.Syntax + +HsIntPrim +Language.Haskell.Syntax + +HsIrrPat +Language.Haskell.Syntax + +HsLambda +Language.Haskell.Syntax + +HsLeftSection +Language.Haskell.Syntax + +HsLet +Language.Haskell.Syntax + +HsLetStmt +Language.Haskell.Syntax + +HsList +Language.Haskell.Syntax + +HsListComp +Language.Haskell.Syntax + +HsListCon +Language.Haskell.Syntax + +HsLit +Language.Haskell.Syntax + +HsLiteral +Language.Haskell.Syntax + +HsMatch +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsModule +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsName +Language.Haskell.Syntax + +HsNegApp +Language.Haskell.Syntax + +HsNewTypeDecl +Language.Haskell.Syntax + +HsOp +Language.Haskell.Syntax + +HsPApp +Language.Haskell.Syntax + +HsPAsPat +Language.Haskell.Syntax + +HsPFieldPat +Language.Haskell.Syntax + +HsPInfixApp +Language.Haskell.Syntax + +HsPIrrPat +Language.Haskell.Syntax + +HsPList +Language.Haskell.Syntax + +HsPLit +Language.Haskell.Syntax + +HsPNeg +Language.Haskell.Syntax + +HsPParen +Language.Haskell.Syntax + +HsPRec +Language.Haskell.Syntax + +HsPTuple +Language.Haskell.Syntax + +HsPVar +Language.Haskell.Syntax + +HsPWildCard +Language.Haskell.Syntax + +HsParen +Language.Haskell.Syntax + +HsPat +Language.Haskell.Syntax + +HsPatBind +Language.Haskell.Syntax + +HsPatField +Language.Haskell.Syntax + +HsQConOp +Language.Haskell.Syntax + +HsQName +Language.Haskell.Syntax + +HsQOp +Language.Haskell.Syntax + +HsQVarOp +Language.Haskell.Syntax + +HsQualType +Language.Haskell.Syntax +Language.Haskell.Syntax + +HsQualifier +Language.Haskell.Syntax + +HsRecConstr +Language.Haskell.Syntax + +HsRecDecl +Language.Haskell.Syntax + +HsRecUpdate +Language.Haskell.Syntax + +HsRhs +Language.Haskell.Syntax + +HsRightSection +Language.Haskell.Syntax + +HsSpecialCon +Language.Haskell.Syntax + +HsStmt +Language.Haskell.Syntax + +HsString +Language.Haskell.Syntax + +HsStringPrim +Language.Haskell.Syntax + +HsSymbol +Language.Haskell.Syntax + +HsTuple +Language.Haskell.Syntax + +HsTupleCon +Language.Haskell.Syntax + +HsTyApp +Language.Haskell.Syntax + +HsTyCon +Language.Haskell.Syntax + +HsTyFun +Language.Haskell.Syntax + +HsTyTuple +Language.Haskell.Syntax + +HsTyVar +Language.Haskell.Syntax + +HsType +Language.Haskell.Syntax + +HsTypeDecl +Language.Haskell.Syntax + +HsTypeSig +Language.Haskell.Syntax + +HsUnBangedTy +Language.Haskell.Syntax + +HsUnGuardedAlt +Language.Haskell.Syntax + +HsUnGuardedRhs +Language.Haskell.Syntax + +HsUnitCon +Language.Haskell.Syntax + +HsVar +Language.Haskell.Syntax + +HsVarName +Language.Haskell.Syntax + +HsVarOp +Language.Haskell.Syntax + +HsWildCard +Language.Haskell.Syntax + +Html +Text.Html +Network.CGI +Text.Html + +HtmlAttr +Text.Html +Text.Html + +HtmlElement +Text.Html + +HtmlLeaf +Text.Html + +HtmlNode +Text.Html + +HtmlString +Text.Html + +HtmlTable +Text.Html +Text.Html + +HtmlTag +Text.Html + +HtmlTree +Text.Html + +Hugs +Distribution.Setup + +h1 +Text.Html + +h2 +Text.Html + +h3 +Text.Html + +h4 +Text.Html + +h5 +Text.Html + +h6 +Text.Html + +hClose +System.IO + +hFileSize +System.IO + +hFlush +System.IO + +hGetArray +Data.Array.IO + +hGetBuf +System.IO + +hGetBufNonBlocking +System.IO + +hGetBuffering +System.IO + +hGetChar +System.IO + +hGetContents +System.IO + +hGetEcho +System.IO + +hGetLine +System.IO + +hGetPS +Data.PackedString + +hGetPosn +System.IO + +hIsClosed +System.IO + +hIsEOF +System.IO + +hIsOpen +System.IO + +hIsReadable +System.IO + +hIsSeekable +System.IO + +hIsTerminalDevice +System.IO + +hIsWritable +System.IO + +hLookAhead +System.IO + +hPrint +System.IO + +hPrintf +Text.Printf + +hPutArray +Data.Array.IO + +hPutBuf +System.IO + +hPutBufNonBlocking +System.IO + +hPutChar +System.IO + +hPutPS +Data.PackedString + +hPutStr +System.IO + +hPutStrLn +System.IO + +hReady +System.IO + +hSeek +System.IO + +hSetBinaryMode +System.IO + +hSetBuffering +System.IO + +hSetEcho +System.IO + +hSetFileSize +System.IO + +hSetPosn +System.IO + +hShow +System.IO + +hTell +System.IO + +hWaitForInput +System.IO + +haddockHTMLs +Distribution.InstalledPackageInfo + +haddockInterfaces +Distribution.InstalledPackageInfo + +handle +Control.Exception + +handleJust +Control.Exception + +handleToFd +System.Posix.IO +System.Posix + +hang +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +hardLimit +System.Posix.Resource +System.Posix + +hasKeyboard +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +hasLibs +Distribution.PackageDescription + +hasLoop +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +hasOverlay +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +hashInt +Data.HashTable + +hashStableName +System.Mem.StableName + +hashString +Data.HashTable + +hashUnique +Data.Unique + +haskell +Text.ParserCombinators.Parsec.Language + +haskellDef +Text.ParserCombinators.Parsec.Language + +haskellStyle +Text.ParserCombinators.Parsec.Language + +haveRtldLocal +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +haveRtldNext +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +hcOptions +Distribution.PackageDescription + +hcat +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +head +Data.List +Prelude + +headPS +Data.PackedString + +header +Text.Html + +heapsort +Data.Graph.Inductive.Internal.Heap + +height +Text.Html + +heightMMOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +heightOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +hexDigit +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +hexadecimal +Text.ParserCombinators.Parsec.Token + +hidden +Text.Html + +hiddenModules +Distribution.InstalledPackageInfo + +hiding_name +Language.Haskell.Syntax + +hint +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +histogramLuminanceSize +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +histogramRGBASizes +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +homeDirectory +System.Posix.User +System.Posix + +homepage +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +hookedPreProcessors +Distribution.Simple + +hostAddress +Network.BSD + +hostAddresses +Network.BSD + +hostAliases +Network.BSD + +hostFamily +Network.BSD + +hostName +Network.BSD + +hotLinkAttributes +Text.Html + +hotLinkContents +Text.Html + +hotLinkURL +Text.Html + +hotlink +Text.Html + +hr +Text.Html + +href +Text.Html + +hsLex +Text.Read.Lex + +hsLibraries +Distribution.InstalledPackageInfo + +hsSourceDir +Distribution.PackageDescription + +hs_libraries +Distribution.Simple.GHCPackageConfig + +hsep +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +hspace +Text.Html + +httpequiv +Text.Html + +hugsMainFilename +Distribution.Simple.Install + +hugsOptions +Distribution.InstalledPackageInfo + +hugsPackageDir +Distribution.Simple.Install + +hugsProgramsDirs +Distribution.Simple.Install + +I# +GHC.Exts + +IArray +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff + +IO +System.IO +Prelude + +IOArray +Data.Array.IO + +IOError +System.IO.Error +Prelude + +IOErrorType +System.IO.Error + +IOException +Control.Exception +Control.Exception + +IOMode +System.IO + +IORef +Data.IORef + +IOToDiffArray +Data.Array.Diff + +IOUArray +Data.Array.IO + +IToA +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IToB +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IToG +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IToI +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IToR +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Iconified +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Icosahedron +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +Ident +Text.Read.Lex +Text.Read + +Identity +Control.Monad.Identity +Control.Monad.Identity + +IdleCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Ignore +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +IgnoreBreak +System.Posix.Terminal +System.Posix + +IgnoreCR +System.Posix.Terminal +System.Posix + +IgnoreParityErrors +System.Posix.Terminal +System.Posix + +Immediately +System.Posix.Terminal +System.Posix + +ImplicitParams +Distribution.Extension +Distribution.Simple + +ImportF +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InUse +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Indent +Language.Haskell.Pretty + +Index +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Index1 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IndexArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IndexComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IndexMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IndexOutOfBounds +Control.Exception + +Infix +Data.Generics.Basics +Data.Generics +Text.ParserCombinators.Parsec.Expr + +InfixC +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfixE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfixL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfixN +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfixP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfixR +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Info +Graphics.UI.GLUT.Window +Graphics.UI.GLUT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +InfoQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Inherit +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +InlinePhase +Distribution.Extension +Distribution.Simple + +InputLineLimit +System.Posix.Files +System.Posix + +InputQueue +System.Posix.Terminal +System.Posix + +InputQueueLimit +System.Posix.Files +System.Posix + +Inside +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +InsideFrame +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +InstallCmd +Distribution.Setup + +InstallFlags +Distribution.Setup + +InstalledPackageInfo +Distribution.InstalledPackageInfo +Distribution.InstalledPackageInfo + +InstanceD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Int +Data.Int +Foreign +Prelude +GHC.Exts +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Text.Read.Lex +Text.Read + +Int16 +Data.Int +Foreign + +Int32 +Data.Int +Foreign + +Int64 +Data.Int +Foreign + +Int8 +Data.Int +Foreign + +IntConstr +Data.Generics.Basics +Data.Generics + +IntMap +Data.IntMap + +IntPrimL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +IntRep +Data.Generics.Basics +Data.Generics + +IntSet +Data.IntSet + +Integer +Prelude +GHC.Exts + +IntegerL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Integral +Prelude + +Intensity +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Intensity12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Intensity16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Intensity4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Intensity8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +InterleavedArrays +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Interpolate +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Interrupt +System.Posix.Terminal +System.Posix + +InterruptOnBreak +System.Posix.Terminal +System.Posix + +IntersectVersionRanges +Distribution.Version +Distribution.Simple + +InvalidEnum +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +InvalidOperation +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +InvalidValue +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Invert +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +IsAtLeast +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsChar +Text.Printf + +IsEqualTo +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsGreaterThan +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsLessThan +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsNotEqualTo +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsNotGreaterThan +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsNotLessThan +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +IsStrict +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Ix +Data.Ix +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff + +iNADDR_ANY +Network.Socket + +iNTEGER +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +iShiftL# +GHC.Exts + +iShiftRA# +GHC.Exts + +iShiftRL# +GHC.Exts + +iTALIC_ANGLE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +iconTitle +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +iconifyWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +id +Prelude + +identLetter +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +identStart +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +identifier +Text.Html +Text.ParserCombinators.Parsec.Token + +idleCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +illegalInstruction +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +illegalOperationErrorType +System.IO.Error + +imagPart +Data.Complex + +image +Text.Html + +imageByteOrder +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +imageHeight +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +importAs +Language.Haskell.Syntax + +importDirs +Distribution.InstalledPackageInfo + +importLoc +Language.Haskell.Syntax + +importModule +Language.Haskell.Syntax + +importQualified +Language.Haskell.Syntax + +importSpecs +Language.Haskell.Syntax + +import_dirs +Distribution.Simple.GHCPackageConfig + +inRange +Data.Ix +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff + +inSignalSet +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +incSourceColumn +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +incSourceLine +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +includeDirs +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +includeInferiors +Graphics.X11.Types +Graphics.X11.Xlib + +include_dirs +Distribution.Simple.GHCPackageConfig + +includes +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +indeg +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +indeg' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +indegree +Data.Graph + +indep +Data.Graph.Inductive.Query.Indep +Data.Graph.Inductive.Query +Data.Graph.Inductive + +index +Data.Ix +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +indexConstr +Data.Generics.Basics +Data.Generics + +indexMask +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +indexOffset +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +indexPS +Data.PackedString + +indexShift +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +indexv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +indices +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff +Data.Array + +inet_addr +Network.Socket + +inet_ntoa +Network.Socket + +infixApp +Language.Haskell.TH.Lib +Language.Haskell.TH + +infixC +Language.Haskell.TH.Lib +Language.Haskell.TH + +infixE +Language.Haskell.TH.Lib +Language.Haskell.TH + +infixP +Language.Haskell.TH.Lib +Language.Haskell.TH + +init +Data.List +Prelude + +initialDisplayCapabilities +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +initialDisplayMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +initialPos +Text.ParserCombinators.Parsec.Pos + +initialWindowPosition +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +initialWindowSize +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +initialise +System.Console.SimpleLineEditor + +initialize +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT +System.Console.Readline + +inits +Data.List + +inn +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +inn' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +input +Text.Html + +inputOnly +Graphics.X11.Types +Graphics.X11.Xlib + +inputOutput +Graphics.X11.Types +Graphics.X11.Xlib + +inputSpeed +System.Posix.Terminal +System.Posix + +inputTime +System.Posix.Terminal +System.Posix + +insEdge +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +insEdges +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +insMapEdge +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapEdgeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapEdges +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapEdgesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNode +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNodeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNode_ +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNodes +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNodesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insMapNodes_ +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +insNode +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +insNodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +insert +Data.Graph.Inductive.Internal.Heap +Data.HashTable +Data.IntMap +Data.IntSet +Data.List +Data.Map +Data.Set + +insertBy +Data.List + +insertCompletions +System.Console.Readline + +insertLookupWithKey +Data.IntMap +Data.Map + +insertText +System.Console.Readline + +insertWith +Data.IntMap +Data.Map + +insertWithKey +Data.IntMap +Data.Map + +install +Distribution.Simple.Install + +installColormap +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +installHandler +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +installedPkgConfigFile +Distribution.Simple.Register + +instanceD +Language.Haskell.TH.Lib +Language.Haskell.TH + +int +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +intAttr +Text.Html + +intPrimL +Language.Haskell.TH.Lib +Language.Haskell.TH + +intToDigit +Data.Char + +integer +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +integerL +Language.Haskell.TH.Lib +Language.Haskell.TH + +interact +System.IO +Prelude + +interleavedArrays +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +internAtom +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +internalAbort +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +intersect +Data.List +Data.Set + +intersectBy +Data.List + +intersectFM +Data.FiniteMap + +intersectFM_C +Data.FiniteMap + +intersectFileModes +System.Posix.Files +System.Posix + +intersectRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +intersection +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +intersectionWith +Data.IntMap +Data.Map + +intersectionWithKey +Data.IntMap +Data.Map + +intersperse +Data.List + +intervals +System.Locale + +ioError +System.IO.Error +Prelude +Control.Exception + +ioErrors +Control.Exception + +ioToDraw +Graphics.HGL.Draw.Monad +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +ioeGetErrorString +System.IO.Error + +ioeGetErrorType +System.IO.Error + +ioeGetFileName +System.IO.Error + +ioeGetHandle +System.IO.Error + +ioeSetErrorString +System.IO.Error + +ioeSetErrorType +System.IO.Error + +ioeSetFileName +System.IO.Error + +ioeSetHandle +System.IO.Error + +isAbsolutePath +Distribution.Compat.FilePath + +isAbsoluteURI +Network.URI + +isAlgType +Data.Generics.Basics +Data.Generics + +isAllowedInURI +Network.URI + +isAlpha +Data.Char + +isAlphaNum +Data.Char + +isAlreadyExistsError +System.IO.Error + +isAlreadyExistsErrorType +System.IO.Error + +isAlreadyInUseError +System.IO.Error + +isAlreadyInUseErrorType +System.IO.Error + +isAscii +Data.Char + +isAssociative +Test.QuickCheck.Utils +Debug.QuickCheck.Utils + +isAssociativeBy +Test.QuickCheck.Utils +Debug.QuickCheck.Utils + +isBackSpaceKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isBlockDevice +System.Posix.Files +System.Posix + +isBottom +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +isCharKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isCharacterDevice +System.Posix.Files +System.Posix + +isClearKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isCommutable +Test.QuickCheck.Utils +Debug.QuickCheck.Utils + +isCommutableBy +Test.QuickCheck.Utils +Debug.QuickCheck.Utils + +isConnected +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +isControl +Data.Char + +isControlLKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isControlRKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isCurrentThreadBound +Control.Concurrent + +isDeleteKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isDenormalized +Prelude + +isDigit +Data.Char + +isDirectory +System.Posix.Files +System.Posix + +isDoesNotExistError +System.IO.Error + +isDoesNotExistErrorType +System.IO.Error + +isDown +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +isDownKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isEOF +System.IO + +isEOFError +System.IO.Error + +isEOFErrorType +System.IO.Error + +isEmpty +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Data.Graph.Inductive.Internal.Heap +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +isEmptyChan +Control.Concurrent.Chan +Control.Concurrent + +isEmptyFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +isEmptyM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +isEmptyMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +isEmptySampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +isEmptySet +Data.Set + +isEmptyTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +isEmptyTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +isEndKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isEscapeKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isFullError +System.IO.Error + +isFullErrorType +System.IO.Error + +isHexDigit +Data.Char + +isHomeKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isIEEE +Prelude + +isIPv4address +Network.URI + +isIPv6address +Network.URI + +isIllegalOperation +System.IO.Error + +isIllegalOperationErrorType +System.IO.Error + +isInfinite +Prelude + +isJust +Data.Maybe + +isLatin1 +Data.Char + +isLeft +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +isLeftKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isList +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +isLower +Data.Char + +isNaN +Prelude + +isNamedPipe +System.Posix.Files +System.Posix + +isNegativeZero +Prelude + +isNextKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isNorepType +Data.Generics.Basics +Data.Generics + +isNothing +Data.Maybe + +isObjectName +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +isOctDigit +Data.Char + +isPageDownKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isPageUpKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isPathSeparator +Distribution.Compat.FilePath + +isPermissionError +System.IO.Error + +isPermissionErrorType +System.IO.Error + +isPrefixOf +Data.List + +isPrint +Data.Char + +isPriorKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isProperSubmapOf +Data.IntMap +Data.Map + +isProperSubmapOfBy +Data.IntMap +Data.Map + +isProperSubsetOf +Data.IntSet +Data.Set + +isRegularFile +System.Posix.Files +System.Posix + +isRelativeReference +Network.URI + +isReserved +Network.URI + +isReturnKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isRightKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isRootedPath +Distribution.Compat.FilePath + +isShiftLKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isShiftRKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isSigned +Data.Bits +Foreign + +isSimple +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +isSocket +System.Posix.Files +System.Posix + +isSpace +Data.Char + +isStrict +Language.Haskell.TH.Lib +Language.Haskell.TH + +isSubmapOf +Data.IntMap +Data.Map + +isSubmapOfBy +Data.IntMap +Data.Map + +isSubsetOf +Data.IntSet +Data.Set + +isSuffixOf +Data.List + +isSymbolicLink +System.Posix.Files +System.Posix + +isTabKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isTotalOrder +Test.QuickCheck.Utils +Debug.QuickCheck.Utils + +isURI +Network.URI + +isURIReference +Network.URI + +isUnescapedInURI +Network.URI + +isUnreserved +Network.URI + +isUpKey +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +isUpper +Data.Char + +isUserError +System.IO.Error + +isUserErrorType +System.IO.Error + +isValidErrno +Foreign.C.Error +Foreign.C + +ismap +Text.Html + +iso8601DateFormat +System.Locale + +itag +Text.Html + +italics +Text.Html + +iterate +Data.List +Prelude + +ixmap +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array + +J# +GHC.Exts + +January +System.Time + +JoinStyle +Graphics.X11.Types +Graphics.X11.Xlib + +JoystickButtons +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +JoystickCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +JoystickPosition +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +July +System.Time + +June +System.Time + +Just +Data.Maybe +Prelude + +javaStyle +Text.ParserCombinators.Parsec.Language + +join +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +joinBevel +Graphics.X11.Types +Graphics.X11.Xlib + +joinFileExt +Distribution.Compat.FilePath + +joinFileName +Distribution.Compat.FilePath + +joinMiter +Graphics.X11.Types +Graphics.X11.Xlib + +joinPS +Data.PackedString + +joinPaths +Distribution.Compat.FilePath + +joinProcessGroup +System.Posix.Process +System.Posix + +joinRound +Graphics.X11.Types +Graphics.X11.Xlib + +joystickButtonA +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +joystickButtonB +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +joystickButtonC +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +joystickButtonD +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +joystickCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +joystickInfo +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +KeepAlive +Network.Socket + +Key +Data.IntMap +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyCode +Graphics.X11.Types +Graphics.X11.Xlib + +KeyDown +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyEnd +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF1 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF10 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF11 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF12 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF2 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF3 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF4 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF5 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF6 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF7 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF8 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyF9 +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyHome +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyInsert +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyLeft +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyMask +Graphics.X11.Types +Graphics.X11.Xlib + +KeyPageDown +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyPageUp +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyRight +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyState +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeySym +Graphics.X11.Types +Graphics.X11.Xlib + +KeyUp +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +KeyboardInterrupts +System.Posix.Terminal +System.Posix + +KeyboardMouseCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Keymap +System.Console.Readline +System.Console.Readline + +Kill +System.Posix.Terminal +System.Posix + +Kleisli +Control.Arrow +Control.Arrow + +keyPress +Graphics.X11.Types +Graphics.X11.Xlib + +keyPressMask +Graphics.X11.Types +Graphics.X11.Xlib + +keyRelease +Graphics.X11.Types +Graphics.X11.Xlib + +keyReleaseMask +Graphics.X11.Types +Graphics.X11.Xlib + +keyToChar +Graphics.HGL.Key +Graphics.HGL.Core +Graphics.HGL + +keyboard +Text.Html + +keyboardMouseCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +keyboardSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +keyboardStop +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +keyboardTermination +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +keycodeToKeysym +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +keymapNotify +Graphics.X11.Types +Graphics.X11.Xlib + +keymapStateMask +Graphics.X11.Types +Graphics.X11.Xlib + +keys +Data.IntMap +Data.Map + +keysFM +Data.FiniteMap + +keysFM_GE +Data.FiniteMap + +keysFM_LE +Data.FiniteMap + +keysSet +Data.IntMap +Data.Map + +keysym +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +keysymToKeycode +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +keysymToString +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +killProcess +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +killText +System.Console.Readline + +killThread +GHC.Conc +Control.Concurrent + +kin248 +Data.Graph.Inductive.Example + +kin248' +Data.Graph.Inductive.Example + +knownSuffixHandlers +Distribution.PreProcess + +LEdge +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +LGPL +Distribution.License +Distribution.Make +Distribution.Simple + +LNode +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +LOD +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LP +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +LPath +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +LRTree +Data.Graph.Inductive.Internal.RootPath + +LT +Prelude + +Label +Test.HUnit.Base +Test.HUnit + +LamE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Landscape +Data.Graph.Inductive.Graphviz +Data.Graph.Inductive + +LanguageDef +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +LaterVersion +Distribution.Version +Distribution.Simple + +Layer +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +Left +Data.Either +Prelude + +Left' +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +LeftArrow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +LeftBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LeftButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +LeftMode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +LeftRight +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +LeftSide +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Lequal +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LequalR +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Less +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LetE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +LetS +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Level +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Lexeme +Text.Read.Lex +Text.Read + +Library +Distribution.PackageDescription +Distribution.PackageDescription + +License +Distribution.License +Distribution.Make +Distribution.Simple + +Lift +Language.Haskell.TH.Syntax + +Light +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LightModelColorControl +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LightingAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Limit +System.Posix.Types +System.Posix + +Line +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +LineAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LineBuffering +System.IO + +LineLoop +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LineNo +Distribution.PackageDescription + +LineResetToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LineSmooth +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LineStrip +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LineStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +LineToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Linear +Graphics.Rendering.OpenGL.GL.Fog +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Linear' +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Lines +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Linger +Network.Socket + +LinkCount +System.Posix.Types +System.Posix + +LinkLimit +System.Posix.Files +System.Posix + +ListArc +Graphics.X11.Xlib.Types + +ListAssertable +Test.HUnit.Base +Test.HUnit + +ListAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ListColor +Graphics.X11.Xlib.Types + +ListE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ListItem +Test.HUnit.Base +Test.HUnit + +ListMode +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ListP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ListPoint +Graphics.X11.Xlib.Types + +ListRectangle +Graphics.X11.Xlib.Types + +ListSegment +Graphics.X11.Xlib.Types + +ListT +Control.Monad.List +Control.Monad.List +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Listening +Network.Socket + +Lit +Language.Haskell.TH.Syntax +Language.Haskell.TH + +LitE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +LitP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Load +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LocalBuildInfo +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +LocalMode +System.Posix.Terminal +System.Posix + +LockRequest +System.Posix.IO +System.Posix + +LogicOp +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Loops +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LossOfPrecision +Control.Exception + +Luminance +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance12Alpha12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance12Alpha4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance16Alpha16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance4Alpha4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance6Alpha2 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Luminance8Alpha8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LuminanceAlpha +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LuminanceAlpha' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +LuminanceMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +lASTEvent +Graphics.X11.Types +Graphics.X11.Xlib + +lAST_PREDEFINED +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +lSBFirst +Graphics.X11.Types +Graphics.X11.Xlib + +lab +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +lab' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +labEdges +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +labEdgesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +labM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +labNode' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +labNodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +labNodesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +labUEdges +Data.Graph.Inductive.Example + +label +Test.QuickCheck +Debug.QuickCheck +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +labelThread +GHC.Conc + +labels +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +lam1E +Language.Haskell.TH.Lib +Language.Haskell.TH + +lamE +Language.Haskell.TH.Lib +Language.Haskell.TH + +lang +Text.Html + +last +Data.List +Prelude + +lastExtensionError +Graphics.X11.Types +Graphics.X11.Xlib + +lastKnownRequestProcessed +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +layerInUse +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +layout +Language.Haskell.Pretty + +lazyToStrictST +Control.Monad.ST.Lazy + +lbft +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +lbrace +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +lbrack +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +lcm +Prelude + +ldOptions +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +leaveGameMode +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +leaveMainLoop +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +leaveNotify +Graphics.X11.Types +Graphics.X11.Xlib + +leaveWindowMask +Graphics.X11.Types +Graphics.X11.Xlib + +left +Control.Arrow + +leftApp +Control.Arrow + +legend +Text.Html + +length +Data.List +Prelude + +lengthArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +lengthPS +Data.PackedString + +length_of_tests +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +lesp +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +letE +Language.Haskell.TH.Lib +Language.Haskell.TH + +letIndent +Language.Haskell.Pretty + +letS +Language.Haskell.TH.Lib +Language.Haskell.TH + +letter +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +level +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +leveln +Data.Graph.Inductive.Query.BFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +levels +Data.Tree + +lex +Text.Read +Prelude +Text.Read.Lex + +lexChar +Text.Read.Lex + +lexDigits +Numeric + +lexLitChar +Data.Char + +lexP +Text.Read + +lexeme +Text.ParserCombinators.Parsec.Token + +li +Text.Html + +libBuildInfo +Distribution.PackageDescription + +libModules +Distribution.PackageDescription + +library +Distribution.PackageDescription + +libraryDirs +Distribution.InstalledPackageInfo + +library_dirs +Distribution.Simple.GHCPackageConfig + +license +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +licenseFile +Distribution.PackageDescription + +lift +Control.Monad.Trans +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List +Language.Haskell.TH.Syntax +Text.ParserCombinators.ReadPrec +Text.Read + +liftIO +Control.Monad.Trans +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +liftM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +liftM2 +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +liftM3 +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +liftM4 +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +liftM5 +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +light +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lightModelAmbient +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lightModelColorControl +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lightModelLocalViewer +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lightModelTwoSide +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lighting +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lime +Text.Html + +line +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +lineDoubleDash +Graphics.X11.Types +Graphics.X11.Xlib + +lineLength +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +lineOnOffDash +Graphics.X11.Types +Graphics.X11.Xlib + +linePragmas +Language.Haskell.Pretty + +lineSmooth +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lineSolid +Graphics.X11.Types +Graphics.X11.Xlib + +lineStipple +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lineToHtml +Text.Html + +lineWidth +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lines +Data.List +Prelude + +linesPS +Data.PackedString + +linesToHtml +Text.Html + +link +Text.Html + +linkCount +System.Posix.Files +System.Posix + +listArray +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array + +listAssert +Test.HUnit.Base +Test.HUnit + +listBase +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +listE +Language.Haskell.TH.Lib +Language.Haskell.TH + +listFunmapNames +System.Console.Readline + +listIndex +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +listMode +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +listP +Language.Haskell.TH.Lib +Language.Haskell.TH + +listT +Language.Haskell.TH.Lib +Language.Haskell.TH + +listToFM +Data.FiniteMap + +listToMaybe +Data.Maybe + +listToQueue +Data.Queue + +list_cons_name +Language.Haskell.Syntax + +list_tycon +Language.Haskell.Syntax + +list_tycon_name +Language.Haskell.Syntax + +listen +Control.Monad.Writer +Control.Monad.RWS +Network.Socket + +listenOn +Network + +listens +Control.Monad.Writer +Control.Monad.RWS + +listify +Data.Generics.Schemes +Data.Generics + +litE +Language.Haskell.TH.Lib +Language.Haskell.TH + +litP +Language.Haskell.TH.Lib +Language.Haskell.TH + +loadIdentity +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +loadName +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +loadQueryFont +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +loadSamplingMatrices +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +local +Control.Monad.Reader +Control.Monad.RWS + +localBuildInfoFile +Distribution.Simple.Configure + +localPackageConfig +Distribution.Simple.GHCPackageConfig + +lockArrays +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lockMapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +lockMask +Graphics.X11.Types +Graphics.X11.Xlib + +log +Prelude + +logBase +Prelude + +logicOp +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +longestChain +Data.HashTable + +look +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +lookAhead +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +lookAt +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lookup +Data.HashTable +Data.IntMap +Data.Map +Data.List +Prelude + +lookupColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +lookupFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +lookupIndex +Data.Map + +lookupKeysym +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +lookupString +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +lookupWithDefaultFM +Data.FiniteMap + +loop +Control.Arrow +Data.Graph.Inductive.Example + +loop' +Data.Graph.Inductive.Example + +lostConnection +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +lower +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +lowerHighest +Graphics.X11.Types +Graphics.X11.Xlib + +lowerWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +lparen +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +lpre +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +lpre' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +lsbFirst +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +lsuc +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +lsuc' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +MArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +MContext +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +MGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +MVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +Macro +System.Console.Readline + +Magenta +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +MagnificationFilter +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MainLoopReturns +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +Map +Data.Map + +Map1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Map2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MapCRtoLF +System.Posix.Terminal +System.Posix + +MapDescriptor +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MapLFtoCR +System.Posix.Terminal +System.Posix + +MappingFailed +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MappingFailure +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MappingRequest +Graphics.X11.Types +Graphics.X11.Xlib + +March +System.Time + +MarkParityErrors +System.Posix.Terminal +System.Posix + +Mask +Graphics.X11.Types +Graphics.X11.Xlib + +Match +Language.Haskell.TH.Syntax +Language.Haskell.TH +Language.Haskell.TH.Syntax +Language.Haskell.TH + +MatchQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Matrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MatrixComponent +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MatrixIndexArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MatrixMode +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MatrixOrder +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MatrixPalette +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Max +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MaxSegment +Network.Socket + +May +System.Time + +Maybe +Data.Maybe +Prelude + +Menu +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +MenuCallback +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +MenuEntry +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +MenuItem +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +MenuStatusCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +MenuUsage +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Message +Text.ParserCombinators.Parsec.Error +Text.ParserCombinators.Parsec.Error + +MiddleButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Min +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MinificationFilter +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Mirrored +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MkQueue +Data.Graph.Inductive.Internal.Queue + +MkSocket +Network.Socket + +ModName +Language.Haskell.TH.Syntax + +Mode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +Modelview +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Modifier +Graphics.X11.Types +Graphics.X11.Xlib + +Modifiers +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Modulate +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Modulate' +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Module +Language.Haskell.Syntax +Language.Haskell.Syntax +System.Posix.DynamicLinker.Module + +Monad +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +MonadCont +Control.Monad.Cont + +MonadError +Control.Monad.Error + +MonadFix +Control.Monad.Fix +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Error + +MonadIO +Control.Monad.Trans +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +MonadPlus +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +MonadReader +Control.Monad.Reader +Control.Monad.RWS + +MonadState +Control.Monad.State +Control.Monad.RWS + +MonadTrans +Control.Monad.Trans +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +MonadWriter +Control.Monad.Writer +Control.Monad.RWS + +Monday +System.Time + +MonoRoman +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Monoid +Data.Monoid +Control.Monad.Writer +Control.Monad.RWS + +Month +System.Time + +MotionCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +MouseButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +MouseMove +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +Mult +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +MultiParamTypeClasses +Distribution.Extension +Distribution.Simple + +MultisampleAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Multisampling +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +mAX_SPACE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +mIN_SPACE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +mSBFirst +Graphics.X11.Types +Graphics.X11.Xlib + +machine +System.Posix.Unistd +System.Posix + +magnitude +Data.Complex + +mainLoop +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +mainLoopEvent +Graphics.UI.GLUT.Begin +Graphics.UI.GLUT + +main_mod +Language.Haskell.Syntax + +main_name +Language.Haskell.Syntax + +maintainer +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +makeGettableStateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +makeSettableStateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +makeStableName +System.Mem.StableName + +makeStateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +makeTokenParser +Text.ParserCombinators.Parsec.Token + +malloc +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +mallocArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +mallocArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +mallocBytes +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +mallocForeignPtr +Foreign.ForeignPtr +Foreign + +mallocForeignPtrArray +Foreign.ForeignPtr +Foreign + +mallocForeignPtrArray0 +Foreign.ForeignPtr +Foreign + +mallocForeignPtrBytes +Foreign.ForeignPtr +Foreign + +many +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +many1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +manyTill +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +map +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Data.List +Prelude + +map1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +map2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +mapAccum +Data.IntMap +Data.Map + +mapAccumL +Data.List + +mapAccumR +Data.List + +mapAccumWithKey +Data.IntMap +Data.Map + +mapAndUnzipM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +mapArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +mapColor +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +mapCont +Control.Monad.Cont + +mapContT +Control.Monad.Cont + +mapErrorT +Control.Monad.Error + +mapException +Control.Exception + +mapFM +Data.FiniteMap + +mapFst +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +mapGrid1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +mapGrid2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +mapIndices +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +mapKeys +Data.Map + +mapKeysMonotonic +Data.Map + +mapKeysWith +Data.Map + +mapListT +Control.Monad.List + +mapM +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +mapM_ +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +mapMaybe +Data.Maybe + +mapMonotonic +Data.Set + +mapNotify +Graphics.X11.Types +Graphics.X11.Xlib + +mapPS +Data.PackedString + +mapRWS +Control.Monad.RWS + +mapRWST +Control.Monad.RWS + +mapReader +Control.Monad.Reader +Control.Monad.RWS + +mapReaderT +Control.Monad.Reader +Control.Monad.RWS + +mapRequest +Graphics.X11.Types +Graphics.X11.Xlib + +mapSet +Data.Set + +mapSnd +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +mapState +Control.Monad.State +Control.Monad.RWS + +mapStateT +Control.Monad.State +Control.Monad.RWS + +mapStencil +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +mapSubwindows +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +mapWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +mapWithKey +Data.IntMap +Data.Map + +mapWriter +Control.Monad.Writer +Control.Monad.RWS + +mapWriterT +Control.Monad.Writer +Control.Monad.RWS + +mappend +Data.Monoid +Control.Monad.Writer +Control.Monad.RWS + +mappingKeyboard +Graphics.X11.Types +Graphics.X11.Xlib + +mappingModifier +Graphics.X11.Types +Graphics.X11.Xlib + +mappingNotify +Graphics.X11.Types +Graphics.X11.Xlib + +mappingPointer +Graphics.X11.Types +Graphics.X11.Xlib + +marginheight +Text.Html + +marginwidth +Text.Html + +markupAttrs +Text.Html + +markupContent +Text.Html + +markupTag +Text.Html + +maroon +Text.Html + +marshalObject +GHC.Dotnet + +marshalString +GHC.Dotnet + +maskEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +match +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Language.Haskell.TH.Lib +Language.Haskell.TH + +matchAny +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +matchAnyM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +matchM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +matchRegex +Text.Regex + +matchRegexAll +Text.Regex + +materialAmbient +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialAmbientAndDiffuse +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialColorIndexes +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialDiffuse +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialEmission +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialShininess +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +materialSpecular +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +matrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +matrixMode +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +max +Prelude + +maxBound +Prelude + +maxClipPlanes +Graphics.Rendering.OpenGL.GL.Clipping +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxCmapsOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +maxConstrIndex +Data.Generics.Basics +Data.Generics + +maxConvolutionHeight +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxConvolutionWidth +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxElementsIndices +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxElementsVertices +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +maxFlow +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +maxFlowgraph +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +maxLights +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxListNesting +Graphics.Rendering.OpenGL.GL.DisplayLists +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxListenQueue +Network.Socket + +maxNameStackDepth +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxOrder +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxPixelMapTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxPrecedence +Language.Haskell.TH.Syntax +Language.Haskell.TH + +maxRequestSize +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +maxShininess +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxSpotExponent +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxStackDepth +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxTextureLODBias +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxTextureMaxAnisotropy +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxTextureUnit +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maxViewportDims +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +maximum +Data.List +Prelude + +maximumBy +Data.List + +maxlength +Text.Html + +maybe +Data.Maybe +Prelude + +maybeCreateLocalPackageConfig +Distribution.Simple.GHCPackageConfig + +maybeExit +Distribution.Simple.Utils + +maybeGetWindowEvent +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +maybeNew +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +maybePeek +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +maybeToList +Data.Maybe + +maybeWith +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +mconcat +Data.Monoid +Control.Monad.Writer +Control.Monad.RWS + +member +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +mempty +Data.Monoid +Control.Monad.Writer +Control.Monad.RWS + +menu +Text.Html + +menuStatusCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +merge +Data.Graph.Inductive.Internal.Heap + +mergeAll +Data.Graph.Inductive.Internal.Heap + +mergeError +Text.ParserCombinators.Parsec.Error + +mergeIO +Control.Concurrent + +message +System.Console.Readline + +messageCompare +Text.ParserCombinators.Parsec.Error + +messageEq +Text.ParserCombinators.Parsec.Error + +messageString +Text.ParserCombinators.Parsec.Error + +meta +Text.Html + +method +Text.Html + +mf +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +mfix +Control.Monad.Fix +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Error + +mfmg +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +min +Prelude + +minBound +Prelude + +minCmapsOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +minFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +minInput +System.Posix.Terminal +System.Posix + +minPrec +Text.ParserCombinators.ReadPrec +Text.Read + +minimum +Data.List +Prelude + +minimumBy +Data.List + +minmax +Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +minusFM +Data.FiniteMap + +minusPtr +Foreign.Ptr +Foreign + +minusSet +Data.Set + +minus_name +Language.Haskell.Syntax + +mkAppTy +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +mkBinDir +Distribution.Simple.Install + +mkBrush +Graphics.HGL.Draw.Brush +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +mkConstr +Data.Generics.Basics +Data.Generics + +mkDataType +Data.Generics.Basics +Data.Generics + +mkEdge +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkEdgeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkEdges +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkEdgesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkFloatConstr +Data.Generics.Basics +Data.Generics + +mkFloatType +Data.Generics.Basics +Data.Generics + +mkFont +Graphics.HGL.Draw.Font +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +mkFunTy +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +mkGHCPackageConfig +Distribution.Simple.GHCPackageConfig + +mkGraph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +mkGraphM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +mkHtmlTable +Text.Html + +mkIOError +System.IO.Error + +mkIntConstr +Data.Generics.Basics +Data.Generics + +mkIntType +Data.Generics.Basics +Data.Generics + +mkLibDir +Distribution.Simple.Install + +mkLibName +Distribution.Simple.Utils + +mkM +Data.Generics.Aliases +Data.Generics + +mkMapGraph +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkModName +Language.Haskell.TH.Syntax + +mkMp +Data.Generics.Aliases +Data.Generics + +mkName +Language.Haskell.TH.Syntax +Language.Haskell.TH + +mkNameG_d +Language.Haskell.TH.Syntax + +mkNameG_tc +Language.Haskell.TH.Syntax + +mkNameG_v +Language.Haskell.TH.Syntax + +mkNameL +Language.Haskell.TH.Syntax + +mkNameU +Language.Haskell.TH.Syntax + +mkNode +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNodeM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNode_ +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNodes +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNodesM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNodes_ +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +mkNorepType +Data.Generics.Basics +Data.Generics + +mkOccName +Language.Haskell.TH.Syntax + +mkPen +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +mkPolar +Data.Complex + +mkQ +Data.Generics.Aliases +Data.Generics + +mkQueue +Data.Graph.Inductive.Internal.Queue + +mkR +Data.Generics.Aliases +Data.Generics + +mkRegex +Text.Regex + +mkRegexWithOpts +Text.Regex + +mkSearchPath +Distribution.Compat.FilePath + +mkSet +Data.Set + +mkSocket +Network.Socket + +mkStdGen +System.Random + +mkStringConstr +Data.Generics.Basics +Data.Generics + +mkStringType +Data.Generics.Basics +Data.Generics + +mkT +Data.Generics.Aliases +Data.Generics + +mkTyCon +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +mkTyConApp +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +mkUGraph +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +mkUGraphM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +mkWeak +System.Mem.Weak + +mkWeakIORef +Data.IORef + +mkWeakPair +System.Mem.Weak + +mkWeakPtr +System.Mem.Weak + +mkstemp +System.Posix.Temp +System.Posix + +mod +Prelude + +mod1MapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +mod1Mask +Graphics.X11.Types +Graphics.X11.Xlib + +mod2MapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +mod2Mask +Graphics.X11.Types +Graphics.X11.Xlib + +mod3MapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +mod3Mask +Graphics.X11.Types +Graphics.X11.Xlib + +mod4MapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +mod4Mask +Graphics.X11.Types +Graphics.X11.Xlib + +mod5MapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +mod5Mask +Graphics.X11.Types +Graphics.X11.Xlib + +modGraphic +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +modString +Language.Haskell.TH.Syntax + +mode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +modificationTime +System.Posix.Files +System.Posix + +modify +Control.Monad.State +Control.Monad.RWS + +modifyIOError +System.IO.Error + +modifyIORef +Data.IORef + +modifyMVar +Control.Concurrent.MVar +Control.Concurrent + +modifyMVar_ +Control.Concurrent.MVar +Control.Concurrent + +modifySTRef +Data.STRef +Data.STRef.Strict +Data.STRef.Lazy + +modifying +System.Console.Readline + +moduleClose +System.Posix.DynamicLinker.Module + +moduleError +System.Posix.DynamicLinker.Module + +moduleOpen +System.Posix.DynamicLinker.Module + +modulePath +Distribution.PackageDescription + +moduleSymbol +System.Posix.DynamicLinker.Module + +moduleToFilePath +Distribution.Simple.Utils + +mondrian +Text.ParserCombinators.Parsec.Language + +mondrianDef +Text.ParserCombinators.Parsec.Language + +months +System.Locale + +motionCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +motionNotify +Graphics.X11.Types +Graphics.X11.Xlib + +moveArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +moveBytes +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +moveResizeWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +moveWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +mplus +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +msPath +Data.Graph.Inductive.Query.MST +Data.Graph.Inductive.Query +Data.Graph.Inductive + +msTree +Data.Graph.Inductive.Query.MST +Data.Graph.Inductive.Query +Data.Graph.Inductive + +msTreeAt +Data.Graph.Inductive.Query.MST +Data.Graph.Inductive.Query +Data.Graph.Inductive + +msum +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +multMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +multiDrawArrays +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +multiDrawElements +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +multiTexCoord +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +multiTexCoordv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +multiple +Text.Html + +multisample +Graphics.Rendering.OpenGL.GL.Antialiasing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +munch +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +munch1 +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +myThreadId +GHC.Conc +Control.Concurrent + +mzero +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +N3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NFData +Control.Parallel.Strategies + +NFDataIntegral +Control.Parallel.Strategies + +NFDataOrd +Control.Parallel.Strategies + +NHC +Distribution.Setup + +NURBSError +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NURBSMode +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NURBSRenderer +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NURBSTessellator +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Name +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Language.Haskell.TH.Syntax +Language.Haskell.TH +Language.Haskell.TH.Syntax + +NameFlavour +Language.Haskell.TH.Syntax + +NameG +Language.Haskell.TH.Syntax + +NameL +Language.Haskell.TH.Syntax + +NameQ +Language.Haskell.TH.Syntax + +NameS +Language.Haskell.TH.Syntax + +NameSpace +Language.Haskell.TH.Syntax + +NameU +Language.Haskell.TH.Syntax + +NamedFieldPuns +Distribution.Extension +Distribution.Simple + +Nand +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Nearest +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Network +Data.Graph.Inductive.Query.MaxFlow2 +Data.Graph.Inductive.Query +Data.Graph.Inductive + +NetworkAddr +Network.BSD + +NetworkEntry +Network.BSD +Network.BSD + +NetworkName +Network.BSD + +Never +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NewtypeD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Next +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +Nicest +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NoArg +Distribution.GetOpt +System.Console.GetOpt + +NoBindS +Language.Haskell.TH.Syntax +Language.Haskell.TH + +NoBuffering +System.IO + +NoBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NoDelay +Network.Socket + +NoFlushOnInterrupt +System.Posix.Terminal +System.Posix + +NoImplicitPrelude +Distribution.Extension +Distribution.Simple + +NoMethodError +Control.Exception + +NoMonomorphismRestriction +Distribution.Extension +Distribution.Simple + +NoProxy +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NoRep +Data.Generics.Basics +Data.Generics + +NoReset +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NoSocketType +Network.Socket + +NoTextureCoordinates +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Node +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Data.Graph.Inductive.Internal.FiniteMap +Data.Graph.Inductive.Internal.Heap +Data.Tree +Data.Graph +Test.HUnit.Base +Test.HUnit + +NodeMap +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +NodeMapM +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +NonBlockingRead +System.Posix.IO +System.Posix + +NonTermination +Control.Exception + +None +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Noop +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Nor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Normal +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +Normal3 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NormalArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NormalB +Language.Haskell.TH.Syntax +Language.Haskell.TH + +NormalC +Language.Haskell.TH.Syntax +Language.Haskell.TH + +NormalComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NormalG +Language.Haskell.TH.Syntax +Language.Haskell.TH + +NormalMap +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NotConnected +Network.Socket + +NotInUse +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +NotStrict +Language.Haskell.TH.Syntax +Language.Haskell.TH + +NotVisible +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Notequal +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Nothing +Data.Maybe +Prelude + +NotifyDetail +Graphics.X11.Types +Graphics.X11.Xlib + +NotifyMode +Graphics.X11.Types +Graphics.X11.Xlib + +November +System.Time + +Null +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +Num +Prelude + +NumArrayIndices +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NumComponents +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NumIndexBlocks +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +NumLevels +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +nORM_SPACE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +nOTICE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +name +Distribution.Simple.GHCPackageConfig +Text.Html + +nameBase +Language.Haskell.TH.Syntax +Language.Haskell.TH + +nameModule +Language.Haskell.TH.Syntax +Language.Haskell.TH + +nameStackDepth +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +namedFunction +System.Console.Readline + +natural +Text.ParserCombinators.Parsec.Token + +naturalOrFloat +Text.ParserCombinators.Parsec.Token + +navy +Text.Html + +nearestDist +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +nearestNode +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +nearestPath +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +negate +Prelude + +neighbors +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +neighbors' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +nest +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +nestDepth +Language.Haskell.TH.Ppr + +nestedComments +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +networkAddress +Network.BSD + +networkAliases +Network.BSD + +networkFamily +Network.BSD + +networkName +Network.BSD + +new +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive +Data.HashTable +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +newArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +newArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +newArray_ +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +newBareKeymap +System.Console.Readline + +newCAString +Foreign.C.String +Foreign.C + +newCAStringLen +Foreign.C.String +Foreign.C + +newCString +Foreign.C.String +Foreign.C + +newCStringLen +Foreign.C.String +Foreign.C + +newCWString +Foreign.C.String +Foreign.C + +newCWStringLen +Foreign.C.String +Foreign.C + +newChan +Control.Concurrent.Chan +Control.Concurrent + +newDiffArray +Data.Array.Diff + +newEmptyMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +newEmptySampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +newEmptyTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +newErrorMessage +Text.ParserCombinators.Parsec.Error + +newErrorUnknown +Text.ParserCombinators.Parsec.Error + +newForeignPtr +Foreign.Concurrent +Foreign.ForeignPtr +Foreign + +newForeignPtr_ +Foreign.ForeignPtr +Foreign + +newIORef +Data.IORef + +newKeymap +System.Console.Readline + +newListArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +newMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +newMap1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +newMap2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +newMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +newName +Language.Haskell.TH.Syntax +Language.Haskell.TH + +newNodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +newNodesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +newPixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +newPolygonStipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +newPool +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +newPos +Text.ParserCombinators.Parsec.Pos + +newQSem +Control.Concurrent.QSem +Control.Concurrent + +newQSemN +Control.Concurrent.QSemN +Control.Concurrent + +newSTRef +Data.STRef.Lazy +Data.STRef +Data.STRef.Strict + +newSampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +newStablePtr +Foreign.StablePtr +Foreign + +newStdGen +System.Random + +newTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +newTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +newTVar +GHC.Conc +Control.Concurrent.STM.TVar +Control.Concurrent.STM + +newUnique +Data.Unique + +newline +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +newtypeD +Language.Haskell.TH.Lib +Language.Haskell.TH + +next +System.Random + +nextEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +nice +System.Posix.Process +System.Posix + +nilPS +Data.PackedString + +nmap +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +nmergeIO +Control.Concurrent + +noBindS +Language.Haskell.TH.Lib +Language.Haskell.TH + +noComponents +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +noEdges +Data.Graph.Inductive.Example + +noEventMask +Graphics.X11.Types +Graphics.X11.Xlib + +noExpose +Graphics.X11.Types +Graphics.X11.Xlib + +noHtml +Text.Html + +noMsg +Control.Monad.Error + +noNodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +noNodesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +noOp +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +noPrec +Language.Haskell.TH.Ppr + +noSymbol +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +noTimeDiff +System.Time + +no_of_tests +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +noctty +System.Posix.IO +System.Posix + +node' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +nodeName +System.Posix.Unistd +System.Posix + +nodeRange +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +nodeRangeM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +nodes +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +nodesM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +noframes +Text.Html + +nohref +Text.Html + +nonBlock +System.Posix.IO +System.Posix + +nonStrictRelativeTo +Network.URI + +nonconvex +Graphics.X11.Types +Graphics.X11.Xlib + +noneOf +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +noresize +Text.Html + +normal +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +normalB +Language.Haskell.TH.Lib +Language.Haskell.TH + +normalC +Language.Haskell.TH.Lib +Language.Haskell.TH + +normalG +Language.Haskell.TH.Lib +Language.Haskell.TH + +normalGE +Language.Haskell.TH.Lib +Language.Haskell.TH + +normalize +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +normalizeCase +Network.URI + +normalizeEscape +Network.URI + +normalizePathSegments +Network.URI + +normalizeTimeDiff +System.Time + +normalv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +northEastGravity +Graphics.X11.Types +Graphics.X11.Xlib + +northGravity +Graphics.X11.Types +Graphics.X11.Xlib + +northWestGravity +Graphics.X11.Types +Graphics.X11.Xlib + +noshade +Text.Html + +not +Data.Bool +Prelude + +notElem +Data.List +Prelude + +notFollowedBy +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +notStrict +Language.Haskell.TH.Lib +Language.Haskell.TH + +notUseful +Graphics.X11.Types +Graphics.X11.Xlib + +notifyAncestor +Graphics.X11.Types +Graphics.X11.Xlib + +notifyDetailNone +Graphics.X11.Types +Graphics.X11.Xlib + +notifyGrab +Graphics.X11.Types +Graphics.X11.Xlib + +notifyHint +Graphics.X11.Types +Graphics.X11.Xlib + +notifyInferior +Graphics.X11.Types +Graphics.X11.Xlib + +notifyNonlinear +Graphics.X11.Types +Graphics.X11.Xlib + +notifyNonlinearVirtual +Graphics.X11.Types +Graphics.X11.Xlib + +notifyNormal +Graphics.X11.Types +Graphics.X11.Xlib + +notifyPointer +Graphics.X11.Types +Graphics.X11.Xlib + +notifyPointerRoot +Graphics.X11.Types +Graphics.X11.Xlib + +notifyUngrab +Graphics.X11.Types +Graphics.X11.Xlib + +notifyVirtual +Graphics.X11.Types +Graphics.X11.Xlib + +notifyWhileGrabbed +Graphics.X11.Types +Graphics.X11.Xlib + +nowrap +Text.Html + +nub +Data.List + +nubBy +Data.List + +null +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Data.List +Prelude + +nullFileMode +System.Posix.Files +System.Posix + +nullFunPtr +Foreign.Ptr +Foreign + +nullPS +Data.PackedString + +nullPtr +Foreign.Ptr +Foreign + +nullSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +nullURI +Network.URI + +numColorMapEntries +Graphics.UI.GLUT.Colormap +Graphics.UI.GLUT + +numDialsAndButtons +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +numMenuItems +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +numMouseButtons +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +numSpaceballButtons +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +numSubWindows +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +numTabletButtons +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +numerator +Data.Ratio + +nurbsBeginEndCurve +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +nurbsBeginEndSurface +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +nurbsBeginEndTrim +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OOBInline +Network.Socket + +Object +GHC.Dotnet +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +ObjectLinear +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ObjectName +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ObjectParametricError +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ObjectPathLength +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OccName +Language.Haskell.TH.Syntax + +Octahedron +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +October +System.Time + +OddParity +System.Posix.Terminal +System.Posix + +One +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneLineMode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +OneMinusConstantAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneMinusConstantColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneMinusDstAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneMinusDstColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneMinusSrcAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OneMinusSrcColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpDecr +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpDecrWrap +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpIncr +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpIncrWrap +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpInvert +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpKeep +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpReplace +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OpZero +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Opaque +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +OpenFileFlags +System.Posix.IO +System.Posix +System.Posix.IO +System.Posix + +OpenFileLimit +System.Posix.Unistd +System.Posix + +OpenMode +System.Posix.IO +System.Posix + +Operator +Text.ParserCombinators.Parsec.Expr + +OperatorTable +Text.ParserCombinators.Parsec.Expr + +Opt +Distribution.Extension +Distribution.Simple + +OptArg +Distribution.GetOpt +System.Console.GetOpt + +OptDescr +Distribution.GetOpt +System.Console.GetOpt + +Option +Distribution.GetOpt +System.Console.GetOpt + +Or +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OrInverted +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OrReverse +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Ord +Prelude + +OrdALPHA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +OrdBETA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +OrdGAMMA +Test.QuickCheck.Poly +Debug.QuickCheck.Poly + +Order +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Ordering +Prelude + +Orient +Data.Graph.Inductive.Graphviz +Data.Graph.Inductive + +OtherCompiler +Distribution.Setup + +OtherLicense +Distribution.License +Distribution.Make +Distribution.Simple + +OutOfMemory +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OutlinePatch +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OutlinePolygon +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +OutputQueue +System.Posix.Terminal +System.Posix + +Outside +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Overflow +Control.Exception + +OverlappingInstances +Distribution.Extension +Distribution.Simple + +Overlay +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +objExtension +Distribution.Compat.FilePath + +occString +Language.Haskell.TH.Syntax + +octDigit +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +octal +Text.ParserCombinators.Parsec.Token + +odd +Prelude + +offsetRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +ok +Test.QuickCheck +Debug.QuickCheck + +olist +Text.Html + +olive +Text.Html + +onNewLine +System.Console.Readline + +onNewLineWithPrompt +System.Console.Readline + +oneOf +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +oneof +Test.QuickCheck +Debug.QuickCheck + +onsideIndent +Language.Haskell.Pretty + +opLetter +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +opPrec +Language.Haskell.TH.Ppr + +opStart +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +openBinaryFile +System.IO + +openBinaryTempFile +System.IO + +openDirStream +System.Posix.Directory +System.Posix + +openDisplay +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +openEndedPipe +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +openFd +System.Posix.IO +System.Posix + +openFile +System.IO + +openTempFile +System.IO + +openWindow +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +openWindowEx +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +operator +Text.ParserCombinators.Parsec.Token + +option +Text.Html +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +optional +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +options +Distribution.PackageDescription + +or +Data.List +Prelude + +orEarlierVersion +Distribution.Version +Distribution.Simple + +orElse +Data.Generics.Aliases +Data.Generics +GHC.Conc +Control.Concurrent.STM + +orLaterVersion +Distribution.Version +Distribution.Simple + +orP +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +orRegion +Graphics.SOE + +ord +Data.Char + +ordList +Text.Html + +ortho +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ortho2D +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +os +System.Info + +otherExecuteMode +System.Posix.Files +System.Posix + +otherModes +System.Posix.Files +System.Posix + +otherModules +Distribution.PackageDescription + +otherReadMode +System.Posix.Files +System.Posix + +otherWriteMode +System.Posix.Files +System.Posix + +otherwise +Data.Bool +Prelude + +out +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +out' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +outdeg +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +outdeg' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +outdegree +Data.Graph + +outputSpeed +System.Posix.Terminal +System.Posix + +overGraphic +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +overGraphics +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +overlayDisplayCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +overlayPossible +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +overlayVisible +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +ownerExecuteMode +System.Posix.Files +System.Posix + +ownerGrabButtonMask +Graphics.X11.Types +Graphics.X11.Xlib + +ownerModes +System.Posix.Files +System.Posix + +ownerReadMode +System.Posix.Files +System.Posix + +ownerWriteMode +System.Posix.Files +System.Posix + +PError +Distribution.PackageDescription + +PPHsMode +Language.Haskell.Pretty +Language.Haskell.Pretty + +PPInLine +Language.Haskell.Pretty + +PPLayout +Language.Haskell.Pretty + +PPNoLayout +Language.Haskell.Pretty + +PPOffsideRule +Language.Haskell.Pretty + +PPSemiColon +Language.Haskell.Pretty + +PPSuffixHandler +Distribution.PreProcess + +PStr +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +Pack +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PackCMYK +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PackageDescription +Distribution.PackageDescription +Distribution.PackageDescription + +PackageIdentifier +Distribution.Package +Distribution.Make +Distribution.Simple +Distribution.Package +Distribution.Make +Distribution.Simple + +PackedString +Data.PackedString + +PageMode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +ParS +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ParallelListComp +Distribution.Extension +Distribution.Simple + +ParametricError +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ParseError +Text.ParserCombinators.Parsec.Error +Text.ParserCombinators.Parsec + +ParseFailed +Distribution.InstalledPackageInfo +Distribution.PackageDescription +Language.Haskell.Parser + +ParseMode +Language.Haskell.Parser +Language.Haskell.Parser + +ParseOk +Distribution.InstalledPackageInfo +Distribution.PackageDescription +Language.Haskell.Parser + +ParseResult +Distribution.InstalledPackageInfo +Distribution.PackageDescription +Language.Haskell.Parser + +Parser +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +PartialDisk +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PassThrough +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PassThroughToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PassThroughValue +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Pat +Language.Haskell.TH.Syntax +Language.Haskell.TH + +PatG +Language.Haskell.TH.Syntax +Language.Haskell.TH + +PatQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Path +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Test.HUnit.Base +Test.HUnit + +PathLength +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PathNameLimit +System.Posix.Files +System.Posix + +PathVar +System.Posix.Files +System.Posix + +PatternMatchFail +Control.Exception + +Pen +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +PerWindowKeyRepeat +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +PerWindowKeyRepeatOff +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +PerWindowKeyRepeatOn +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +PermParser +Text.ParserCombinators.Parsec.Perm + +Permissions +System.Directory +Distribution.Compat.Directory +System.Directory +Distribution.Compat.Directory + +Permute +Distribution.GetOpt +System.Console.GetOpt + +PerspectiveCorrection +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PipeBufferLimit +System.Posix.Files +System.Posix + +Pixel +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +PixelCopyType +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelData +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelFormat +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelInternalFormat +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelMapComponent +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelMapTarget +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelModeAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelStoreAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelStoreDirection +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PixelTransferStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Pixmap +Graphics.X11.Types +Graphics.X11.Xlib + +Place +Graphics.X11.Types +Graphics.X11.Xlib + +Plane +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Point +Graphics.HGL.Units +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +PointAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PointSmooth +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PointStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PointToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Points +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PollRate +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +Polygon +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonContours +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonMode +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonShape +Graphics.X11.Types +Graphics.X11.Xlib + +PolygonSmooth +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonStipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonStippleAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolygonToken +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PolymorphicComponents +Distribution.Extension +Distribution.Simple + +Pool +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +PortID +Network + +PortNum +Network.Socket + +PortNumber +Network +Network.Socket +Network.BSD +Network + +Portrait +Data.Graph.Inductive.Graphviz +Data.Graph.Inductive + +Position +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +PosixVersion +System.Posix.Unistd +System.Posix + +PostColorMatrix +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PostColorMatrixColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PostColorMatrixColorTableStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PostConvolution +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PostConvolutionColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PostConvolutionColorTableStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Postfix +Text.ParserCombinators.Parsec.Expr + +Ppr +Language.Haskell.TH.Ppr +Language.Haskell.TH + +PprM +Language.Haskell.TH.PprLib + +PreConvolution +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PreProcessor +Distribution.PreProcess + +Prec +Text.ParserCombinators.ReadPrec +Text.Read + +Precedence +Language.Haskell.TH.Ppr + +PreferBlankingMode +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +Prefix +Data.Generics.Basics +Data.Generics +Text.ParserCombinators.Parsec.Expr + +Pretty +Language.Haskell.Pretty + +Previous +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PrimTyConI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +PrimaryColor +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Primitive +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PrimitiveMode +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +PrintfArg +Text.Printf + +PrintfType +Text.Printf + +PrioIOAvailable +System.Posix.Files +System.Posix + +ProcessGroupID +System.Posix.Types +System.Posix + +ProcessHandle +System.Process + +ProcessID +System.Posix.Types +System.Posix + +ProcessInput +System.Posix.Terminal +System.Posix + +ProcessOutput +System.Posix.Terminal +System.Posix + +ProcessStatus +System.Posix.Process +System.Posix + +ProcessTimes +System.Posix.Process +System.Posix +System.Posix.Process +System.Posix + +ProgramaticaCmd +Distribution.Setup + +Projection +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Property +Test.QuickCheck +Debug.QuickCheck + +PropertyNotification +Graphics.X11.Types +Graphics.X11.Xlib + +Protocol +Graphics.X11.Types +Graphics.X11.Xlib + +ProtocolEntry +Network.BSD +Network.BSD + +ProtocolName +Network.BSD + +ProtocolNumber +Network.Socket +Network.BSD + +Proxy +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Ptr +Foreign.Ptr +Foreign +GHC.Exts +GHC.Exts + +PublicDomain +Distribution.License +Distribution.Make +Distribution.Simple + +Punc +Text.Read.Lex +Text.Read + +PutText +Test.HUnit.Text +Test.HUnit +Test.HUnit.Text +Test.HUnit + +p +Text.Html + +pIXMAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +pOINT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +pOINT_SIZE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +pRIMARY +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +packDL +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +packFamily +Network.Socket + +packRTLDFlags +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +packSocketType +Network.Socket + +packString +Data.PackedString + +package +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +packageDeps +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +package_deps +Distribution.Simple.GHCPackageConfig + +par +GHC.Conc +Control.Parallel +Graphics.HGL.Utils +Graphics.HGL + +parArr +Control.Parallel.Strategies + +parBuffer +Control.Parallel.Strategies + +parFlatMap +Control.Parallel.Strategies + +parList +Control.Parallel.Strategies + +parListChunk +Control.Parallel.Strategies + +parListN +Control.Parallel.Strategies + +parListNth +Control.Parallel.Strategies + +parMany +Graphics.HGL.Utils +Graphics.HGL + +parMap +Control.Parallel.Strategies + +parPair +Control.Parallel.Strategies + +parS +Language.Haskell.TH.Lib +Language.Haskell.TH + +parTriple +Control.Parallel.Strategies + +parZipWith +Control.Parallel.Strategies + +par_ +Graphics.HGL.Utils +Graphics.HGL + +paragraph +Text.Html + +param +Text.Html + +parens +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +parensIf +Language.Haskell.TH.Ppr + +parentWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +parse +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +parseAndBind +System.Console.Readline + +parseBuildArgs +Distribution.Setup + +parseCleanArgs +Distribution.Setup + +parseColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +parseConfigureArgs +Distribution.Setup + +parseCopyArgs +Distribution.Setup + +parseDescription +Distribution.PackageDescription + +parseFilename +Language.Haskell.Parser + +parseFromFile +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +parseGlobalArgs +Distribution.Setup + +parseHaddockArgs +Distribution.Setup + +parseHookedBuildInfo +Distribution.PackageDescription + +parseInstallArgs +Distribution.Setup + +parseInstalledPackageInfo +Distribution.InstalledPackageInfo + +parseModule +Language.Haskell.Parser + +parseModuleWithMode +Language.Haskell.Parser + +parsePackageId +Distribution.Package +Distribution.Make +Distribution.Simple + +parsePackageName +Distribution.Package +Distribution.Make +Distribution.Simple + +parseProgramaticaArgs +Distribution.Setup + +parseRegisterArgs +Distribution.Setup + +parseRelativeReference +Network.URI + +parseSDistArgs +Distribution.Setup + +parseSearchPath +Distribution.Compat.FilePath + +parseTest +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +parseURI +Network.URI + +parseURIReference +Network.URI + +parseUnregisterArgs +Distribution.Setup + +parseVersion +Data.Version +Distribution.Version +Distribution.Simple + +parseVersionRange +Distribution.Version +Distribution.Simple + +parseabsoluteURI +Network.URI + +partition +Data.IntMap +Data.IntSet +Data.List +Data.Map +Data.Set + +partitionWithKey +Data.IntMap +Data.Map + +pass +Control.Monad.Writer +Control.Monad.RWS + +passThrough +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +passiveMotionCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +password +Text.Html + +patG +Language.Haskell.TH.Lib +Language.Haskell.TH + +patGE +Language.Haskell.TH.Lib +Language.Haskell.TH + +path +Data.Graph +Network.URI +Test.HUnit.Base +Test.HUnit + +pathParents +Distribution.Compat.FilePath + +pathSeparator +Distribution.Compat.FilePath + +peek +Foreign.Storable +Foreign + +peek' +Graphics.X11.Xlib.Types + +peekAngleField +Graphics.X11.Xlib.Types + +peekArc +Graphics.X11.Xlib.Types + +peekArcArray +Graphics.X11.Xlib.Types + +peekArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +peekArray' +Graphics.X11.Xlib.Types + +peekArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +peekByteOff +Foreign.Storable +Foreign + +peekCAString +Foreign.C.String +Foreign.C + +peekCAStringLen +Foreign.C.String +Foreign.C + +peekCString +Foreign.C.String +Foreign.C + +peekCStringLen +Foreign.C.String +Foreign.C + +peekCWString +Foreign.C.String +Foreign.C + +peekCWStringLen +Foreign.C.String +Foreign.C + +peekColor +Graphics.X11.Xlib.Types + +peekColorArray +Graphics.X11.Xlib.Types + +peekDimensionField +Graphics.X11.Xlib.Types + +peekElemOff +Foreign.Storable +Foreign + +peekElemOff' +Graphics.X11.Xlib.Types + +peekEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +peekPoint +Graphics.X11.Xlib.Types + +peekPointArray +Graphics.X11.Xlib.Types + +peekPositionField +Graphics.X11.Xlib.Types + +peekRectangle +Graphics.X11.Xlib.Types + +peekRectangleArray +Graphics.X11.Xlib.Types + +peekSegment +Graphics.X11.Xlib.Types + +peekSegmentArray +Graphics.X11.Xlib.Types + +pending +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +perWindowKeyRepeat +Graphics.UI.GLUT.DeviceControl +Graphics.UI.GLUT + +performGC +System.Mem + +performTest +Test.HUnit.Base +Test.HUnit + +performTestCase +Test.HUnit.Lang + +permissionErrorType +System.IO.Error + +permute +Text.ParserCombinators.Parsec.Perm + +perspective +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pfail +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +phase +Data.Complex + +pi +Prelude + +pickMatrix +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pixelMapIToRGBA +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pixelMapRGBAToRGBA +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pixelZoom +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pkgName +Distribution.Package +Distribution.Make +Distribution.Simple + +pkgUrl +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +pkgVersion +Distribution.Package +Distribution.Make +Distribution.Simple + +placeOnBottom +Graphics.X11.Types +Graphics.X11.Xlib + +placeOnTop +Graphics.X11.Types +Graphics.X11.Xlib + +plain +Distribution.PreProcess.Unlit + +planesOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +pling_name +Language.Haskell.Syntax + +plusFM +Data.FiniteMap + +plusFM_C +Data.FiniteMap + +plusPtr +Foreign.Ptr +Foreign + +pointDistanceAttenuation +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointFadeThresholdSize +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointInRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +pointSize +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointSizeRange +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointSmooth +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointSprite +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +pointerMotionHintMask +Graphics.X11.Types +Graphics.X11.Xlib + +pointerMotionMask +Graphics.X11.Types +Graphics.X11.Xlib + +pointerPosition +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +poke +Foreign.Storable +Foreign + +poke' +Graphics.X11.Xlib.Types + +pokeAngleField +Graphics.X11.Xlib.Types + +pokeArc +Graphics.X11.Xlib.Types + +pokeArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +pokeArray' +Graphics.X11.Xlib.Types + +pokeArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +pokeByteOff +Foreign.Storable +Foreign + +pokeColor +Graphics.X11.Xlib.Types + +pokeDimensionField +Graphics.X11.Xlib.Types + +pokeElemOff +Foreign.Storable +Foreign + +pokeElemOff' +Graphics.X11.Xlib.Types + +pokePoint +Graphics.X11.Xlib.Types + +pokePositionField +Graphics.X11.Xlib.Types + +pokeRectangle +Graphics.X11.Xlib.Types + +pokeSegment +Graphics.X11.Xlib.Types + +polar +Data.Complex + +pollableEvent +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +polyBezier +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +polygon +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +polygonMode +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonOffset +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonOffsetFill +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonOffsetLine +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonOffsetPoint +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +polygonSmooth +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polygonStipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +polyline +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +pooledMalloc +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledMallocArray +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledMallocArray0 +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledMallocBytes +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledNew +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledNewArray +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledNewArray0 +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledRealloc +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledReallocArray +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledReallocArray0 +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +pooledReallocBytes +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +popWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +position +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +possibleCompletions +System.Console.Readline + +postBuild +Distribution.Simple + +postClean +Distribution.Simple + +postConf +Distribution.Simple + +postCopy +Distribution.Simple + +postHaddock +Distribution.Simple + +postInst +Distribution.Simple + +postOverlayRedisplay +Graphics.UI.GLUT.Overlay +Graphics.UI.GLUT + +postPFE +Distribution.Simple + +postRedisplay +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +postReg +Distribution.Simple + +postSDist +Distribution.Simple + +postUnreg +Distribution.Simple + +postorder +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +postorderF +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +ppAlex +Distribution.PreProcess + +ppC2hs +Distribution.PreProcess + +ppCpp +Distribution.PreProcess + +ppCpp' +Distribution.PreProcess + +ppGreenCard +Distribution.PreProcess + +ppHappy +Distribution.PreProcess + +ppHsc2hs +Distribution.PreProcess + +ppSuffixes +Distribution.PreProcess + +ppUnlit +Distribution.PreProcess + +ppr +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprBody +Language.Haskell.TH.Ppr + +pprCxt +Language.Haskell.TH.Ppr + +pprExp +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprFields +Language.Haskell.TH.Ppr + +pprFixity +Language.Haskell.TH.Ppr + +pprLit +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprMaybeExp +Language.Haskell.TH.Ppr + +pprName +Language.Haskell.TH.PprLib + +pprParendType +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprPat +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprStrictType +Language.Haskell.TH.Ppr + +pprTyApp +Language.Haskell.TH.Ppr + +pprVarStrictType +Language.Haskell.TH.Ppr + +ppr_list +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pprint +Language.Haskell.TH.Ppr +Language.Haskell.TH + +pre +Data.Graph.Inductive.Graph +Data.Graph.Inductive +Text.Html + +pre' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +preBuild +Distribution.Simple + +preClean +Distribution.Simple + +preConf +Distribution.Simple + +preCopy +Distribution.Simple + +preHaddock +Distribution.Simple + +preInst +Distribution.Simple + +prePFE +Distribution.Simple + +preReg +Distribution.Simple + +preSDist +Distribution.Simple + +preUnreg +Distribution.Simple + +prec +Text.ParserCombinators.ReadPrec +Text.Read + +pred +Prelude + +predFM +Data.Graph.Inductive.Internal.FiniteMap + +preferBlanking +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +prefix +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +prelude_mod +Language.Haskell.Syntax + +preorder +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +preorderF +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +preprocessSources +Distribution.PreProcess + +preservingAttrib +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +preservingClientAttrib +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +preservingMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +prettyHtml +Text.Html + +prettyHtml' +Text.Html + +prettyPrint +Language.Haskell.Pretty + +prettyPrintStyleMode +Language.Haskell.Pretty + +prettyPrintWithMode +Language.Haskell.Pretty + +primHtml +Text.Html + +primHtmlChar +Text.Html + +prime +Data.HashTable + +primitiveRestart +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +primitiveRestartIndex +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +print +System.IO +Prelude + +printf +Text.Printf + +prioritizeTextures +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +processStatusChanged +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +product +Data.List +Prelude + +profilingTimerExpired +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +project +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +promote +Test.QuickCheck +Debug.QuickCheck + +properFraction +Prelude + +property +Test.QuickCheck +Debug.QuickCheck + +propertyChangeMask +Graphics.X11.Types +Graphics.X11.Xlib + +propertyDelete +Graphics.X11.Types +Graphics.X11.Xlib + +propertyNewValue +Graphics.X11.Types +Graphics.X11.Xlib + +propertyNotify +Graphics.X11.Types +Graphics.X11.Xlib + +protoAliases +Network.BSD + +protoName +Network.BSD + +protoNumber +Network.BSD + +protocolRevision +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +protocolVersion +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +pseq +GHC.Conc + +pt +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +ptext +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +punctuate +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +pure +Control.Arrow + +purple +Text.Html + +pushWindow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +put +Control.Monad.State +Control.Monad.RWS + +putBackEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +putChar +System.IO +Prelude + +putEnv +System.Posix.Env +System.Posix + +putMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +putStr +System.IO +Prelude + +putStrLn +System.IO +Prelude + +putTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +putTextToHandle +Test.HUnit.Text +Test.HUnit + +putTextToShowS +Test.HUnit.Text +Test.HUnit + +putTraceMsg +Debug.Trace + +pwrapper +Network.CGI + +pzero +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +Q +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +QSem +Control.Concurrent.QSem +Control.Concurrent + +QSemN +Control.Concurrent.QSemN +Control.Concurrent + +QuadStrip +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricDrawStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricNormal +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricOrientation +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricPrimitive +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QuadricTexture +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Quads +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Qual +Language.Haskell.Syntax + +Quasi +Language.Haskell.TH.Syntax + +QueryBestSizeClass +Graphics.X11.Types +Graphics.X11.Xlib + +QueryObject +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +QueryTarget +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Queue +Data.Graph.Inductive.Internal.Queue +Data.Queue + +QueueSelector +System.Posix.Terminal +System.Posix + +QueuedMode +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +Quit +System.Posix.Terminal +System.Posix + +qCurrentModule +Language.Haskell.TH.Syntax + +qLength +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +qNewName +Language.Haskell.TH.Syntax + +qRecover +Language.Haskell.TH.Syntax + +qReify +Language.Haskell.TH.Syntax + +qReport +Language.Haskell.TH.Syntax + +qRunIO +Language.Haskell.TH.Syntax + +qUAD_WIDTH +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +qualified_name +Language.Haskell.Syntax + +query +Network.URI + +queryBestCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +queryBestSize +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +queryBestStipple +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +queryBestTile +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +queryColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +queryColors +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +queryCounterBits +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +queryFdOption +System.Posix.IO +System.Posix + +queryFont +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +queryPointer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +queryResult +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +queryResultAvailable +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +queryStoppedChildFlag +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +queryTerminal +System.Posix.Terminal +System.Posix + +queueEmpty +Data.Graph.Inductive.Internal.Queue + +queueGet +Data.Graph.Inductive.Internal.Queue + +queuePut +Data.Graph.Inductive.Internal.Queue + +queuePutList +Data.Graph.Inductive.Internal.Queue + +queueToList +Data.Queue + +queuedAfterFlush +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +queuedAfterReading +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +queuedAlready +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +quickCheck +Test.QuickCheck +Debug.QuickCheck + +quot +Prelude + +quotRem +Prelude + +quoteFilename +System.Console.Readline + +quotes +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +R +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +R3G3B2 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RDM +Network.Socket + +RGB +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB10 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB10A2 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB5 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB5A1 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGB8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA' +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA12 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA16 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA2 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA4 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBA8 +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RGBAMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +RGBMode +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +RTLDFlags +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +RTLD_GLOBAL +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +RTLD_LAZY +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +RTLD_LOCAL +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +RTLD_NOW +System.Posix.DynamicLinker.Prim +System.Posix.DynamicLinker + +RToR +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RTree +Data.Graph.Inductive.Internal.RootPath + +RWS +Control.Monad.RWS +Control.Monad.RWS + +RWST +Control.Monad.RWS +Control.Monad.RWS + +Radius +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Random +System.Random + +RandomGen +System.Random + +Range +Language.Haskell.TH.Syntax +Language.Haskell.TH + +RangeQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +RankNTypes +Distribution.Extension +Distribution.Simple + +RasterPos +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RasterPosComponent +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Rat +Text.Read.Lex +Text.Read + +Ratio +Data.Ratio + +Rational +Prelude +Data.Ratio + +RationalL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Raw +Network.Socket + +Read +Text.Read +Prelude + +ReadEnable +System.Posix.Terminal +System.Posix + +ReadFromBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReadLock +System.Posix.IO +System.Posix + +ReadMode +System.IO + +ReadOnly +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +System.Posix.IO +System.Posix + +ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadP + +ReadPrec +Text.ParserCombinators.ReadPrec +Text.Read + +ReadS +Text.ParserCombinators.ReadP +Text.Read +Prelude +Distribution.Compat.ReadP + +ReadWrite +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +System.Posix.IO +System.Posix + +ReadWriteMode +System.IO + +Reader +Control.Monad.Reader +Control.Monad.RWS +Control.Monad.Reader +Control.Monad.RWS + +ReaderT +Control.Monad.Reader +Control.Monad.RWS +Control.Monad.Reader +Control.Monad.RWS + +Real +Prelude + +RealFloat +Prelude + +RealFrac +Prelude + +RealWorld +Control.Monad.ST +Control.Monad.ST.Lazy +Control.Monad.ST.Strict + +RecC +Language.Haskell.TH.Syntax +Language.Haskell.TH + +RecConE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +RecConError +Control.Exception + +RecP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +RecSelError +Control.Exception + +RecUpdE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +RecUpdError +Control.Exception + +Rect +Graphics.Rendering.OpenGL.GL.Rectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RectInRegionResult +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +Rectangle +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +RecursiveDo +Distribution.Extension +Distribution.Simple + +RecvBuffer +Network.Socket + +RecvLowWater +Network.Socket + +RecvTimeOut +Network.Socket + +Red +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RedrawMode +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +Reduce +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReflectionMap +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RefreshRate +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +Regex +Text.Regex.Posix +Text.Regex + +Region +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +RegisterCmd +Distribution.Setup + +RegisterFlags +Distribution.Setup + +Relation +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +RelativeSeek +System.IO + +Render +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RenderMode +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RenderingContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Repeat +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Repeated +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Repetition +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Replace +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Replace' +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReplicateBorder +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReportProblem +Test.HUnit.Base +Test.HUnit + +ReportStart +Test.HUnit.Base +Test.HUnit + +ReqArg +Distribution.GetOpt +System.Console.GetOpt + +RequireOrder +Distribution.GetOpt +System.Console.GetOpt + +Reset +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReshapeCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Resize +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +Resource +System.Posix.Resource +System.Posix + +ResourceCPUTime +System.Posix.Resource +System.Posix + +ResourceCoreFileSize +System.Posix.Resource +System.Posix + +ResourceDataSize +System.Posix.Resource +System.Posix + +ResourceFileSize +System.Posix.Resource +System.Posix + +ResourceLimit +System.Posix.Resource +System.Posix +System.Posix.Resource +System.Posix + +ResourceLimitInfinity +System.Posix.Resource +System.Posix + +ResourceLimitUnknown +System.Posix.Resource +System.Posix + +ResourceLimits +System.Posix.Resource +System.Posix +System.Posix.Resource +System.Posix + +ResourceOpenFiles +System.Posix.Resource +System.Posix + +ResourceStackSize +System.Posix.Resource +System.Posix + +ResourceTotalMemory +System.Posix.Resource +System.Posix + +RestartOutput +System.Posix.Terminal +System.Posix + +RestrictedTypeSynonyms +Distribution.Extension +Distribution.Simple + +Result +Test.QuickCheck +Debug.QuickCheck +Test.QuickCheck +Debug.QuickCheck + +Return +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ReturnInOrder +Distribution.GetOpt +System.Console.GetOpt + +ReuseAddr +Network.Socket + +RhombicDodecahedron +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +Right +Data.Either +Prelude + +Right' +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +RightArrow +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +RightBuffers +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +RightButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +RightSide +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Rings +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +Roman +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +RowMajor +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +r0 +Control.Parallel.Strategies + +rECTANGLE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rESOLUTION +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rESOURCE_MANAGER +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_BEST_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_BLUE_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_COLOR_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_DEFAULT_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_GRAY_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_GREEN_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +rGB_RED_MAP +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +radio +Text.Html + +raiseLowest +Graphics.X11.Types +Graphics.X11.Xlib + +raiseSignal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +raiseWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +rand +Test.QuickCheck +Debug.QuickCheck + +random +System.Random + +randomIO +System.Random + +randomR +System.Random + +randomRIO +System.Random + +randomRs +System.Random + +randoms +System.Random + +range +Data.Ix +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff + +rangeFM +Data.Graph.Inductive.Internal.FiniteMap + +rangeSize +Data.Ix +Data.Array +Data.Array.IArray +Data.Array.Unboxed +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable +Data.Array.Diff + +rasterPos +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rasterPositionUnclipped +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rasterPosv +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rational +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +rationalL +Language.Haskell.TH.Lib +Language.Haskell.TH + +rawSystem +System.Cmd +Distribution.Compat.RawSystem + +rawSystemExit +Distribution.Simple.Utils + +rawSystemPath +Distribution.Simple.Utils + +rawSystemPathExit +Distribution.Simple.Utils + +rawSystemVerbose +Distribution.Simple.Utils + +rbrace +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +rbrack +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +rdff +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +rdff' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +rdfs +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +rdfs' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +reachable +Data.Graph +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +read +Text.Read +Prelude + +readArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +readBuffer +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +readChan +Control.Concurrent.Chan +Control.Concurrent + +readConstr +Data.Generics.Basics +Data.Generics + +readDec +Numeric + +readDecP +Text.Read.Lex + +readDesc +Distribution.Simple + +readDiffArray +Data.Array.Diff + +readDirStream +System.Posix.Directory +System.Posix + +readFile +System.IO +Prelude + +readFloat +Numeric + +readHex +Numeric + +readHexP +Text.Read.Lex + +readHookedBuildInfo +Distribution.PackageDescription + +readIO +System.IO +Prelude + +readIORef +Data.IORef + +readInitFile +System.Console.Readline + +readInt +Numeric + +readIntP +Text.Read.Lex + +readKey +System.Console.Readline + +readList +Text.Read +Prelude + +readListDefault +Text.Read + +readListPrec +Text.Read + +readListPrecDefault +Text.Read + +readLitChar +Data.Char + +readLn +System.IO +Prelude + +readMVar +Control.Concurrent.MVar +Control.Concurrent + +readOct +Numeric + +readOctP +Text.Read.Lex + +readP_to_Prec +Text.ParserCombinators.ReadPrec +Text.Read + +readP_to_S +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +readPackageDescription +Distribution.PackageDescription + +readParen +Text.Read +Prelude + +readPixels +Graphics.Rendering.OpenGL.GL.ReadCopyPixels +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +readPrec +Text.Read + +readPrec_to_P +Text.ParserCombinators.ReadPrec +Text.Read + +readPrec_to_S +Text.ParserCombinators.ReadPrec +Text.Read + +readSTRef +Data.STRef.Lazy +Data.STRef +Data.STRef.Strict + +readS_to_P +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +readS_to_Prec +Text.ParserCombinators.ReadPrec +Text.Read + +readSampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +readSigned +Numeric + +readSymbolicLink +System.Posix.Files +System.Posix + +readTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +readTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +readTVar +GHC.Conc +Control.Concurrent.STM.TVar +Control.Concurrent.STM + +readable +System.Directory +Distribution.Compat.Directory + +readline +System.Console.Readline + +readlink +Network.BSD + +reads +Text.Read +Prelude + +readsPrec +Text.Read +Prelude + +realPart +Data.Complex + +realTimeAlarm +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +realToFrac +Prelude + +realloc +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +reallocArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +reallocArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +reallocBytes +Foreign.Marshal.Alloc +Foreign.Marshal +Foreign + +recC +Language.Haskell.TH.Lib +Language.Haskell.TH + +recConE +Language.Haskell.TH.Lib +Language.Haskell.TH + +recMGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +recMGT' +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +recP +Language.Haskell.TH.Lib +Language.Haskell.TH + +recUpdE +Language.Haskell.TH.Lib +Language.Haskell.TH + +recip +Prelude + +recolorCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +recover +Language.Haskell.TH.Syntax +Language.Haskell.TH + +recoverMp +Data.Generics.Aliases +Data.Generics + +recoverQ +Data.Generics.Aliases +Data.Generics + +rect +Graphics.Rendering.OpenGL.GL.Rectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rectInRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +rectangleIn +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +rectangleOut +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +rectanglePart +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +rectangleRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +rectv +Graphics.Rendering.OpenGL.GL.Rectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +recv +Network.Socket + +recvAncillary +Network.Socket + +recvBufFrom +Network.Socket + +recvFd +Network.Socket + +recvFrom +Network +Network.Socket + +recvLen +Network.Socket + +red +Text.Html + +redisplay +System.Console.Readline + +refreshKeyboardMapping +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +regExtended +Text.Regex.Posix + +regIgnoreCase +Text.Regex.Posix + +regNewline +Text.Regex.Posix + +regScriptLocation +Distribution.Simple.Register + +regcomp +Text.Regex.Posix + +regexec +Text.Regex.Posix + +regionToGraphic +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +register +Distribution.Simple.Register + +reify +Language.Haskell.TH.Syntax +Language.Haskell.TH + +rel +Text.Html + +relativeFrom +Network.URI + +relativeTo +Network.URI + +release +System.Posix.Unistd +System.Posix + +rem +Prelude + +removeDel +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +removeDirectory +System.Directory +System.Posix.Directory +System.Posix +Distribution.Compat.Directory + +removeDirectoryRecursive +System.Directory +Distribution.Compat.Directory + +removeFile +System.Directory +Distribution.Compat.Directory + +removeFromSaveSet +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +removeInstalledConfig +Distribution.Simple.Register + +removeLink +System.Posix.Files +System.Posix + +removePreprocessed +Distribution.PreProcess + +removePreprocessedPackage +Distribution.PreProcess + +rename +Language.Haskell.TH.Lib +System.Posix.Files +System.Posix + +renameDirectory +System.Directory +Distribution.Compat.Directory + +renameFile +System.Directory +Distribution.Compat.Directory + +render +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +renderHtml +Text.Html + +renderHtml' +Text.Html + +renderMode +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +renderObject +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +renderPrimitive +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +renderQuadric +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +renderString +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +renderStyle +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +renderTable +Text.Html + +renderTag +Text.Html + +renderer +Graphics.Rendering.OpenGL.GL.StringQueries +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +renderingContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +repConstr +Data.Generics.Basics +Data.Generics + +reparentNotify +Graphics.X11.Types +Graphics.X11.Xlib + +reparentWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +repeat +Data.List +Prelude + +replaceDiffArray +Data.Array.Diff + +replayKeyboard +Graphics.X11.Types +Graphics.X11.Xlib + +replayPointer +Graphics.X11.Types +Graphics.X11.Xlib + +replicate +Data.List +Prelude + +replicateM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +replicateM_ +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +report +Language.Haskell.TH.Syntax +Language.Haskell.TH + +reportErrors +Graphics.UI.GLUT.Debugging +Graphics.UI.GLUT + +rescaleNormal +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +reserved +Network.URI +Text.ParserCombinators.Parsec.Token + +reservedNames +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +reservedOp +Text.ParserCombinators.Parsec.Token + +reservedOpNames +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Language + +reset +Text.Html +Text.ParserCombinators.ReadPrec +Text.Read + +resetAfterSignal +System.Console.Readline + +resetErrno +Foreign.C.Error +Foreign.C + +resetHistogram +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +resetLineState +System.Console.Readline + +resetMinmax +Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +resetScreenSaver +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +resetTerminal +System.Console.Readline + +reshapeCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +resize +Test.QuickCheck +Debug.QuickCheck + +resizeRedirectMask +Graphics.X11.Types +Graphics.X11.Xlib + +resizeRequest +Graphics.X11.Types +Graphics.X11.Xlib + +resizeTerminal +System.Console.Readline + +resizeWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +resourceManagerString +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +restackWindows +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +restore +System.Console.SimpleLineEditor + +restorePrompt +System.Console.Readline + +retainPermanent +Graphics.X11.Types +Graphics.X11.Xlib + +retainTemporary +Graphics.X11.Types +Graphics.X11.Xlib + +retry +GHC.Conc +Control.Concurrent.STM + +return +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +returnA +Control.Arrow + +returnQ +Language.Haskell.TH.Syntax + +rev +Text.Html + +reverse +Data.List +Prelude + +reversePS +Data.PackedString + +revertToNone +Graphics.X11.Types +Graphics.X11.Xlib + +revertToParent +Graphics.X11.Types +Graphics.X11.Xlib + +revertToPointerRoot +Graphics.X11.Types +Graphics.X11.Xlib + +rewindDirStream +System.Posix.Directory +System.Posix + +rfc822DateFormat +System.Locale + +rgbScale +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rgba +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +rgbaBias +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rgbaBits +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rgbaBufferDepths +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +rgbaMode +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rgbaScale +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ribbonsPerLine +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +right +Control.Arrow + +rmInitialize +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +rnf +Control.Parallel.Strategies + +rootLabel +Data.Tree + +rootWindow +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +rootWindowOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +rotate +Data.Bits +Foreign +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rotateBuffers +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +rotateL +Data.Bits +Foreign + +rotateR +Data.Bits +Foreign + +round +Prelude + +rowAlignment +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rowLength +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +rows +Text.Html + +rowspan +Text.Html + +rparen +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +rtsSupportsBoundThreads +Control.Concurrent + +rules +Text.Html + +run +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +runCommand +System.Process + +runCont +Control.Monad.Cont + +runContT +Control.Monad.Cont + +runErrorT +Control.Monad.Error + +runGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +runGraphics +Graphics.HGL.Run +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +runIO +Language.Haskell.TH.Syntax +Language.Haskell.TH + +runIdentity +Control.Monad.Identity + +runInBoundThread +Control.Concurrent + +runInUnboundThread +Control.Concurrent + +runInteractiveCommand +System.Process + +runInteractiveProcess +System.Process + +runKleisli +Control.Arrow + +runListT +Control.Monad.List + +runParser +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +runProcess +System.Process + +runQ +Language.Haskell.TH.Syntax +Language.Haskell.TH + +runRWS +Control.Monad.RWS + +runRWST +Control.Monad.RWS + +runReader +Control.Monad.Reader +Control.Monad.RWS + +runReaderT +Control.Monad.Reader +Control.Monad.RWS + +runST +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +runSTArray +Data.Array.ST + +runSTUArray +Data.Array.ST + +runState +Control.Monad.State +Control.Monad.RWS + +runStateT +Control.Monad.State +Control.Monad.RWS + +runTestTT +Test.HUnit.Text +Test.HUnit + +runTestText +Test.HUnit.Text +Test.HUnit + +runTests +Distribution.Simple +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +runWindow +Graphics.HGL.Utils +Graphics.HGL + +runWriter +Control.Monad.Writer +Control.Monad.RWS + +runWriterT +Control.Monad.Writer +Control.Monad.RWS + +run_ +Data.Graph.Inductive.NodeMap +Data.Graph.Inductive + +rwhnf +Control.Parallel.Strategies + +S +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +S# +GHC.Exts + +SCC +Data.Graph + +SDistCmd +Distribution.Setup + +SGr +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +ST +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +STArray +Data.Array.ST + +STM +GHC.Conc +Control.Concurrent.STM + +STRef +Data.STRef +Data.STRef.Lazy +Data.STRef.Strict + +STUArray +Data.Array.ST + +SToS +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Safe +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Safety +Language.Haskell.TH.Syntax +Language.Haskell.TH + +SampleCount +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +SampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +SamplesPassed +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SamplingMethod +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Saturday +System.Time + +ScissorAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ScopedTypeVariables +Distribution.Extension +Distribution.Simple + +Screen +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +ScreenNumber +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +ScreenSaverMode +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +SecondaryColor +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SecondaryColorArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SeekFromEnd +System.IO + +SeekMode +System.IO + +Segment +Graphics.X11.Xlib.Types +Graphics.X11.Xlib + +Select +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SendBuffer +Network.Socket + +SendLowWater +Network.Socket + +SendTimeOut +Network.Socket + +Separable2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SeparateSpecularColor +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +September +System.Time + +SeqPacket +Network.Socket + +ServerAttributeGroup +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Service +Network + +ServiceEntry +Network.BSD +Network.BSD + +ServiceName +Network.BSD + +Set +Data.Set +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SetOwnerAndGroupIsRestricted +System.Posix.Files +System.Posix + +SettableStateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ShadingModel +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SharedTexturePalette +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Short +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.X11.Xlib.Types + +ShortAngle +Graphics.X11.Xlib.Types + +ShortDimension +Graphics.X11.Xlib.Types + +ShortPosition +Graphics.X11.Xlib.Types + +Show +Text.Show +Prelude + +ShowS +Text.Show +Prelude + +Shown +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +ShutdownBoth +Network.Socket + +ShutdownCmd +Network.Socket + +ShutdownReceive +Network.Socket + +ShutdownSend +Network.Socket + +Sides +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +SierpinskiSponge +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +SigD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +SigE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +SigP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Signal +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +SignalSet +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +SilhouetteStyle +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SimpleContour +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SimplePolygon +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SingleBuffered +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +SingleColor +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Sink +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Size +Graphics.HGL.Units +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Slices +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Smooth +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SoError +Network.Socket + +SockAddr +Network.Socket + +SockAddrInet +Network.Socket + +SockAddrUnix +Network.Socket + +Socket +Network.Socket +Network + +SocketOption +Network.Socket + +SocketStatus +Network.Socket + +SocketType +Network.Socket + +Solid +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +SourceName +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +SourcePos +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +SpaceballButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +SpaceballCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +SpaceballInput +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +SpaceballMotion +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +SpaceballRotation +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Special +Language.Haskell.Syntax + +SpecialKey +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Specular +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Sphere +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Sphere' +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +SphereMap +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Split +Data.Graph.Inductive.Internal.Thread + +SplitM +Data.Graph.Inductive.Internal.Thread + +Splittable +GHC.Exts + +Spray +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Src +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SrcAlpha +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SrcAlphaSaturate +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SrcColor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +SrcLoc +Language.Haskell.Syntax +Language.Haskell.Syntax + +StableName +System.Mem.StableName + +StablePtr +Foreign.StablePtr +Foreign + +StackOverflow +Control.Exception +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StackUnderflow +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Stacks +Graphics.Rendering.OpenGL.GLU.Quadrics +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StanzaField +Distribution.PackageDescription +Distribution.PackageDescription + +Start +System.Posix.Terminal +System.Posix + +StartStopInput +System.Posix.Terminal +System.Posix + +StartStopOutput +System.Posix.Terminal +System.Posix + +State +Control.Monad.State +Control.Monad.RWS +Control.Monad.State +Control.Monad.RWS +Test.HUnit.Base +Test.HUnit +Test.HUnit.Base +Test.HUnit +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +StateT +Control.Monad.State +Control.Monad.RWS +Control.Monad.State +Control.Monad.RWS + +StateVar +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StaticCopy +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StaticDraw +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StaticRead +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Status +Graphics.X11.Types +Graphics.X11.Xlib + +StdCall +Language.Haskell.TH.Syntax +Language.Haskell.TH + +StdGen +System.Random + +StencilBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StencilBufferAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StencilIndex +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StencilOp +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Stereoscopic +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Stmt +Language.Haskell.TH.Syntax +Language.Haskell.TH + +StmtQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Stop +System.Posix.Terminal +System.Posix + +Stopped +System.Posix.Process +System.Posix + +Storable +Foreign.Storable +Foreign + +Storable' +Graphics.X11.Xlib.Types +Graphics.X11.Xlib.Types + +StorableArray +Data.Array.Storable + +Str +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +Strategy +Control.Parallel.Strategies + +Stream +Network.Socket + +StreamCopy +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StreamDraw +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +StreamRead +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Strict +Language.Haskell.TH.Syntax +Language.Haskell.TH + +StrictType +Language.Haskell.TH.Syntax + +StrictTypeQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +Stride +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +String +Data.Char +Prelude +Text.Read.Lex +Text.Read + +StringConstr +Data.Generics.Basics +Data.Generics + +StringL +Language.Haskell.TH.Syntax +Language.Haskell.TH + +StringRep +Data.Generics.Basics +Data.Generics + +StripHighBit +System.Posix.Terminal +System.Posix + +StrokeFont +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Style +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +SubMenu +Graphics.UI.GLUT.Menu +Graphics.UI.GLUT + +SubWindowMode +Graphics.X11.Types +Graphics.X11.Xlib + +Subtract +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Sunday +System.Time + +Suspend +System.Posix.Terminal +System.Posix + +SuspendOutput +System.Posix.Terminal +System.Posix + +Symbol +Text.Read.Lex +Text.Read + +SymbolicLinkLimit +System.Posix.Files +System.Posix + +SyncIOAvailable +System.Posix.Files +System.Posix + +SynchronousWrites +System.Posix.IO +System.Posix + +SysUnExpect +Text.ParserCombinators.Parsec.Error + +SysVar +System.Posix.Unistd +System.Posix + +SystemID +System.Posix.Unistd +System.Posix +System.Posix.Unistd +System.Posix + +sCM_RIGHTS +Network.Socket + +sClose +Network.Socket +Network + +sECONDARY +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sIsBound +Network.Socket + +sIsConnected +Network.Socket + +sIsListening +Network.Socket + +sIsReadable +Network.Socket + +sIsWritable +Network.Socket + +sOL_SOCKET +Network.Socket + +sOMAXCONN +Network.Socket + +sPar +Control.Parallel.Strategies + +sSeq +Control.Parallel.Strategies + +sTRIKEOUT_ASCENT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sTRIKEOUT_DESCENT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sTRING +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sUBSCRIPT_X +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sUBSCRIPT_Y +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sUPERSCRIPT_X +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +sUPERSCRIPT_Y +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +s_Arc +Graphics.X11.Xlib.Types + +s_Color +Graphics.X11.Xlib.Types + +s_Point +Graphics.X11.Xlib.Types + +s_Rectangle +Graphics.X11.Xlib.Types + +s_Segment +Graphics.X11.Xlib.Types + +safe +Language.Haskell.TH.Lib +Language.Haskell.TH + +sample +Text.Html + +sampleAlphaToCoverage +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sampleAlphaToOne +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sampleBuffers +Graphics.Rendering.OpenGL.GL.Antialiasing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sampleCount +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +sampleCoverage +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +samples +Graphics.Rendering.OpenGL.GL.Antialiasing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sanityCheckPackage +Distribution.PackageDescription + +satisfy +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +savePrompt +System.Console.Readline + +scale +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +scaleFloat +Prelude + +scaleImage +Graphics.Rendering.OpenGL.GLU.Mipmapping +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +scanl +Data.List +Prelude + +scanl1 +Data.List +Prelude + +scanr +Data.List +Prelude + +scanr1 +Data.List +Prelude + +scc +Data.Graph +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +scheduleAlarm +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +scheme +Network.URI + +scissor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +screenCount +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +screenNumberOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +screenOfDisplay +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +screenResourceString +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +screenSaverActive +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +screenSaverReset +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +screenSize +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +screenSizeMM +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +scrolling +Text.Html + +sdist +Distribution.Simple.SrcDist + +searchPathSeparator +Distribution.Compat.FilePath + +searchable +System.Directory +Distribution.Compat.Directory + +second +Control.Arrow + +secondaryColor +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +secondaryColorv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sectionL +Language.Haskell.TH.Lib +Language.Haskell.TH + +sectionR +Language.Haskell.TH.Lib +Language.Haskell.TH + +seekDirStream +System.Posix.Directory +System.Posix + +segmentationViolation +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +select +Text.Html + +selectBrush +Graphics.HGL.Draw.Brush +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +selectFont +Graphics.HGL.Draw.Font +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +selectInput +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +selectPen +Graphics.HGL.Draw.Pen +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +selected +Text.Html + +selectionClear +Graphics.X11.Types +Graphics.X11.Xlib + +selectionNotify +Graphics.X11.Types +Graphics.X11.Xlib + +selectionRequest +Graphics.X11.Types +Graphics.X11.Xlib + +semi +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Token +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +semiSep +Text.ParserCombinators.Parsec.Token + +semiSep1 +Text.ParserCombinators.Parsec.Token + +send +Network.Socket + +sendAncillary +Network.Socket + +sendBreak +System.Posix.Terminal +System.Posix + +sendBufTo +Network.Socket + +sendEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +sendFd +Network.Socket + +sendTo +Network +Network.Socket + +sep +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +sepBy +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +sepBy1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +sepEndBy +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +sepEndBy1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec + +separableFilter2D +Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +seq +Prelude +Control.Parallel + +seqArr +Control.Parallel.Strategies + +seqList +Control.Parallel.Strategies + +seqListN +Control.Parallel.Strategies + +seqListNth +Control.Parallel.Strategies + +seqPair +Control.Parallel.Strategies + +seqTriple +Control.Parallel.Strategies + +sequence +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +sequenceQ +Language.Haskell.TH.Syntax + +sequence_ +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +serverVendor +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +serviceAliases +Network.BSD + +serviceName +Network.BSD + +servicePort +Network.BSD + +serviceProtocol +Network.BSD + +set +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +setAlreadyPrompted +System.Console.Readline + +setArcMode +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setAttemptedCompletionFunction +System.Console.Readline + +setBackground +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setBasicQuoteCharacters +System.Console.Readline + +setBasicWordBreakCharacters +System.Console.Readline + +setBit +Data.Bits +Foreign + +setBkColor +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +setBkMode +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +setCatchSignals +System.Console.Readline + +setCatchSigwinch +System.Console.Readline + +setCharIsQuotedP +System.Console.Readline + +setClipMask +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setClipOrigin +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setCloseDownMode +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setCompleterQuoteCharacters +System.Console.Readline + +setCompleterWordBreakCharacters +System.Console.Readline + +setCompletionAppendCharacter +System.Console.Readline + +setCompletionDisplayMatchesHook +System.Console.Readline + +setCompletionEntryFunction +System.Console.Readline + +setCompletionQueryItems +System.Console.Readline + +setCulling +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +setCurrentDirectory +System.Directory +Distribution.Compat.Directory + +setDashes +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setDefaultErrorHandler +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setDirectoryCompletionHook +System.Console.Readline + +setDisplayMode +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +setDone +System.Console.Readline + +setEnd +System.Console.Readline + +setEnv +System.Posix.Env +System.Posix + +setEraseEmptyLine +System.Console.Readline + +setErrorMessage +Text.ParserCombinators.Parsec.Error + +setErrorPos +Text.ParserCombinators.Parsec.Error + +setEventHook +System.Console.Readline + +setFdMode +System.Posix.Files +System.Posix + +setFdOption +System.Posix.IO +System.Posix + +setFdOwnerAndGroup +System.Posix.Files +System.Posix + +setFdSize +System.Posix.Files +System.Posix + +setFileCreationMask +System.Posix.Files +System.Posix + +setFileMode +System.Posix.Files +System.Posix + +setFileSize +System.Posix.Files +System.Posix + +setFileTimes +System.Posix.Files +System.Posix + +setFilenameCompletionDesired +System.Console.Readline + +setFilenameDequotingFunction +System.Console.Readline + +setFilenameQuoteCharacters +System.Console.Readline + +setFilenameQuotingDesired +System.Console.Readline + +setFilenameQuotingFunction +System.Console.Readline + +setFillRule +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setFillStyle +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setFont +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setForeground +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setFunction +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setGraphic +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +setGraphicsExposures +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setGroupID +System.Posix.User +System.Posix + +setGroupIDMode +System.Posix.Files +System.Posix + +setHostEntry +Network.BSD + +setIconName +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setIgnoreCompletionDuplicates +System.Console.Readline + +setIgnoreSomeCompletionsFunction +System.Console.Readline + +setInhibitCompletion +System.Console.Readline + +setInput +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +setInputFocus +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setKeymap +System.Console.Readline + +setLineAttributes +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setLineBuffer +System.Console.Readline + +setLocaleModifiers +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setLock +System.Posix.IO +System.Posix + +setMark +System.Console.Readline + +setModeDelete +Graphics.X11.Types +Graphics.X11.Xlib + +setModeInsert +Graphics.X11.Types +Graphics.X11.Xlib + +setNURBSMode +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +setNetworkEntry +Network.BSD + +setOwnerAndGroup +System.Posix.Files +System.Posix + +setParserState +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +setPendingInput +System.Console.Readline + +setPermissions +System.Directory +Distribution.Compat.Directory + +setPlaneMask +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setPoint +System.Console.Readline + +setPosition +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +setPreInputHook +System.Console.Readline + +setProcessGroupID +System.Posix.Process +System.Posix + +setProcessGroupPriority +System.Posix.Process +System.Posix + +setProcessPriority +System.Posix.Process +System.Posix + +setProtocolEntry +Network.BSD + +setReadlineName +System.Console.Readline + +setRedisplayFunction +System.Console.Readline + +setRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +setResourceLimit +System.Posix.Resource +System.Posix + +setSamplingMethod +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +setScreenSaver +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setServiceEntry +Network.BSD + +setSignalMask +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +setSignals +System.Console.Readline + +setSocketOption +Network.Socket + +setSourceColumn +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +setSourceLine +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +setSourceName +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +setSpecialPrefixes +System.Console.Readline + +setStartupHook +System.Console.Readline + +setState +Graphics.X11.Xlib.Context +Graphics.X11.Xlib +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +setStdGen +System.Random + +setStipple +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setStoppedChildFlag +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +setSubwindowMode +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setSymbolicLinkOwnerAndGroup +System.Posix.Files +System.Posix + +setTSOrigin +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setTerminalAttributes +System.Posix.Terminal +System.Posix + +setTerminalProcessGroupID +System.Posix.Terminal +System.Posix + +setTextAlignment +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +setTextColor +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +setTextProperty +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setTile +Graphics.X11.Xlib.Context +Graphics.X11.Xlib + +setToList +Data.Set + +setUncaughtExceptionHandler +Control.Exception + +setUserID +System.Posix.User +System.Posix + +setUserIDMode +System.Posix.Files +System.Posix + +setUserPriority +System.Posix.Process +System.Posix + +setWMProtocols +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setWindowBackground +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +setWindowBackgroundPixmap +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +setWindowBorder +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +setWindowBorderPixmap +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +setWindowBorderWidth +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +setWindowColormap +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +set_background_pixel +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_background_pixmap +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_backing_pixel +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_backing_planes +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_backing_store +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_bit_gravity +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_border_pixel +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_border_pixmap +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_colormap +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_cursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_do_not_propagate_mask +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_event_mask +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_override_redirect +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_save_under +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +set_win_gravity +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +setupMessage +Distribution.PackageDescription + +sforce +Control.Parallel.Strategies + +shadeModel +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +shape +Text.Html + +shearEllipse +Graphics.HGL.Draw.Picture +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +shift +Data.Bits +Foreign +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +shiftL +Data.Bits +Foreign + +shiftL# +GHC.Exts + +shiftMapIndex +Graphics.X11.Types +Graphics.X11.Xlib + +shiftMask +Graphics.X11.Types +Graphics.X11.Xlib + +shiftR +Data.Bits +Foreign + +shiftRL# +GHC.Exts + +show +Text.Show +Prelude + +showChar +Text.Show +Prelude + +showConstr +Data.Generics.Basics +Data.Generics + +showCounts +Test.HUnit.Text +Test.HUnit + +showEFloat +Numeric + +showError +Distribution.PackageDescription + +showErrorMessages +Text.ParserCombinators.Parsec.Error + +showFFloat +Numeric + +showFloat +Numeric + +showGFloat +Numeric + +showGHCPackageConfig +Distribution.Simple.GHCPackageConfig + +showHex +Numeric + +showHookedBuildInfo +Distribution.PackageDescription + +showInstalledPackageInfo +Distribution.InstalledPackageInfo + +showInstalledPackageInfoField +Distribution.InstalledPackageInfo + +showInt +Numeric + +showIntAtBase +Numeric + +showList +Text.Show +Prelude + +showListWith +Text.Show + +showLitChar +Data.Char + +showOct +Numeric + +showPackageDescription +Distribution.PackageDescription + +showPackageId +Distribution.Package +Distribution.Make +Distribution.Simple + +showParen +Text.Show +Prelude + +showPath +Test.HUnit.Text +Test.HUnit + +showSigned +Numeric + +showString +Text.Show +Prelude + +showTable +Text.Html.BlockTable + +showTree +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +showTreeWith +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +showVersion +Data.Version +Distribution.Version +Distribution.Simple + +showVersionRange +Distribution.Version +Distribution.Simple + +shows +Text.Show +Prelude + +showsPrec +Text.Show +Prelude + +showsTable +Text.Html.BlockTable + +showtextl +Language.Haskell.TH.Ppr + +shrinkRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +shutdown +Network.Socket + +sigABRT +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigALRM +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigBUS +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigCHLD +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigCONT +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigD +Language.Haskell.TH.Lib +Language.Haskell.TH + +sigE +Language.Haskell.TH.Lib +Language.Haskell.TH + +sigFPE +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigHUP +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigILL +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigINT +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigKILL +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigP +Language.Haskell.TH.Lib +Language.Haskell.TH + +sigPIPE +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigPOLL +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigPROF +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigQUIT +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigSEGV +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigSTOP +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigSYS +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigTERM +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigTRAP +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigTSTP +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigTTIN +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigTTOU +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigURG +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigUSR1 +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigUSR2 +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigVTALRM +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigWINCH +System.Posix.Signals.Exts + +sigXCPU +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +sigXFSZ +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +signalProcess +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +signalProcessGroup +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +signalQSem +Control.Concurrent.QSem +Control.Concurrent + +signalQSemN +Control.Concurrent.QSemN +Control.Concurrent + +significand +Prelude + +signum +Prelude + +silver +Text.Html + +simpleMatch +Language.Haskell.TH.Lib + +simpleTable +Text.Html + +sin +Prelude + +single +Text.Html.BlockTable + +singleton +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +sinh +Prelude + +size +Data.IntMap +Data.IntSet +Data.Map +Data.Set +Graphics.X11.Xlib.Types +Text.Html + +sizeFM +Data.FiniteMap +Data.Graph.Inductive.Internal.FiniteMap + +sizeOf +Foreign.Storable +Foreign + +sized +Test.QuickCheck +Debug.QuickCheck + +skipImages +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +skipMany +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +skipMany1 +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +skipPixels +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +skipRows +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +skipSpaces +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +sleep +System.Posix.Unistd +System.Posix + +small +Text.Html + +smartCopySources +Distribution.Simple.Utils + +smoothLineWidthGranularity +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +smoothLineWidthRange +Graphics.Rendering.OpenGL.GL.LineSegments +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +smoothPointSizeGranularity +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +smoothPointSizeRange +Graphics.Rendering.OpenGL.GL.Points +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +snd +Data.Tuple +Prelude + +socket +Network.Socket + +socketPair +Network.Socket + +socketPort +Network +Network.Socket + +socketToHandle +Network.Socket + +softLimit +System.Posix.Resource +System.Posix + +softwareStop +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +softwareTermination +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +something +Data.Generics.Schemes +Data.Generics + +somewhere +Data.Generics.Schemes +Data.Generics + +sort +Data.List + +sortBy +Data.List + +sourceColumn +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +sourceLine +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +sourceName +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec + +source_dirs +Distribution.Simple.GHCPackageConfig + +southEastGravity +Graphics.X11.Types +Graphics.X11.Xlib + +southGravity +Graphics.X11.Types +Graphics.X11.Xlib + +southWestGravity +Graphics.X11.Types +Graphics.X11.Xlib + +sp +Data.Graph.Inductive.Query.SP +Data.Graph.Inductive.Query +Data.Graph.Inductive + +spLength +Data.Graph.Inductive.Query.SP +Data.Graph.Inductive.Query +Data.Graph.Inductive + +spTree +Data.Graph.Inductive.Query.SP +Data.Graph.Inductive.Query +Data.Graph.Inductive + +space +Language.Haskell.TH.PprLib +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +spaceHtml +Text.Html + +spaceballCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +spaces +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +spacing +Language.Haskell.Pretty + +span +Data.List +Prelude + +spanPS +Data.PackedString + +sparking +Control.Parallel.Strategies + +specialDeviceID +System.Posix.Files +System.Posix + +specular +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +split +Data.IntMap +Data.IntSet +Data.Map +Data.Set +GHC.Exts +Language.Haskell.TH.Ppr +System.Random + +splitAt +Data.List +Prelude + +splitAtPS +Data.PackedString + +splitFM +Data.Graph.Inductive.Internal.FiniteMap + +splitFileExt +Distribution.Compat.FilePath + +splitFileName +Distribution.Compat.FilePath + +splitFilePath +Distribution.Compat.FilePath + +splitLookup +Data.IntMap +Data.Map + +splitMember +Data.IntSet +Data.Set + +splitMin +Data.Graph.Inductive.Internal.Heap + +splitMinFM +Data.Graph.Inductive.Internal.FiniteMap + +splitPS +Data.PackedString + +splitPar +Data.Graph.Inductive.Internal.Thread + +splitParM +Data.Graph.Inductive.Internal.Thread + +splitRegex +Text.Regex + +splitTyConApp +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +splitWithPS +Data.PackedString + +spotCutoff +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +spotDirection +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +spotExponent +Graphics.Rendering.OpenGL.GL.Colors +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +sqrt +Prelude + +squares +Text.ParserCombinators.Parsec.Token + +src +Text.Html + +srcColumn +Language.Haskell.Syntax + +srcFilename +Language.Haskell.Syntax + +srcLine +Language.Haskell.Syntax + +stToIO +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +stability +Distribution.InstalledPackageInfo +Distribution.PackageDescription + +stackDepth +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stamp +Test.QuickCheck +Debug.QuickCheck + +star +Data.Graph.Inductive.Example + +starM +Data.Graph.Inductive.Example + +start +Text.Html + +stateInput +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +statePos +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +stateUser +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +staticGravity +Graphics.X11.Types +Graphics.X11.Xlib + +statusChangeTime +System.Posix.Files +System.Posix + +stdCall +Language.Haskell.TH.Lib +Language.Haskell.TH + +stdError +System.Posix.IO +System.Posix + +stdFileMode +System.Posix.Files +System.Posix + +stdInput +System.Posix.IO +System.Posix + +stdOutput +System.Posix.IO +System.Posix + +stderr +System.IO + +stdin +System.IO + +stdout +System.IO + +stencilBits +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stencilBufferDepth +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +stencilFunc +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stencilMask +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stencilOp +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stencilTest +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +step +Text.ParserCombinators.ReadPrec +Text.Read + +stereo +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +stereoBuffer +Graphics.Rendering.OpenGL.GL.Framebuffer +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +stippleShape +Graphics.X11.Types +Graphics.X11.Xlib + +storeBuffer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +storeBytes +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +storeColor +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +storeName +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +strAttr +Text.Html + +strMsg +Control.Monad.Error + +strictToLazyST +Control.Monad.ST.Lazy + +strictType +Language.Haskell.TH.Lib +Language.Haskell.TH + +string +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP + +stringE +Language.Haskell.TH.Lib +Language.Haskell.TH + +stringL +Language.Haskell.TH.Lib +Language.Haskell.TH + +stringLiteral +Text.ParserCombinators.Parsec.Token + +stringToHtml +Text.Html + +stringToHtmlString +Text.Html + +stringToKeysym +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +stringWidth +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +stripComments +Distribution.Simple.Utils + +strong +Text.Html + +stronglyConnComp +Data.Graph + +stronglyConnCompR +Data.Graph + +structureNotifyMask +Graphics.X11.Types +Graphics.X11.Xlib + +stuffChar +System.Console.Readline + +style +Text.Html +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +sub +Text.Html + +subForest +Data.Tree + +subRegex +Text.Regex + +submit +Text.Html + +subpixelBits +Graphics.Rendering.OpenGL.GL.Antialiasing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +substrPS +Data.PackedString + +substructureNotifyMask +Graphics.X11.Types +Graphics.X11.Xlib + +substructureRedirectMask +Graphics.X11.Types +Graphics.X11.Xlib + +subtract +Prelude + +subtractRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +suc +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +suc' +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +sucGT +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +sucM +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +succ +Prelude + +succFM +Data.Graph.Inductive.Internal.FiniteMap + +success +Graphics.X11.Types +Graphics.X11.Xlib + +sum +Data.List +Prelude + +sup +Text.Html + +supportsLocale +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +swapBuffers +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +swapBytes +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +swapMVar +Control.Concurrent.MVar +Control.Concurrent + +swapTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +symbol +Text.ParserCombinators.Parsec.Token + +symlink +Network.BSD + +sync +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +syncBoth +Graphics.X11.Types +Graphics.X11.Xlib + +syncKeyboard +Graphics.X11.Types +Graphics.X11.Xlib + +syncPointer +Graphics.X11.Types +Graphics.X11.Xlib + +synopsis +Distribution.PackageDescription + +synthesize +Data.Generics.Schemes +Data.Generics + +system +System.Cmd + +systemName +System.Posix.Unistd +System.Posix + +systemTime +System.Posix.Process +System.Posix + +T +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T2fC3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T2fC4fN3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T2fC4ubV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T2fN3fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T2fV3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T4fC4fN3fV4f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +T4fV4f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +TMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +TOD +System.Time + +TVar +GHC.Conc +Control.Concurrent.STM.TVar +Control.Concurrent.STM + +Table +Data.Graph + +TableTooLarge +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TabletButton +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TabletCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TabletInput +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TabletMotion +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TabletPosition +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TcClsName +Language.Haskell.TH.Syntax + +Teapot +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +TemplateHaskell +Distribution.Extension +Distribution.Simple + +TerminalAttributes +System.Posix.Terminal +System.Posix + +TerminalMode +System.Posix.Terminal +System.Posix + +TerminalState +System.Posix.Terminal +System.Posix + +Terminated +System.Posix.Process +System.Posix + +TessWinding +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TessWindingAbsGeqTwo +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TessWindingNegative +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TessWindingNonzero +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TessWindingOdd +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TessWindingPositive +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TesselatorError +Graphics.Rendering.OpenGL.GLU.Errors +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Tessellator +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Test +Test.HUnit.Base +Test.HUnit + +TestAborted +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +TestCase +Test.HUnit.Base +Test.HUnit + +TestExausted +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +TestFailed +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +TestLabel +Test.HUnit.Base +Test.HUnit + +TestList +Test.HUnit.Base +Test.HUnit + +TestOk +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +TestOptions +Test.QuickCheck.Batch +Debug.QuickCheck.Batch +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +TestResult +Test.QuickCheck.Batch +Debug.QuickCheck.Batch + +Testable +Test.HUnit.Base +Test.HUnit +Test.QuickCheck +Debug.QuickCheck + +Tetrahedron +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +TexCoord +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexCoord1 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexCoord2 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexCoord3 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexCoord4 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexCoordComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Text +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +TextDetails +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +Texture +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture1DColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture2DColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Texture3DColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureColorTableStage +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCombineFunction +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCompareOperator +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCompression +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCoordArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCoordName +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMap +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTable +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapNegativeX +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapNegativeY +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapNegativeZ +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapPositiveX +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapPositiveY +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureCubeMapPositiveZ +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureFilter +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureFunction +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureGenMode +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureObject +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexturePosition1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexturePosition2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexturePosition3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TexturePriority +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureQuery +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureRectangle +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureSize1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureSize2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureSize3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureTarget +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TextureUnit +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ThisVersion +Distribution.Version +Distribution.Simple + +Thread +Data.Graph.Inductive.Internal.Thread + +ThreadId +GHC.Conc +Control.Concurrent +GHC.Conc + +ThreadKilled +Control.Exception + +Threadsafe +Language.Haskell.TH.Syntax +Language.Haskell.TH + +ThreeBytes +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ThreeD +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ThreeDColor +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ThreeDColorTexture +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Thursday +System.Time + +TildeP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Time +Graphics.HGL.Units +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Types +Graphics.X11.Xlib + +TimeDiff +System.Time +System.Time + +TimeLocale +System.Locale +System.Locale + +TimeToLive +Network.Socket + +Timeout +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TimerCallback +Graphics.UI.GLUT.Callbacks.Global +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +TimesRoman10 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +TimesRoman24 +Graphics.UI.GLUT.Fonts +Graphics.UI.GLUT + +Title +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE + +TokenParser +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.Parsec.Token + +Tolerance +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Top +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +TopLeftCorner +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +TopRightCorner +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +TopSide +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Torus +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +TransferDirection +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TransformAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TransmitStart +System.Posix.Terminal +System.Posix + +TransmitStop +System.Posix.Terminal +System.Posix + +Transparent +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +Tree +Data.Tree +Data.Graph + +Triangle +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TriangleFan +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TriangleStrip +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TriangleVertex +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Triangles +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Triangulation +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +True +Data.Bool +Prelude + +TryDirectContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Tuesday +System.Time + +TupE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +TupP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +TupleT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +TwoBytes +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TwoD +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +TwoStopBits +System.Posix.Terminal +System.Posix + +TyCon +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +TyConI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +TySynD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +TyVarI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Type +Language.Haskell.TH.Syntax +Language.Haskell.TH +Network.Socket + +TypeQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +TypeRep +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +TypeSynonymInstances +Distribution.Extension +Distribution.Simple + +Typeable +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable1 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable2 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable3 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable4 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable5 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable6 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +Typeable7 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +tab +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +table +Text.Html + +tabletCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +tag +Text.Html + +tail +Data.List +Prelude + +tailPS +Data.PackedString + +tails +Data.List + +take +Data.List +Prelude + +takeMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +takePS +Data.PackedString + +takeTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +takeWhile +Data.List +Prelude + +takeWhilePS +Data.PackedString + +tan +Prelude + +tanh +Prelude + +target +Text.Html + +td +Text.Html + +tdDay +System.Time + +tdHour +System.Time + +tdMin +System.Time + +tdMonth +System.Time + +tdPicosec +System.Time + +tdSec +System.Time + +tdYear +System.Time + +teal +Text.Html + +tell +Control.Monad.Writer +Control.Monad.RWS + +tellDirStream +System.Posix.Directory +System.Posix + +terminalAppearance +Test.HUnit.Terminal + +terminalMode +System.Posix.Terminal +System.Posix + +terminateProcess +System.Process + +tessellate +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +test +Test.HUnit.Base +Test.HUnit +Test.QuickCheck +Debug.QuickCheck + +testBit +Data.Bits +Foreign + +testCaseCount +Test.HUnit.Base +Test.HUnit + +testCasePaths +Test.HUnit.Base +Test.HUnit + +testedWith +Distribution.PackageDescription + +texCoord +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texCoordv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texImage3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texSubImage1D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texSubImage2D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texSubImage3D +Graphics.Rendering.OpenGL.GL.Texturing.Specification +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +text +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Language.Haskell.TH.PprLib +Text.Html +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +textExtents +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +textInfo +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +textWidth +Graphics.X11.Xlib.Font +Graphics.X11.Xlib + +textarea +Text.Html + +textfield +Text.Html + +texture +Graphics.Rendering.OpenGL.GL.Texturing.Application +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureBinding +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureBorder +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureBorderColor +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureCompareFailValue +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureCompareMode +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureCompareOperator +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureCompressedImageSize +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureDepthBits +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureFilter +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureFunction +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureGenMode +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureIndexSize +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureIntensitySize +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureInternalFormat +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureLODRange +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureLevelRange +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureLuminanceSize +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureMaxAnisotropy +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureObjectLODBias +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +texturePriority +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureProxyOK +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureRGBASizes +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureResident +Graphics.Rendering.OpenGL.GL.Texturing.Objects +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureSize1D +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureSize2D +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureSize3D +Graphics.Rendering.OpenGL.GL.Texturing.Queries +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureUnitLODBias +Graphics.Rendering.OpenGL.GL.Texturing.Environments +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +textureWrapMode +Graphics.Rendering.OpenGL.GL.Texturing.Parameters +Graphics.Rendering.OpenGL.GL.Texturing +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +th +Text.Html + +thaw +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +thebase +Text.Html + +theclass +Text.Html + +thecode +Text.Html + +thediv +Text.Html + +thehtml +Text.Html + +thelink +Text.Html + +themap +Text.Html + +thespan +Text.Html + +thestyle +Text.Html + +thetitle +Text.Html + +thetype +Text.Html + +threadDelay +GHC.Conc +Control.Concurrent + +threadList +Data.Graph.Inductive.Internal.Thread + +threadList' +Data.Graph.Inductive.Internal.Thread + +threadMaybe +Data.Graph.Inductive.Internal.Thread + +threadMaybe' +Data.Graph.Inductive.Internal.Thread + +threadWaitRead +GHC.Conc +Control.Concurrent + +threadWaitWrite +GHC.Conc +Control.Concurrent + +threadsafe +Language.Haskell.TH.Lib +Language.Haskell.TH + +three +Test.QuickCheck +Debug.QuickCheck + +throw +Control.Exception + +throwDyn +Control.Exception + +throwDynTo +Control.Exception + +throwErrno +Foreign.C.Error +Foreign.C + +throwErrnoIf +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1 +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1Retry +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1RetryMayBlock +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1RetryMayBlock_ +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1Retry_ +Foreign.C.Error +Foreign.C + +throwErrnoIfMinus1_ +Foreign.C.Error +Foreign.C + +throwErrnoIfNull +Foreign.C.Error +Foreign.C + +throwErrnoIfNullRetry +Foreign.C.Error +Foreign.C + +throwErrnoIfNullRetryMayBlock +Foreign.C.Error +Foreign.C + +throwErrnoIfRetry +Foreign.C.Error +Foreign.C + +throwErrnoIfRetryMayBlock +Foreign.C.Error +Foreign.C + +throwErrnoIfRetryMayBlock_ +Foreign.C.Error +Foreign.C + +throwErrnoIfRetry_ +Foreign.C.Error +Foreign.C + +throwErrnoIf_ +Foreign.C.Error +Foreign.C + +throwErrnoPath +System.Posix.Error + +throwErrnoPathIf +System.Posix.Error + +throwErrnoPathIfMinus1 +System.Posix.Error + +throwErrnoPathIfMinus1_ +System.Posix.Error + +throwErrnoPathIfNull +System.Posix.Error + +throwErrnoPathIf_ +System.Posix.Error + +throwError +Control.Monad.Error + +throwIO +Control.Exception + +throwIf +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +throwIfNeg +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +throwIfNeg_ +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +throwIfNull +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +throwIfZero +Graphics.X11.Types +Graphics.X11.Xlib + +throwIf_ +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +throwSocketErrorIfMinus1_ +Network.Socket + +throwTo +GHC.Conc +Control.Exception +Control.Concurrent + +throwUnlessSuccess +Graphics.X11.Types +Graphics.X11.Xlib + +tildeP +Language.Haskell.TH.Lib +Language.Haskell.TH + +tileShape +Graphics.X11.Types +Graphics.X11.Xlib + +time12Fmt +System.Locale + +timeDiffToString +System.Time + +timeFmt +System.Locale + +timeGetTime +Graphics.SOE + +title +Text.Html + +toAscList +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +toBool +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +toCalendarTime +System.Time + +toClockTime +System.Time + +toConstr +Data.Generics.Basics +Data.Generics + +toDyn +Data.Dynamic + +toEnum +Prelude + +toHtml +Text.Html + +toHtmlFromList +Text.Html + +toInteger +Prelude + +toList +Data.Graph.Inductive.Internal.Heap +Data.HashTable +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +toLower +Data.Char + +toRational +Prelude + +toUTCTime +System.Time + +toUpper +Data.Char + +to_HPJ_Doc +Language.Haskell.TH.PprLib + +token +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +tokenPrim +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +tokenPrimEx +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +tokens +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +topSort +Data.Graph + +topsort +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +topsort' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +touchFile +System.Posix.Files +System.Posix + +touchForeignPtr +Foreign.ForeignPtr +Foreign + +touchStorableArray +Data.Array.Storable + +tr +Text.Html + +trace +Debug.Trace + +translate +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +translateCoordinates +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +transparentIndex +Graphics.UI.GLUT.Colormap +Graphics.UI.GLUT + +transpose +Data.List + +transposeG +Data.Graph + +trc +Data.Graph.Inductive.Query.TransClos +Data.Graph.Inductive.Query +Data.Graph.Inductive + +treeHtml +Text.Html + +triangulate +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +tried +Test.HUnit.Base +Test.HUnit + +trivial +Test.QuickCheck +Debug.QuickCheck + +trunc +System.Posix.IO +System.Posix + +truncate +Prelude + +try +Control.Exception +System.IO.Error +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +tryJust +Control.Exception + +tryPutMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +tryPutTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +tryTakeMVar +GHC.Conc +Control.Concurrent.MVar +Control.Concurrent + +tryTakeTMVar +Control.Concurrent.STM.TMVar +Control.Concurrent.STM + +tt +Text.Html + +tupE +Language.Haskell.TH.Lib +Language.Haskell.TH + +tupP +Language.Haskell.TH.Lib +Language.Haskell.TH + +tupleDataName +Language.Haskell.TH.Syntax +Language.Haskell.TH + +tupleT +Language.Haskell.TH.Lib +Language.Haskell.TH + +tupleTypeName +Language.Haskell.TH.Syntax +Language.Haskell.TH + +tuple_con +Language.Haskell.Syntax + +tuple_con_name +Language.Haskell.Syntax + +tuple_tycon +Language.Haskell.Syntax + +tuple_tycon_name +Language.Haskell.Syntax + +two +Test.QuickCheck +Debug.QuickCheck + +tyConString +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +tySynD +Language.Haskell.TH.Lib +Language.Haskell.TH + +tyconModule +Data.Generics.Basics +Data.Generics + +tyconUQname +Data.Generics.Basics +Data.Generics + +typeOf +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf1 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf1Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf2 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf2Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf3 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf3Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf4 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf4Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf5 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf5Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf6 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf6Default +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOf7 +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeOfDefault +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeRepArgs +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +typeRepTyCon +Data.Typeable +Data.Dynamic +Data.Generics.Basics +Data.Generics + +UArray +Data.Array.Unboxed + +UContext +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +UDecomp +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +UEdge +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +UGr +Data.Graph.Inductive.Tree +Data.Graph.Inductive + +UNode +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +UPath +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +URI +Network.URI +Network.URI + +URIAuth +Network.URI +Network.URI + +URL +Text.Html + +USGr +Data.Graph.Inductive.Monad.IOArray +Data.Graph.Inductive + +UnExpect +Text.ParserCombinators.Parsec.Error + +UnQual +Language.Haskell.Syntax + +Unbuffered +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL + +UndefinedElement +Control.Exception + +Underflow +Control.Exception + +UndoBegin +System.Console.Readline + +UndoCode +System.Console.Readline + +UndoDelete +System.Console.Readline + +UndoEnd +System.Console.Readline + +UndoInsert +System.Console.Readline + +UnionVersionRanges +Distribution.Version +Distribution.Simple + +Uniq +Language.Haskell.TH.Syntax + +Unique +Data.Unique + +UnixSocket +Network + +Unlock +System.Posix.IO +System.Posix + +UnmappingFailed +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Unpack +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnpackCMYK +Graphics.Rendering.OpenGL.GL.Hints +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnregisterCmd +Distribution.Setup + +Unsafe +Language.Haskell.TH.Syntax +Language.Haskell.TH + +UnsafeOverlappingInstances +Distribution.Extension +Distribution.Simple + +UnsignedByte +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedByte233Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedByte332 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt1010102 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt2101010Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt248 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt8888 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedInt8888Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort1555Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort4444 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort4444Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort5551 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort565 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort565Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort88 +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +UnsignedShort88Rev +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Up +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +UpDown +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +UseCurrentContext +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +UserEntry +System.Posix.User +System.Posix +System.Posix.User +System.Posix + +UserHooks +Distribution.Simple +Distribution.Simple + +UserID +System.Posix.Types +System.Posix + +uNDERLINE_POSITION +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +uNDERLINE_THICKNESS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +ucycle +Data.Graph.Inductive.Example + +ucycleM +Data.Graph.Inductive.Example + +udff +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +udff' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +udfs +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +udfs' +Data.Graph.Inductive.Query.DFS +Data.Graph.Inductive.Query +Data.Graph.Inductive + +ufold +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +ufoldM +Data.Graph.Inductive.Monad +Data.Graph.Inductive + +ulist +Text.Html + +unEscapeString +Network.URI + +unGM +Data.Generics.Aliases +Data.Generics + +unGQ +Data.Generics.Aliases +Data.Generics + +unGT +Data.Generics.Aliases +Data.Generics + +unGeneric' +Data.Generics.Aliases +Data.Generics + +unGetChan +Control.Concurrent.Chan +Control.Concurrent + +unGetTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +unProject +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +unProject4 +Graphics.Rendering.OpenGL.GLU.Matrix +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +unbindCommandInMap +System.Console.Readline + +unbindKey +System.Console.Readline + +unbindKeyInMap +System.Console.Readline + +unblock +Control.Exception + +unblockSignals +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +uncurry +Data.Tuple +Prelude + +undefineCursor +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +undefined +Prelude + +underline +Text.Html + +undir +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +undl +System.Posix.DynamicLinker + +unexpected +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +unfoldForest +Data.Tree + +unfoldForestM +Data.Tree + +unfoldForestM_BF +Data.Tree + +unfoldTree +Data.Tree + +unfoldTreeM +Data.Tree + +unfoldTreeM_BF +Data.Tree + +unfoldr +Data.List + +ungrabButton +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +ungrabKey +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +ungrabKeyboard +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +ungrabPointer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +ungrabServer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +uninstallColormap +Graphics.X11.Xlib.Color +Graphics.X11.Xlib + +union +Data.IntMap +Data.IntSet +Data.List +Data.Map +Data.Set + +unionBy +Data.List + +unionFileModes +System.Posix.Files +System.Posix + +unionManySets +Data.Set + +unionRectWithRegion +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +unionRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +unionWith +Data.IntMap +Data.Map + +unionWithKey +Data.IntMap +Data.Map + +unions +Data.IntMap +Data.IntSet +Data.Map +Data.Set + +unionsWith +Data.IntMap +Data.Map + +unit +Data.Graph.Inductive.Internal.Heap + +unitFM +Data.FiniteMap + +unitSet +Data.Set + +unit_con +Language.Haskell.Syntax + +unit_con_name +Language.Haskell.Syntax + +unit_tycon +Language.Haskell.Syntax + +unit_tycon_name +Language.Haskell.Syntax + +unlab +Data.Graph.Inductive.Basic +Data.Graph.Inductive + +unless +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +unlines +Data.List +Prelude + +unlinesPS +Data.PackedString + +unlit +Distribution.PreProcess.Unlit + +unmapGravity +Graphics.X11.Types +Graphics.X11.Xlib + +unmapNotify +Graphics.X11.Types +Graphics.X11.Xlib + +unmapSubwindows +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +unmarshalObject +GHC.Dotnet + +unmarshalString +GHC.Dotnet + +unordList +Text.Html + +unpackFamily +Network.Socket + +unpackPS +Data.PackedString + +unregScriptLocation +Distribution.Simple.Register + +unregister +Distribution.Simple.Register + +unreserved +Network.URI + +unsafe +Language.Haskell.TH.Lib +Language.Haskell.TH + +unsafeForeignPtrToPtr +Foreign.ForeignPtr +Foreign + +unsafeFreeze +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +unsafeIOToST +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +unsafeIOToSTM +GHC.Conc + +unsafeInterleaveIO +System.IO.Unsafe + +unsafeInterleaveST +Control.Monad.ST.Lazy +Control.Monad.ST +Control.Monad.ST.Strict + +unsafePerformIO +System.IO.Unsafe +Foreign + +unsafePreservingMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +unsafeRenderPrimitive +Graphics.Rendering.OpenGL.GL.BeginEnd +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +unsafeThaw +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +unsetEnv +System.Posix.Env +System.Posix + +until +Prelude + +unwords +Data.List +Prelude + +unwordsPS +Data.PackedString + +unzip +Data.List +Prelude + +unzip3 +Data.List +Prelude + +unzip4 +Data.List + +unzip5 +Data.List + +unzip6 +Data.List + +unzip7 +Data.List + +updAdjList +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +updFM +Data.Graph.Inductive.Internal.FiniteMap + +update +Data.HashTable +Data.IntMap +Data.Map + +updateAt +Data.Map + +updateFlow +Data.Graph.Inductive.Query.MaxFlow +Data.Graph.Inductive.Query +Data.Graph.Inductive + +updateLookupWithKey +Data.IntMap +Data.Map + +updateMax +Data.Map + +updateMaxWithKey +Data.Map + +updateMin +Data.Map + +updateMinWithKey +Data.Map + +updatePackageDescription +Distribution.PackageDescription + +updatePosChar +Text.ParserCombinators.Parsec.Pos + +updatePosString +Text.ParserCombinators.Parsec.Pos + +updateState +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +updateWithKey +Data.IntMap +Data.Map + +upper +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec + +urgentDataAvailable +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +uriAuthority +Network.URI + +uriFragment +Network.URI + +uriPath +Network.URI + +uriPort +Network.URI + +uriQuery +Network.URI + +uriRegName +Network.URI + +uriScheme +Network.URI + +uriToString +Network.URI + +uriUserInfo +Network.URI + +usageInfo +Distribution.GetOpt +System.Console.GetOpt + +usemap +Text.Html + +userDefinedSignal1 +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +userDefinedSignal2 +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +userError +System.IO.Error +Prelude + +userErrorType +System.IO.Error + +userErrors +Control.Exception + +userGroupID +System.Posix.User +System.Posix + +userID +System.Posix.User +System.Posix + +userName +System.Posix.User +System.Posix + +userShell +System.Posix.User +System.Posix + +userTime +System.Posix.Process +System.Posix + +usernameCompletionFunction +System.Console.Readline + +using +Control.Parallel.Strategies + +usleep +System.Posix.Unistd +System.Posix + +V2f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +V3f +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VAlign +Graphics.HGL.Draw.Text +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL + +VDisableChar +System.Posix.Files +System.Posix + +ValD +Language.Haskell.TH.Syntax +Language.Haskell.TH + +VarE +Language.Haskell.TH.Syntax +Language.Haskell.TH + +VarI +Language.Haskell.TH.Syntax +Language.Haskell.TH + +VarName +Language.Haskell.TH.Syntax + +VarP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +VarStrictType +Language.Haskell.TH.Syntax + +VarStrictTypeQ +Language.Haskell.TH.Lib +Language.Haskell.TH + +VarT +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Vector2 +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vector3 +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Version +Data.Version +Distribution.Version +Distribution.Make +Distribution.Simple +Data.Version +Distribution.Version +Distribution.Make +Distribution.Simple + +VersionRange +Distribution.Version +Distribution.Simple + +Vertex +Data.Graph +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex2 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex2D +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex3 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex3D +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex3DColor +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex3DColorTexture +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex4 +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Vertex4DColorTexture +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VertexArray +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VertexArrayAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VertexArrayDescriptor +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GL.VertexArrays +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VertexComponent +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +VertexInfo +Graphics.Rendering.OpenGL.GL.Feedback +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ViewportAttributes +Graphics.Rendering.OpenGL.GL.SavingState +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Visibility +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +VisibilityCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Visible +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +Visual +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +VisualID +Graphics.X11.Types +Graphics.X11.Xlib + +Voronoi +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +vISUALID +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +valD +Language.Haskell.TH.Lib +Language.Haskell.TH + +valid +Data.Map +Data.Set + +validHtmlAttrs +Text.Html + +validHtmlITags +Text.Html + +validHtmlTags +Text.Html + +valign +Text.Html + +value +Text.Html + +varE +Language.Haskell.TH.Lib +Language.Haskell.TH + +varP +Language.Haskell.TH.Lib +Language.Haskell.TH + +varStrictType +Language.Haskell.TH.Lib +Language.Haskell.TH + +varT +Language.Haskell.TH.Lib +Language.Haskell.TH + +variable +Text.Html + +variant +Test.QuickCheck +Debug.QuickCheck + +vcat +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +vector +Test.QuickCheck +Debug.QuickCheck + +vendor +Graphics.Rendering.OpenGL.GL.StringQueries +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +verboseCheck +Test.QuickCheck +Debug.QuickCheck + +version +Data.Graph.Inductive +System.Posix.Unistd +System.Posix +Text.Html + +versionBranch +Data.Version +Distribution.Version +Distribution.Make +Distribution.Simple + +versionTags +Data.Version +Distribution.Version +Distribution.Make +Distribution.Simple + +vertex +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +vertexv +Graphics.Rendering.OpenGL.GL.VertexSpec +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +vertices +Data.Graph + +viewport +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +virtualTimerExpired +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix + +visibilityCallback +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +visibilityChangeMask +Graphics.X11.Types +Graphics.X11.Xlib + +visibilityFullyObscured +Graphics.X11.Types +Graphics.X11.Xlib + +visibilityNotify +Graphics.X11.Types +Graphics.X11.Xlib + +visibilityPartiallyObscured +Graphics.X11.Types +Graphics.X11.Xlib + +visibilityUnobscured +Graphics.X11.Types +Graphics.X11.Xlib + +vlink +Text.Html + +void +Foreign.Marshal.Error +Foreign.Marshal +Foreign + +vor +Data.Graph.Inductive.Example + +vor' +Data.Graph.Inductive.Example + +voronoiSet +Data.Graph.Inductive.Query.GVD +Data.Graph.Inductive.Query +Data.Graph.Inductive + +vspace +Text.Html + +W# +GHC.Exts + +Wait +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Weak +System.Mem.Weak + +Wednesday +System.Time + +WeightedProperties +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +Graphics.Rendering.OpenGL.GLU.Tessellation +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +WheelDown +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +WheelUp +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +WhenDrained +System.Posix.Terminal +System.Posix + +WhenFlushed +System.Posix.Terminal +System.Posix + +Where +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Where' +Graphics.UI.GLUT.GameMode +Graphics.UI.GLUT + +White +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +WildP +Language.Haskell.TH.Syntax +Language.Haskell.TH + +Window +Graphics.HGL.Window +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.UI.GLUT.Window +Graphics.UI.GLUT +Graphics.X11.Types +Graphics.X11.Xlib + +WindowClass +Graphics.X11.Types +Graphics.X11.Xlib + +WindowEntered +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +WindowGravity +Graphics.X11.Types +Graphics.X11.Xlib + +WindowLeft +Graphics.UI.GLUT.Callbacks.Window +Graphics.UI.GLUT.Callbacks +Graphics.UI.GLUT + +WindowPos +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +WindowPosComponent +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +WindowStatus +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +Wireframe +Graphics.UI.GLUT.Objects +Graphics.UI.GLUT + +With +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +WithAccumBuffer +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +WithAlphaComponent +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +WithDepthBuffer +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +WithStencilBuffer +Graphics.UI.GLUT.Initialization +Graphics.UI.GLUT + +Word +Data.Word +Foreign +GHC.Exts + +Word16 +Data.Word +Foreign + +Word32 +Data.Word +Foreign +Graphics.SOE + +Word64 +Data.Word +Foreign + +Word8 +Data.Word +Foreign + +WriteLock +System.Posix.IO +System.Posix + +WriteMode +System.IO + +WriteOnly +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT +System.Posix.IO +System.Posix + +WriteToBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Writer +Control.Monad.Writer +Control.Monad.RWS +Control.Monad.Writer +Control.Monad.RWS + +WriterT +Control.Monad.Writer +Control.Monad.RWS +Control.Monad.Writer +Control.Monad.RWS + +wDays +System.Locale + +wEIGHT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wGetChar +Graphics.HGL.Utils +Graphics.HGL + +wINDOW +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_CLASS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_CLIENT_MACHINE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_COMMAND +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_HINTS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_ICON_NAME +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_ICON_SIZE +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_NAME +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_NORMAL_HINTS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_SIZE_HINTS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_TRANSIENT_FOR +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +wM_ZOOM_HINTS +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +waitForEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +waitForProcess +System.Process + +waitQSem +Control.Concurrent.QSem +Control.Concurrent + +waitQSemN +Control.Concurrent.QSemN +Control.Concurrent + +waitToSetLock +System.Posix.IO +System.Posix + +warpPointer +Graphics.X11.Xlib.Misc +Graphics.X11.Xlib + +westGravity +Graphics.X11.Types +Graphics.X11.Xlib + +when +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +whenMapped +Graphics.X11.Types +Graphics.X11.Xlib + +whereIndent +Language.Haskell.Pretty + +where_clause +Language.Haskell.TH.Ppr + +white +Text.Html + +whitePixel +Graphics.X11.Xlib.Display +Graphics.X11.Xlib + +whitePixelOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +whiteSpace +Text.ParserCombinators.Parsec.Token + +widget +Text.Html + +width +Text.Html + +widthMMOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +widthOfScreen +Graphics.X11.Xlib.Screen +Graphics.X11.Xlib + +wildP +Language.Haskell.TH.Lib +Language.Haskell.TH + +windingRule +Graphics.X11.Types +Graphics.X11.Xlib + +windowBorderWidth +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +windowChange +System.Posix.Signals.Exts + +windowEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +windowHeaderHeight +Graphics.UI.GLUT.State +Graphics.UI.GLUT + +windowPos +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +windowPosition +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +windowPosv +Graphics.Rendering.OpenGL.GL.RasterPos +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +windowSize +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +windowStatus +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +windowTitle +Graphics.UI.GLUT.Window +Graphics.UI.GLUT + +with +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +withAlex +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +withArcArray +Graphics.X11.Xlib.Types + +withArgs +System.Environment + +withArray +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +withArray' +Graphics.X11.Xlib.Types + +withArray0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +withArrayLen +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +withArrayLen0 +Foreign.Marshal.Array +Foreign.Marshal +Foreign + +withBeginCallback +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withBits +System.Posix.Terminal +System.Posix + +withBkColor +Graphics.HGL.Utils +Graphics.HGL + +withBkMode +Graphics.HGL.Utils +Graphics.HGL + +withBrush +Graphics.HGL.Utils +Graphics.HGL + +withCAString +Foreign.C.String +Foreign.C + +withCAStringLen +Foreign.C.String +Foreign.C + +withCC +System.Posix.Terminal +System.Posix + +withCString +Foreign.C.String +Foreign.C + +withCStringLen +Foreign.C.String +Foreign.C + +withCWString +Foreign.C.String +Foreign.C + +withCWStringLen +Foreign.C.String +Foreign.C + +withColor +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE +Graphics.X11.Xlib.Types + +withColorArray +Graphics.X11.Xlib.Types + +withColorCallback +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withCont +Control.Monad.Cont + +withContT +Control.Monad.Cont + +withCpphs +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +withDL +System.Posix.DynamicLinker + +withDL_ +System.Posix.DynamicLinker + +withEndCallback +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withExe +Distribution.PackageDescription + +withFont +Graphics.HGL.Utils +Graphics.HGL + +withForeignPtr +Foreign.ForeignPtr +Foreign + +withHaddock +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +withHappy +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +withHsc2hs +Distribution.Simple.LocalBuildInfo +Distribution.Simple.Configure + +withInputSpeed +System.Posix.Terminal +System.Posix + +withLib +Distribution.PackageDescription + +withMVar +Control.Concurrent.MVar +Control.Concurrent + +withMany +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +withMap1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withMap2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withMappedBuffer +Graphics.Rendering.OpenGL.GL.BufferObjects +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withMinInput +System.Posix.Terminal +System.Posix + +withMode +System.Posix.Terminal +System.Posix + +withModule +System.Posix.DynamicLinker.Module + +withModule_ +System.Posix.DynamicLinker.Module + +withNURBSObj +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withName +Graphics.Rendering.OpenGL.GL.Selection +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNewMap1 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNewMap2 +Graphics.Rendering.OpenGL.GL.Evaluators +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNewMatrix +Graphics.Rendering.OpenGL.GL.CoordTrans +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNewPixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNewPolygonStipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withNormalCallback +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withObject +Foreign.Marshal.Utils +Foreign.Marshal +Foreign + +withOutputSpeed +System.Posix.Terminal +System.Posix + +withPen +Graphics.HGL.Utils +Graphics.HGL + +withPixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withPointArray +Graphics.X11.Xlib.Types + +withPolygonStipple +Graphics.Rendering.OpenGL.GL.Polygons +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withPool +Foreign.Marshal.Pool +Foreign.Marshal +Foreign + +withProgName +System.Environment + +withQuery +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withRGB +Graphics.HGL.Utils +Graphics.HGL + +withRWS +Control.Monad.RWS + +withRWST +Control.Monad.RWS + +withReader +Control.Monad.Reader +Control.Monad.RWS + +withReaderT +Control.Monad.Reader +Control.Monad.RWS + +withRectangle +Graphics.X11.Xlib.Types + +withRectangleArray +Graphics.X11.Xlib.Types + +withSegmentArray +Graphics.X11.Xlib.Types + +withSocketsDo +Network.Socket +Network + +withState +Control.Monad.State +Control.Monad.RWS + +withStateT +Control.Monad.State +Control.Monad.RWS + +withStorable' +Graphics.X11.Xlib.Types + +withStorableArray +Data.Array.Storable + +withTempFile +Distribution.Simple.Utils + +withTextAlignment +Graphics.HGL.Utils +Graphics.HGL + +withTextColor +Graphics.HGL.Utils +Graphics.HGL + +withTime +System.Posix.Terminal +System.Posix + +withVertexCallback +Graphics.Rendering.OpenGL.GLU.NURBS +Graphics.Rendering.OpenGL.GLU +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +withWindow +Graphics.HGL.Utils +Graphics.HGL + +withWindow_ +Graphics.HGL.Utils +Graphics.HGL + +withdrawWindow +Graphics.X11.Xlib.Window +Graphics.X11.Xlib + +withinRange +Distribution.Version +Distribution.Simple + +withoutCC +System.Posix.Terminal +System.Posix + +withoutMode +System.Posix.Terminal +System.Posix + +word32ToInt +Graphics.SOE + +words +Data.List +Prelude + +wordsPS +Data.PackedString + +wrapper +Network.CGI + +writable +System.Directory +Distribution.Compat.Directory + +writeArray +Data.Array.MArray +Data.Array.IO +Data.Array.ST +Data.Array.Storable + +writeChan +Control.Concurrent.Chan +Control.Concurrent + +writeFile +System.IO +Prelude + +writeHookedBuildInfo +Distribution.PackageDescription + +writeIORef +Data.IORef + +writeInstalledConfig +Distribution.Simple.Register + +writeList2Chan +Control.Concurrent.Chan +Control.Concurrent + +writePackageDescription +Distribution.PackageDescription + +writePersistBuildConfig +Distribution.Simple.Configure + +writeSTRef +Data.STRef.Lazy +Data.STRef +Data.STRef.Strict + +writeSampleVar +Control.Concurrent.SampleVar +Control.Concurrent + +writeTChan +Control.Concurrent.STM.TChan +Control.Concurrent.STM + +writeTVar +GHC.Conc +Control.Concurrent.STM.TVar +Control.Concurrent.STM + +XButtonEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XConfigureEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XEventPtr +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XExposeEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XGCValues +Graphics.X11.Xlib.Types +Graphics.X11.Xlib.Types + +XID +Graphics.X11.Types +Graphics.X11.Xlib + +XKeyEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XKeyEventPtr +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XMappingEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XMotionEvent +Graphics.X11.Xlib.Event +Graphics.X11.Xlib + +XSetWindowAttributes +Graphics.X11.Xlib.Types +Graphics.X11.Xlib +Graphics.X11.Xlib.Types + +XSetWindowAttributesPtr +Graphics.X11.Xlib.Types + +Xor +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +xK_0 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_5 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_6 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_7 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_8 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_9 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_A +Graphics.X11.Types +Graphics.X11.Xlib + +xK_AE +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Aacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Acircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Adiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Agrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Alt_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Alt_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Aring +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Atilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_B +Graphics.X11.Types +Graphics.X11.Xlib + +xK_BackSpace +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Begin +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Break +Graphics.X11.Types +Graphics.X11.Xlib + +xK_C +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Cancel +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Caps_Lock +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ccedilla +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Clear +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Control_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Control_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_D +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Delete +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Down +Graphics.X11.Types +Graphics.X11.Xlib + +xK_E +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ETH +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Eacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ecircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ediaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Egrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_End +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Escape +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Eth +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Execute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F10 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F11 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F12 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F13 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F14 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F15 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F16 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F17 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F18 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F19 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F20 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F21 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F22 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F23 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F24 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F25 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F26 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F27 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F28 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F29 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F30 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F31 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F32 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F33 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F34 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F35 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F5 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F6 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F7 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F8 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_F9 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Find +Graphics.X11.Types +Graphics.X11.Xlib + +xK_G +Graphics.X11.Types +Graphics.X11.Xlib + +xK_H +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Help +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Home +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Hyper_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Hyper_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_I +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Iacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Icircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Idiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Igrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Insert +Graphics.X11.Types +Graphics.X11.Xlib + +xK_J +Graphics.X11.Types +Graphics.X11.Xlib + +xK_K +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_0 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_5 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_6 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_7 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_8 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_9 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Add +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Begin +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Decimal +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Delete +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Divide +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Down +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_End +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Enter +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Equal +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_F1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_F2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_F3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_F4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Home +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Insert +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Left +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Multiply +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Next +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Page_Down +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Page_Up +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Prior +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Right +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Separator +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Space +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Subtract +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Tab +Graphics.X11.Types +Graphics.X11.Xlib + +xK_KP_Up +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L10 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L5 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L6 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L7 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L8 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_L9 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Left +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Linefeed +Graphics.X11.Types +Graphics.X11.Xlib + +xK_M +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Menu +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Meta_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Meta_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Mode_switch +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Multi_key +Graphics.X11.Types +Graphics.X11.Xlib + +xK_N +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Next +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ntilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Num_Lock +Graphics.X11.Types +Graphics.X11.Xlib + +xK_O +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Oacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ocircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Odiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ograve +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ooblique +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Otilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_P +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Page_Down +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Page_Up +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Pause +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Print +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Prior +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Q +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R1 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R10 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R11 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R12 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R13 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R14 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R15 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R2 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R3 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R4 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R5 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R6 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R7 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R8 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_R9 +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Redo +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Return +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Right +Graphics.X11.Types +Graphics.X11.Xlib + +xK_S +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Scroll_Lock +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Select +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Shift_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Shift_Lock +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Shift_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Super_L +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Super_R +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Sys_Req +Graphics.X11.Types +Graphics.X11.Xlib + +xK_T +Graphics.X11.Types +Graphics.X11.Xlib + +xK_THORN +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Tab +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Thorn +Graphics.X11.Types +Graphics.X11.Xlib + +xK_U +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Uacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ucircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Udiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Ugrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Undo +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Up +Graphics.X11.Types +Graphics.X11.Xlib + +xK_V +Graphics.X11.Types +Graphics.X11.Xlib + +xK_VoidSymbol +Graphics.X11.Types +Graphics.X11.Xlib + +xK_W +Graphics.X11.Types +Graphics.X11.Xlib + +xK_X +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Y +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Yacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_Z +Graphics.X11.Types +Graphics.X11.Xlib + +xK_a +Graphics.X11.Types +Graphics.X11.Xlib + +xK_aacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_acircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_acute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_adiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ae +Graphics.X11.Types +Graphics.X11.Xlib + +xK_agrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ampersand +Graphics.X11.Types +Graphics.X11.Xlib + +xK_apostrophe +Graphics.X11.Types +Graphics.X11.Xlib + +xK_aring +Graphics.X11.Types +Graphics.X11.Xlib + +xK_asciicircum +Graphics.X11.Types +Graphics.X11.Xlib + +xK_asciitilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_asterisk +Graphics.X11.Types +Graphics.X11.Xlib + +xK_at +Graphics.X11.Types +Graphics.X11.Xlib + +xK_atilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_b +Graphics.X11.Types +Graphics.X11.Xlib + +xK_backslash +Graphics.X11.Types +Graphics.X11.Xlib + +xK_bar +Graphics.X11.Types +Graphics.X11.Xlib + +xK_braceleft +Graphics.X11.Types +Graphics.X11.Xlib + +xK_braceright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_bracketleft +Graphics.X11.Types +Graphics.X11.Xlib + +xK_bracketright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_brokenbar +Graphics.X11.Types +Graphics.X11.Xlib + +xK_c +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ccedilla +Graphics.X11.Types +Graphics.X11.Xlib + +xK_cedilla +Graphics.X11.Types +Graphics.X11.Xlib + +xK_cent +Graphics.X11.Types +Graphics.X11.Xlib + +xK_colon +Graphics.X11.Types +Graphics.X11.Xlib + +xK_comma +Graphics.X11.Types +Graphics.X11.Xlib + +xK_copyright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_currency +Graphics.X11.Types +Graphics.X11.Xlib + +xK_d +Graphics.X11.Types +Graphics.X11.Xlib + +xK_degree +Graphics.X11.Types +Graphics.X11.Xlib + +xK_diaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_division +Graphics.X11.Types +Graphics.X11.Xlib + +xK_dollar +Graphics.X11.Types +Graphics.X11.Xlib + +xK_e +Graphics.X11.Types +Graphics.X11.Xlib + +xK_eacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ecircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ediaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_egrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_equal +Graphics.X11.Types +Graphics.X11.Xlib + +xK_eth +Graphics.X11.Types +Graphics.X11.Xlib + +xK_exclam +Graphics.X11.Types +Graphics.X11.Xlib + +xK_exclamdown +Graphics.X11.Types +Graphics.X11.Xlib + +xK_f +Graphics.X11.Types +Graphics.X11.Xlib + +xK_g +Graphics.X11.Types +Graphics.X11.Xlib + +xK_grave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_greater +Graphics.X11.Types +Graphics.X11.Xlib + +xK_guillemotleft +Graphics.X11.Types +Graphics.X11.Xlib + +xK_guillemotright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_h +Graphics.X11.Types +Graphics.X11.Xlib + +xK_hyphen +Graphics.X11.Types +Graphics.X11.Xlib + +xK_i +Graphics.X11.Types +Graphics.X11.Xlib + +xK_iacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_icircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_idiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_igrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_j +Graphics.X11.Types +Graphics.X11.Xlib + +xK_k +Graphics.X11.Types +Graphics.X11.Xlib + +xK_l +Graphics.X11.Types +Graphics.X11.Xlib + +xK_less +Graphics.X11.Types +Graphics.X11.Xlib + +xK_m +Graphics.X11.Types +Graphics.X11.Xlib + +xK_macron +Graphics.X11.Types +Graphics.X11.Xlib + +xK_masculine +Graphics.X11.Types +Graphics.X11.Xlib + +xK_minus +Graphics.X11.Types +Graphics.X11.Xlib + +xK_mu +Graphics.X11.Types +Graphics.X11.Xlib + +xK_multiply +Graphics.X11.Types +Graphics.X11.Xlib + +xK_n +Graphics.X11.Types +Graphics.X11.Xlib + +xK_nobreakspace +Graphics.X11.Types +Graphics.X11.Xlib + +xK_notsign +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ntilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_numbersign +Graphics.X11.Types +Graphics.X11.Xlib + +xK_o +Graphics.X11.Types +Graphics.X11.Xlib + +xK_oacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ocircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_odiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ograve +Graphics.X11.Types +Graphics.X11.Xlib + +xK_onehalf +Graphics.X11.Types +Graphics.X11.Xlib + +xK_onequarter +Graphics.X11.Types +Graphics.X11.Xlib + +xK_onesuperior +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ordfeminine +Graphics.X11.Types +Graphics.X11.Xlib + +xK_oslash +Graphics.X11.Types +Graphics.X11.Xlib + +xK_otilde +Graphics.X11.Types +Graphics.X11.Xlib + +xK_p +Graphics.X11.Types +Graphics.X11.Xlib + +xK_paragraph +Graphics.X11.Types +Graphics.X11.Xlib + +xK_parenleft +Graphics.X11.Types +Graphics.X11.Xlib + +xK_parenright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_percent +Graphics.X11.Types +Graphics.X11.Xlib + +xK_period +Graphics.X11.Types +Graphics.X11.Xlib + +xK_periodcentered +Graphics.X11.Types +Graphics.X11.Xlib + +xK_plus +Graphics.X11.Types +Graphics.X11.Xlib + +xK_plusminus +Graphics.X11.Types +Graphics.X11.Xlib + +xK_q +Graphics.X11.Types +Graphics.X11.Xlib + +xK_question +Graphics.X11.Types +Graphics.X11.Xlib + +xK_questiondown +Graphics.X11.Types +Graphics.X11.Xlib + +xK_quotedbl +Graphics.X11.Types +Graphics.X11.Xlib + +xK_quoteleft +Graphics.X11.Types +Graphics.X11.Xlib + +xK_quoteright +Graphics.X11.Types +Graphics.X11.Xlib + +xK_r +Graphics.X11.Types +Graphics.X11.Xlib + +xK_registered +Graphics.X11.Types +Graphics.X11.Xlib + +xK_s +Graphics.X11.Types +Graphics.X11.Xlib + +xK_script_switch +Graphics.X11.Types +Graphics.X11.Xlib + +xK_section +Graphics.X11.Types +Graphics.X11.Xlib + +xK_semicolon +Graphics.X11.Types +Graphics.X11.Xlib + +xK_slash +Graphics.X11.Types +Graphics.X11.Xlib + +xK_space +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ssharp +Graphics.X11.Types +Graphics.X11.Xlib + +xK_sterling +Graphics.X11.Types +Graphics.X11.Xlib + +xK_t +Graphics.X11.Types +Graphics.X11.Xlib + +xK_thorn +Graphics.X11.Types +Graphics.X11.Xlib + +xK_threequarters +Graphics.X11.Types +Graphics.X11.Xlib + +xK_threesuperior +Graphics.X11.Types +Graphics.X11.Xlib + +xK_twosuperior +Graphics.X11.Types +Graphics.X11.Xlib + +xK_u +Graphics.X11.Types +Graphics.X11.Xlib + +xK_uacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ucircumflex +Graphics.X11.Types +Graphics.X11.Xlib + +xK_udiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ugrave +Graphics.X11.Types +Graphics.X11.Xlib + +xK_underscore +Graphics.X11.Types +Graphics.X11.Xlib + +xK_v +Graphics.X11.Types +Graphics.X11.Xlib + +xK_w +Graphics.X11.Types +Graphics.X11.Xlib + +xK_x +Graphics.X11.Types +Graphics.X11.Xlib + +xK_y +Graphics.X11.Types +Graphics.X11.Xlib + +xK_yacute +Graphics.X11.Types +Graphics.X11.Xlib + +xK_ydiaeresis +Graphics.X11.Types +Graphics.X11.Xlib + +xK_yen +Graphics.X11.Types +Graphics.X11.Xlib + +xK_z +Graphics.X11.Types +Graphics.X11.Xlib + +x_HEIGHT +Graphics.X11.Xlib.Atom +Graphics.X11.Xlib + +xor +Data.Bits +Foreign + +xorRegion +Graphics.HGL.Draw.Region +Graphics.HGL.Draw +Graphics.HGL.Core +Graphics.HGL +Graphics.SOE +Graphics.X11.Xlib.Region +Graphics.X11.Xlib + +YCBCR422 +Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization +Graphics.Rendering.OpenGL.GL.PixelRectangles +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +Yellow +Graphics.HGL.Utils +Graphics.HGL +Graphics.SOE + +yellow +Text.Html + +yield +GHC.Conc +Control.Concurrent + +Zero +Graphics.Rendering.OpenGL.GL.PerFragment +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +ZigZagMode +Text.PrettyPrint.HughesPJ +Text.PrettyPrint +Language.Haskell.Pretty + +zeroArrow +Control.Arrow + +zip +Data.List +Prelude + +zip3 +Data.List +Prelude + +zip4 +Data.List + +zip5 +Data.List + +zip6 +Data.List + +zip7 +Data.List + +zipWith +Data.List +Prelude + +zipWith3 +Data.List +Prelude + +zipWith4 +Data.List + +zipWith5 +Data.List + +zipWith6 +Data.List + +zipWith7 +Data.List + +zipWithM +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +zipWithM_ +Control.Monad +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +:+ +Data.Complex + +:= +Control.Parallel.Strategies + +! +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.IntMap +Data.Map +Data.Array +Text.Html + +!! +Data.List +Prelude + +$ +Prelude + +$! +Prelude + +$$ +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +$+$ +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +$= +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +$=! +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +$| +Control.Parallel.Strategies + +$|| +Control.Parallel.Strategies + +$~ +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +$~! +Graphics.Rendering.OpenGL.GL.StateVar +Graphics.Rendering.OpenGL.GL +Graphics.Rendering.OpenGL +Graphics.UI.GLUT + +% +Data.Ratio + +& +Data.Graph.Inductive.Graph +Data.Graph.Inductive + +&& +Data.Bool +Prelude + +&&& +Control.Arrow + +* +Prelude + +** +Prelude + +*** +Control.Arrow + ++ +Prelude + +++ +Data.List +Prelude + ++++ +Control.Arrow +Text.Html +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +. +Prelude + +.&. +Data.Bits +Foreign + +.| +Control.Parallel.Strategies + +.|. +Data.Bits +Foreign + +.|| +Control.Parallel.Strategies + +/ +Prelude + +// +Data.Array.IArray +Data.Array.Unboxed +Data.Array.Diff +Data.Array + +/= +Prelude + +< +Prelude + +<$$> +Text.ParserCombinators.Parsec.Perm + +<$?> +Text.ParserCombinators.Parsec.Perm + +<++ +Text.ParserCombinators.ReadP +Distribution.Compat.ReadP +Text.ParserCombinators.ReadPrec +Text.Read + +<+> +Control.Arrow +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + +<-> +Text.Html + + +Text.Html + +<< +Text.Html + +<<< +Control.Arrow + +<<^ +Control.Arrow + +<= +Prelude + +<> +Language.Haskell.TH.PprLib +Text.PrettyPrint.HughesPJ +Text.PrettyPrint + + +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +<|> +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec + +<|?> +Text.ParserCombinators.Parsec.Perm + +<||> +Text.ParserCombinators.Parsec.Perm + +=<< +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +== +Prelude + +==> +Test.QuickCheck +Debug.QuickCheck + +> +Prelude + +>< +Data.Graph.Inductive.Query.Monad +Data.Graph.Inductive.Query +Data.Graph.Inductive + +>= +Prelude + +>> +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +>>= +Control.Monad +Prelude +Control.Monad.Reader +Control.Monad.Writer +Control.Monad.State +Control.Monad.RWS +Control.Monad.Identity +Control.Monad.Cont +Control.Monad.Error +Control.Monad.List + +>>> +Control.Arrow + +>>^ +Control.Arrow + +>| +Control.Parallel.Strategies + +>|| +Control.Parallel.Strategies + +@=? +Test.HUnit.Base +Test.HUnit + +@? +Test.HUnit.Base +Test.HUnit + +@?= +Test.HUnit.Base +Test.HUnit + +\\\\ +Data.IntMap +Data.IntSet +Data.List +Data.Map +Data.Set + +^ +Prelude + +^<< +Control.Arrow + +^>> +Control.Arrow + +^^ +Prelude + +|| +Data.Bool +Prelude + +||| +Control.Arrow + +- +Prelude + +-| +Control.Parallel.Strategies + +-|| +Control.Parallel.Strategies + +~: +Test.HUnit.Base +Test.HUnit + +~=? +Test.HUnit.Base +Test.HUnit + +~? +Test.HUnit.Base +Test.HUnit + +~?= +Test.HUnit.Base +Test.HUnit + diff --git a/State/karma b/State/karma new file mode 100644 --- /dev/null +++ b/State/karma @@ -0,0 +1,152 @@ +("ADEpt",1) +("Banksy",1) +("Beelsebob",3) +("Blicero",-1) +("CVS",-1) +("Cale",11) +("CategoryTheory",1) +("CosmicRay",4) +("Data.Typeable",1) +("GHC",1) +("Haskell",5) +("Heffalump",3) +("Igloo",8) +("Itkovian",0) +("JaffaCake",4) +("Java",-2) +("KZM",2) +("Korolary",1) +("Korollary",3) +("Korrolary",1) +("KrispyKringle",-1) +("Kzm",1) +("Lemmih",17) +("Lucinda",1) +("Maddas",1) +("Oejet",1) +("Parsec",1) +("Pseudonym",2) +("Pupeno",1) +("QuickCheck",7) +("RyanT5000",1) +("SKI",0) +("SamB",9) +("Saulzar",1) +("Spark",1) +("Speck",1) +("SyntaxNinja",8) +("Taral",1) +("TheHunter",5) +("TuringTest",4) +("ValarQ",1) +("_astrolabe",1) +("adept",0) +("akemp",1) +("alar",1) +("aleator",1) +("angLia",-1) +("araujo",4) +("arjanoosting",1) +("arrows",1) +("astrolabe",3) +("autrijus",6) +("basti",1) +("beelsebob",2) +("beelsebob_",-1) +("benny",1) +("blackdog",3) +("boegel",2) +("bolrod",1) +("boy",1) +("bug",-1) +("chucky",1) +("cinema",1) +("cormen",1) +("cosmicray",1) +("cparrott",1) +("daan",1) +("darcs",2) +("davidhouse",1) +("dcoutts",12) +("dons",35) +("droundy",1) +("eivuokko",1) +("elvix",6) +("epichrom",-1) +("epigram",1) +("foobar",1) +("foxy",1) +("franka",2) +("ghcprof",1) +("goltrpoat",1) +("goron",0) +("gour",1) +("grephthosthenes",2) +("haskell",2) +("hefner",1) +("hoogle",2) +("hugs",1) +("humasect",1) +("ibid",1) +("ihope",2) +("int-e",5) +("interact",1) +("java",4) +("jethr0",1) +("jip",4) +("joelr1",2) +("jonkri",1) +("juhp",2) +("jyp",1) +("korollary",-1) +("kosmikus",1) +("kowey",1) +("kzm",1) +("lambdabot",12) +("lightstep",1) +("lispy",3) +("lomeX",1) +("maths",1) +("mauke",1) +("mflux",3) +("monochrom",3) +("musasabi",10) +("mwc",-1) +("ncalexan",1) +("ndm",6) +("norpan",2) +("nothingmuch",0) +("oasisbot",1) +("ocaml",0) +("palomer",4) +("paolino",1) +("perl",-1) +("petekaz",1) +("phys_rules",1) +("poetix",3) +("rep",1) +("robdockins",3) +("romildo",1) +("runhaskell",3) +("samB",0) +("sethk",4) +("shapr",17) +("sjanssen",9) +("sjanssen_",1) +("ski",4) +("stefanw",1) +("stepcut",1) +("syntaxfree",1) +("the_evil_mangler",1) +("thighs",1) +("timbod",1) +("twobitsprite",1) +("ulfdoz",1) +("unfoldr",3) +("vim7",1) +("vincenz",4) +("wli",1) +("xerox",15) +("yhc",1) +("yozora",1) +("zellyn",0) diff --git a/State/lambda b/State/lambda new file mode 100644 --- /dev/null +++ b/State/lambda @@ -0,0 +1,262 @@ +100000 +("Arrow"," \\t1 t2 v a q.a t1 t2") +("B"," \\f g x. f (g x)") +("Branch"," \\l k r lk bk.bk l k r") +("C"," \\f x y.f y x") +("Cons"," \\a l n c.c a l") +("False"," \\x y. y") +("Forall"," \\vs t v a q.q vs t") +("I"," \\x.x") +("Just"," \\x n j.j x") +("K"," \\x y.x") +("Leaf"," \\x l b.l x") +("Left"," \\x l r.l x") +("MonadError"," [flip (either Left),Right,Left,\\m h.either h Right m]") +("MonadLP"," [\\m f k.m (\\a.f a k),\\a k.k a]") +("MonadParser"," [\\m f s.either Left (pair (\\a s.f a s)) (m s),\\a s.Right (Pair a s),\\s.Right (Pair s s),\\s x.Right (Pair x s),\\e s.Left e,\\m1 m2 s.either (const (m2 s)) Right (m1 s)]") +("MonadReader"," [\\m f r.f (m r) r,\\a r.a,\\r.r,\\f e r.e (f r)]") +("MonadState"," [\\m f s.pair (\\a s.f a s) (m s),\\a s.Pair a s,\\s.Pair s s,\\x s.Pair s x]") +("MonadWriter"," MonadWriter_ [] (\\x y.x++y)") +("MonadWriter_"," \\mempty mappend.[\\m f.pair (\\a w.pair (\\b w2.Pair b (mappend w w2)) (f a)) m,\\a.Pair a mempty,\\w.Pair w w,\\m.pair (\\a w.Pair (Pair a w) w) m,\\m.pair (\\p w.pair (\\a f.Pair a (f w)) p) m]") +("Nil"," const") +("Nothing"," const") +("Pair"," \\x y k.k x y") +("Right"," \\x l r.r x") +("S"," \\f g x.f x (g x)") +("StateT"," \\m.[\\e f s.runMonad m (bind (e s) (pair (\\a s.f a s))),\\a s.runMonad m (return (Pair a s)),\\s.runMonad m (return (Pair s s)),\\s x.runMonad m (return (Pair x s))]") +("Succ"," \\n z s.s n") +("TVar"," \\s v a q.v s") +("Term"," \\a ts var term.term a ts") +("True"," \\x y. x") +("U"," \\f. f f") +("Var"," \\v var term.var v") +("X"," \\x.x K S K") +("Y"," \\f.U(\\g.f(U g))") +("Zero"," \\z s.z") +("a"," map (either bad fst . runMonad MonadParser parseRule) [\"lookup(cons(pair(K,V),T),K,V).\",\"lookup(cons(P,T),K,V) :- lookup(T,K,V).\"]") +("all"," \\p.and . map p") +("alt"," \\m1 m2 m.nth 5 m (m1 m) (m2 m)") +("ana"," unfoldr") +("and"," foldr (\\x y.x&&y) True") +("any"," \\p.or . map p") +("apo"," \\g n.maybe [] (\\p.fst p:either id (apo g) (snd p)) (g n)") +("app"," flip (foldr (\\x xs.x:xs))") +("append"," flip (fold Cons)") +("ask"," nth 2") +("between"," \\l r p.bind_ l $ bind_ spaces $ bind p $ \\res.bind_ r $ bind_ spaces (return res)") +("bind"," \\m1 f m.bind_internal m (m1 m) (\\a.f a m)") +("bind_"," \\m1 m2.bind m1 (const m2)") +("bind_internal"," nth 0") +("brp"," \\l.if null (tail l) then l else cat $ unzip $ brp $ group' l id") +("car"," list undefined const") +("cat"," pair (\\x y.x++y)") +("cata"," foldr") +("catchError"," \\e h m.nth 3 m (e m) (\\a.h a m)") +("cdr"," list undefined (K I)") +("chAnd"," \\x y . x y chFalse") +("chFalse"," \\x y. y") +("chIf"," I") +("chNot"," \\x y z . x z y") +("chOr"," \\x y . x chTrue y") +("chTrue"," \\x y. x") +("char"," \\c.sat (\\x.x==c)") +("charToDigit"," \\c.if c == '0' then 0 else if c == '1' then 1 else if c == '2' then 2 else if c == '3' then 3 else if c == '4' then 4 else if c == '5' then 5 else if c == '6' then 6 else if c == '7' then 7 else if c == '8' then 8 else if c == '9' then 9 else undefined") +("choice"," foldl alt (parseError \"parse error - choice\")") +("comma"," symbol \",\"") +("concat"," foldr (\\x y.x++y) []") +("concatMap"," \\f.concat . map f") +("cons"," \\h t n c. c h t") +("const"," \\x y.x") +("curry"," \\f x y.f (Pair x y)") +("cycle"," \\l.fix (\\x.l++x)") +("decay"," \\n.sum (factors n) - n") +("decaySequence"," \\n.n : unfoldr (\\n.if n == 0 then Nothing else (\\m.Just (Pair m m)) (decay n)) n") +("delete"," deleteBy (\\x y.x==y)") +("deleteBy"," \\eq x l.if null l then [] else if x `eq` head l then tail l else head l : deleteBy eq x (tail l)") +("deleteFirstsBy"," \\eq.foldl (flip (deleteBy eq))") +("diff"," foldl (flip delete)") +("digitToChar"," \\n.if n==0 then '0' else if n==1 then '1' else if n==2 then '2' else if n==3 then '3' else if n==4 then '4' else if n==5 then '5' else if n==6 then '6' else if n==7 then '7' else if n==8 then '8' else if n==9 then '9' else undefined") +("divides"," \\d.\\n.n `mod` d == 0") +("dot"," symbol \".\"") +("drop"," \\n l.if null l || n <= 0 then l else drop (n-1) (tail l)") +("dropWhile"," \\p l.if null l then [] else if p (head l) then dropWhile p (tail l) else l") +("either"," \\f g e. e f g") +("elem"," \\x.any (\\y.x==y)") +("enumFrom"," iterate (\\x.x+1)") +("enumFromThen"," \\m n.iterate (\\x.(n-m)+x) m") +("enumFromThenTo"," \\l r h.takeWhile (if r>=l then (\\x.x<=h) else (\\x.x>=h)) $ enumFromThen l r") +("enumFromTo"," \\l h.take (h-l+1) $ iterate (\\x.x+1) l") +("even"," \\x.x `mod` 2 == 0") +("fac"," product . fromTo 1") +("fact"," Y (\\fact. (\\n. if (n == 1) then 1 else (n * (fact (n - 1)))))") +("factors"," \\n.if n == 0 then from 0 else filter (\\d.d `divides` n) (fromTo 1 n)") +("factorsOLD"," \\n.if n == 0 then from 0 else filter (\\d.d `divides` n) (fromTo 1 n)") +("failed"," \\dict k.id") +("fibs"," 1:1:zipWith (\\x y.x+y) fibs (tail fibs)") +("filter"," \\p.foldr (\\x y.if p x then x:y else y) []") +("first"," head") +("fix"," \\f.f (fix f)") +("flip"," \\f x y.f y x") +("foldTerm"," \\var term.termCase var (\\a ts.term a (map (foldTerm var term) ts))") +("foldl"," \\c n l.if null l then n else foldl c (c n (head l)) (tail l)") +("foldl1"," \\f l.foldl f (head l) (tail l)") +("foldr"," \\c n l.if null l then n else c (head l) (foldr c n (tail l))") +("foldr1"," \\f l.if null (tail l) then head l else f (head l) (foldr1 f (tail l))") +("followLinks"," foldTerm (\\v.readLPRef v `bind` maybe (return (Var v)) followLinks) (\\a ts.sequence ts `bind` \\ts'.return (Term a ts'))") +("foo"," 3") +("free"," newLPRef Nothing `bind` \\ref. return (Var ref)") +("freevars"," type (\\x.[x]) (\\t1 t2.freevars t1 `union` freevars t2) (\\vs t.freevars t `diff` vs)") +("from"," enumFrom") +("fromList"," foldr Cons Nil") +("fromThen"," enumFromThen") +("fromThenTo"," enumFromThenTo") +("fromTo"," enumFromTo") +("fst"," \\p.p const") +("genCase"," \\n l d.if null l then d n else if fst (head l) == n then snd (head l) n else genCase n (tail l) d") +("get"," nth 2") +("getConstructor"," termCase error_getConstructor (\\a _.a)") +("group"," groupBy (\\x y.x==y)") +("group'"," \\l k.if null l then k [] else group' (tail (tail l)) (k . (\\x.Pair (head l) (head (tail l)) : x))") +("groupBy"," \\eq l.if null l then [] else pair (\\ys zs.(head l : ys) : groupBy eq zs) (span (eq (head l)) (tail l))") +("id"," \\x.x") +("identifier"," bind get $ \\s.bind (sat (\\c.isIdentifierLetter c && not (isDigit c) && (c/='-' || null (tail s) || not (isDigit (head (tail s)))))) $ \\c.bind (many (sat isIdentifierLetter)) $ \\cs.bind_ spaces $ return (c:cs)") +("init"," \\l.if null (tail l) then [] else head l : init (tail l)") +("internalListCase"," \\n c l.if null l then n else c (head l) (tail l)") +("interpretTerm"," foldTerm (\\v env.maybe (free `bind` \\v'.return (Pair v' (Pair v v':env))) (\\a.return (Pair a env)) (lookup v env)) (\\a ts env.foldl (\\m f.m `bind` \\p.f (snd p) `bind` pair (\\t env'.return (Pair (t:fst p) env'))) (return (Pair [] env)) ts `bind` pair (\\ts' env'.return (Pair (Term a (reverse ts')) env')))") +("intersperse"," \\sep l.if null l then [] else if null (tail l) then l else head l : sep : intersperse sep (tail l)") +("isDigit"," \\c.c >= '0' && c <= '9'") +("isIdentifierLetter"," \\c.notElem c \" []\\\"{}';(),\"") +("isPrime"," (\\n. all (\\x. x /= 0) (map (mod n) (enumFromTo 2 (sqrt n + 1))))") +("isSpace"," \\c.c==' '") +("isUpper"," \\c.elem c \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"") +("isVar"," termCase Just (\\_ _.Nothing)") +("iterate"," \\f x.x:iterate f (f x)") +("joy"," either id (flip joyEval [] . fst) . joyParse") +("joyBinOp"," \\op s.op (second s) (first s) : tail (tail s)") +("joyDefs"," [Pair \"+\" (joyBinOp (\\x y.x+y)),Pair \"-\" (joyBinOp (\\x y.x-y)),Pair \"/\" (joyBinOp (\\x y.x/y)),Pair \"*\" (joyBinOp (\\x y.x*y)),Pair \"=\" (joyBinOp (\\x y.x==y)),Pair \"dup\" \\s.first s : s,Pair \"i\" \\s.joyEval (first s) (tail s),Pair \"true\" \\s.True:s,Pair \"false\" \\s.False:s,Pair \"ifte\" joyIFTE,Pair \"x\" \\s.joyEval (first s) s,Pair \"pop\" tail,Pair \"dip\" \\s.second s:joyEval (first s) (tail (tail s))]") +("joyEval"," \\l.foldr (flip B) id (map (lookupDef joyDefs) l)") +("joyExpr"," many $ choice [bind (squares joyExpr) (return . Left),bind identifier (return . Right),bind_ (sat (\\c.c=='\\'')) $ bind next $ \\c.bind_ spaces $ return (Left c),bind parseNum $ \\n.bind_ spaces $ return (Left n)]") +("joyIFTE"," \\s.if head (joyEval (nth 2 s) (drop 3 s)) then joyEval (second s) (drop 3 s) else joyEval (first s) (drop 3 s)") +("joyParse"," runMonad MonadParser joyExpr") +("last"," \\l.if null (tail l) then (head l) else last (tail l)") +("lcFalse"," (C K)") +("lcIf"," I") +("lcTrue"," K") +("length"," foldl (\\x y.x+1) 0") +("lexeme"," \\p.p `bind` \\r.spaces `bind` \\_.return r") +("liftLP"," \\m dict k f s.pair (\\a s'.k a f s') (m s)") +("liftS"," \\e x s m.runMonad m (bind e (\\a.return (Pair a s)))") +("list"," \\c n l.l c n") +("listen"," \\e m.nth 3 m (e m)") +("local"," \\f e m.nth 3 m f (e m)") +("lookup"," \\k l.if null l then Nothing else if fst (head l) == k then Just (snd (head l)) else lookup k (tail l)") +("lookupDef"," \\d.either (\\a s.a:s) (\\k.maybe unbound_variable_error id (lookup k d))") +("lookupRef"," \\k l.if fst (head l) == k then snd (head l) else lookupRef k (tail l)") +("lookupTree"," \\i.tree id (\\l k r.if i < k then lookupTree i l else lookupTree i r)") +("makePerfect"," \\x.(\\y.y * (y + 1) / 2) (pow 2 x - 1)") +("many"," \\p.alt (many1 p) (return [])") +("many1"," \\p.bind p $ \\h.bind (many p) $ \\t.return (h:t)") +("map"," \\f.foldr (\\x y.f x:y) []") +("mapAccumL"," \\f s l.if null l then Pair s [] else pair (\\s' y.pair (\\s'' ys.Pair s'' (y:ys)) (mapAccumL f s' xs)) (f s (head l))") +("mapAccumR"," \\f s l.if null l then Pair s [] else pair (\\s' ys.pair (\\s'' y.Pair s'' (y:ys)) (f s' x)) (mapAccumR f s xs)") +("maybe"," \\f g m.m f g") +("mersenneExponents"," filter (\\x. isPrime (pow 2 x - 1)) (from 1)") +("mersennePrimes"," (filter isPrime (map (\\x. pow 2 x - 1) (enumFrom 1)))") +("mod"," \\n d.n-(n/d)*d") +("modifyTree"," \\i f.tree (\\x.Leaf (f x)) (\\l k r.if i < k then Branch (modifyTree i f l) k r else Branch l k (modifyTree i f r))") +("nat"," \\z s n.n z s") +("natuals"," \\x . (x : (naturals (x+1)))") +("naturals"," \\x . (x : (naturals (x+1)))") +("ndivby"," \\a b. (mod b a) /= 0") +("newLPRef"," \\x.liftLP (\\s.if null s then Pair 0 [Pair 0 x] else (\\r.Pair r ((Pair r x):s)) (fst (head s) + 1))") +("next"," bind get $ \\s.if null s then parseError \"end of input\" else bind_ (put (tail s)) $ return (head s)") +("nil"," \\n c. n") +("not"," \\x.if x then False else True") +("notElem"," \\c s.not (elem c s)") +("nth"," \\n l.if n == 0 then head l else nth (n-1) (tail l)") +("nub"," nubBy (\\x y.x==y)") +("nubBy"," \\eq l.if null l then [] else head l : nubBy eq (filter (\\x.not (x `eq` head l)) (tail l))") +("nullL"," list True (K (K False))") +("or"," foldr (\\x y.x||y) False") +("orLP"," \\m n dict k.m dict k . n dict k") +("pair"," \\k p.p k") +("para"," \\c n l.if null l then n else c (head l) (tail l) (para c n (tail l))") +("paraNat"," \\s z n.if n == 0 then z else s n $ paraNat s z (n-1)") +("parens"," between (char '(') (char ')')") +("parseError"," \\e m.nth 4 m e") +("parseNum"," bind (alt (bind_ (sat (\\c.c=='-')) $ return (\\x.0-x)) (return id)) $ \\op.bind (many1 (sat isDigit)) $ \\ns.return (op (foldl (\\x y.10*x+y) 0 (map charToDigit ns)))") +("parseRule"," parseTerm `bind` \\h.(symbol \":-\" `bind_` (parseTerm `sepBy1` comma) `bind` \\b.return (Pair h b)) `alt` (return (Pair h [])) `bind` \\r.dot `bind_` return r") +("parseTerm"," identifier `bind` \\h.parens ((parseTerm `sepBy1` comma) `bind` \\ts.if isUpper (head h) then parseError \"variable for constructor\" else return (Term h ts)) `alt` if isUpper (head h) then return (Var h) else return (Term h [])") +("pass"," \\e m.nth 4 m (e m)") +("piDigits"," piGen 1 0 1 1") +("piGen"," \\q r t k. (\\n.if (4*q+r)/t == n then n : piGen (10*q) (10*(r-n*t)) t k else piGen (q*k) (q*(4*k+2)+r*(2*k+1)) (t*(2*k+1)) (k+1)) ((3*q+r)/t)") +("pow"," \\b. \\n. if n == 0 then 1 else (if even n then (square (pow b (n / 2))) else (b * (pow b (n - 1))))") +("primes"," (sieve (naturals 2))") +("product"," foldl (\\x y.x*y) 1") +("prologFreevars"," nub . foldTerm (\\v.[v]) (\\_.concat)") +("prologMatch"," \\t db.(\\c.foldr orLP failed $ map (pair (\\h b.interpretTerm h [] `bind` pair (\\h' env.unify t h' `bind_` foldr (\\t' rest env'.interpretTerm t' env' `bind` pair (\\t'' env''.prologMatch t'' db `bind_` rest env'')) (const success) b env))) $ filter (\\r.getConstructor (fst r) == c) db) (getConstructor t)") +("put"," \\x m.nth 3 m x") +("rando"," \\s.(25173*s + 13849) `mod` 65536") +("random-list"," \\n. \\s. tail (take (n + 1) (iterate rando s))") +("randomList"," \\n. \\s. tail (take (n + 1) (iterate rando s))") +("readLPRef"," \\ref.liftLP (\\s.Pair (lookupRef ref s) s)") +("repeat"," iterate id") +("replicate"," \\n x.take n (iterate id x)") +("return"," \\a m.return_internal m a") +("return_internal"," nth 1") +("reverse"," foldl (\\x y.y:x) []") +("runLP"," \\m.runMonad MonadLP m (\\a f s.a:f s) (\\_.[]) []") +("runMonad"," \\m e.e m") +("sat"," \\p.bind next $ \\a.if p a then return a else get `bind` \\s.parseError (\"parse error at: \\\"\"++s++\"\\\"\")") +("scanl"," \\c n.reverse . foldl (\\x y.c (head x) y:x) [n]") +("scanr"," \\c n.foldr (\\x y.c x (head y):y) [n]") +("second"," head . tail") +("sepBy"," \\p sep.sepBy1 p sep `alt` return []") +("sepBy1"," \\p sep.p `bind` \\a.(sep `bind` \\_.sepBy p sep `bind` \\as.return (a:as)) `alt` return [a]") +("sequence"," \\l.if null l then return [] else head l `bind` (\\x.sequence (tail l) `bind` (\\xs.return (x:xs)))") +("sequence_"," foldr bind_ (return [])") +("showList"," \\se.(\\x.'[':(x++\"]\")) . concat . intersperse \", \" . map se") +("showMaybe"," \\showA.maybe \"Nothing\" (\\a.\"Just \"++showA a)") +("showNum"," \\n.(\\showNum.if n < 0 then '-':(reverse $ showNum (0-n)) else reverse $ showNum n) $ fix (\\showNum n.if n < 10 then [digitToChar n] else digitToChar (mod n 10) : showNum (n/10))") +("showPair"," \\sa sb.pair (\\a b.'(':sa a ++ ',':sb b++\")\")") +("showTerm"," showTerm' id (\\n.'_':showNum n)") +("showTerm'"," \\showAtom showVar.termCase showVar (\\a ts.if null ts then showAtom a else showAtom a++'(':concat (intersperse \",\" (map (showTerm' showAtom showVar) ts))++\")\")") +("showType"," type id (\\t1 t2.type id (\\t1 t2.'(':showType (Arrow t1 t2)++\")\") (\\vs t.'(':showType (Forall vs t)++\")\") t1 ++ \" -> \" ++ showType t2) (\\vs t.\"forall \"++concat (intersperse \" \" vs)++'.':showType t)") +("sieve"," \\l . (head l) : sieve (filter (ndivby (head l)) (tail l))") +("snd"," \\p.p (\\x y.y)") +("someMersennePrimeExponents"," [2,3,5,7,13,17,19,31,67,127,257]") +("somePerfectNumbers"," map makePerfect someMersennePrimeExponents") +("spaces"," get `bind` \\s.put (dropWhile isSpace s)") +("span"," \\p l.if null l then Pair [] [] else pair (\\ys zs.if p (head l) then Pair (head l : ys) zs else Pair [] l) (span p (tail l))") +("sqrt"," (\\x.fix (\\sqrt.\\a.if square a <= x && square (a+1) > x then a else sqrt ((a + x / a) / 2)) x)") +("square"," \\x.x*x") +("squares"," between (char '[') (char ']')") +("string"," \\s.sequence (map char s)") +("success"," return []") +("sum"," foldl (\\x y.x+y) 0") +("symbol"," lexeme . string") +("tails"," \\l.if null l then [[]] else l:tails (tail l)") +("take"," \\n l.if null l || n <= 0 then [] else head l : take (n-1) (tail l)") +("takeWhile"," \\p.unfoldr (\\s.if p (head s) then Just (Pair (head s) (tail s)) else Nothing)") +("tell"," \\w m.nth 2 m w") +("termCase"," \\var term t.t var term") +("test"," \"hello\"") +("throwError"," \\e m.nth 2 m e") +("toList"," \\l.if nullL l then [] else car l : toList (cdr l)") +("tree"," \\l b t.t l b") +("type"," \\v a q t.t v a q") +("uncurry"," \\f.pair (\\x y.f x y)") +("undefined"," undefined") +("unfoldr"," \\g n.maybe [] (pair (\\a s.a:unfoldr g s)) (g n)") +("unify"," \\a b.maybe (maybe (unifyTerm a b) (\\vb.unifyVar vb a) (isVar b)) (\\va.maybe (unifyVar va b) (\\vb.if va == vb then success else unifyVar va b) (isVar b)) (isVar a)") +("unifyTerm"," \\a b.termCase (\\_.failed) (\\aa ats.termCase (\\_.failed) (\\ba bts.if aa == ba then zipWithM_ unify ats bts else failed) b) a") +("unifyVar"," \\ref a.readLPRef ref `bind` maybe (writeLPRef ref (Just a)) (\\b.a `unify` b)") +("union"," unionBy (\\x y.x==y)") +("unionBy"," \\eq xs ys.xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs") +("unzip"," foldr (\\p ps.pair (\\l r.Pair (l:fst ps) (r:snd ps)) p) (Pair [] [])") +("updateRef"," \\k a l.if fst (head l) == k then Pair k a:tail l else head l:updateRef k a (tail l)") +("writeLPRef"," \\ref a dict k f s.k [] (f . updateRef ref (lookupRef ref s)) (updateRef ref a s)") +("zip"," zipWith Pair") +("zipWith"," \\f l r.if null l || null r then [] else f (head l) (head r) : zipWith f (tail l) (tail r)") +("zipWithM"," \\f xs ys.sequence (zipWith f xs ys)") +("zipWithM_"," \\f xs ys.sequence_ (zipWith f xs ys)") diff --git a/State/prelude.lam b/State/prelude.lam new file mode 100644 --- /dev/null +++ b/State/prelude.lam @@ -0,0 +1,153 @@ +# the church encoding for booleans +true = \t f. t; +false = \t f. f; +if = \b x y. b x y; +not = \x. if x false true; +and = \x y. if x y false; +or = \x y. if x true y; +xor = \x y. if x (not y) y; + +# the church encoding for peano numbers +zero = \f x. x; +succ = \n f x. f (n f x); +pred = \n f x. n (\g h. h (g f)) (\u. x) (\u. u); + +# addition, subtraction and multiplication +plus = \m n f x. m f (n f x); +sub = \m n. (n pred) m; +mul = \m n f. m (n f); + +# some useful predicates on church numerals +even = \n. n not true; +iszero = \m. m (\x. false) true; +lte = \m n. iszero (sub m n); +gte = \m n. iszero (sub n m); +eq = \m n. and (lte m n) (gte m n); +lt = \m n. and (lte m n) (not (gte m n)); +gt = \m n. and (gte m n) (not (lte m n)); + +# aliases for the church numerals up to ten +one = succ zero; +two = succ one; +three = succ two; +four = succ three; +five = succ four; +six = succ five; +seven = succ six; +eight = succ seven; +nine = succ eight; +ten = succ nine; + +# Turner's combinators +I = \x .x; +K = \x y. x; +S = \f g x. (f x) (g x); +W = \f x. f x x; +B = \f g x. f (g x); + +# the fixpoint combinator +Y = \f. (\x. f (x x)) \x. f (x x); + +# a divergent labmda term +omega = (\x. x x) \x. x x; + +# integer exponentation +pow = \m. Y (\powF n. n (\x. mul m x) one); + +# factorial +fac = Y (\facF n. if (iszero n) + one + (mul n (facF (pred n)))); + +# the church encoding for pairs +pair = \x y f. f x y; +fst = \p. p (\x y. x); +snd = \p. p (\x y. y); + +# now, encode ADTs +match = \x pats. x (\n f. f (fst ((n snd) pats))); + +# the ADT representation of lists +nil = \ w. w zero (\f. f); +cons = \h t w. w one (\f. f h t); + +# head and tail, by pattern matching +head = \l. match l (pair nil + (pair (\h t. h) + zero)); + +tail = \l. match l (pair nil + (pair (\h t. t) + zero)); + +# the ith element of a list +index = \n l. head (n tail l); + +# right fold on a list +foldr = \f z. Y (\foldF l. match l (pair z + (pair (\h t. f h (foldF t)) + zero))); + +# left fold on a list +foldl = \f. Y (\foldF r l. match l (pair r + (pair (\h t. foldF (f r h) t) + zero))); + +# the length of a list +len = foldl (\x h. succ x) zero; + +# the mapping function on a list +map = \f. Y (\mapF l. match l (pair nil + (pair (\h t. cons (f h) (mapF t)) + zero))); + +# list generator +unfold = \g until. Y (\unfoldF x. if (until x) + (cons x nil) + (cons x (unfoldF (g x)))); + +# some other interesting list functions.... + +iterate = \g. unfold g (K false); +nats = iterate succ zero; + +upTo = \n. unfold succ (\x. gte x n) zero; + +zipWith = \f. Y (\zipF l1 l2. match l1 + (pair nil + (pair (\h1 t1. match l2 + (pair nil + (pair (\h2 t2. + cons (f h1 h2) (zipF t1 t2)) + zero))) + zero))); + +zip = zipWith pair; + +take = \n l. zipWith K l (tail (upTo n)); +drop = \n l. n tail l; + +minAux = foldl (\x y. if (lt y x) y x); + +min = \l. match l + (pair nil + (pair minAux + zero)); + +maxAux = foldl (\x y. if (gt y x) y x); + +max = \l. match l + (pair nil + (pair maxAux + zero)); + +remove = \x. Y (\removeF l. match l + (pair nil + (pair (\h t. + if (eq h x) t (cons h (removeF t))) + zero))); + +insertSort = Y (\sortF l. match l + (pair nil + (pair (\h t. (\x. cons x (sortF (remove x l))) (minAux h t)) + zero))); diff --git a/State/quote b/State/quote new file mode 100644 --- /dev/null +++ b/State/quote @@ -0,0 +1,390 @@ +##C++ + haskell == plain english ?? +[asking about C++ rules] vincenz: how should we know what those rules mean ? + + +Snow doeth lay upon the lands. Even with cunning newtype; deriving the newtype is recursive. Great leaders brings less pain. + +Alanna +Saying that Java is nice because it works on all OS's is like saying that anal sex is nice because it works on all genders. + +Cale +The perfect programming language is mathematics, but that only runs on mathematicians. +Beware of the function [a] -> a. For it may contain trappes and sprynges of great variety and harm. + +ChilliX +You need to seek a balance between category theory and VLSI + +ChrisKuklewicz +Are there little known Haskell idioms for doing math? Is there an undocumented -funleash-fortran parameter? + +ChristopherHendrie +Sometimes I wonder if Java will be indirectly responsible for hastening the adoption of functional programming languages + +DukeDave +what, if your kids start doing drugs? or worse, business school + +Gahhh +monads are usually a personal experience. + +HavocPennington +Haskell is the least-broken programming language available today. + +Heffalump +docs aren't all that useful, generally +CPP leads to suffering + +Igloo +[dons: anyone know what happened to [the] Haskell wishlist?] Igloo: Did it have "Crush Java" listed? + +Itkovian +real programmers don't write docs, if it was hard to write, it should be hard to understand + +JaffaCake +gcc is getting smarter, so we need to hit it with a bigger stick +not all IOError -> String functions are created equal :) +I'm afraid I'm completely IA64-ignorant (and hoping to remain that way until IA64 goes away :-) + +JohnMeacham +There will also be a karaoke competition to determine the fate of the monomorphism restriction. +Type theory makes totally awesome material for bar room shit talk. +Last night I was at this dive bar listening to live music and there was this cute girl I was talking too while this guy was there, we started ribbing each other in the appropriate way when confronted with the situation of two guys talking to the same girl, and our jeers eventually turned technical until we were arguing about haskell, perl, and pugs development. it turning out he was one of the pugs de + +Korollary +an olegweek is a complex entity with an imaginary part +an olegweek is a complex entity with an imaginary part + +Lemmih +calling an out-of-scope function isn't as easy as I had hoped + +Oleg +The implementation of RSA on type level is left for future work + +PaulGraham +An algorithm for lazy evaluation of research papers: Just write whatever you want and don't cite any previous work, and indignant readers will send you references to all the papers you should have cited. +I get the impression that using [Haskell] would feel like reading a novel written by a literary critic. + +Philippa +hey, if the guy wants a monadectomy that's his choice + +Pseudonym +I think principal types are overrated +Lazy evalution is really, really trippy. +Well, personally, I don't think dumb people should be let near a programming language. + +S.Behrens +or maybe she is the Queen of Sciences and he is the Mack Daddy. +Computer science is the womanizer, and math is the pure-hearted girl he won't call the next day. + +SamB +Because sliced bread gives horribly uninformative error messages? +C is a good language. If what you want is an assembly language where you can't be sure what anything does +fworp: next time, load your shirt up in to GHCi *before* having it printed +Boy, point-free Arrows are worse than Forth... + +SebastianHanowski +I tried to formalise a proof of rev (rev l) = l i found in W. Kluges book "Abstract Computing Machines - A Lambda Calculus Perspective" which is pretty much a 'Pimp My Ride' for SECD-machines. + +SyntaxNinja +I think that the compiler authors will fly here from England just to kill me if I did that + +Taral +But I can do DP in C, which has no RT +How do you add an @quote? + +TuringTest +They got it work in Haskell without understanding Haskell. It is quite an achievement, of some description. + +adept +Tried to co-read and co-understand comonads, but got co-re dump +I think I need cobrain to understand coeffects + +astrolabe +I put my thing in inverted commas because it isn't a really stalactite, but it looks like one, and contains nitrates from urea. + +autrijus +Mechanical and super-natty! Inspect the result and *if* happy; freeze, sell and get some sleep! +Woot. I got larry wall started learning Haskell ;) +Parrot is fine except every time I build it, it fails +Well, ever since the monadic revolution of '98 Haskell people have started to do real world apps + +blackdog +My variables aren't varying. +I'm not encouraged by the comment "i don't know haskell, but CL is much better", though. it doesn't suggest careful thought and objectivity... +i think coding in your sleep should trigger an exception + +chromatic +My productivity increased when Autrijus told me about Haskell's trace function. He called it a refreshing desert in the oasis of referential transparency. + +cjs +I have to explain this shit to people. I mean, I start out right, "Hey, you know how you always have these bugs because what you thought was in the variable is not there?" And I get all of these nods of agreement. "Well, I've found a new language that solves that problem." Audience: "Ooooh! How?" Me: "There's no variables!" And then they all start moving away from me slowly.... + +darius +Well profiling does add a bit of reflection, but it should have the good sense not too go near the barbed wire fences and armed guards. +I imagine XSLT programmers say "It's a one pager" the way most other programmers say "It's a one liner". + +dcnstrct +even the #lisp people say go with haskell + +desrt +man... there's this whole dark side to haskell that dr. kahl didn't teach us in 3e03 + +dons +Haskell: The language that never sells out! +ihope reaches level 4 hacker +note to self: grep only works on disks +but let is more lazy ;) +who was it who said (shapr?) that they welcome their competitors using languages other than haskell? it's a bad sign if your enemies start coding in haskell! +the type system is *great* for coding while sleepy.. you just hack any garbage together, and let the type checker deal with it +boegel, stop polluting the quote-space please +I don't mind autoconf, except for the fact that it's stupid and ugly + +gFunk +[the main advantage of functional programs are that they're] incorrect the first 1000 times you try to compile it! + +ghc +ld64: INFO 171: Multigot invoked. Gp relative region broken up into 2 separate regions. +ld64: WARNING 47 : This module contains branch instruction(s) that might degrade performance on an R4000 processor. +Unable to mmap( MAP_FIXED ) for Jump Islands +Only unit numeric type pattern is valid +yi-static: internal error: TSO object entered! +deadlock: main thread blocked in a strange way +Bad eta expand +GHCi's bytecode generation machinery can't handle 64-bit code properly yet. +Malformed predicate +Can't happen +accepting non-standard pattern guards (-fglasgow-exts to suppress this message) +Bindings in hs-boot files are not allowed +Pattern bindings (except simple variables) not allowed in instance declarations +Simplifier reached fixed point +In a RHS constructor application, con type doesn't match arg types +In a case expression, type of scrutinee does not match patterns +Offending Program +WARNING: SE CAFs unsupported, forcing UPD instead +Interesting! A join var that isn't let-no-escaped +Oops! Entered absent arg +absApply: Duff function +TELL SIMON: evalAbsence +panic! (the `impossible' happened, GHC version 6.4) +For basic information, try the `--help' option. +magic number mismatch: old/corrupt interface file? +Exotic pattern inside meta brackets +Can't represent a guarded lambda in Template Haskell +Exotic Stmt in meta brackets +Can't represent Oxford brackets +Can't represent explicit kind signatures yet +DsExpr.dsExpr: Infinite parallel array! +GHC error in desugarer lookup +Cannot desugar this Template Haskell declaration +foreign declaration uses deprecated non-standard syntax +CPR Analysis tried to take the lub of a function and a tuple +GHC's heap exhausted +GHC stack-space overflow +Precedence out of range +Empty record update +Type signature given for an expression +Qualified name in function definition +Malformed context in instance header +parse error in data/newtype declaration +Type found where type variable expected +Malformed context in type or class declaration +parse error on input +lexical error in string/character literal +primitive string literal must contain only characters <= '\\\\xFF\\' +invalid character +PArse error (possibly incorrect indentation) +Can't match unequal length lists +Kind error +Cannot unify a type variable with a type scheme +Unexpected kind unification failure +Use -fglasgow-exts to allow GADTs +Data constructor does not return its parent type +Can't combine named fields with locally-quantified type variables or context +Cycle in class declarations (via superclasses) +Cycle in type synonym declarations +Generic method type is too complex +Use -fglasgow-exts to allow multi-parameter classes +Too many parameters for class +No parameters for class +Use -fcontext-stack20 to increase stack size to (e.g.) 20 +Use -fallow-incoherent-instances +Implicit parameters escape from the monomorphic top-level binding(s) +Splices are not allowed in hs-boot files +Inaccessible case alternative +A lazy (~) pattern connot bind existential type variables +Non-type variables in constraint +All of the type variables in the constraint are already in scope (at least one must be universally quantified here) +At least one of the forall'd type variables mentioned by the constraint must be reachable from the type after the '=>' +Ambiguous constraint +Kind signature on data type declaration has non-* return kind +Malformed constructor signature +Illegal deriving item +does not have the required strict field(s) +No constructor has all these fields +Urk infer +You need -fglasgow-exts to derive an instance for this class +Try -fglasgow-exts for GHC's newtype-deriving extension +Multiple default declarations +All the type patterns for a generic type constructor must be identical +More than one type pattern for a single generic type constructor +No explicit method nor default method +falls under the monomorphism restriction +Illegal overloaded type signature(s) +bindings for unlifted types aren't allowed +Command stack underflow at command +Duplicate instance declarations +internal error: scavenge_mark_stack: unimplemented/strange closure type -1368815400 @ 0x2aaaae6981f8 +My brain just exploded. +internal error: Invalid object in processHeapClosureForDead +Urk! Inventing strangely-kinded void TyCon: ZCt{tc a2AN} (* -> *) -> * -> * +parse error (possibly incorrect indentation) +Inferred type is less polymorphic than expected +Kind error +Occurs check: cannot construct the infinite type +Occurs check: cannot construct the infinite kind +Can't reify a non-Haskell-98 data constructor +Illegal polymorphic type signature in pattern +Illegal unlifted type argument +Illegal polymorphic type +The instance types do not agree with the functional dependencies of the class +Unexpected strictness annotation +Unexpected type splice +Can't splice the polymorphic local variable +On Alpha, I can only handle 4 non-floating-point arguments to foreign export dynamic +GHC internal error +GHC stage restriction +the eta-reduction property does not hold +even with cunning newtype deriving the newtype is recursive +Can't mix generic and non-generic equations for class method +The signature contexts in a mutually recursive group should all be identical +Functional dependencies conflict between instance declarations +There must be at least one non-type-variable in the instance head +Illegal constraint +Illegal unboxed tuple type as function argument +Kinds don't match in type application +From-type of Coerce differs from type of enclosed expression +foreign declaration uses deprecated non-standard syntax +Illegal binding of built-in syntax +Duplicate binding in parallel list comprehension +Implicit-parameter bindings illegal in a parallel list comprehension +adjustor creation not supported on this platform +eval_thunk_selector: strange selectee +scavenge: unimplemented/strange closure type +scavenge_stack: weird activation record found on stack +Info table already? +ARGH! Jump uses %esi or %edi with -monly-2-regs + +gzl +[on why monads are scary] maybe it's because people look up monad on wikipedia, find the category theory page, and crap themselves + +hakko +most programmers have a lot of religious issues about their work, yes. + +ihope +Laziness is free, but it doesn't always pay off. +Oops, I forgot that Djinn doesn't do GADT's. + +jjuggle +I was riding around town and this cop on patrol on a bike rode up next to me and said, "There's always a show off." I offered to teach him to ride and help set up a unicycle patrol squad, but he declined. + +jlouis +Q: When does one know he has programmed too much Haskell? A: When he uses == and /= in everyday IRC chat or when he tries to fix a relationship by passing himself as a continuation + +joelr +the learning curve is far steeper with Haskell but it is far more elegant and readable +Fundeps, existential types, HList take a while to grasp + +kolmodin +I would rather lose my left arm than write it in Java + +kzm +My program contains a bug. How ungrateful, after all I've done for it. + +lambdabot +Occurs check: cannot construct the infinite type: a +Couldn't match kind `?? -> ? -> *' against `(* -> *) -> * -> *' +Of course i'm female +lambdabot hasn't said anything memorable + +lispy +I just remembered this dream i had the other morning. I was trying to tell my alarm clock how to snooze by using a list comprehension + +malcolm +I don't believe you need to invoke the full awesome majesty of Template Haskell +Most software doesn't need to be fast. But all software needs a fighting chance of correctness + +malig +quantum mechanics actually strikes me as less wierd than lazy evaluation sometimes. at least it disallows time travel +I have to admit I'm still stunned when "tying the knot" actually works. it's like I just performed the kind of magic that normally requires a lot more goat's blood + +mattam +[Monads are] much more elegant [than soccer] in general. + +mikaeli +hmm, one national tv station I was watching while eating breakfast crashed with bsod. I guess that's what you get for running windows in production use +My friend bought a new laptop; it had MSBLASTER preinstalled. I couldn't believe it either and installed XP and the apps many times, run virus killers and everytime the blaster came back. Everything was packed on a rescue cd. And virus was in m$ works installation files. + +musasabi + no reason to reinvent the whole wheel (usually reinvented wheels end up square) + +mwc +I actually got away with running Haskell through a TeX pretty printer and handing it in as pseudocode + +ndm +the only language i've seen which is ugly at a deeper level than syntax is perl + +pesco +"Scientists Reveal: Human Consciousness Stems From Two Files in Different Directories!" + +reddi +and now i know: IT DOES NOT WORK ALWAYS ;-) + +samc +monads are hard, let's go shopping + +sethk +it's certainly true that you can clobber the stack in C without even getting out of bed in the morning + +shapr +Programming is the Magic Executable Fridge Poetry, it is machines made of thought, fueled by ideas. +The legal system is the ultimate denial of service attack. +I don't know why the GHC team won't accept my spoonIO patch +I've toked on so many lambdas I'm getting dependent types +Anyway, I'm just a walking index into the Haskell world. I can tell you a little bit about many things, but I will quickly forward you to the experts for more detail. +I am hexed and vexed ;-) +Academics are continually chewing pieces off of impossible and making them merely difficult. +Windows users are like the wives of alcoholics, they'll take any amount of abuse and come right back. +I encourage my competitors to use Windows. +GHC has more flags than the UN +I've tried to teach people autodidactism, but I've realized they have to learn it for themselves. + +skew +We don't believe in constant factors. +Swapping is just a constant factor +I think blackdog is right + +tennin +[very #haskell] anyone know of any good books/papers on the application of category theory to databases? + +tomasz +After all, return is only a fancy name for liftM0 :-) + +twb +But, I love my job. It's like being in a rock band. i.e. no pay, but fun. + +vegai +Hey Haskell! Give me that File! -Naah, I'm too lazy. *thinks* I'll give you a cookie if you tell me how many letters that file has! -Oh, ok! + +vixen +If you see this, gentle sir, know that you are being trolled by a poorly configured VixenLove program + +wilx +I mean, besides the murders, it all looks so nice. + +xahlee +The Haskell Logo is the perfection of logos + +xerox +> take 10 lol where lol = "ol" : zipWith (:) (intersperse 'o' $ cycle "l") lol +you know, befunge is probably the only language I've seen where you can run code pasted from IRC with the tags still in place ;-) + diff --git a/State/todo b/State/todo new file mode 100644 --- /dev/null +++ b/State/todo @@ -0,0 +1,46 @@ +A way to get multiple results from a google search +SamB +@get-shapr summons shapr instantly +SamB +stop mangling long urls +SamB +improve formatting of @dict +dons +write Haskell Manifesto +dons +don't let lambdabot's prettyprinter split the sequence @foo across lines +lispy +priviledged users should get priviledged listcommands. +TheHunter +@type 1 :: Int +TheHunter +haddock gives a link from a type signature to the types. It would be nice if it also let you find functions in the given module that use a type. +lispy +Implement @whatis +dons +implement @cool list, as a clone of the @todo(-add) commands +dcoutts +there's some bug in the 'when i left' code of @seen +dons +sarahbot style @tell +dons +@tell command - relays a message to someone when they next speak +beelsebob_ +@seen on lambdabot should report lambdabot's channels too +dons +when printing first lines of infinite things (or all cases with nonexact), should say 'at least' +ski +provide '@more ', at least for privmsg +ski +'@todo-remove ' for priviledged users, and possibly the user who added the todo note (is @todo-replace worth it ?) +ski +BUG: @pl (\_ -> return ()) --> const return +dons +"@tell command to make lambdabot give someone a message when they're next seen" +beelsebob_ +"@remind command formatted as '@remind {at