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

BlogLiterately-0.8.6.3
1 matches
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

            
Buster-0.1.1
1 matches
src/Buster/Main.hs
module Main (main) where

import Control.Applicative ((<$>))
import Control.Error.Script (runScript,
                             scriptIO)
import Control.Error.Safe (tryHead)
import System.Environment (getArgs)


            
Cabal-3.0.0.0
3 matches
Distribution/Compat/Binary/Class.hs
import Data.Binary.Put
import Data.Binary.Get

import Control.Applicative ((<$>), (<*>), (*>))
import Foreign

import Data.ByteString.Lazy (ByteString)
import qualified Data.ByteString.Lazy as L


            
Distribution/Compat/Prelude.hs

#if !MINVER_base_48
    -- * base 4.8 shim
    Applicative(..), (<$), (<$>),
    Monoid(..),
#endif

    -- * Common type-classes
    Semigroup (..),

            
Distribution/Compat/Prelude.hs
  )

#if !MINVER_base_48
import Control.Applicative           (Applicative (..), (<$), (<$>))
import Distribution.Compat.Semigroup (Monoid (..))
#else
import Data.Foldable                 (length, null)
#endif


            
Cabal-ide-backend-1.23.0.0
1 matches
Distribution/Simple/Program/Db.hs

import Distribution.Compat.Binary (Binary(..))
#if __GLASGOW_HASKELL__ < 710
import Data.Functor ((<$>))
#endif
import Data.List
         ( foldl' )
import Data.Maybe
         ( catMaybes )

            
Cassava-0.5.1.0
4 matches
Data/Csv/Conversion.hs
import Data.Csv.Types

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative (Applicative, (<$>), (<*>), (<*), (*>), pure)
import Data.Monoid (Monoid, mappend, mempty)
import Data.Traversable (traverse)
import Data.Word (Word)
#endif


            
Data/Csv/Parser.hs
import Data.Csv.Util ((<$!>), blankLine, endOfLine, liftM2', cr, newline, doubleQuote, toStrict)

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>), (*>), (<*), pure)
import Data.Monoid (mappend, mempty)
#endif

-- | Options that controls how data is decoded. These options can be
-- used to e.g. decode tab-separated data instead of comma-separated

            
Data/Csv/Streaming.hs
import Data.Csv.Types

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>), (<*>), pure)
import Data.Traversable (Traversable(..))
#endif

#if !MIN_VERSION_bytestring(0,10,0)
import qualified Data.ByteString.Lazy.Internal as BL  -- for constructors

            
tests/UnitTests.hs
import qualified Data.Csv.Streaming as S

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>), (<*>))
#endif

------------------------------------------------------------------------
-- Parse tests


            
Chart-1.9.1
1 matches
Graphics/Rendering/Chart/Layout.hs
  ) where

#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>))
#endif

import Graphics.Rendering.Chart.Axis
import Graphics.Rendering.Chart.Geometry
import Graphics.Rendering.Chart.Drawing

            
Chitra-0.2.2
1 matches
Utilities/ParseByteString.hs
module Utilities.ParseByteString (parseByteString) where

import Control.Applicative ((<$>))
import Data.Word
import Data.Binary.Get
import qualified Data.ByteString.Lazy as BS

data Action m = A1 (m Word8) | A2 (m Word16) | A4 (m Word32)

            
Clean-0.6
2 matches
src/Clean/Functor.hs
  
  Id(..),Const(..),Flip(..),Compose(..),

  (<$>),(<$),(<&>),void,
  promap
  ) where

import qualified Prelude as P


            
src/Clean/Functor.hs
instance Applicative IO
instance Monad IO where (>>=) = (P.>>=)

(<$>) = map
x<&>f = map f x
a <$ x = const a <$> x

void :: Functor f => f a -> f ()
void = map (const ())

            
Clipboard-2.3.2.0
1 matches
System/Clipboard/X11.hs
import System.Directory         (setCurrentDirectory)
import System.IO                (hClose, stderr, stdin, stdout)
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>))
#endif

getClipboardString :: IO (Maybe String)
getClipboardString = do
    (display, window, clipboards) <- initialSetup

            
Commando-1.0.0.4
1 matches
System/Commando.hs
import GHC.IO.Handle             (hClose, hFlush)
import GHC.IO.Handle.Types       (Handle)
import System.Process.Internals  (ProcessHandle)
import Control.Applicative       ((<$>), (<*>))
import Data.Monoid               ((<>))
import Control.Concurrent        (forkIO)
import Data.Maybe                (fromMaybe, isJust, catMaybes)
import Control.Concurrent.Chan   (newChan, writeChan, getChanContents, Chan)


            
ComonadSheet-0.3.0.0
1 matches
Control/Comonad/Sheet/Examples.hs

import Control.Comonad.Sheet

import Control.Applicative ( (<$>), (<*>) )
import Data.List ( intersperse )
import Data.Bool ( bool )

import Data.Stream ( Stream , repeat , (<:>) )


            
ConstraintKinds-1.3.0
1 matches
src/Control/ConstraintKinds/Functor.hs
    fmap :: (FunctorConstraint f a, FunctorConstraint f b) => (a -> b) -> f a -> f b

-- | An infix synonym for 'fmap'.
(<$>) :: (Functor f, FunctorConstraint f a, FunctorConstraint f b) => (a -> b) -> f a -> f b
(<$>) = fmap

-------------------------------------------------------------------------------
-- Instances

instance Functor [] where

            
DAV-1.3.3
1 matches
hdav.hs
import qualified Data.ByteString.Lazy as BL
import qualified Data.ByteString.UTF8 as BU
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>),(<*>), pure)
#endif
import Control.Applicative (optional)
import Control.Monad (liftM2, unless)
import Control.Monad.IO.Class (MonadIO)
import Data.Version (showVersion)

            
DSH-0.12.0.1
3 matches
src/Database/DSH/FKL/Lang.hs

module Database.DSH.FKL.Lang where

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

import           Database.DSH.Common.Impossible
import           Database.DSH.Common.Pretty

            
src/Database/DSH/VL/Opt/Properties/Types.hs
module Database.DSH.VL.Opt.Properties.Types where

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

import           Database.DSH.Common.Lang
import           Database.DSH.Common.Pretty
import           Database.DSH.VL.Lang

            
src/Database/DSH/VL/Render/Dot.hs

module Database.DSH.VL.Render.Dot(renderVLDot) where

import Prelude hiding ((<$>))
import qualified Data.IntMap                 as Map
import qualified Data.List.NonEmpty          as N
import           Data.List

import           Text.PrettyPrint.ANSI.Leijen

            
Elm-0.13
5 matches
compiler/AST/Module.hs
import Data.Binary
import qualified Data.List as List
import qualified Data.Map as Map
import Control.Applicative ((<$>),(<*>))

import qualified AST.Expression.Canonical as Canonical
import qualified AST.Declaration as Decl
import qualified AST.Type as Type
import qualified AST.Variable as Var

            
compiler/AST/Type.hs
{-# OPTIONS_GHC -W #-}
module AST.Type where

import Control.Applicative ((<$>), (<*>))
import Data.Binary
import qualified Data.Map as Map

import qualified AST.Variable as Var
import AST.PrettyPrint

            
compiler/AST/Variable.hs
module AST.Variable where

import Data.Binary
import Control.Applicative ((<$>), (<*>))
import Text.PrettyPrint as P
import qualified AST.Helpers as Help
import AST.PrettyPrint

newtype Raw = Raw String

            
compiler/Build/File.hs
{-# OPTIONS_GHC -W #-}
module Build.File (build) where

import Control.Applicative      ((<$>))
import Control.Monad.Error      (runErrorT)
import Control.Monad.RWS.Strict
import System.Directory
import System.Exit
import System.FilePath

            
compiler/Docs.hs
import System.Exit
import System.IO

import Control.Applicative ((<$>))
import Control.Arrow (second)
import Data.Aeson
import Data.Aeson.Encode.Pretty
import Data.Aeson.Types (Pair)
import qualified Data.List as List