Aelve Codesearch

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

total matches: more than 1000

Elm-0.13
25 matches
compiler/Elm/Internal/Documentation.hs
{-# LANGUAGE OverloadedStrings #-}
module Elm.Internal.Documentation where

import Control.Applicative ((<$>),(<*>))
import Control.Monad
import Data.Aeson

data Document = Doc
    { moduleName :: String

            
compiler/Generate/Cases.hs
{-# OPTIONS_GHC -W #-}
module Generate.Cases (toMatch, Match (..), Clause (..), matchSubst, newVar) where

import Control.Applicative ((<$>))
import Control.Arrow (first)
import Control.Monad.State (State)
import qualified Control.Monad.State as State
import Data.List (groupBy,sortBy)
import Data.Maybe (fromMaybe)

            
compiler/Generate/JavaScript.hs
{-# OPTIONS_GHC -W #-}
module Generate.JavaScript (generate) where

import Control.Applicative ((<$>),(<*>))
import Control.Arrow (first,(***))
import Control.Monad.State
import qualified Data.List as List
import qualified Data.Map as Map
import qualified Data.Set as Set

            
compiler/Parse/Binop.hs
{-# OPTIONS_GHC -W #-}
module Parse.Binop (binops, OpTable) where

import Control.Applicative ((<$>))
import qualified Data.List as List
import qualified Data.Map as Map

import AST.Annotation (merge)
import AST.Declaration (Assoc(..))

            
compiler/Parse/Declaration.hs
{-# OPTIONS_GHC -Wall -fno-warn-unused-do-bind #-}
module Parse.Declaration where

import Control.Applicative ((<$>))
import Text.Parsec hiding (newline,spaces)

import Parse.Helpers
import qualified Parse.Expression as Expr
import qualified Parse.Type as Type

            
compiler/Parse/Expression.hs
module Parse.Expression (def,term,typeAnnotation,expr) where

import Control.Applicative ((<$>), (<*>))
import Data.List (foldl')
import Text.Parsec hiding (newline,spaces)
import Text.Parsec.Indent

import Parse.Binop

            
compiler/Parse/Helpers.hs
module Parse.Helpers where

import Prelude hiding (until)
import Control.Applicative ((<$>),(<*>))
import Control.Monad
import Control.Monad.State
import Data.Char (isUpper)
import qualified Data.Map as Map
import qualified Language.GLSL.Parser as GLP

            
compiler/Parse/Literal.hs
{-# OPTIONS_GHC -W #-}
module Parse.Literal (literal) where

import Control.Applicative ((<$>))
import Text.Parsec hiding (newline,spaces)
import Parse.Helpers
import AST.Literal

literal :: IParser Literal

            
compiler/Parse/Module.hs
module Parse.Module (moduleDef, getModuleName, imports) where

import Control.Applicative ((<$>), (<*>))
import Data.List (intercalate)
import Text.Parsec hiding (newline,spaces)

import Parse.Helpers
import AST.Module (ImportMethod(..))

            
compiler/Parse/Parse.hs
{-# OPTIONS_GHC -W #-}
module Parse.Parse (program, dependencies) where

import Control.Applicative ((<$>), (<*>))
import qualified Data.List as List
import qualified Data.Map as Map
import Text.Parsec hiding (newline,spaces)
import qualified Text.PrettyPrint as P


            
compiler/Parse/Pattern.hs
{-# OPTIONS_GHC -W #-}
module Parse.Pattern (term, expr) where

import Control.Applicative ((<$>))
import Data.Char (isUpper)
import qualified Data.List as List
import Text.Parsec hiding (newline,spaces,State)

import Parse.Helpers

            
compiler/Parse/Type.hs
{-# OPTIONS_GHC -Wall -fno-warn-unused-do-bind #-}
module Parse.Type where

import Control.Applicative ((<$>),(<*>),(<*))
import Data.List (intercalate)
import Text.Parsec

import qualified AST.Type as T
import qualified AST.Variable as Var

            
compiler/Transform/Canonicalize/Type.hs
module Transform.Canonicalize.Type (tipe) where

import Control.Arrow (second)
import Control.Applicative ((<$>),(<*>))
import Control.Monad.Error
import qualified Data.Map as Map
import Data.Traversable (traverse)

import qualified AST.Type as T

            
compiler/Transform/Canonicalize.hs
{-# OPTIONS_GHC -W #-}
module Transform.Canonicalize (module') where

import Control.Applicative ((<$>),(<*>))
import Control.Monad.Error (runErrorT, throwError)
import Control.Monad.State (runState)
import qualified Data.List as List
import qualified Data.Map as Map
import qualified Data.Set as Set

            
compiler/Transform/Declaration.hs
{-# OPTIONS_GHC -Wall #-}
module Transform.Declaration (combineAnnotations, toExpr) where

import Control.Applicative ((<$>))

import qualified AST.Annotation as A
import qualified AST.Declaration as D
import qualified AST.Expression.General as E
import qualified AST.Expression.Source as Source

            
compiler/Transform/Definition.hs
{-# OPTIONS_GHC -Wall #-}
module Transform.Definition where

import Control.Applicative ((<$>))
import qualified AST.Pattern as P
import qualified AST.Expression.Source as Source
import qualified AST.Expression.Valid as Valid
import qualified Transform.Expression as Expr


            
compiler/Transform/Expression.hs
{-# OPTIONS_GHC -Wall #-}
module Transform.Expression (crawlLet, checkPorts) where

import Control.Applicative ((<$>),(<*>))
import AST.Annotation ( Annotated(A) )
import AST.Expression.General
import qualified AST.Expression.Canonical as Canonical
import AST.Type (Type, CanonicalType)


            
compiler/Transform/SortDefinitions.hs
module Transform.SortDefinitions (sortDefs) where

import Control.Monad.State
import Control.Applicative ((<$>),(<*>))
import qualified Data.Graph as Graph
import qualified Data.Map as Map
import qualified Data.Maybe as Maybe
import qualified Data.Set as Set


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

import Control.Applicative ((<$>))
import qualified Control.Monad as Monad
import Control.Monad.Error
import qualified Data.List as List
import qualified Data.Map as Map
import qualified Text.PrettyPrint as PP

            
compiler/Type/Constrain/Pattern.hs
module Type.Constrain.Pattern where

import Control.Arrow (second)
import Control.Applicative ((<$>))
import qualified Control.Monad as Monad
import Control.Monad.Error
import qualified Data.Map as Map
import qualified Text.PrettyPrint as PP


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

import Control.Applicative ((<$>), (<*>))
import Control.Exception (try, SomeException)
import Control.Monad
import Control.Monad.Error (ErrorT, throwError, liftIO)
import qualified Control.Monad.State as State
import qualified Data.Traversable as Traverse

            
compiler/Type/ExtraChecks.hs
-}
module Type.ExtraChecks (mainType, occurs, portTypes) where

import Control.Applicative ((<$>),(<*>))
import Control.Monad.Error
import Control.Monad.State
import qualified Data.Map as Map
import qualified Data.Traversable as Traverse
import qualified Data.UnionFind.IO as UF

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

import Control.Applicative ( (<$>), (<*>), Applicative, (<|>) )
import Control.Monad.State
import qualified Data.Map as Map
import qualified Data.Traversable as Traversable
import qualified Data.UnionFind.IO as UF


            
compiler/Type/Type.hs
import Type.PrettyPrint
import Text.PrettyPrint as P
import System.IO.Unsafe
import Control.Applicative ((<$>),(<*>))
import Control.Monad.State (StateT, get, put, execStateT, runStateT)
import Control.Monad.Error (ErrorT, Error, liftIO)
import Data.Traversable (traverse)
import AST.Annotation
import qualified AST.PrettyPrint as PP

            
tests/compiler/Tests/Property/Arbitrary.hs
{-# OPTIONS_GHC -W -fno-warn-orphans #-}
module Tests.Property.Arbitrary where

import Control.Applicative       ((<$>), (<*>), pure)
import Test.QuickCheck.Arbitrary
import Test.QuickCheck.Gen

import qualified Data.Set as Set
import qualified Parse.Helpers (reserveds)

            
Eq-1.1.3
3 matches
Language/Eq/Algorithm/Eval/Complex.hs
module Language.Eq.Algorithm.Eval.Complex( complexEvalRules ) where

{-import qualified Language.Eq.ErrorMessages as Err-}
import Control.Applicative( (<$>), (<*>) )
import Language.Eq.Types
import Language.Eq.Algorithm.Utils
import Language.Eq.Algorithm.Eval.Utils
import Language.Eq.Algorithm.Eval.Types


            
Language/Eq/InputParser/EqCode.hs
    ) where


import Control.Applicative( (<$>), (<*) )
{-import Data.Functor.Identity( Identity )-}

import Language.Eq.Types
import Language.Eq.Polynome
import Language.Eq.Linker

            
Language/Eq/Polynome.hs
                        ) where
import Data.Maybe( fromMaybe )
import Data.Ord( comparing )
import Control.Applicative( (<$>), (<*>) )
import Control.Arrow( (***), second )
import Control.Monad( join )
import Data.Either( partitionEithers )
import Data.List( sortBy, groupBy, foldl' )
import Data.Ratio

            
EtaMOO-0.3.0.0
2 matches
src/MOO/AST.hs

  ) where

import Control.Applicative ((<$>), (<*>), pure)
import Data.Typeable (Typeable)
import Data.Word (Word8)
import Database.VCache (VCacheable(put, get), VPut, VGet, putWord8)

import MOO.Types

            
src/MOO/Builtins/Crypt.hs

module MOO.Builtins.Crypt (crypt) where

import Control.Applicative ((<$>))
import Control.Concurrent.MVar (MVar, newMVar, takeMVar, putMVar)
import Control.Exception (bracket)
import Foreign (nullPtr)
import Foreign.C (CString, withCString, peekCString)
import System.IO.Unsafe (unsafePerformIO)