Aelve Codesearch

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

total matches: more than 1000

HStringTemplate-0.8.7
1 matches
Text/StringTemplate/Group.hs
--------------------------------------------------------------------}

(<$$>) :: (Functor f1, Functor f) => (a -> b) -> f (f1 a) -> f (f1 b)
(<$$>) = (<$>) . (<$>)

readFileUTF :: FilePath -> IO String
readFileUTF f = do
   h <- openFile f ReadMode
   hSetEncoding h utf8

            
HStringTemplateHelpers-0.0.14
1 matches
Text/StringTemplate/Helpers.hs
              mbFoundbadattr

(<$$>) :: (Functor f1, Functor f) => (a -> b) -> f (f1 a) -> f (f1 b)
(<$$>) = (<$>) . (<$>)

{- Check for a variable that will cause errors and heartache using HStringTemplate -}
badTmplVarName :: String -> Bool
badTmplVarName t = not . null . filter (not . isAlpha) $ t


            
HTTP-4000.3.14
1 matches
Network/Browser.hs
import Data.Char (toLower)
import Data.List (isPrefixOf)
import Data.Maybe (fromMaybe, listToMaybe, catMaybes )
import Control.Applicative (Applicative (..), (<$>))
#ifdef MTL1
import Control.Monad (filterM, forM_, when, ap)
#else
import Control.Monad (filterM, forM_, when)
#endif

            
HTab-1.6.3
4 matches
src/HTab/Branch.hs
isTransitive
) where

import Control.Applicative ( (<$>) )
import Data.Maybe( mapMaybe )

import Data.Map ( Map )
import qualified Data.Map as Map
import Data.Set ( Set )

            
src/HTab/Main.hs
( runWithParams, TaskRunFlag(..))

where
import Control.Applicative ( (<$>) )
import Control.Monad       ( when )
import Control.Monad.State( runStateT )

import System.Console.CmdArgs ( whenNormal, whenLoud )


            
src/htab.hs
where

import Control.Monad ( unless )
import Control.Applicative ( (<$>) )

import System.Console.CmdArgs

import System.IO           ( hPrint, stderr ) 
import System.Exit         ( exitWith, ExitCode(ExitFailure) )

            
tests/test-example-formulas.hs
import Data.List ( tails )
import qualified Data.Set as Set

import Control.Applicative ( (<$>) )
import HyLo.Util           ( sequenceUntil )

import System.Exit        ( exitFailure          )
import System.FilePath    ( (</>)                )
import System.Directory   ( getDirectoryContents )

            
HUnit-Diff-0.1
1 matches
Test/HUnit/Diff.hs
-}
module Test.HUnit.Diff ((@?==), (@==?)) where

import Data.Functor        ( (<$>) )

import Data.Algorithm.Diff ( getDiff, DI(B, F, S) )
import System.Console.ANSI ( Color(Green, Red), ColorIntensity(Dull)
                           , ConsoleLayer(Foreground), SGR(SetColor, Reset)
                           , setSGRCode )

            
HXQ-0.20.1
4 matches
src/hxml-0.2/LLParsing.hs

module LLParsing
    ( pTest , pCheck , pSym , pSucceed
    ,(<|>),(<*>),(<$>),(<^>),(<$),(<*),(*>),(<?>),(<**>)
    , pMaybe , pFoldr , pList , pSome , pChainr , pChainl, pTry
    , pRun
    ) where

import Prelude hiding ((<$), (<$>), (<*>), (<*), (*>), (<**>))

            
src/hxml-0.2/LLParsing.hs
    , pRun
    ) where

import Prelude hiding ((<$), (<$>), (<*>), (<*), (*>), (<**>))

infixl 3 <|>
infixl 4 <*>, <$>, <^>, <?>, <$, <*, *>, <**>

{- <H98> -}

            
src/hxml-0.2/LLParsing.hs
pSucceed:: b -> Parser a b
(<|>)	:: Parser a b -> Parser a b -> Parser a b	-- union
(<*>)	:: Parser a (b->c) -> Parser a b -> Parser a c	-- sequence
(<$>) 	:: (b->c) -> Parser a b -> Parser a c		-- application
(<$ )	:: c -> Parser a b -> Parser a c		-- application, dropr
(<^>)	:: Parser a b -> Parser a c -> Parser a (b,c)	-- sequence
(<* )	:: Parser a b -> Parser a c -> Parser a b	-- sequence, dropr
( *>)	:: Parser a b -> Parser a c -> Parser a c	-- sequence, dropl
(<?>)	:: Parser a b -> b -> Parser a b		-- optional

            
src/hxml-0.2/XMLParse.hs
    , parseInstance, parseDTD, parseDocument
    ) where

import Prelude hiding ((<$), (<$>), (<*>), (<*), (*>), (<**>))

import XMLScanner
import LLParsing
import XML
import DTD

            
HaLeX-1.2.6
2 matches
HaLeX_lib/Language/HaLex/Parser.hs

module Language.HaLex.Parser where

import Prelude hiding ((<$>), (<*>))

infixl 3 <|> ; infixl 4 <*>


--

            
HaLeX_lib/Language/HaLex/RegExpParser.hs
module Language.HaLex.RegExpParser ( parseRegExp
                                   ) where

import Prelude hiding ((<$>), (<*>))
import Data.Char
import Language.HaLex.Parser
import Language.HaLex.RegExp



            
HaTeX-3.22.0.0
1 matches
Text/LaTeX/Packages/Graphicx.hs
--
import Data.Char (toLower)
#if !MIN_VERSION_base(4,8,0)
import Data.Functor ((<$>))
#endif

-- | The 'graphicx' package.
--
-- > usepackage [] graphicx

            
Hach-0.1.2
4 matches
nclient/NClient/GUI.hs
module NClient.GUI (gui) where

import Control.Applicative ((<$>))
import Control.Concurrent (forkIO, threadDelay)
import Control.Concurrent.Chan (readChan, writeChan)
import Control.Monad (forever, forM_, void)
import Data.IORef (newIORef, atomicModifyIORef)
import Graphics.Vty

            
server/Server/Client.hs
module Server.Client (clientProcessing) where

import Control.Applicative ((<$>))
import Control.Concurrent
import Control.Exception
import Control.Monad (forever)
import Data.Time.Clock (getCurrentTime)
import System.IO

            
server/Server/History.hs
  , emptyHistory, putMessage, getMessages, lastNMinutes
  ) where

import Control.Applicative ((<$>))
import Control.Concurrent.MVar
import Data.Time.Clock (diffUTCTime, NominalDiffTime)

import qualified Data.Sequence as S


            
server/Server/Storage.hs
  , showStorage
  ) where

import Control.Applicative ((<$>))
import Control.Concurrent.MVar
import qualified Data.Map as M
import Data.Text

type ClientId = Int

            
Haggressive-0.1.0.4
1 matches
src-lib/Data/Haggressive/Tweets.hs
  (filterByLabel
, Tweet(..)) where

import           Control.Applicative ((<$>), (<*>), (<|>))
import           Control.Monad       (mzero)
import           Data.Csv
import qualified Data.PSQueue        as PS
import qualified Data.Vector         as V


            
Haschoo-0.1.2
7 matches
Haschoo/Evaluator/Macros.hs

module Haschoo.Evaluator.Macros (mkMacro) where

import Control.Applicative         ((<$>))
import Control.Arrow               (first)
import Control.Monad               (liftM2, when)
import Control.Monad.Error         (throwError)
import Control.Monad.Loops         (andM, allM, firstM, untilM)
import Control.Monad.State.Strict  (State, runState, put, get, modify)

            
Haschoo/Evaluator/Primitives.hs
{-# LANGUAGE PatternGuards #-}
module Haschoo.Evaluator.Primitives (context) where

import Control.Applicative ((<$>))
import Control.Arrow       (first, (&&&))
import Control.Monad       (when)
import Control.Monad.Error (throwError)
import Control.Monad.State (get)
import Control.Monad.Trans (liftIO)

            
Haschoo/Evaluator/Standard/PairsLists.hs

module Haschoo.Evaluator.Standard.PairsLists (procedures, scmAppend) where

import Control.Applicative ((<$>))
import Control.Arrow       ((&&&))
import Control.Monad       (join, replicateM, (>=>))
import Control.Monad.Loops (dropWhileM, firstM)
import Data.Foldable       (foldrM)
import Data.IORef          (IORef, newIORef, readIORef, writeIORef)

            
Haschoo/Evaluator/Standard/Strings.hs
module Haschoo.Evaluator.Standard.Strings (procedures, isString, strToList)
 where

import Control.Applicative ((<$>))
import Control.Arrow       ((&&&))
import Control.Monad       (join, liftM2)
import Data.Array.IArray   ((!), bounds, elems)
import Data.Array.IO       (IOUArray)
import Data.Array.MArray   ( readArray, writeArray

            
Haschoo/Evaluator/Standard/Vectors.hs

module Haschoo.Evaluator.Standard.Vectors (procedures) where

import Control.Applicative ((<$>))
import Data.Array          (Array)
import Data.Array.IArray   ((!), bounds, elems)
import Data.Array.IO       (IOArray)
import Data.Array.MArray   ( readArray, writeArray
                           , newArray, newListArray

            
Haschoo/Parser.hs

module Haschoo.Parser (runParser, programValue, value, number) where

import Control.Applicative                  ((<$>))
import Control.Arrow                        (first)
import Control.Monad                        (liftM2)
import Data.Char                            (digitToInt, toLower)
import Data.Complex                         (Complex((:+)), mkPolar)
import Data.Maybe                           (fromJust, fromMaybe, isJust)

            
Haschoo/Types.hs
   , scmShow, scmShowWith
   ) where

import Control.Applicative        ((<$>))
import Control.Arrow              (second)
import Control.Monad.Error        (ErrorT, MonadError, runErrorT)
import Control.Monad.State.Strict (StateT, MonadState, evalStateT)
import Control.Monad.Trans        (MonadIO, liftIO)
import Data.Array.IO              (IOArray, IOUArray, newListArray, getElems)

            
HaskellNet-0.5.1
3 matches
src/Network/HaskellNet/IMAP/Connection.hs
    , modifyIORef
    )
import Control.Applicative
    ( (<$>)
    , (<*>)
    )

import Network.HaskellNet.BSStream
import Network.HaskellNet.IMAP.Types

            
src/Network/HaskellNet/IMAP.hs
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BS

import Control.Applicative ((<$>))
import Control.Monad

import System.Time

import Data.Maybe

            
src/Network/HaskellNet/POP3.hs
import Crypto.Hash.MD5
import Numeric (showHex)

import Control.Applicative ((<$>))
import Control.Exception
import Control.Monad (when, unless)

import Data.List
import Data.Char (isSpace, isControl)