Aelve Codesearch

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

total matches: more than 1000

JuicyPixels-3.3.4
21 matches
src/Codec/Picture/Bitmap.hs

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

import Control.Arrow( first )
import Control.Monad( replicateM, when, foldM_, forM_, void )
import Control.Monad.ST ( ST, runST )

            
src/Codec/Picture/ColorQuant.hs
    ) where

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

import           Data.Bits           (unsafeShiftL, unsafeShiftR, (.&.), (.|.))
import           Data.List           (elemIndex)
import           Data.Maybe          (fromMaybe)

            
src/Codec/Picture/Gif/Internal/LZW.hs
module Codec.Picture.Gif.Internal.LZW( decodeLzw, decodeLzwTiff ) where

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

import Data.Word( Word8 )
import Control.Monad( when, unless )


            
src/Codec/Picture/Gif/Internal/LZWEncoding.hs
module Codec.Picture.Gif.Internal.LZWEncoding( lzwEncode ) where

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

import Control.Monad.ST( runST )
import qualified Data.ByteString.Lazy as L

            
src/Codec/Picture/Gif.hs
                         ) where

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

import Control.Arrow( first )
import Control.Monad( replicateM, replicateM_, unless, when )
import Control.Monad.ST( runST )

            
src/Codec/Picture/HDR.hs
                        ) where

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

import Data.Bits( Bits, (.&.), (.|.), unsafeShiftL, unsafeShiftR )
import Data.Char( ord, chr, isDigit )
import Data.Word( Word8 )

            
src/Codec/Picture/InternalHelper.hs

#if MIN_VERSION_binary(0,6,4)
#else
import Control.Applicative( (<$>) )
import qualified Control.Exception as E
-- I feel so dirty. :(
import System.IO.Unsafe( unsafePerformIO )
#endif


            
src/Codec/Picture/Jpg/Internal/Common.hs
    ) where

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

import Control.Monad( when )
import Control.Monad.ST( ST, runST )
import Data.Bits( unsafeShiftL, unsafeShiftR, (.&.) )

            
src/Codec/Picture/Jpg/Internal/FastDct.hs
module Codec.Picture.Jpg.Internal.FastDct( referenceDct, fastDctLibJpeg ) where

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

import Data.Int( Int16, Int32 )
import Data.Bits( unsafeShiftR, unsafeShiftL )
import Control.Monad.ST( ST )

            
src/Codec/Picture/Jpg/Internal/Progressive.hs
    ) where

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

import Control.Monad( when, unless, forM_ )
import Control.Monad.ST( ST )
import Control.Monad.Trans( lift )

            
src/Codec/Picture/Jpg/Internal/Types.hs


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

import Control.Monad( when, replicateM, forM, forM_, unless )
import Control.Monad.ST( ST )
import Data.Bits( (.|.), (.&.), unsafeShiftL, unsafeShiftR )

            
src/Codec/Picture/Jpg.hs
#if !MIN_VERSION_base(4,8,0)
import Data.Foldable( foldMap )
import Data.Monoid( mempty )
import Control.Applicative( pure, (<$>) )
#endif

import Control.Applicative( (<|>) )

import Control.Arrow( (>>>) )

            
src/Codec/Picture/Png/Internal/Metadata.hs
                                 ) where

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

import Data.Maybe( fromMaybe )

            
src/Codec/Picture/Png/Internal/Type.hs
                             ) where

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

import Control.Monad( when, replicateM )
import Data.Bits( xor, (.&.), unsafeShiftR )
import Data.Binary( Binary(..), Get, get )

            
src/Codec/Picture/Png.hs
                        ) where

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

import Control.Arrow( first )
import Control.Monad( forM_, foldM_, when, void )
import Control.Monad.ST( ST, runST )

            
src/Codec/Picture/Tga.hs

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

import Control.Arrow( first )
import Control.Monad.ST( ST, runST )
import Data.Bits( (.&.)

            
src/Codec/Picture/Tiff/Internal/Metadata.hs
#if !MIN_VERSION_base(4,8,0)
import Data.Monoid( mempty )
import Data.Foldable( foldMap )
import Control.Applicative( (<$>) )
#endif

import Data.Bits( unsafeShiftL, (.|.) )
import Data.Foldable( find )
import Data.List( sortBy )

            
src/Codec/Picture/Tiff/Internal/Types.hs
    ) where

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

import Control.Monad( forM_, when, replicateM, )
import Data.Bits( (.&.), unsafeShiftR )
import Data.Binary( Binary( .. ) )

            
src/Codec/Picture/Tiff.hs
                         ) where

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

import Control.Arrow( first )
import Control.Monad( when, foldM_, unless, forM_ )

            
src/Codec/Picture/Types.hs

#if !MIN_VERSION_base(4,8,0)
import Data.Monoid( Monoid, mempty )
import Control.Applicative( Applicative, pure, (<*>), (<$>) )
#endif
#if !MIN_VERSION_base(4,11,0)
import Data.Monoid( (<>) )
#endif
import Control.Monad( foldM, liftM, ap )

            
src/Codec/Picture.hs
                     ) where

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

import Control.Arrow( first )
import Data.Bits( unsafeShiftR )
import Control.DeepSeq( NFData, deepseq )

            
L-seed-0.2
1 matches
src/Lseed/Data.hs

import Data.Foldable (Foldable, foldMap)
import Data.Traversable (Traversable, sequenceA)
import Control.Applicative ((<$>),(<*>),pure)
import Control.Arrow (second)
import Data.Monoid
import System.Time (ClockTime)
import Data.Monoid


            
LambdaPrettyQuote-0.0.0.8
3 matches
src/Language/Lambda/SimplyTyped/Arbitrary.hs
    shrink_expr
) where
import Test.QuickCheck
import Control.Applicative ((<*>), (<$>))
import Data.List
import Language.Lambda.SimplyTyped.Syntax
import Control.Monad.RWS.Strict
import Control.Applicative
import Test.QuickCheck.Gen

            
src/Language/Lambda/SimplyTyped/Let/Arbitrary.hs
    shrink_expr
) where
import Test.QuickCheck
import Control.Applicative ((<*>), (<$>))
import Data.List
import Language.Lambda.SimplyTyped.Let.Syntax
import Control.Monad.RWS.Strict
import Control.Applicative
import Test.QuickCheck.Gen

            
src/Language/Lambda/Untyped/Arbitrary.hs
    gexpr_arb'
) where
import Test.QuickCheck
import Control.Applicative ((<*>), (<$>))
import Language.Lambda.Untyped.Syntax
import Language.Lambda.Common.Arbitrary

-- | An arbitrary function for Expr. See the example above.
expr_arb :: Gen Expr

            
Level0-1.0
1 matches
src/Logic.hs
import Data.List (nub, delete)
import Data.Maybe (fromMaybe)
import Control.Monad (unless, void)
import Control.Applicative ( (<$>) )
import Data.Foldable (for_)
import Data.Traversable (forM)

paused :: World -> Bool
paused w = snd (mode w) == Scoreboard

            
LibClang-3.8.0
1 matches
Setup.hs
import System.Process(readProcess)
import System.Environment(lookupEnv, getEnv, setEnv)
import System.FilePath.Posix((</>))
import Control.Applicative((<$>))
import Control.Exception(bracket)

rtrim :: String -> String
rtrim = f . f
  where f = reverse . dropWhile isSpace

            
LogicGrowsOnTrees-MPI-1.0.0.1.1
3 matches
sources/LogicGrowsOnTrees/Parallel/Adapter/MPI.hs

import Prelude hiding (catch)

import Control.Applicative ((<$>),(<*>),Applicative(),liftA2)
import Control.Concurrent (threadDelay)
import Control.Exception (onException)
import Control.Monad (liftM2,unless)
import Control.Monad.CatchIO (MonadCatchIO(..),bracket)
import Control.Monad.IO.Class (MonadIO(liftIO))

            
tests/test-nqueens.hs
{-# LANGUAGE UnicodeSyntax #-}

import Data.Functor ((<$>))

import System.Console.CmdTheLine
import System.Log.Logger (Priority(..),rootLoggerName,setLevel,updateGlobalLogger)

import LogicGrowsOnTrees.Examples.Queens (BoardSize(..),nqueensCorrectCount,nqueensCount)

            
tests/test-trivial.hs
{-# LANGUAGE UnicodeSyntax #-}

import Control.Applicative ((<$>))

import Data.Monoid (mempty)

import System.Log.Logger (Priority(..),rootLoggerName,setLevel,updateGlobalLogger)