Aelve Codesearch

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

total matches: more than 1000

ADPfusion-0.5.2.2
2 matches
ADP/Fusion/Core/TH/Backtrack.hs

module ADP.Fusion.Core.TH.Backtrack where

import           Control.Applicative ( (<$>) )
import           Control.Monad
import           Control.Monad.Primitive (PrimState, PrimMonad)
import           Data.List
import           Data.Tuple.Select
import           Data.Vector.Fusion.Stream.Monadic (Stream(..))

            
ADP/Fusion/SynVar/Recursive/Type.hs

module ADP.Fusion.SynVar.Recursive.Type where

import Control.Applicative (Applicative,(<$>),(<*>))
import Control.Monad.Morph
import Data.Proxy
import Data.Strict.Tuple
import Data.Vector.Fusion.Stream.Monadic (Stream,head,map,mapM)
import Prelude hiding (head,map,mapM)

            
Agata-0.2.1.1
1 matches
Test/Agata/Base.hs
import Test.QuickCheck
import Control.Monad.State.Lazy
import Control.Monad (liftM2)
import Control.Applicative((<$>))

import Data.Maybe(mapMaybe)
import Data.Tagged

import Test.Agata.Common

            
Agda-2.6.0.1
8 matches
src/full/Agda/Compiler/JS/Compiler.hs
import Agda.Utils.FileName ( filePath )
import Agda.Utils.Function ( iterate' )
import Agda.Utils.Maybe
import Agda.Utils.Monad ( (<$>), (<*>), ifM )
import Agda.Utils.Pretty (prettyShow)
import qualified Agda.Utils.Pretty as P
import Agda.Utils.IO.Directory
import Agda.Utils.IO.UTF8 ( writeFile )
import qualified Agda.Utils.HashMap as HMap

            
src/full/Agda/Interaction/Highlighting/Precise.hs
  , mergeC
  ) where

import Control.Applicative ((<$>), (<*>))
import Control.Arrow (second)
import Control.Monad

import Data.Function
import qualified Data.List as List

            
src/full/Agda/Interaction/Highlighting/Range.hs
  , minus
  ) where

import Control.Applicative ((<$>))

import qualified Agda.Syntax.Position as P
import Agda.Utils.List

-- | Character ranges. The first character in the file has position 1.

            
src/full/Agda/TypeChecking/Monad/Mutual.hs

import Control.Monad.Reader

import Data.Functor ((<$>))
import Data.Set (Set)
import qualified Data.Set as Set
import qualified Data.Map as Map

import Agda.Syntax.Info as Info

            
src/full/Agda/Utils/Functor.hs

module Agda.Utils.Functor
  ( module Agda.Utils.Functor
  , (<$>)  -- from Data.Functor
  , ($>)   -- from Data.Functor
#if MIN_VERSION_base(4,11,0)
  , (<&>)  -- from Data.Functor
#endif
  )

            
src/full/Agda/Utils/List.hs

import Control.Arrow (first)

import Data.Functor ((<$>))
import Data.Function
import qualified Data.List as List
import Data.Maybe
import qualified Data.Map as Map
import qualified Data.Set as Set

            
src/full/Agda/Utils/Maybe/Strict.hs
import           Prelude             hiding (Maybe (..), maybe, null)
import qualified Prelude             as Lazy

import           Control.Applicative (pure, (<$>))
import           Control.DeepSeq     (NFData (..))
import           Data.Binary         (Binary (..))
import           Data.Data           (Data (..))
import           Data.Monoid         (Monoid, mempty, mappend)
import           Data.Semigroup      (Semigroup, (<>))

            
src/full/Agda/Utils/Monad.hs
module Agda.Utils.Monad
    ( module Agda.Utils.Monad
    , when, unless, MonadPlus(..)
    , (<$>), (<*>)
    , (<$)
    )
    where

import Prelude       hiding (concat)

            
Annotations-0.2.2
1 matches
tests/F/Expr.hs
import Annotations.F.Annotated
import Annotations.F.Fixpoints

import Control.Applicative (Applicative(..), (<$>))
import Data.Foldable (Foldable(..))
import Data.Traversable


-- type  PositionalExpr = (Bounds, PositionalExpr')

            
Ansi2Html-0.9
1 matches
Ansi2Html.hs
import System.Environment
import System.IO
import System.Exit
import Control.Applicative ((<$>))
import Data.Char
import Data.Maybe
import Text.XHtml as X
import Control.Monad
import Control.Monad.State as S

            
AttoBencode-0.3.1.0
1 matches
src/Data/AttoBencode/Parser.hs
import Prelude hiding (take)
import Data.Attoparsec (maybeResult, parse, Parser)
import Data.Attoparsec.Char8 (char, decimal, signed, take)
import Control.Applicative (many, (<$>), (<|>), (*>), (<*))
import Data.Map (fromList)
import qualified Data.ByteString as B

-- | Deserialise a bencoded ByteString.
-- If parsing or conversion fails, Nothing is returned.

            
BCMtools-0.1.1
4 matches
src/BCM/Binary.hs
{-# LANGUAGE FlexibleInstances #-}
module BCM.Binary where

import Control.Applicative ((<$>))
import Foreign
import System.IO
import System.IO.Unsafe (unsafePerformIO)

import qualified Data.Vector.Unboxed as U

            
src/BCM/DiskMatrix.hs
import Prelude hiding (replicate)
import Control.Monad (replicateM_)
import Control.Monad.IO.Class (MonadIO(..))
import Control.Applicative ((<$>))
import qualified Data.ByteString as B
import Data.Bits (shiftR)
import Data.Int
import Data.Word
import qualified Data.Vector.Generic as G

            
src/BCM/IOMatrix.hs
    ) where

import Control.Monad (when, forM_)
import Control.Applicative ((<$>))
import Control.Monad.IO.Class (MonadIO(..))
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L

import qualified Data.Matrix.Generic as MG

            
src/BCM.hs
    , closeContactMap
    ) where

import Control.Applicative ((<$>))
import Control.Monad (when, guard)
import Control.Monad.IO.Class (MonadIO(..))
import qualified Data.ByteString as L
import qualified Data.ByteString.Char8 as B
import qualified Data.HashMap.Strict as M

            
BNFC-2.8.2
1 matches
runtime/Parsing/Chart.hs
import Data.Maybe
import Prelude ()
import Data.Traversable (sequenceA)
import Control.Applicative ((<$>),(<*>),pure)
import Control.Monad(join)

import Data.List (splitAt)
import Algebra.RingUtils
import qualified Data.Matrix.Quad as Q

            
Bang-0.1.1.1
1 matches
src/Bang/Experimental/Live.hs
import Data.IORef
import Control.Monad(forever, when)
import Data.Time.Clock.POSIX
import Control.Applicative((<$>))

import Bang

waitTime :: IORef Int
waitTime = unsafePerformIO (newIORef 0)

            
BiobaseInfernal-0.8.1.0
2 matches
Biobase/SElab/CM/Import.hs

module Biobase.SElab.CM.Import where

import           Control.Applicative ( (<|>), pure, (<$>), (<$), (<*>), (<*) )
import           Control.DeepSeq (($!!))
import           Control.Lens
import           Control.Monad (forM_)
import           Control.Monad.IO.Class (MonadIO)
import           Data.Attoparsec.ByteString (takeTill,count,many1,(<?>),manyTill,option)

            
Biobase/SElab/HMM/Import.hs

module Biobase.SElab.HMM.Import where

import           Control.Applicative ( (<|>), pure, (<$>), (<$), (<*>), (*>), (<*) )
import           Control.Lens hiding ((|>))
import           Control.Monad
import           Control.Monad.IO.Class (MonadIO)
import           Data.Attoparsec.ByteString (count,many1,(<?>),manyTill,option)
import           Data.ByteString.Char8 (ByteString,unpack)

            
BiobaseTypes-0.2.0.0
1 matches
Biobase/Types/Index/Type.hs

module Biobase.Types.Index.Type where

import           Control.Applicative ((<$>))
import           Control.DeepSeq
import           Data.Aeson
import           Data.Binary
import           Data.Data (Data)
import           Data.Hashable (Hashable)

            
BiobaseXNA-0.10.0.0
1 matches
Biobase/Primary/Unknown.hs
module Biobase.Primary.Unknown where

import           Data.Aeson
import           Control.Applicative ((<$>))
import           Control.Arrow ((***),first)
import           Data.Hashable
import           Data.Ix (Ix(..))
import           Data.Map.Strict (Map)
import           Data.Primitive.Types

            
BlogLiterately-0.8.6.3
3 matches
src/Text/BlogLiterately/Ghci.hs
import           Control.Monad.IO.Class     (liftIO)
import           Control.Monad.Trans.Reader (ReaderT, ask, runReaderT)
import           Data.Char                  (isSpace)
import           Data.Functor               ((<$>))
import           Data.List                  (intercalate, isPrefixOf)
import           System.FilePath            (takeFileName)
import           System.IO
import qualified System.IO.Strict           as Strict
import           System.IO.Temp

            
src/Text/BlogLiterately/Options/Parse.hs
    , parseBLOption
    ) where

import           Control.Applicative         (pure, (*>), (<$>), (<*))
import           Control.Arrow               (second)
import           Control.Lens                (ASetter', (&), (.~))
import           Data.Char                   (isSpace)
import           Data.Either                 (partitionEithers)
import           Data.Monoid                 (Monoid, mconcat, mempty)

            
src/Text/BlogLiterately/Transform.hs
    , fixLineEndings
    ) where

import           Control.Applicative               ((<$>))
import           Control.Arrow                     ((>>>))
import           Control.Lens                      (has, isn't, use, (%=), (&),
                                                    (.=), (.~), (^.), _1, _2,
                                                    _Just)
import           Control.Monad.State

            
Blueprint-0.1
3 matches
Blueprint/Options.hs
import System.Environment
import System.IO.Unsafe

import Text.PrettyPrint.ANSI.Leijen hiding ((<$>))

import Blueprint.Error
import Blueprint.Miscellaneous
-- @-node:gcross.20091129000542.1452:<< Import needed modules >>
-- @nl

            
Blueprint/Tools/GHC.hs
import System.IO.Unsafe
import System.Process

import Text.PrettyPrint.ANSI.Leijen hiding ((</>),(<$>))

import Text.Regex.TDFA
import Text.Regex.TDFA.ByteString.Lazy

import Blueprint.Cache.ExplicitDependencies

            
Setup.hs
import System.Directory
import System.IO.Unsafe

import Text.PrettyPrint.ANSI.Leijen hiding ((<$>))

import Blueprint.Configuration
import Blueprint.Error
import Blueprint.Main
import Blueprint.Miscellaneous