Aelve Codesearch

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

total matches: more than 1000

GPipe-2.2.4
2 matches
src/Graphics/GPipe/Internal/Context.hs
import Control.Monad.Trans.Reader
import Control.Monad.IO.Class
import Control.Monad.Trans.Class
import Control.Applicative (Applicative, (<$>))
import Data.Typeable
import qualified Data.IntSet as Set
import qualified Data.IntMap.Strict as IMap
import Data.IntMap ((!))
import qualified Data.Map.Strict as Map

            
src/Graphics/GPipe/Internal/Expr.hs
import qualified Data.IntMap as Map
import Data.Boolean
import Data.List (intercalate)
import Control.Applicative ((<$>), liftA, liftA2, liftA3)
import Linear.V4
import Linear.V3
import Linear.V2
import Linear.V1
import Linear.V0

            
Gamgine-0.5.3
7 matches
Gamgine/Engine.hs
module Gamgine.Engine where
import Graphics.UI.GLFW (getTime)
import Control.Monad.State (MonadIO, liftIO)
import Control.Applicative ((<$>))
import Data.Maybe (fromMaybe)


mkUpdateLoop :: (MonadIO m) => Int -> Int -> m a -> (Double -> m (Double, Double))
mkUpdateLoop ticksPerSecond maxFrameSkip update = \nextFrame -> loop nextFrame 0

            
Gamgine/Font/GLF.hs
import Foreign.C.Types
import Foreign.C.String
import Foreign.Marshal.Alloc
import Control.Applicative ((<$>))


init :: IO ()
init = c_glfInit


            
Gamgine/Image/PNG/Internal/LBS.hs
import Data.Int (Int64)
import qualified Data.ByteString.Lazy as LB
import qualified Data.ByteString.Lazy.Char8 as C
import Control.Applicative ((<$>))

newtype LBS = LBS { unLBS :: LB.ByteString } deriving (Show)

instance (Monad m) => Stream LBS m Word8 where
    uncons = return . uncons'

            
Gamgine/Lens/IORef.hs
#include "Gamgine/Utils.cpp"
IMPORT_LENS_AS_LE

import Control.Applicative ((<$>))
import Control.Monad (void)
import qualified Control.Monad.State as ST
import qualified Data.IORef as R

type StateIORef a = ST.StateT (R.IORef a) IO 

            
Gamgine/Lens/State.hs
#include "Gamgine/Utils.cpp"
IMPORT_LENS_AS_LE

import Control.Applicative ((<$>))
import qualified Control.Monad.State as ST

-- | apply the getter lens on the value of the state 
getL :: Monad m => LE.Lens a b -> ST.StateT a m b
getL lens = ST.gets $ LE.getL lens

            
Gamgine/State/InputInfo.hs
import qualified Graphics.UI.GLFW as GLFW
import Gamgine.Control ((?))
import qualified Gamgine.Math.Vect as V
import Control.Applicative ((<$>), (<*>))

data Modifier = Ctrl | Alt | Shift deriving (Eq, Ord)

-- | mouse position in world coordinates
type MousePos = V.Vect

            
Gamgine/State/RenderState.hs

module Gamgine.State.RenderState where
#include "Gamgine/Utils.cpp"
import Control.Applicative ((<$>))
import qualified Data.List as L
import qualified Graphics.GL as GL
import qualified Gamgine.Font.GLF as GLF
IMPORT_LENS_AS_LE


            
GenI-0.25.0.1
12 matches
src/NLP/GenI/Configuration.hs
    )
where

import           Control.Applicative       (pure, (<$>))
import           Control.Arrow             (first)
import           Control.Monad
import qualified Data.ByteString.Char8     as BC
import           Data.Char                 (isSpace, toLower)
import           Data.List                 (find, intersperse, nubBy)

            
src/NLP/GenI/Console.hs
        RunAs(..), writeResults, getBatchDir
        ) where

import           Control.Applicative           (pure, (<$>))
import           Control.Monad
import           Control.Monad.Except
import qualified Data.ByteString               as B
import           Data.IORef                    (modifyIORef, readIORef)
import           Data.List                     (find, partition)

            
src/NLP/GenI/GeniVal/Internal.hs
-- | Gory details for 'NLP.GenI.GeniVal'
module NLP.GenI.GeniVal.Internal where

import           Control.Applicative ((<$>))
import           Control.Arrow       (first, second, (***))
import           Control.DeepSeq
import           Control.Monad.Except
import           Data.Binary
import           Data.Generics       (Data)

            
src/NLP/GenI/LexicalSelection.hs
module NLP.GenI.LexicalSelection
  where

import           Control.Applicative             ((<$>))
import           Control.Arrow                   ((***))
import           Control.Monad.Trans.Maybe
import           Control.Monad.Writer
import           Data.Function                   (on)
import           Data.List

            
src/NLP/GenI/Main.hs
{-# LANGUAGE CPP #-}
module NLP.GenI.Main where

import           Control.Applicative       ((<$>))
import           Data.IORef                (newIORef)
import           Data.Typeable             (Typeable)
import           Data.Version              (showVersion)
import           System.Environment        (getArgs, getProgName)


            
src/NLP/GenI/OptimalityTheory.hs
   )
 where

import           Control.Applicative ((<$>), (<*>))
import           Control.Arrow       (first)
import           Data.Char           (isSpace)
import           Data.Function       (on)
import           Data.List           (groupBy, nub, partition, sort, sortBy,
                                      unfoldr, (\\))

            
src/NLP/GenI/Parser.hs
) where


import           Control.Applicative       ((*>), (<$>), (<*), (<*>), pure)
import           Control.Monad             (liftM, when)
import qualified Data.ByteString           as B
import           Data.Functor.Identity     (Identity)
import qualified Data.Map                  as Map
import           Data.Monoid               ((<>))

            
src/NLP/GenI/Semantics.hs
-- | We use a flat semantics in GenI (bag of literals).
module NLP.GenI.Semantics where

import           Control.Applicative       ((<$>))
import           Control.Arrow             (first, (&&&), (***))
import           Control.DeepSeq
import           Control.Monad.Except
import           Data.Binary
import           Data.Data

            
src/NLP/GenI/Simple/SimpleBuilder.hs
   )
where

import           Control.Applicative        ((<$>))
import           Control.Arrow              (first)
import           Control.Monad              (liftM2, unless, when)
import           Control.Monad.State.Strict (execStateT, get, gets, modify, put,
                                             runState)
import           Data.Bits

            
src/NLP/GenI/Statistics.hs
    incrIntMetric, queryIntMetric,
) where

import Control.Applicative ( (<$>) )
import Control.Monad.State
import Data.Maybe (mapMaybe)
import Text.JSON

import Control.DeepSeq

            
src/NLP/GenI/Tag.hs
   collect, detectSites,
) where

import           Control.Applicative       ((<$>), (<*>))
import qualified Data.Map                  as Map
import           Data.Maybe                (catMaybes, fromMaybe, listToMaybe,
                                            mapMaybe)
import           Data.Text                 (Text)
import qualified Data.Text                 as T

            
src/NLP/GenI.hs
             )
where

import           Control.Applicative       ((<$>), (<*>))
import           Control.DeepSeq
import           Control.Exception
import           Control.Monad.Except
import           Data.Binary               (Binary, decodeFile)
import qualified Data.ByteString           as BS

            
GenussFold-0.0.0.2
1 matches
src/GenussFold.hs

module Main where

import Control.Applicative ( (<$>) )
import Control.Monad (forM_)
import System.Console.CmdArgs
import Text.Printf

import BioInf.GenussFold

            
GraphHammer-0.3
1 matches
src/GraphHammer/IntMap.hs
import Data.Maybe (fromMaybe)
import Data.Foldable (Foldable(foldMap))
import Data.Traversable (Traversable(traverse))
import Control.Applicative (Applicative(pure,(<*>)),(<$>))
import Control.Monad ( liftM )
import Data.Int
import Data.Word
{-
-- just for testing

            
GtkGLTV-0.2.0
2 matches
src/Interface/TV/Gtk/GL.hs
  ) where


import Control.Applicative ((<$>))
import Data.IORef

import Graphics.UI.Gtk hiding (Action)

import Graphics.UI.Gtk.OpenGL

            
src/Interface/TV/Gtk/GL2.hs
  , renderOut, emptyTexture, textureIsEmpty, textureIn
  ) where

import Control.Applicative ((<$>))
import Data.IORef

import Graphics.UI.Gtk hiding (Action)

import Graphics.UI.Gtk.OpenGL

            
GtkTV-0.2.0
2 matches
src/Interface/TV/Gtk.hs
  , MkI, MkI', MkO, MkO', primMkI, primMkO, forget, forget2
  ) where

import Control.Applicative (liftA2,(<$>),(<*>),(<$))
import Control.Monad (when)
import Data.IORef
import Data.Maybe (fromMaybe)

import Data.Time (getCurrentTime,utctDayTime)

            
src/Interface/TV/Gtk2.hs
  , MkI, MkI', MkO, MkO', primMkI, primMkO, forget, forget2
  ) where

import Control.Applicative (liftA2,(<$>),(<*>),(<$))
import Control.Monad (when,join)
import Data.IORef
import Data.Maybe (fromMaybe)

import Data.Time (getCurrentTime,utctDayTime)

            
HLogger-0.0.1.0
1 matches
HLogger.hs
               , logEmergency
               , HLoggerState ) where

import Control.Applicative ((<$>))
import Control.Concurrent (forkIO)
import Control.Concurrent.Chan (Chan, newChan, readChan, writeChan)
import Data.Time.Clock (getCurrentTime)
import Data.Time.Format (formatTime)
import System.IO (Handle, IOMode (WriteMode), hClose, hFlush, hPutStrLn,

            
HPi-0.5.1
1 matches
System/RaspberryPi/GPIO.hs
-- FFI wrapper over the I2C portions of the BCM2835 library by Mike McCauley, also some utility functions to
-- make reading and writing simpler

import Control.Applicative ((<$>))
import Control.Exception
import Foreign
import Foreign.C
import Foreign.C.String
import qualified Data.ByteString as BS

            
HStringTemplate-0.8.7
1 matches
Text/StringTemplate/Base.hs
type TmplParser = GenParser Char ((Char, Char),[String],[String],[String])

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

(|.) :: (t1 -> t2) -> (t -> t1) -> t -> t2
(|.) f g = f . g
infixr 3 |.