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

FTGL-2.1
1 matches
Graphics/Rendering/FTGL.hs
import Data.Bits 
import Data.Char (ord)

import Control.Applicative ((<$>))

foreign import ccall unsafe "ftglCreateBitmapFont" fcreateBitmapFont :: CString -> IO Font
-- | Create a bitmapped version of a TrueType font.  Bitmapped versions will not
-- | respond to matrix transformations, but rather must be transformed using the
-- | raster positioning functions in OpenGL

            
FTPLine-1.4.1.1
1 matches
Main.hs
import Network.FTP.Client
import Network.FTP.Client.Parser
import System.Directory
import Control.Applicative ((<$>))
import Data.List (intercalate,isPrefixOf)
import System.Console.ANSI
import System.IO
import System.Environment (getArgs)
import qualified Data.ByteString.Lazy as B

            
Feval-1.0.0.1
1 matches
FVL/Parser.hs
import Text.Parsec.String
import Text.Parsec.Expr
import Control.Monad
import Control.Applicative ((<$>), (<$), (<*>), (<*), (*>))

import FVL.Algebra
import FVL.EFAST
import FVL.Lexer


            
FileSystem-1.0.0
3 matches
System/FileSystem/Class.hs

import System.FileSystem.Types
--
import Control.Applicative ((<$>))
-- MTL Monad transformers
import Control.Monad.State
import Control.Monad.Reader
import Control.Monad.Writer
import Control.Monad.RWS

            
System/FileSystem/Computations.hs
import Control.Monad.Identity (runIdentity)
import Control.Monad.State (runStateT,modify,put)
import Control.Arrow ( (***) , first , second )
import Control.Applicative ( (<$>) , pure )
import Data.Maybe (isJust)
import Data.Either (partitionEithers)
--
import System.FileSystem.Types
import System.FileSystem.Operators

            
System/FileSystem/Utils.hs
   , pairMap
     ) where

import Control.Applicative (Applicative,liftA2,(<$>))
import Control.Arrow ( (&&&) , (|||) , (***) , arr
                     , Arrow , (<<<) , ArrowChoice )
import Control.Monad.State (MonadState,get,zipWithM)
import Data.Maybe (catMaybes,listToMaybe)
import Control.Monad (join)

            
Fin-0.2.7.0
1 matches
Data/Fin/Permutation.hs

module Data.Fin.Permutation (Permutation, apply, unapply, swap, orbit, cycles) where

import Prelude (Functor (..), Applicative (..), Eq (..), Show (..), Bool (..), ($), (<$>), otherwise, snd, flip, curry, uncurry)
import Algebra
import Control.Category (Category (..))
import Data.Fin
import Data.Fin.List hiding (swap)
import qualified Data.Fin.List as L

            
FontyFruity-0.5.3.5
12 matches
src/Graphics/Text/TrueType/Bytecode.hs
module Graphics.Text.TrueType.Bytecode where

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

import Prelude hiding ( EQ, GT, LT )
{-import Control.Monad.State.Strict( modify )-}

            
src/Graphics/Text/TrueType/CharacterMap.hs
    ) where

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

import Control.DeepSeq( NFData( .. ) )
import Control.Monad( replicateM,  when, foldM  )
import Data.Binary( Binary( .. ) )

            
src/Graphics/Text/TrueType/FontFolders.hs
    ) where

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

#if !MIN_VERSION_base(4,6,0)
import Control.Monad( guard )
import Control.Exception( tryJust )

            
src/Graphics/Text/TrueType/Glyph.hs

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

import Control.DeepSeq
import Data.Bits( setBit, testBit, shiftL )
import Data.Int( Int16 )

            
src/Graphics/Text/TrueType/Header.hs
    ) where

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

import Control.DeepSeq( NFData( .. ) )
import Data.Bits( (.|.), setBit, testBit )
import Data.Binary( Binary( .. ) )

            
src/Graphics/Text/TrueType/HorizontalInfo.hs
    ) where

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

import Control.DeepSeq( NFData( .. ) )
import Control.Monad( when, replicateM_ )
import Data.Word( Word16 )

            
src/Graphics/Text/TrueType/LanguageIds.hs
    ) where

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

import Data.Binary( Binary( .. ) )
import Data.Binary.Get( getWord16be )
import Data.Binary.Put( putWord16be )

            
src/Graphics/Text/TrueType/MaxpTable.hs
module Graphics.Text.TrueType.MaxpTable( MaxpTable( .. ) ) where

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

import Control.DeepSeq( NFData( .. ) )
import Data.Word( Word16 )
import Data.Binary( Binary( .. ) )

            
src/Graphics/Text/TrueType/Name.hs

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

import Control.DeepSeq( NFData( .. ) )
import Control.Monad( when, replicateM )
import Data.Foldable( asum )

            
src/Graphics/Text/TrueType/OffsetTable.hs
    ) where

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

import Data.Word( Word16, Word32 )
import Data.Binary( Binary( .. ) )
import Data.Binary.Get( getWord16be

            
src/Graphics/Text/TrueType/Types.hs
    ) where

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

import Data.Int( Int32 )
import Data.Word( Word16 )
import Data.Binary( Binary( .. ) )

            
src/Graphics/Text/TrueType.hs

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

import Control.Monad( foldM, forM )
import Data.Function( on )
import Data.Int ( Int16 )

            
ForSyDe-3.1.1
1 matches
src/ForSyDe/Netlist/Traverse.hs
import Data.Monoid (mempty)
-- qualified to avoid nameclash
import qualified Data.Traversable as DT (Traversable(traverse,mapM)) 
import Control.Applicative (pure, (<$>))
import Control.Monad.State
import Control.Monad.ST (ST)

-- Instances to traverse a netlist Node (and implicitly the whole netlist)


            
ForestStructures-0.0.1.0
1 matches
Data/Forest/Static.hs

module Data.Forest.Static where

import           Control.Applicative ((<$>),(<*>))
import           Control.Monad (replicateM)
import           Data.Foldable (toList)
import           Data.Graph.Inductive.Basic
import           Data.List (span,uncons,sort)
import           Data.Traversable (mapAccumL)

            
FormalGrammars-0.3.1.2
3 matches
FormalLanguage/CFG/PrettyPrint/ANSI.hs
import           Control.Lens hiding (outside,Index)
import           Control.Monad.Reader
import           Data.List (intersperse)
import           Prelude hiding ((<$>))
import qualified Data.Map as M
import qualified Data.Set as S
import           System.IO (stdout)
import           Text.PrettyPrint.ANSI.Leijen
import           Data.Char (toUpper)

            
FormalLanguage/CFG/PrettyPrint/Haskell.hs
import           Text.PrettyPrint.ANSI.Leijen
import           Text.Printf
import           Control.Arrow hiding ((<+>))
import           Prelude hiding ((<$>))

import FormalLanguage.CFG.Grammar
import FormalLanguage.CFG.Parser



            
FormalLanguage/CFG/QQ.hs

module FormalLanguage.CFG.QQ where

import Control.Applicative ((<$>),(<*>),empty)
import Control.Monad hiding (mapM)
import Control.Monad.Trans.State.Strict (evalStateT)
import Data.ByteString.Char8 (pack)
import Data.Default (def)
import Language.Haskell.TH

            
FreeTypeGL-0.0.4
2 matches
Graphics/Rendering/FreeTypeGL/Internal/Markup.hsc
{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
module Graphics.Rendering.FreeTypeGL.Internal.Markup(Markup(..), noMarkup) where

import Control.Applicative ((<$>), (<*>))
import Foreign (Ptr, plusPtr)
import Foreign.C.Types (CInt)
import Foreign.Storable (Storable(..))
import Graphics.Rendering.OpenGL.GL (Color4(..))


            
Graphics/Rendering/FreeTypeGL/Internal/TextBuffer.hsc
  , Pen, Vector2(..)
  ) where

import Control.Applicative ((<$>))
import Foreign (FunPtr, Ptr)
import Foreign.C.String (CWString, withCWString)
import Foreign.C.Types (CUInt(..), CInt(..))
import Foreign.ForeignPtr (ForeignPtr, withForeignPtr, newForeignPtr)
import Foreign.Marshal.Alloc (alloca)

            
GLUtil-0.9.3
3 matches
examples/TGA.hs
-- Working with textures will require loading images from disk. We will
-- use the TGA format since it is quite simple to work with.
module TGA (readTGA) where
import Control.Applicative ((<$>))
import Control.Monad ((<=<))
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BL
import Data.Binary.Get


            
src/Graphics/GLUtil/JuicyTextures.hs
import Codec.Picture (readImage, DynamicImage(..), Image(..))
import Codec.Picture.Types (convertImage)
#if __GLASGOW_HASKELL__ < 710
import Control.Applicative ((<$>))
#endif
import Graphics.GLUtil.Textures
import Graphics.Rendering.OpenGL (TextureObject)

-- | Load a 'TexInfo' value from an image file, and supply it to a

            
src/Graphics/GLUtil/ShaderProgram.hs
   getAttrib, enableAttrib, setAttrib, setUniform, getUniform) where
import Prelude hiding (lookup)
#if __GLASGOW_HASKELL__ < 710
import Control.Applicative ((<$>), (<*>))
#endif
import qualified Data.ByteString as BS
import Data.List (find, findIndex, isSuffixOf)
import Data.Map.Strict (Map, fromList, lookup)
import Data.Maybe (isJust, isNothing, catMaybes)

            
GPipe-2.2.4
1 matches
src/Graphics/GPipe/Internal/Buffer.hs
import Control.Monad.Trans.Reader
import Control.Monad.Trans.Class (lift)
import Data.IORef
import Control.Applicative ((<$>))
import Linear.V4
import Linear.V3
import Linear.V2
import Linear.V1
import Linear.V0