Aelve Codesearch

grep over package repositories
Please provide a string to search for.
3+ characters are required.
Index updated about an hour ago

total matches: more than 1000

EtaMOO-0.3.0.0
24 matches
src/MOO/Builtins/Match.hsc
  , verifyPCRE
  ) where

import Control.Applicative ((<$>))
import Control.Arrow ((&&&))
import Control.Monad (unless)
import Data.Bits (Bits(zeroBits, (.|.), (.&.), complement))
import Data.ByteString (ByteString, useAsCString, useAsCStringLen)
import Data.Function (on)

            
src/MOO/Builtins/Misc.hs

module MOO.Builtins.Misc ( builtins ) where

import Control.Applicative ((<$>))
import Control.Monad.State (gets)
import Data.Monoid ((<>))
import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds, posixSecondsToUTCTime)
import Database.VCache (VCacheStats(..), vcacheStats)


            
src/MOO/Builtins/Network.hs

module MOO.Builtins.Network ( builtins ) where

import Control.Applicative ((<$>))
import Control.Concurrent.STM (readTVar)
import Control.Monad (unless, (<=<))
import Control.Monad.State (gets)
import Data.Time (UTCTime, diffUTCTime)


            
src/MOO/Builtins/Objects.hs

module MOO.Builtins.Objects ( builtins ) where

import Control.Applicative ((<$>))
import Control.Monad (when, unless, void, forM_, foldM)
import Data.Maybe (isJust, isNothing, fromJust)
import Data.Monoid (mempty, mappend)
import Data.Set (Set)
import Data.Text.Lazy.Builder (Builder)

            
src/MOO/Builtins/Tasks.hs

module MOO.Builtins.Tasks ( builtins ) where

import Control.Applicative ((<$>))
import Control.Arrow ((&&&))
import Control.Concurrent (forkIO, killThread)
import Control.Concurrent.STM (atomically, newEmptyTMVar, takeTMVar, putTMVar)
import Control.Monad (void)
import Control.Monad.Cont (callCC)

            
src/MOO/Builtins/Values.hs

module MOO.Builtins.Values ( builtins ) where

import Control.Applicative ((<$>), (<*>), (<|>))
import Control.Monad (unless, (<=<))
import Data.ByteString (ByteString)
import Data.Char (isDigit, digitToInt)
import Data.Monoid ((<>), mconcat)
import Data.Text (Text)

            
src/MOO/Builtins.hs

module MOO.Builtins ( builtinFunctions, callBuiltin, verifyBuiltins ) where

import Control.Applicative ((<$>))
import Control.Monad (foldM)
import Data.HashMap.Lazy (HashMap)
import Data.List (transpose, inits)
import Data.Maybe (fromMaybe)
import Data.Monoid ((<>))

            
src/MOO/Command.hs

  ) where

import Control.Applicative ((<$>))
import Control.Monad (void, foldM)
import Data.Char (isSpace, isDigit)
import Data.Monoid (Monoid(mempty, mappend, mconcat), First(First, getFirst))
import Data.Text (Text)
import Text.Parsec (parse, try, many, many1, char, anyChar, noneOf, spaces,

            
src/MOO/Compiler.hs
-- | Compiling abstract syntax trees into 'MOO' computations
module MOO.Compiler ( compile, evaluate ) where

import Control.Applicative ((<$>), (<*>))
import Control.Monad (forM_, when, unless, void, join, (<=<))
import Control.Monad.Cont (callCC)
import Control.Monad.Reader (asks, local)
import Control.Monad.State (gets)
import Data.Monoid ((<>))

            
src/MOO/Connection.hs
  , getConnectionOptions
  ) where

import Control.Applicative ((<$>))
import Control.Concurrent (forkIO)
import Control.Concurrent.STM (STM, TVar, TMVar, atomically, newTVar,
                               newEmptyTMVar, takeTMVar,
                               putTMVar, tryPutTMVar, tryTakeTMVar,
                               readTVar, writeTVar, modifyTVar, swapTVar,

            
src/MOO/Database/LambdaMOO.hs

module MOO.Database.LambdaMOO ( loadLMDatabase, saveLMDatabase ) where

import Control.Applicative ((<$>))
import Control.Monad (unless, when, forM, forM_, join)
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Reader (ReaderT, runReaderT, local, asks, ask)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Writer (WriterT, execWriterT, tell)

            
src/MOO/Database.hs
  , saveDatabase
  ) where

import Control.Applicative ((<$>), (<*>))
import Control.Monad (forM, forM_, when, (>=>))
import Data.IntSet (IntSet)
import Data.Maybe (isJust)
import Data.Monoid ((<>))
import Data.Text (Text)

            
src/MOO/List.hs
  , delete
  ) where

import Control.Applicative ((<$>))
import Data.Function (on)
import Data.HashMap.Lazy (HashMap)
import Data.Monoid (Monoid(mempty, mappend, mconcat), (<>))
import Data.Typeable (Typeable)
import Data.Vector (Vector)

            
src/MOO/Network/TCP.hs
  , createTCPListener
  ) where

import Control.Applicative ((<$>))
import Control.Concurrent (forkIO, killThread)
import Control.Concurrent.STM (STM, TMVar, newEmptyTMVarIO, atomically,
                               putTMVar, readTMVar)
import Control.Exception (SomeException, IOException, mask, try, finally,
                          bracketOnError)

            
src/MOO/Network.hs
  , unlisten
  ) where

import Control.Applicative ((<$>))
import Control.Concurrent.STM (TVar, atomically, modifyTVar, readTVarIO)
import Control.Exception (try, finally)
import Control.Monad (when)
import Data.Monoid ((<>))
import Data.Text (Text)

            
src/MOO/Object.hs
                  , failedMatch
                  ) where

import Control.Applicative ((<$>), (<*>))
import Control.Arrow (second)
import Control.Monad ((>=>), forM_)
import Data.HashMap.Strict (HashMap)
import Data.IntSet (IntSet)
import Data.List (find)

            
src/MOO/Parser.hs

module MOO.Parser ( parseProgram, parseNum, parseObj, keywords ) where

import Control.Applicative ((<$>), (<*>))
import Control.Arrow ((&&&))
import Control.Monad (when, unless, mplus)
import Control.Monad.Identity (Identity)
import Data.List (find)
import Data.Maybe (catMaybes)

            
src/MOO/Server.hs

module MOO.Server (startServer, importDatabase, exportDatabase) where

import Control.Applicative ((<$>))
import Control.Arrow ((&&&))
import Control.Concurrent (takeMVar, getNumCapabilities, threadDelay)
import Control.Concurrent.Async (async, withAsync, waitEither, wait)
import Control.Concurrent.STM (STM, TVar, atomically, retry, newEmptyTMVarIO,
                               tryPutTMVar, putTMVar, tryTakeTMVar, takeTMVar,

            
src/MOO/String.hs
  , index
  ) where

import Control.Applicative ((<$>))
import Data.ByteString (ByteString)
import Data.Char (isAscii, isPrint, isHexDigit, digitToInt, intToDigit)
import Data.Function (on)
import Data.Hashable (Hashable(hashWithSalt))
import Data.Monoid (Monoid(mempty, mappend, mconcat))

            
src/MOO/Task.hs
  , notyet
  ) where

import Control.Applicative ((<$>))
import Control.Arrow ((&&&))
import Control.Concurrent (MVar, ThreadId, myThreadId, forkIO, threadDelay,
                           newEmptyMVar, putMVar, tryPutMVar, takeMVar)
import Control.Concurrent.STM (STM, TVar, atomically, retry, throwSTM,
                               newEmptyTMVar, putTMVar, takeTMVar,

            
src/MOO/Types.hs

  ) where

import Control.Applicative ((<$>))
import Control.Concurrent (ThreadId)
import Control.Concurrent.STM (TVar)
import Data.CaseInsensitive (CI)
import Data.Hashable (Hashable)
import Data.HashMap.Strict (HashMap)

            
src/MOO/Unparser.hs
-- built-in function
module MOO.Unparser ( unparse ) where

import Control.Applicative ((<$>))
import Control.Monad (unless, (<=<))
import Control.Monad.Reader (ReaderT, runReaderT, asks, local)
import Control.Monad.Writer (Writer, execWriter, tell)
import Data.Char (isAlpha, isAlphaNum)
import Data.HashSet (HashSet)

            
src/MOO/Util.hs
  , VVersion(..)
  ) where

import Control.Applicative ((<$>), (<*>))
import Data.Hashable (Hashable)
import Data.HashMap.Strict (HashMap)
import Data.IntSet (IntSet)
import Data.Ratio (numerator, denominator, (%))
import Data.Time (UTCTime(..), Day(..), DiffTime, utcToLocalZonedTime,

            
src/MOO/Verb.hs
                , verbNameMatch
                ) where

import Control.Applicative ((<$>), (<*>))
import Data.Typeable (Typeable)
import Database.VCache (VCacheable(put, get))

import MOO.AST
import {-# SOURCE #-} MOO.Object (nothing)

            
EuroIT-2010.2.5
1 matches
Data/EuroIT.hs

-- import Text.ParserCombinators.ReadPrec
import Control.Arrow
import Control.Applicative ((<$>))
import Text.ParserCombinators.ReadP
import Text.Read (readPrec, lift)
import Text.Printf
import Data.Ratio
import Data.List

            
FPretty-1.1
4 matches
Text/PrettyPrint/FPretty.hs
  -- ** The base binary combinator
  ,(<>)
  -- ** Derived binary combinators
  ,(<+>),(<$>),(<$$>),(</>),(<//>)
  -- * Modifying the layouts of one document
  ,group,nest,align,hang
  -- * Combining many documents
  ,hsep,vsep,fillSep,sep,hcat,vcat,fillCat,cat) where


            
Text/PrettyPrint/FPretty.hs

#if __GLASGOW_HASKELL__ >= 710
-- The base libraries from GHC 7.10 onwards export <$> as synonym for fmap.
import Prelude hiding ((<$>))
#endif

import Data.Maybe (fromJust)
import Data.Sequence as Dequeue (Seq, (<|), viewl, viewr, ViewL(..), ViewR(..))
import qualified Data.Sequence as Dequeue (empty)

            
Text/PrettyPrint/FPretty.hs
dl <+> dr = dl <> text " " <> dr

-- | Combine with a 'line' in between.
(<$>) :: Doc -> Doc -> Doc
dl <$> dr = dl <> line <> dr

-- | Combine with a 'linebreak' in between.
(<$$>) :: Doc -> Doc -> Doc
dl <$$> dr = dl <> linebreak <> dr

            
Text/PrettyPrint/FPretty.hs

-- | Combine non-empty list of documents with '<$>', i.e., a 'line' separator.
vsep :: [Doc] -> Doc
vsep = foldr1 (<$>)  -- differs from PPrint

-- | Combine non-empty list of documents with '</>', i.e., a 'softline' separator.
fillSep :: [Doc] -> Doc
fillSep = foldr1 (</>)  -- differs from PPrint


            
FTGL-bytestring-2.0
1 matches
Graphics/Rendering/FTGL.hs
import qualified Data.ByteString.Char8 as BS8
import Data.StateVar.Trans

import Control.Applicative ((<$>))

foreign import ccall unsafe "ftglCreateBitmapFont" fcreateBitmapFont :: CString -> IO Font
{-# INLINE fcreateBitmapFont #-}

-- | Create a bitmapped version of a TrueType font.  Bitmapped versions will not