Safe Haskell	None
Language	Haskell98

Knots.Prelude

Synopsis

Documentation

module Prelude.YAP

module Control.Applicative

module Control.Monad

module Data.Default

module Data.YAP.Algebra

module GHC.TypeLits

module Data.Foldable

module Data.List

module Data.Monoid

module Data.Traversable

type Ab a = (Default a, AbelianGroup a) Source

type AbDef a = (Default a, AbelianGroup a) Source

type AbEq a = (Eq a, AbelianGroup a) Source

assert :: Bool -> a -> a

If the first argument evaluates to True, then the result is the second argument. Otherwise an AssertionFailed exception is raised, containing a String with the source file and line number of the call to assert.

Assertions can normally be turned on or off with a compiler flag (for GHC, assertions are normally on unless optimisation is turned on with -O or the -fignore-asserts option is given). When assertions are turned off, the first argument to assert is ignored, and the second argument is returned as the result.

type DefEq a = (Eq a, Default a) Source

data F2 Source

Instances

Eq F2
Show F2
Default F2
NFData F2
AbelianGroup F2
Ring F2
Field F2

getArgs :: IO [String]

Computation getArgs returns a list of the program's command line arguments (not including the program name).

ifThenElse :: Bool -> a -> a -> a Source

Should be in scope when using the GHC extension RebindableSyntax

data IntMap a :: * -> *

A map of integers to values a.

Instances

Functor IntMap
Foldable IntMap
Traversable IntMap
Eq a => Eq (IntMap a)
Data a => Data (IntMap a)
Ord a => Ord (IntMap a)
Read e => Read (IntMap e)
Show a => Show (IntMap a)
Monoid (IntMap a)
Default (IntMap v)
NFData a => NFData (IntMap a)
Typeable (* -> *) IntMap

data Map k a :: * -> * -> *

A Map from keys k to values a.

Instances

Functor (Map k)
Foldable (Map k)
Traversable (Map k)
(Eq k, Eq a) => Eq (Map k a)
(Data k, Data a, Ord k) => Data (Map k a)
(Ord k, Ord v) => Ord (Map k v)
(Ord k, Read k, Read e) => Read (Map k e)
(Show k, Show a) => Show (Map k a)
Ord k => Monoid (Map k v)
Default (Map k v)
(NFData k, NFData a) => NFData (Map k a)
Typeable (* -> * -> *) Map

data Ordering :: *

Constructors

LT
EQ
GT

Instances

Bounded Ordering
Enum Ordering
Eq Ordering
Ord Ordering
Read Ordering
Show Ordering
Ix Ordering
Generic Ordering
Monoid Ordering
Default Ordering
type Rep Ordering = D1 D1Ordering ((:+:) (C1 C1_0Ordering U1) ((:+:) (C1 C1_1Ordering U1) (C1 C1_2Ordering U1)))
type (==) Ordering a b = EqOrdering a b

data Ratio a Source

Like the Ratio from the base package, but with a custom Show instance, and with some algebraic instances

Constructors

!a :% !a

Instances

(Eq a, EuclideanDomain a) => Eq (Ratio a)
(Ord a, EuclideanDomain a) => Ord (Ratio a)
(EuclideanDomain a, Eq a, Show a) => Show (Ratio a)
EuclideanDomain a => Default (Ratio a)
EuclideanDomain a => AbelianGroup (Ratio a)
EuclideanDomain a => Ring (Ratio a)
EuclideanDomain a => Field (Ratio a)

type Rational = Ratio Integer Source

type RingDef a = (Default a, Ring a) Source

type RingEq a = (Default a, Eq a, Ring a) Source

data Set a :: * -> *

A set of values a.

Instances

Foldable Set
Eq a => Eq (Set a)
(Data a, Ord a) => Data (Set a)
Ord a => Ord (Set a)
(Read a, Ord a) => Read (Set a)
Show a => Show (Set a)
Ord a => Monoid (Set a)
Default (Set v)
NFData a => NFData (Set a)
Typeable (* -> *) Set

sum :: AbelianGroup a => [a] -> a Source

Like Data.Foldable.sum, but for any instance of AbelianGroup

swap :: (a, b) -> (b, a)

Swap the components of a pair.

data Vector a :: * -> *

Boxed vectors, supporting efficient slicing.

Instances

Alternative Vector
Monad Vector
Functor Vector
MonadPlus Vector
Applicative Vector
Foldable Vector
Traversable Vector
Vector Vector a
IsList (Vector a)
Eq a => Eq (Vector a)
Data a => Data (Vector a)
Ord a => Ord (Vector a)
Read a => Read (Vector a)
Show a => Show (Vector a)
Monoid (Vector a)
NFData a => NFData (Vector a)
Typeable (* -> *) Vector
type Mutable Vector = MVector
type Item (Vector a) = a

xor :: Bool -> Bool -> Bool Source