Aelve Codesearch

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

total matches: 111

ghcjs-base-0.2.0.0
1 matches
test/Tests/Properties.hs
import Test.QuickCheck.Property (Property(..))
import Test.Framework.Providers.HUnit (testCase)
import Test.HUnit ((@=?), Assertion)
import Text.Show.Functions ()
import qualified Control.Exception as Exception
import qualified Data.Bits as Bits (shiftL, shiftR)
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.List as L

            
gps-1.2
1 matches
Geo/Computations/Trail.hs
       , bezierPoint
         ) where

import Text.Show.Functions ()
import Geo.Computations.Basic
import Geo.Types

import Control.Arrow (first)
import Control.Monad

            
haskell-platform-test-2010.2.0.0
1 matches
Main.hs
import Text.Read
import Text.Read.Lex
import Text.Show
import Text.Show.Functions
import Unsafe.Coerce
import Data.ByteString
import Data.ByteString.Char8
import Data.ByteString.Unsafe
import Data.ByteString.Internal

            
hierarchical-clustering-0.4.6
1 matches
tests/runtests.hs
import Control.Monad (when, liftM2)
import Data.List (delete, sort, nub)
import Text.Printf (printf)
import Text.Show.Functions ()

-- from hspec
import Test.Hspec (hspec, describe, it, pendingWith, shouldBe, Spec)
import Test.Hspec.QuickCheck (prop)


            
hledger-ui-1.14.2
1 matches
Hledger/UI/UITypes.hs
import Brick.Widgets.List (List)
import Brick.Widgets.Edit (Editor)
import Lens.Micro.Platform
import Text.Show.Functions ()
  -- import the Show instance for functions. Warning, this also re-exports it

import Hledger
import Hledger.UI.UIOptions


            
hyena-0.1.0.1
1 matches
Hyena/Parser.hs
import Foreign.Ptr (Ptr, plusPtr)
import Foreign.Storable (peekByteOff)
import Prelude hiding (fail, rem, succ)
import Text.Show.Functions ()

-- ---------------------------------------------------------------------
-- The Parser type

-- | The parse state.

            
hylolib-1.5.3
1 matches
src/HyLo/Formula.hs

where

import Text.Show.Functions ()

import Control.Monad          ( liftM2 )

import Text.Read ( Read(..) )


            
hyperion-0.1.0.0
1 matches
src/Hyperion/Run.hs
import qualified System.Clock as Clock
import System.Random (RandomGen(..))
import qualified System.Random.Shuffle as SRS
import Text.Show.Functions ()

-- | Local private copy of 'StateT' to hang our otherwise orphan 'Monoid'
-- instance to. This instance is missing from transformers.
newtype StateT' s m a = StateT' { unStateT' :: StateT s m a }
  deriving (Functor, Applicative, Monad, MonadCatch, MonadMask, MonadThrow, MonadState s, MonadTrans)

            
json-0.9.3
1 matches
tests/QuickCheckUtils.hs

import Test.QuickCheck.Batch
import Test.QuickCheck
import Text.Show.Functions
import Data.Ratio

import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L
import qualified Data.Map as Map

            
leveldb-haskell-0.6.5
1 matches
test/Test/Streaming.hs
import           Test.Tasty
import           Test.Tasty.QuickCheck

import           Text.Show.Functions        () -- Show instance for a -> b

type Prop = Test.Tasty.QuickCheck.Property

data Range' = Range' S.Direction Char Char
    deriving Show

            
monoid-subclasses-0.4.6.1
1 matches
Test/TestMonoidSubclasses.hs
import Data.Sequence (Seq)
import Data.Set (Set)
import Data.Vector (Vector, fromList)
import Text.Show.Functions

import Data.Monoid.Instances.ByteString.UTF8 (ByteStringUTF8(ByteStringUTF8))
import Data.Monoid.Instances.Concat (Concat)
import qualified Data.Monoid.Instances.Concat as Concat
import Data.Monoid.Instances.Measured (Measured)

            
netrium-0.6.0
1 matches
src/Observable.hs
import Data.List (minimumBy)
import Data.Ord (comparing)
import Control.Monad
import Text.Show.Functions ()
import Text.XML.HaXml.Namespaces (localName)
import Text.XML.HaXml.XmlContent
  (XMLParser(), Element(..), Content(), element, interior, text, toText, mkElemC)

-- * Observable type definition

            
network-house-0.1.0.2
1 matches
Net/ARP_Protocol.hs
import qualified Net.IPv4 as IP
import Net.ARP as ARP
--import Net.PacketParsing
import Text.Show.Functions
import Net.Utils(doReq)
import Monad.Util(loop)

data Interface m
    = Interface {

            
permutation-0.5.0.5
1 matches
tests/Driver.hs
import System.Random
import Test.QuickCheck
import Text.Printf
import Text.Show.Functions


newtype Natural = Nat Int deriving (Eq,Show)
instance Arbitrary Natural where
    arbitrary = do

            
pg-store-0.5.0
1 matches
src/Database/PostgreSQL/Store/Types.hs
	Format
) where

import           Text.Show.Functions             ()

import qualified Data.ByteString                 as B

import           Database.PostgreSQL.Store.Tuple


            
postgresql-typed-0.6.0.1
1 matches
Database/PostgreSQL/Typed/Protocol.hs
import           System.IO.Error (IOError, mkIOError, eofErrorType, ioError, ioeSetErrorString)
import           System.IO.Unsafe (unsafeInterleaveIO)
import           Text.Read (readMaybe)
import           Text.Show.Functions ()

import Database.PostgreSQL.Typed.Types
import Database.PostgreSQL.Typed.Dynamic

data PGState

            
prologue-3.2.6
1 matches
src/Prologue.hs
import Text.Read                        as X (readPrec) -- new style Read class implementation
import Prologue.Text.Show               as X
import Prologue.Text.Show.Styled        as X
import Text.Show.Functions              as X ()
import Data.Void                        as X (Void, absurd)


-- === Monads === --
import Prologue.Control.Monad           as X

            
pure-priority-queue-tests-0.12
1 matches
Tests.hs
import Data.Monoid
import qualified Data.Set as S

import Text.Show.Functions ()
import Test.Framework (testGroup, Test, defaultMain)
import Test.Framework.Providers.QuickCheck2 (testProperty)
import Test.QuickCheck

import Prelude hiding (null, filter)

            
quickcheck-classes-0.6.2.2
1 matches
test/Spec.hs
import Data.Word
import Foreign.Storable
import Test.QuickCheck
import Text.Show.Functions

import qualified Data.Vector as V
import qualified Data.Foldable as F

import Test.QuickCheck.Classes

            
quickcheck-with-counterexamples-1.2
2 matches
examples/Set.hs

import Test.QuickCheck.Counterexamples

import Text.Show.Functions
import Data.List
  ( sort
  , group
  , nub
  , (\\)

            
examples/Set.hs

import Data.Maybe

--import Text.Show.Functions

--------------------------------------------------------------------------
-- binary search trees

data Set a

            
reactive-0.11.5
2 matches
src/FRP/Reactive/Fun.hs
#if __GLASGOW_HASKELL__ < 610
                     hiding (pure)
#endif
import Text.Show.Functions ()

import Control.Comonad

import Data.Zip (Zip(..))


            
src/FRP/Reactive/Improving.hs


import Data.Function (on)
import Text.Show.Functions ()
import Control.Applicative (pure,(<$>),liftA2)

import Data.Unamb (unamb,parCommute,pmin,pmax)

import Test.QuickCheck

            
rebase-1.3.1.1
1 matches
library/Rebase/Text/Show/Functions.hs
)
where

import Text.Show.Functions

            
rerebase-1.3.1.1
1 matches
library/Text/Show/Functions.hs
)
where

import Rebase.Text.Show.Functions

            
selective-0.3
1 matches
test/Laws.hs
import Data.Function
import Data.Functor.Identity
import Control.Monad.State
import Text.Show.Functions()

-- | TODO:
-- ifS (pure x) a1 b1 *> ifS (pure x) a2 b2 = ifS (pure x) (a1 *> a2) (b1 *> b2)

--------------------------------------------------------------------------------

            
sexpr-0.2.1
1 matches
Codec/Sexpr/Tests.hs
import Codec.Sexpr.Printer
import Test.QuickCheck
import Data.Monoid()
import Text.Show.Functions()
import qualified Data.Traversable as T
import qualified Data.Foldable as F
import Data.Char
import Data.Binary.Put
import qualified Data.ByteString.Char8 as B

            
storablevector-0.2.13
1 matches
tests/Test/Utility.hs
module Test.Utility where

import Test.QuickCheck (Property, (==>), )
import Text.Show.Functions ()

import Data.Word (Word8)
import Data.Int (Int64)

import qualified Data.ByteString      as P

            
stream-fusion-0.1.2.5
1 matches
tests/Properties/Utils.hs

import Test.QuickCheck
import Test.QuickCheck.Batch
import Text.Show.Functions

import Control.Monad (liftM,liftM5)

import qualified Data.Stream as S


            
target-0.2.0.1
1 matches
test/HOFs.hs
module HOFs where

import           Test.Target
import           Text.Show.Functions ()

{-@ foo :: (x:Int -> {v:Int | v > x}) -> {v:Int | v > 0} @-}
foo :: (Int -> Int) -> Int
foo f = f 0