Knots.Prelude

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)

type AbDef a = (Default a, AbelianGroup a)

type AbEq a = (Eq a, AbelianGroup a)

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.

castLabel :: L l a -> L l' a

type DefEq a = (Eq a, Default a)

data F2

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

Should be in scope when using the GHC extension RebindableSyntax

data IntMap a

A map of integers to values a.

Instances

Functor IntMap

Typeable1 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)

newtype L l a

A value with a label, with a Show instance that is suitable for monomials. a is then the index (multiindex, …) that describes the monomial.

Constructors

L

Fields

unL :: a

Instances

Enum a => Enum (L l a)

Eq a => Eq (L l a)

Ord a => Ord (L l a)

(Show a, SingI Symbol l) => Show (L l a)

(Num a, SingI Symbol l) => Num (L l a)

(Real a, SingI Symbol l) => Real (L l a)

(Integral a, SingI Symbol l) => Integral (L l a)

AbelianGroup a => AbelianGroup (L l a)

Ring a => Ring (L l a)

EuclideanDomain a => EuclideanDomain (L l a)

Field a => Field (L l a)

data Map k a

A Map from keys k to values a.

Instances

Typeable2 Map

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)

data Ordering

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Enum Ordering

Eq Ordering

Ord Ordering

Read Ordering

Show Ordering

Ix Ordering

Monoid Ordering

Default Ordering

data Ratio a

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

type RingDef a = (Default a, Ring a)

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

data Set a

A set of values a.

Instances

Typeable1 Set

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)

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

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

Monad Vector

Functor Vector

Typeable1 Vector

MonadPlus Vector

Applicative Vector

Foldable Vector

Traversable Vector

Alternative Vector

Vector 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)

xor :: Bool -> Bool -> Bool