-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | A compiler front-end generator. -- -- The BNF Converter is a compiler construction tool generating a -- compiler front-end from a Labelled BNF grammar. It was originally -- written to generate Haskell, but starting from Version 2.0, it can -- also be used for generating Java, C++, and C. -- -- Given a Labelled BNF grammar the tool produces: an abstract syntax as -- a HaskellC++C module or Java directory, a case skeleton for the -- abstract syntax in the same language, an Alex, JLex, or Flex lexer -- generator file, a Happy, CUP, or Bison parser generator file, a -- pretty-printer as a HaskellJavaC++/C module, a Latex file -- containing a readable specification of the language. @package BNFC @version 2.7.0.2 module Data.Pair data Pair a (:/:) :: a -> a -> Pair a [leftOf] :: Pair a -> a [rightOf] :: Pair a -> a infixl 2 :/: instance GHC.Show.Show a => GHC.Show.Show (Data.Pair.Pair a) instance GHC.Base.Functor Data.Pair.Pair instance GHC.Base.Applicative Data.Pair.Pair module Algebra.RingUtils -- | Append two lists, i.e., -- --

--   [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
--   [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--

-- -- If the first list is not finite, the result is the first list. (++) :: [a] -> [a] -> [a] infixr 5 ++ -- | The value of seq a b is bottom if a is bottom, and -- otherwise equal to b. In other words, it evaluates the first -- argument a to weak head normal form (WHNF). seq is -- usually introduced to improve performance by avoiding unneeded -- laziness. -- -- A note on evaluation order: the expression seq a b does -- not guarantee that a will be evaluated before -- b. The only guarantee given by seq is that the both -- a and b will be evaluated before seq -- returns a value. In particular, this means that b may be -- evaluated before a. If you need to guarantee a specific order -- of evaluation, you must use the function pseq from the -- "parallel" package. seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0 `seq` -- | <math>. filter, applied to a predicate and a list, -- returns the list of those elements that satisfy the predicate; i.e., -- --

--   filter p xs = [ x | x <- xs, p x]
--

-- --

--   >>> filter odd [1, 2, 3]
--   [1,3]
--

filter :: (a -> Bool) -> [a] -> [a] -- | <math>. zip takes two lists and returns a list of -- corresponding pairs. -- --

--   >>> zip [1, 2] ['a', 'b']
--   [(1,'a'),(2,'b')]
--

-- -- If one input list is shorter than the other, excess elements of the -- longer list are discarded, even if one of the lists is infinite: -- --

--   >>> zip [1] ['a', 'b']
--   [(1,'a')]
--   
--   >>> zip [1, 2] ['a']
--   [(1,'a')]
--   
--   >>> zip [] [1..]
--   []
--   
--   >>> zip [1..] []
--   []
--

-- -- zip is right-lazy: -- --

--   >>> zip [] undefined
--   []
--   
--   >>> zip undefined []
--   *** Exception: Prelude.undefined
--   ...
--

-- -- zip is capable of list fusion, but it is restricted to its -- first list argument and its resulting list. zip :: [a] -> [b] -> [(a, b)] -- | The print function outputs a value of any printable type to the -- standard output device. Printable types are those that are instances -- of class Show; print converts values to strings for -- output using the show operation and adds a newline. -- -- For example, a program to print the first 20 integers and their powers -- of 2 could be written as: -- --

--   main = print ([(n, 2^n) | n <- [0..19]])
--

print :: Show a => a -> IO () -- | Extract the first component of a pair. fst :: (a, b) -> a -- | Extract the second component of a pair. snd :: (a, b) -> b -- | otherwise is defined as the value True. It helps to make -- guards more readable. eg. -- --

--   f x | x < 0     = ...
--       | otherwise = ...
--

otherwise :: Bool -- | <math>. map f xs is the list obtained by -- applying f to each element of xs, i.e., -- --

--   map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
--   map f [x1, x2, ...] == [f x1, f x2, ...]
--

-- --

--   >>> map (+1) [1, 2, 3]
--   [2,3,4]
--

map :: (a -> b) -> [a] -> [b] -- | Application operator. This operator is redundant, since ordinary -- application (f x) means the same as (f $ x). -- However, $ has low, right-associative binding precedence, so it -- sometimes allows parentheses to be omitted; for example: -- --

--   f $ g $ h x  =  f (g (h x))
--

-- -- It is also useful in higher-order situations, such as map -- ($ 0) xs, or zipWith ($) fs xs. -- -- Note that ($) is levity-polymorphic in its result -- type, so that foo $ True where foo :: Bool -> -- Int# is well-typed. ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 $ -- | general coercion from integral types fromIntegral :: (Integral a, Num b) => a -> b -- | general coercion to fractional types realToFrac :: (Real a, Fractional b) => a -> b -- | The Bounded class is used to name the upper and lower limits of -- a type. Ord is not a superclass of Bounded since types -- that are not totally ordered may also have upper and lower bounds. -- -- The Bounded class may be derived for any enumeration type; -- minBound is the first constructor listed in the data -- declaration and maxBound is the last. Bounded may also -- be derived for single-constructor datatypes whose constituent types -- are in Bounded. class Bounded a minBound :: Bounded a => a maxBound :: Bounded a => a -- | Class Enum defines operations on sequentially ordered types. -- -- The enumFrom... methods are used in Haskell's translation of -- arithmetic sequences. -- -- Instances of Enum may be derived for any enumeration type -- (types whose constructors have no fields). The nullary constructors -- are assumed to be numbered left-to-right by fromEnum from -- 0 through n-1. See Chapter 10 of the Haskell -- Report for more details. -- -- For any type that is an instance of class Bounded as well as -- Enum, the following should hold: -- --

The calls succ maxBound and pred -- minBound should result in a runtime error.
fromEnum and toEnum should give a runtime error if -- the result value is not representable in the result type. For example, -- toEnum 7 :: Bool is an error.
enumFrom and enumFromThen should be defined with an -- implicit bound, thus:

-- --

--   enumFrom     x   = enumFromTo     x maxBound
--   enumFromThen x y = enumFromThenTo x y bound
--     where
--       bound | fromEnum y >= fromEnum x = maxBound
--             | otherwise                = minBound
--

class Enum a -- | the successor of a value. For numeric types, succ adds 1. succ :: Enum a => a -> a -- | the predecessor of a value. For numeric types, pred subtracts -- 1. pred :: Enum a => a -> a -- | Convert from an Int. toEnum :: Enum a => Int -> a -- | Convert to an Int. It is implementation-dependent what -- fromEnum returns when applied to a value that is too large to -- fit in an Int. fromEnum :: Enum a => a -> Int -- | Used in Haskell's translation of [n..] with [n..] = -- enumFrom n, a possible implementation being enumFrom n = n : -- enumFrom (succ n). For example: -- --

```
enumFrom 4 :: [Integer] = [4,5,6,7,...]
```

enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
--   Int]

enumFrom :: Enum a => a -> [a] -- | Used in Haskell's translation of [n,n'..] with [n,n'..] = -- enumFromThen n n', a possible implementation being -- enumFromThen n n' = n : n' : worker (f x) (f x n'), -- worker s v = v : worker s (s v), x = fromEnum n' - -- fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n < -- 0 = f (n + 1) (pred y) | otherwise = y For example: -- --

enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound ::
--   Int]

enumFromThen :: Enum a => a -> a -> [a] -- | Used in Haskell's translation of [n..m] with [n..m] = -- enumFromTo n m, a possible implementation being enumFromTo n -- m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For -- example: -- --

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

enumFromTo :: Enum a => a -> a -> [a] -- | Used in Haskell's translation of [n,n'..m] with [n,n'..m] -- = enumFromThenTo n n' m, a possible implementation being -- enumFromThenTo n n' m = worker (f x) (c x) n m, x = -- fromEnum n' - fromEnum n, c x = bool (>=) ((x -- 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + -- 1) (pred y) | otherwise = y and worker s c v m | c v m = v : -- worker s c (s v) m | otherwise = [] For example: -- --

enumFromThenTo 4 2 -6 :: [Integer] =
--   [4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

enumFromThenTo :: Enum a => a -> a -> a -> [a] -- | The Eq class defines equality (==) and inequality -- (/=). All the basic datatypes exported by the Prelude -- are instances of Eq, and Eq may be derived for any -- datatype whose constituents are also instances of Eq. -- -- The Haskell Report defines no laws for Eq. However, instances -- are encouraged to follow these properties: -- --

Reflexivity x == x = True
Symmetry x == y = y == x
Transitivity if x == y && y == z = -- True, then x == z = True
Extensionality if x == y = True and -- f is a function whose return type is an instance of -- Eq, then f x == f y = True
Negation x /= y = not (x == -- y)

-- -- Minimal complete definition: either == or /=. class Eq a (==) :: Eq a => a -> a -> Bool (/=) :: Eq a => a -> a -> Bool infix 4 == infix 4 /= -- | Trigonometric and hyperbolic functions and related functions. -- -- The Haskell Report defines no laws for Floating. However, -- (+), (*) and exp are -- customarily expected to define an exponential field and have the -- following properties: -- --

exp (a + b) = exp a * exp b
exp (fromInteger 0) = fromInteger 1

class Fractional a => Floating a pi :: Floating a => a exp :: Floating a => a -> a log :: Floating a => a -> a sqrt :: Floating a => a -> a (**) :: Floating a => a -> a -> a logBase :: Floating a => a -> a -> a sin :: Floating a => a -> a cos :: Floating a => a -> a tan :: Floating a => a -> a asin :: Floating a => a -> a acos :: Floating a => a -> a atan :: Floating a => a -> a sinh :: Floating a => a -> a cosh :: Floating a => a -> a tanh :: Floating a => a -> a asinh :: Floating a => a -> a acosh :: Floating a => a -> a atanh :: Floating a => a -> a infixr 8 ** -- | Fractional numbers, supporting real division. -- -- The Haskell Report defines no laws for Fractional. However, -- (+) and (*) are customarily expected -- to define a division ring and have the following properties: -- --

recip gives the multiplicative inverse x -- * recip x = recip x * x = fromInteger 1

-- -- Note that it isn't customarily expected that a type instance of -- Fractional implement a field. However, all instances in -- base do. class Num a => Fractional a -- | Fractional division. (/) :: Fractional a => a -> a -> a -- | Reciprocal fraction. recip :: Fractional a => a -> a -- | Conversion from a Rational (that is Ratio -- Integer). A floating literal stands for an application of -- fromRational to a value of type Rational, so such -- literals have type (Fractional a) => a. fromRational :: Fractional a => Rational -> a infixl 7 / -- | Integral numbers, supporting integer division. -- -- The Haskell Report defines no laws for Integral. However, -- Integral instances are customarily expected to define a -- Euclidean domain and have the following properties for the -- div/mod and quot/rem pairs, given suitable -- Euclidean functions f and g: -- --

x = y * quot x y + rem x y with rem x y -- = fromInteger 0 or g (rem x y) < g -- y
x = y * div x y + mod x y with mod x y -- = fromInteger 0 or f (mod x y) < f -- y

-- -- An example of a suitable Euclidean function, for Integer's -- instance, is abs. class (Real a, Enum a) => Integral a -- | integer division truncated toward zero quot :: Integral a => a -> a -> a -- | integer remainder, satisfying -- --

--   (x `quot` y)*y + (x `rem` y) == x
--

rem :: Integral a => a -> a -> a -- | integer division truncated toward negative infinity div :: Integral a => a -> a -> a -- | integer modulus, satisfying -- --

--   (x `div` y)*y + (x `mod` y) == x
--

mod :: Integral a => a -> a -> a -- | simultaneous quot and rem quotRem :: Integral a => a -> a -> (a, a) -- | simultaneous div and mod divMod :: Integral a => a -> a -> (a, a) -- | conversion to Integer toInteger :: Integral a => a -> Integer infixl 7 `rem` infixl 7 `quot` infixl 7 `mod` infixl 7 `div` -- | The Monad class defines the basic operations over a -- monad, a concept from a branch of mathematics known as -- category theory. From the perspective of a Haskell programmer, -- however, it is best to think of a monad as an abstract datatype -- of actions. Haskell's do expressions provide a convenient -- syntax for writing monadic expressions. -- -- Instances of Monad should satisfy the following: -- --

Left identity return a >>= k = k -- a
Right identity m >>= return = -- m
Associativity m >>= (\x -> k x -- >>= h) = (m >>= k) >>= -- h

-- -- Furthermore, the Monad and Applicative operations should -- relate as follows: -- --

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2
--   >>= (x2 -> return (x1 x2)))

-- -- The above laws imply: -- --

```
fmap f xs = xs >>= return .
--   f
```
```
(>>) = (*>)
```

-- -- and that pure and (<*>) satisfy the applicative -- functor laws. -- -- The instances of Monad for lists, Maybe and IO -- defined in the Prelude satisfy these laws. class Applicative m => Monad (m :: Type -> Type) -- | Sequentially compose two actions, passing any value produced by the -- first as an argument to the second. -- -- 'as >>= bs' can be understood as the do -- expression -- --

--   do a <- as
--      bs a
--

(>>=) :: Monad m => m a -> (a -> m b) -> m b -- | Sequentially compose two actions, discarding any value produced by the -- first, like sequencing operators (such as the semicolon) in imperative -- languages. -- -- 'as >> bs' can be understood as the do -- expression -- --

--   do as
--      bs
--

(>>) :: Monad m => m a -> m b -> m b -- | Inject a value into the monadic type. return :: Monad m => a -> m a infixl 1 >> infixl 1 >>= -- | A type f is a Functor if it provides a function fmap -- which, given any types a and b lets you apply any -- function from (a -> b) to turn an f a into an -- f b, preserving the structure of f. Furthermore -- f needs to adhere to the following: -- --

Identity fmap id == id
Composition fmap (f . g) == fmap f . -- fmap g

-- -- Note, that the second law follows from the free theorem of the type -- fmap and the first law, so you need only check that the former -- condition holds. class Functor (f :: Type -> Type) -- | fmap is used to apply a function of type (a -> b) -- to a value of type f a, where f is a functor, to produce a -- value of type f b. Note that for any type constructor with -- more than one parameter (e.g., Either), only the last type -- parameter can be modified with fmap (e.g., b in -- `Either a b`). -- -- Some type constructors with two parameters or more have a -- Bifunctor instance that allows both the last and the -- penultimate parameters to be mapped over. -- --

Examples

-- -- Convert from a Maybe Int to a Maybe String -- using show: -- --

--   >>> fmap show Nothing
--   Nothing
--   
--   >>> fmap show (Just 3)
--   Just "3"
--

-- -- Convert from an Either Int Int to an Either Int -- String using show: -- --

--   >>> fmap show (Left 17)
--   Left 17
--   
--   >>> fmap show (Right 17)
--   Right "17"
--

-- -- Double each element of a list: -- --

--   >>> fmap (*2) [1,2,3]
--   [2,4,6]
--

-- -- Apply even to the second element of a pair: -- --

--   >>> fmap even (2,2)
--   (2,True)
--

-- -- It may seem surprising that the function is only applied to the last -- element of the tuple compared to the list example above which applies -- it to every element in the list. To understand, remember that tuples -- are type constructors with multiple type parameters: a tuple of 3 -- elements (a,b,c) can also be written (,,) a b c and -- its Functor instance is defined for Functor ((,,) a -- b) (i.e., only the third parameter is free to be mapped over with -- fmap). -- -- It explains why fmap can be used with tuples containing -- values of different types as in the following example: -- --

--   >>> fmap even ("hello", 1.0, 4)
--   ("hello",1.0,True)
--

fmap :: Functor f => (a -> b) -> f a -> f b -- | Replace all locations in the input with the same value. The default -- definition is fmap . const, but this may be -- overridden with a more efficient version. (<$) :: Functor f => a -> f b -> f a infixl 4 <$ -- | Basic numeric class. -- -- The Haskell Report defines no laws for Num. However, -- (+) and (*) are customarily expected -- to define a ring and have the following properties: -- --

Associativity of (+) (x + y) + -- z = x + (y + z)
Commutativity of (+) x + y -- = y + x
fromInteger 0 is the additive -- identity x + fromInteger 0 = x
negate gives the additive inverse x + -- negate x = fromInteger 0
Associativity of (*) (x * y) * -- z = x * (y * z)
fromInteger 1 is the multiplicative -- identity x * fromInteger 1 = x and -- fromInteger 1 * x = x
Distributivity of (*) with respect to -- (+) a * (b + c) = (a * b) + (a * -- c) and (b + c) * a = (b * a) + (c * a)

-- -- Note that it isn't customarily expected that a type instance of -- both Num and Ord implement an ordered ring. Indeed, in -- base only Integer and Rational do. class Num a (-) :: Num a => a -> a -> a -- | Unary negation. negate :: Num a => a -> a -- | Absolute value. abs :: Num a => a -> a -- | Sign of a number. The functions abs and signum should -- satisfy the law: -- --

--   abs x * signum x == x
--

-- -- For real numbers, the signum is either -1 (negative), -- 0 (zero) or 1 (positive). signum :: Num a => a -> a -- | Conversion from an Integer. An integer literal represents the -- application of the function fromInteger to the appropriate -- value of type Integer, so such literals have type -- (Num a) => a. fromInteger :: Num a => Integer -> a infixl 6 - -- | The Ord class is used for totally ordered datatypes. -- -- Instances of Ord can be derived for any user-defined datatype -- whose constituent types are in Ord. The declared order of the -- constructors in the data declaration determines the ordering in -- derived Ord instances. The Ordering datatype allows a -- single comparison to determine the precise ordering of two objects. -- -- Ord, as defined by the Haskell report, implements a total order -- and has the following properties: -- --

Comparability x <= y || y <= x = -- True
Transitivity if x <= y && y <= -- z = True, then x <= z = True
Reflexivity x <= x = True
Antisymmetry if x <= y && y <= -- x = True, then x == y = True

-- -- The following operator interactions are expected to hold: -- --

x >= y = y <= x
x < y = x <= y && x /= y
x > y = y < x
x < y = compare x y == LT
x > y = compare x y == GT
x == y = compare x y == EQ
min x y == if x <= y then x else y = True
max x y == if x >= y then x else y = True

-- -- Note that (7.) and (8.) do not require min and -- max to return either of their arguments. The result is merely -- required to equal one of the arguments in terms of (==). -- -- Minimal complete definition: either compare or <=. -- Using compare can be more efficient for complex types. class Eq a => Ord a compare :: Ord a => a -> a -> Ordering (<) :: Ord a => a -> a -> Bool (<=) :: Ord a => a -> a -> Bool (>) :: Ord a => a -> a -> Bool (>=) :: Ord a => a -> a -> Bool max :: Ord a => a -> a -> a min :: Ord a => a -> a -> a infix 4 < infix 4 <= infix 4 > infix 4 >= -- | Parsing of Strings, producing values. -- -- Derived instances of Read make the following assumptions, which -- derived instances of Show obey: -- --

If the constructor is defined to be an infix operator, then the -- derived Read instance will parse only infix applications of the -- constructor (not the prefix form).
Associativity is not used to reduce the occurrence of parentheses, -- although precedence may be.
If the constructor is defined using record syntax, the derived -- Read will parse only the record-syntax form, and furthermore, -- the fields must be given in the same order as the original -- declaration.
The derived Read instance allows arbitrary Haskell -- whitespace between tokens of the input string. Extra parentheses are -- also allowed.

-- -- For example, given the declarations -- --

--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--

-- -- the derived instance of Read in Haskell 2010 is equivalent to -- --

--   instance (Read a) => Read (Tree a) where
--   
--           readsPrec d r =  readParen (d > app_prec)
--                            (\r -> [(Leaf m,t) |
--                                    ("Leaf",s) <- lex r,
--                                    (m,t) <- readsPrec (app_prec+1) s]) r
--   
--                         ++ readParen (d > up_prec)
--                            (\r -> [(u:^:v,w) |
--                                    (u,s) <- readsPrec (up_prec+1) r,
--                                    (":^:",t) <- lex s,
--                                    (v,w) <- readsPrec (up_prec+1) t]) r
--   
--             where app_prec = 10
--                   up_prec = 5
--

-- -- Note that right-associativity of :^: is unused. -- -- The derived instance in GHC is equivalent to -- --

--   instance (Read a) => Read (Tree a) where
--   
--           readPrec = parens $ (prec app_prec $ do
--                                    Ident "Leaf" <- lexP
--                                    m <- step readPrec
--                                    return (Leaf m))
--   
--                        +++ (prec up_prec $ do
--                                    u <- step readPrec
--                                    Symbol ":^:" <- lexP
--                                    v <- step readPrec
--                                    return (u :^: v))
--   
--             where app_prec = 10
--                   up_prec = 5
--   
--           readListPrec = readListPrecDefault
--

-- -- Why do both readsPrec and readPrec exist, and why does -- GHC opt to implement readPrec in derived Read instances -- instead of readsPrec? The reason is that readsPrec is -- based on the ReadS type, and although ReadS is mentioned -- in the Haskell 2010 Report, it is not a very efficient parser data -- structure. -- -- readPrec, on the other hand, is based on a much more efficient -- ReadPrec datatype (a.k.a "new-style parsers"), but its -- definition relies on the use of the RankNTypes language -- extension. Therefore, readPrec (and its cousin, -- readListPrec) are marked as GHC-only. Nevertheless, it is -- recommended to use readPrec instead of readsPrec -- whenever possible for the efficiency improvements it brings. -- -- As mentioned above, derived Read instances in GHC will -- implement readPrec instead of readsPrec. The default -- implementations of readsPrec (and its cousin, readList) -- will simply use readPrec under the hood. If you are writing a -- Read instance by hand, it is recommended to write it like so: -- --

--   instance Read T where
--     readPrec     = ...
--     readListPrec = readListPrecDefault
--

class Read a -- | attempts to parse a value from the front of the string, returning a -- list of (parsed value, remaining string) pairs. If there is no -- successful parse, the returned list is empty. -- -- Derived instances of Read and Show satisfy the -- following: -- --

(x,"") is an element of (readsPrec d -- (showsPrec d x "")).

-- -- That is, readsPrec parses the string produced by -- showsPrec, and delivers the value that showsPrec started -- with. readsPrec :: Read a => Int -> ReadS a -- | The method readList is provided to allow the programmer to give -- a specialised way of parsing lists of values. For example, this is -- used by the predefined Read instance of the Char type, -- where values of type String should be are expected to use -- double quotes, rather than square brackets. readList :: Read a => ReadS [a] class (Num a, Ord a) => Real a -- | the rational equivalent of its real argument with full precision toRational :: Real a => a -> Rational -- | Efficient, machine-independent access to the components of a -- floating-point number. class (RealFrac a, Floating a) => RealFloat a -- | a constant function, returning the radix of the representation (often -- 2) floatRadix :: RealFloat a => a -> Integer -- | a constant function, returning the number of digits of -- floatRadix in the significand floatDigits :: RealFloat a => a -> Int -- | a constant function, returning the lowest and highest values the -- exponent may assume floatRange :: RealFloat a => a -> (Int, Int) -- | The function decodeFloat applied to a real floating-point -- number returns the significand expressed as an Integer and an -- appropriately scaled exponent (an Int). If -- decodeFloat x yields (m,n), then x -- is equal in value to m*b^^n, where b is the -- floating-point radix, and furthermore, either m and -- n are both zero or else b^(d-1) <= abs m < -- b^d, where d is the value of floatDigits -- x. In particular, decodeFloat 0 = (0,0). If the -- type contains a negative zero, also decodeFloat (-0.0) = -- (0,0). The result of decodeFloat x is -- unspecified if either of isNaN x or -- isInfinite x is True. decodeFloat :: RealFloat a => a -> (Integer, Int) -- | encodeFloat performs the inverse of decodeFloat in the -- sense that for finite x with the exception of -0.0, -- uncurry encodeFloat (decodeFloat x) = x. -- encodeFloat m n is one of the two closest -- representable floating-point numbers to m*b^^n (or -- ±Infinity if overflow occurs); usually the closer, but if -- m contains too many bits, the result may be rounded in the -- wrong direction. encodeFloat :: RealFloat a => Integer -> Int -> a -- | exponent corresponds to the second component of -- decodeFloat. exponent 0 = 0 and for finite -- nonzero x, exponent x = snd (decodeFloat x) -- + floatDigits x. If x is a finite floating-point -- number, it is equal in value to significand x * b ^^ -- exponent x, where b is the floating-point radix. -- The behaviour is unspecified on infinite or NaN values. exponent :: RealFloat a => a -> Int -- | The first component of decodeFloat, scaled to lie in the open -- interval (-1,1), either 0.0 or of absolute -- value >= 1/b, where b is the floating-point -- radix. The behaviour is unspecified on infinite or NaN -- values. significand :: RealFloat a => a -> a -- | multiplies a floating-point number by an integer power of the radix scaleFloat :: RealFloat a => Int -> a -> a -- | True if the argument is an IEEE "not-a-number" (NaN) value isNaN :: RealFloat a => a -> Bool -- | True if the argument is an IEEE infinity or negative infinity isInfinite :: RealFloat a => a -> Bool -- | True if the argument is too small to be represented in -- normalized format isDenormalized :: RealFloat a => a -> Bool -- | True if the argument is an IEEE negative zero isNegativeZero :: RealFloat a => a -> Bool -- | True if the argument is an IEEE floating point number isIEEE :: RealFloat a => a -> Bool -- | a version of arctangent taking two real floating-point arguments. For -- real floating x and y, atan2 y x -- computes the angle (from the positive x-axis) of the vector from the -- origin to the point (x,y). atan2 y x returns -- a value in the range [-pi, pi]. It follows the -- Common Lisp semantics for the origin when signed zeroes are supported. -- atan2 y 1, with y in a type that is -- RealFloat, should return the same value as atan -- y. A default definition of atan2 is provided, but -- implementors can provide a more accurate implementation. atan2 :: RealFloat a => a -> a -> a -- | Extracting components of fractions. class (Real a, Fractional a) => RealFrac a -- | The function properFraction takes a real fractional number -- x and returns a pair (n,f) such that x = -- n+f, and: -- --

n is an integral number with the same sign as x; -- and
f is a fraction with the same type and sign as -- x, and with absolute value less than 1.

-- -- The default definitions of the ceiling, floor, -- truncate and round functions are in terms of -- properFraction. properFraction :: (RealFrac a, Integral b) => a -> (b, a) -- | truncate x returns the integer nearest x -- between zero and x truncate :: (RealFrac a, Integral b) => a -> b -- | round x returns the nearest integer to x; the -- even integer if x is equidistant between two integers round :: (RealFrac a, Integral b) => a -> b -- | ceiling x returns the least integer not less than -- x ceiling :: (RealFrac a, Integral b) => a -> b -- | floor x returns the greatest integer not greater than -- x floor :: (RealFrac a, Integral b) => a -> b -- | Conversion of values to readable Strings. -- -- Derived instances of Show have the following properties, which -- are compatible with derived instances of Read: -- --

The result of show is a syntactically correct Haskell -- expression containing only constants, given the fixity declarations in -- force at the point where the type is declared. It contains only the -- constructor names defined in the data type, parentheses, and spaces. -- When labelled constructor fields are used, braces, commas, field -- names, and equal signs are also used.
If the constructor is defined to be an infix operator, then -- showsPrec will produce infix applications of the -- constructor.
the representation will be enclosed in parentheses if the -- precedence of the top-level constructor in x is less than -- d (associativity is ignored). Thus, if d is -- 0 then the result is never surrounded in parentheses; if -- d is 11 it is always surrounded in parentheses, -- unless it is an atomic expression.
If the constructor is defined using record syntax, then -- show will produce the record-syntax form, with the fields given -- in the same order as the original declaration.

-- -- For example, given the declarations -- --

--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--

-- -- the derived instance of Show is equivalent to -- --

--   instance (Show a) => Show (Tree a) where
--   
--          showsPrec d (Leaf m) = showParen (d > app_prec) $
--               showString "Leaf " . showsPrec (app_prec+1) m
--            where app_prec = 10
--   
--          showsPrec d (u :^: v) = showParen (d > up_prec) $
--               showsPrec (up_prec+1) u .
--               showString " :^: "      .
--               showsPrec (up_prec+1) v
--            where up_prec = 5
--

-- -- Note that right-associativity of :^: is ignored. For example, -- --

show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the -- string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

class Show a -- | Convert a value to a readable String. -- -- showsPrec should satisfy the law -- --

--   showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)
--

-- -- Derived instances of Read and Show satisfy the -- following: -- --

(x,"") is an element of (readsPrec d -- (showsPrec d x "")).

-- -- That is, readsPrec parses the string produced by -- showsPrec, and delivers the value that showsPrec started -- with. showsPrec :: Show a => Int -> a -> ShowS -- | A specialised variant of showsPrec, using precedence context -- zero, and returning an ordinary String. show :: Show a => a -> String -- | The method showList is provided to allow the programmer to give -- a specialised way of showing lists of values. For example, this is -- used by the predefined Show instance of the Char type, -- where values of type String should be shown in double quotes, -- rather than between square brackets. showList :: Show a => [a] -> ShowS -- | When a value is bound in do-notation, the pattern on the left -- hand side of <- might not match. In this case, this class -- provides a function to recover. -- -- A Monad without a MonadFail instance may only be used in -- conjunction with pattern that always match, such as newtypes, tuples, -- data types with only a single data constructor, and irrefutable -- patterns (~pat). -- -- Instances of MonadFail should satisfy the following law: -- fail s should be a left zero for >>=, -- --

--   fail s >>= f  =  fail s
--

-- -- If your Monad is also MonadPlus, a popular definition is -- --

--   fail _ = mzero
--

class Monad m => MonadFail (m :: Type -> Type) fail :: MonadFail m => String -> m a -- | A functor with application, providing operations to -- --

embed pure expressions (pure), and
sequence computations and combine their results (<*> -- and liftA2).

-- -- A minimal complete definition must include implementations of -- pure and of either <*> or liftA2. If it -- defines both, then they must behave the same as their default -- definitions: -- --

--   (<*>) = liftA2 id
--

-- --

--   liftA2 f x y = f <$> x <*> y
--

-- -- Further, any definition must satisfy the following: -- --

Identity
```
pure id <*> v =
--   v
```

Composition

pure (.) <*> u
--   <*> v <*> w = u <*> (v
--   <*> w)

Homomorphism
```
pure f <*>
--   pure x = pure (f x)
```
Interchange
```
u <*> pure y =
--   pure ($ y) <*> u
```

-- -- The other methods have the following default definitions, which may be -- overridden with equivalent specialized implementations: -- --

```
u *> v = (id <$ u)
--   <*> v
```
```
u <* v = liftA2 const u v
```

-- -- As a consequence of these laws, the Functor instance for -- f will satisfy -- --

```
fmap f x = pure f <*> x
```

-- -- It may be useful to note that supposing -- --

--   forall x y. p (q x y) = f x . g y
--

-- -- it follows from the above that -- --

--   liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v
--

-- -- If f is also a Monad, it should satisfy -- --

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2
--   >>= (x2 -> return (x1 x2)))

```
(*>) = (>>)
```

-- -- (which implies that pure and <*> satisfy the -- applicative functor laws). class Functor f => Applicative (f :: Type -> Type) -- | Lift a value. pure :: Applicative f => a -> f a -- | Sequential application. -- -- A few functors support an implementation of <*> that is -- more efficient than the default one. -- --

Example

-- -- Used in combination with (<$>), -- (<*>) can be used to build a record. -- --

--   >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
--

-- --

--   >>> produceFoo :: Applicative f => f Foo
--

-- --

--   >>> produceBar :: Applicative f => f Bar
--   
--   >>> produceBaz :: Applicative f => f Baz
--

-- --

--   >>> mkState :: Applicative f => f MyState
--   
--   >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
--

(<*>) :: Applicative f => f (a -> b) -> f a -> f b -- | Sequence actions, discarding the value of the first argument. -- --

Examples

-- -- If used in conjunction with the Applicative instance for Maybe, -- you can chain Maybe computations, with a possible "early return" in -- case of Nothing. -- --

--   >>> Just 2 *> Just 3
--   Just 3
--

-- --

--   >>> Nothing *> Just 3
--   Nothing
--

-- -- Of course a more interesting use case would be to have effectful -- computations instead of just returning pure values. -- --

--   >>> import Data.Char
--   
--   >>> import Text.ParserCombinators.ReadP
--   
--   >>> let p = string "my name is " *> munch1 isAlpha <* eof
--   
--   >>> readP_to_S p "my name is Simon"
--   [("Simon","")]
--

(*>) :: Applicative f => f a -> f b -> f b -- | Sequence actions, discarding the value of the second argument. (<*) :: Applicative f => f a -> f b -> f a infixl 4 <* infixl 4 *> infixl 4 <*> -- | The Foldable class represents data structures that can be reduced to a -- summary value one element at a time. Strict left-associative folds are -- a good fit for space-efficient reduction, while lazy right-associative -- folds are a good fit for corecursive iteration, or for folds that -- short-circuit after processing an initial subsequence of the -- structure's elements. -- -- Instances can be derived automatically by enabling the -- DeriveFoldable extension. For example, a derived instance for -- a binary tree might be: -- --

--   {-# LANGUAGE DeriveFoldable #-}
--   data Tree a = Empty
--               | Leaf a
--               | Node (Tree a) a (Tree a)
--       deriving Foldable
--

-- -- A more detailed description can be found in the Overview -- section of Data.Foldable#overview. -- -- For the class laws see the Laws section of -- Data.Foldable#laws. class Foldable (t :: TYPE LiftedRep -> Type) -- | Map each element of the structure into a monoid, and combine the -- results with (<>). This fold is -- right-associative and lazy in the accumulator. For strict -- left-associative folds consider foldMap' instead. -- --

Examples

-- -- Basic usage: -- --

--   >>> foldMap Sum [1, 3, 5]
--   Sum {getSum = 9}
--

-- --

--   >>> foldMap Product [1, 3, 5]
--   Product {getProduct = 15}
--

-- --

--   >>> foldMap (replicate 3) [1, 2, 3]
--   [1,1,1,2,2,2,3,3,3]
--

-- -- When a Monoid's (<>) is lazy in its second -- argument, foldMap can return a result even from an unbounded -- structure. For example, lazy accumulation enables -- Data.ByteString.Builder to efficiently serialise large data -- structures and produce the output incrementally: -- --

--   >>> import qualified Data.ByteString.Lazy as L
--   
--   >>> import qualified Data.ByteString.Builder as B
--   
--   >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20
--   
--   >>> let lbs = B.toLazyByteString $ foldMap bld [0..]
--   
--   >>> L.take 64 lbs
--   "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"
--

foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m -- | Right-associative fold of a structure, lazy in the accumulator. -- -- In the case of lists, foldr, when applied to a binary operator, -- a starting value (typically the right-identity of the operator), and a -- list, reduces the list using the binary operator, from right to left: -- --

--   foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--

-- -- Note that since the head of the resulting expression is produced by an -- application of the operator to the first element of the list, given an -- operator lazy in its right argument, foldr can produce a -- terminating expression from an unbounded list. -- -- For a general Foldable structure this should be semantically -- identical to, -- --

--   foldr f z = foldr f z . toList
--

-- --

Examples

-- -- Basic usage: -- --

--   >>> foldr (||) False [False, True, False]
--   True
--

-- --

--   >>> foldr (||) False []
--   False
--

-- --

--   >>> foldr (\c acc -> acc ++ [c]) "foo" ['a', 'b', 'c', 'd']
--   "foodcba"
--

-- --

Infinite structures

-- -- ⚠️ Applying foldr to infinite structures usually doesn't -- terminate. -- -- It may still terminate under one of the following conditions: -- --

the folding function is short-circuiting
the folding function is lazy on its second argument

-- --

Short-circuiting

-- -- (||) short-circuits on True values, so the -- following terminates because there is a True value finitely far -- from the left side: -- --

--   >>> foldr (||) False (True : repeat False)
--   True
--

-- -- But the following doesn't terminate: -- --

--   >>> foldr (||) False (repeat False ++ [True])
--   * Hangs forever *
--

-- --

Laziness in the second argument

-- -- Applying foldr to infinite structures terminates when the -- operator is lazy in its second argument (the initial accumulator is -- never used in this case, and so could be left undefined, but -- [] is more clear): -- --

--   >>> take 5 $ foldr (\i acc -> i : fmap (+3) acc) [] (repeat 1)
--   [1,4,7,10,13]
--

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b -- | Left-associative fold of a structure, lazy in the accumulator. This is -- rarely what you want, but can work well for structures with efficient -- right-to-left sequencing and an operator that is lazy in its left -- argument. -- -- In the case of lists, foldl, when applied to a binary operator, -- a starting value (typically the left-identity of the operator), and a -- list, reduces the list using the binary operator, from left to right: -- --

--   foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--

-- -- Note that to produce the outermost application of the operator the -- entire input list must be traversed. Like all left-associative folds, -- foldl will diverge if given an infinite list. -- -- If you want an efficient strict left-fold, you probably want to use -- foldl' instead of foldl. The reason for this is that the -- latter does not force the inner results (e.g. z `f` x1 -- in the above example) before applying them to the operator (e.g. to -- (`f` x2)). This results in a thunk chain <math> -- elements long, which then must be evaluated from the outside-in. -- -- For a general Foldable structure this should be semantically -- identical to: -- --

--   foldl f z = foldl f z . toList
--

-- --

Examples

-- -- The first example is a strict fold, which in practice is best -- performed with foldl'. -- --

--   >>> foldl (+) 42 [1,2,3,4]
--   52
--

-- -- Though the result below is lazy, the input is reversed before -- prepending it to the initial accumulator, so corecursion begins only -- after traversing the entire input string. -- --

--   >>> foldl (\acc c -> c : acc) "abcd" "efgh"
--   "hgfeabcd"
--

-- -- A left fold of a structure that is infinite on the right cannot -- terminate, even when for any finite input the fold just returns the -- initial accumulator: -- --

--   >>> foldl (\a _ -> a) 0 $ repeat 1
--   * Hangs forever *
--

-- -- WARNING: When it comes to lists, you always want to use either -- foldl' or foldr instead. foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b -- | A variant of foldr that has no base case, and thus may only be -- applied to non-empty structures. -- -- This function is non-total and will raise a runtime exception if the -- structure happens to be empty. -- --

Examples

-- -- Basic usage: -- --

--   >>> foldr1 (+) [1..4]
--   10
--

-- --

--   >>> foldr1 (+) []
--   Exception: Prelude.foldr1: empty list
--

-- --

--   >>> foldr1 (+) Nothing
--   *** Exception: foldr1: empty structure
--

-- --

--   >>> foldr1 (-) [1..4]
--   -2
--

-- --

--   >>> foldr1 (&&) [True, False, True, True]
--   False
--

-- --

--   >>> foldr1 (||) [False, False, True, True]
--   True
--

-- --

--   >>> foldr1 (+) [1..]
--   * Hangs forever *
--

foldr1 :: Foldable t => (a -> a -> a) -> t a -> a -- | A variant of foldl that has no base case, and thus may only be -- applied to non-empty structures. -- -- This function is non-total and will raise a runtime exception if the -- structure happens to be empty. -- --

--   foldl1 f = foldl1 f . toList
--

-- --

Examples

-- -- Basic usage: -- --

--   >>> foldl1 (+) [1..4]
--   10
--

-- --

--   >>> foldl1 (+) []
--   *** Exception: Prelude.foldl1: empty list
--

-- --

--   >>> foldl1 (+) Nothing
--   *** Exception: foldl1: empty structure
--

-- --

--   >>> foldl1 (-) [1..4]
--   -8
--

-- --

--   >>> foldl1 (&&) [True, False, True, True]
--   False
--

-- --

--   >>> foldl1 (||) [False, False, True, True]
--   True
--

-- --

--   >>> foldl1 (+) [1..]
--   * Hangs forever *
--

foldl1 :: Foldable t => (a -> a -> a) -> t a -> a -- | Test whether the structure is empty. The default implementation is -- Left-associative and lazy in both the initial element and the -- accumulator. Thus optimised for structures where the first element can -- be accessed in constant time. Structures where this is not the case -- should have a non-default implementation. -- --

Examples

-- -- Basic usage: -- --

--   >>> null []
--   True
--

-- --

--   >>> null [1]
--   False
--

-- -- null is expected to terminate even for infinite structures. The -- default implementation terminates provided the structure is bounded on -- the left (there is a leftmost element). -- --

--   >>> null [1..]
--   False
--

null :: Foldable t => t a -> Bool -- | Returns the size/length of a finite structure as an Int. The -- default implementation just counts elements starting with the -- leftmost. Instances for structures that can compute the element count -- faster than via element-by-element counting, should provide a -- specialised implementation. -- --

Examples

-- -- Basic usage: -- --

--   >>> length []
--   0
--

-- --

--   >>> length ['a', 'b', 'c']
--   3
--   
--   >>> length [1..]
--   * Hangs forever *
--

length :: Foldable t => t a -> Int -- | Does the element occur in the structure? -- -- Note: elem is often used in infix form. -- --

Examples

-- -- Basic usage: -- --

--   >>> 3 `elem` []
--   False
--

-- --

--   >>> 3 `elem` [1,2]
--   False
--

-- --

--   >>> 3 `elem` [1,2,3,4,5]
--   True
--

-- -- For infinite structures, the default implementation of elem -- terminates if the sought-after value exists at a finite distance from -- the left side of the structure: -- --

--   >>> 3 `elem` [1..]
--   True
--

-- --

--   >>> 3 `elem` ([4..] ++ [3])
--   * Hangs forever *
--

elem :: (Foldable t, Eq a) => a -> t a -> Bool -- | The largest element of a non-empty structure. -- -- This function is non-total and will raise a runtime exception if the -- structure happens to be empty. A structure that supports random access -- and maintains its elements in order should provide a specialised -- implementation to return the maximum in faster than linear time. -- --

Examples

-- -- Basic usage: -- --

--   >>> maximum [1..10]
--   10
--

-- --

--   >>> maximum []
--   *** Exception: Prelude.maximum: empty list
--

-- --

--   >>> maximum Nothing
--   *** Exception: maximum: empty structure
--

-- -- WARNING: This function is partial for possibly-empty structures like -- lists. maximum :: (Foldable t, Ord a) => t a -> a -- | The least element of a non-empty structure. -- -- This function is non-total and will raise a runtime exception if the -- structure happens to be empty. A structure that supports random access -- and maintains its elements in order should provide a specialised -- implementation to return the minimum in faster than linear time. -- --

Examples

-- -- Basic usage: -- --

--   >>> minimum [1..10]
--   1
--

-- --

--   >>> minimum []
--   *** Exception: Prelude.minimum: empty list
--

-- --

--   >>> minimum Nothing
--   *** Exception: minimum: empty structure
--

-- -- WARNING: This function is partial for possibly-empty structures like -- lists. minimum :: (Foldable t, Ord a) => t a -> a -- | The product function computes the product of the numbers of a -- structure. -- --

Examples

-- -- Basic usage: -- --

--   >>> product []
--   1
--

-- --

--   >>> product [42]
--   42
--

-- --

--   >>> product [1..10]
--   3628800
--

-- --

--   >>> product [4.1, 2.0, 1.7]
--   13.939999999999998
--

-- --

--   >>> product [1..]
--   * Hangs forever *
--

product :: (Foldable t, Num a) => t a -> a infix 4 `elem` -- | Functors representing data structures that can be transformed to -- structures of the same shape by performing an -- Applicative (or, therefore, Monad) action on each -- element from left to right. -- -- A more detailed description of what same shape means, the -- various methods, how traversals are constructed, and example advanced -- use-cases can be found in the Overview section of -- Data.Traversable#overview. -- -- For the class laws see the Laws section of -- Data.Traversable#laws. class (Functor t, Foldable t) => Traversable (t :: Type -> Type) -- | Map each element of a structure to an action, evaluate these actions -- from left to right, and collect the results. For a version that -- ignores the results see traverse_. -- --

Examples

-- -- Basic usage: -- -- In the first two examples we show each evaluated action mapping to the -- output structure. -- --

--   >>> traverse Just [1,2,3,4]
--   Just [1,2,3,4]
--

-- --

--   >>> traverse id [Right 1, Right 2, Right 3, Right 4]
--   Right [1,2,3,4]
--

-- -- In the next examples, we show that Nothing and Left -- values short circuit the created structure. -- --

--   >>> traverse (const Nothing) [1,2,3,4]
--   Nothing
--

-- --

--   >>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
--   Nothing
--

-- --

--   >>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
--   Left 0
--

traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) -- | Evaluate each action in the structure from left to right, and collect -- the results. For a version that ignores the results see -- sequenceA_. -- --

Examples

-- -- Basic usage: -- -- For the first two examples we show sequenceA fully evaluating a a -- structure and collecting the results. -- --

--   >>> sequenceA [Just 1, Just 2, Just 3]
--   Just [1,2,3]
--

-- --

--   >>> sequenceA [Right 1, Right 2, Right 3]
--   Right [1,2,3]
--

-- -- The next two example show Nothing and Just will short -- circuit the resulting structure if present in the input. For more -- context, check the Traversable instances for Either and -- Maybe. -- --

--   >>> sequenceA [Just 1, Just 2, Just 3, Nothing]
--   Nothing
--

-- --

--   >>> sequenceA [Right 1, Right 2, Right 3, Left 4]
--   Left 4
--

sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a) -- | Map each element of a structure to a monadic action, evaluate these -- actions from left to right, and collect the results. For a version -- that ignores the results see mapM_. -- --

Examples

-- -- mapM is literally a traverse with a type signature -- restricted to Monad. Its implementation may be more efficient -- due to additional power of Monad. mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) -- | Evaluate each monadic action in the structure from left to right, and -- collect the results. For a version that ignores the results see -- sequence_. -- --

Examples

-- -- Basic usage: -- -- The first two examples are instances where the input and and output of -- sequence are isomorphic. -- --

--   >>> sequence $ Right [1,2,3,4]
--   [Right 1,Right 2,Right 3,Right 4]
--

-- --

--   >>> sequence $ [Right 1,Right 2,Right 3,Right 4]
--   Right [1,2,3,4]
--

-- -- The following examples demonstrate short circuit behavior for -- sequence. -- --

--   >>> sequence $ Left [1,2,3,4]
--   Left [1,2,3,4]
--

-- --

--   >>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
--   Left 0
--

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) -- | The class of semigroups (types with an associative binary operation). -- -- Instances should satisfy the following: -- --

Associativity x <> (y <> z) = -- (x <> y) <> z

class Semigroup a -- | An associative operation. -- --

--   >>> [1,2,3] <> [4,5,6]
--   [1,2,3,4,5,6]
--

(<>) :: Semigroup a => a -> a -> a infixr 6 <> -- | The class of monoids (types with an associative binary operation that -- has an identity). Instances should satisfy the following: -- --

Right identity x <> mempty = -- x
Left identity mempty <> x = -- x
Associativity x <> (y <> z) = -- (x <> y) <> z (Semigroup -- law)
Concatenation mconcat = foldr -- (<>) mempty

-- -- The method names refer to the monoid of lists under concatenation, but -- there are many other instances. -- -- Some types can be viewed as a monoid in more than one way, e.g. both -- addition and multiplication on numbers. In such cases we often define -- newtypes and make those instances of Monoid, e.g. -- Sum and Product. -- -- NOTE: Semigroup is a superclass of Monoid since -- base-4.11.0.0. class Semigroup a => Monoid a -- | Identity of mappend -- --

--   >>> "Hello world" <> mempty
--   "Hello world"
--

mempty :: Monoid a => a -- | An associative operation -- -- NOTE: This method is redundant and has the default -- implementation mappend = (<>) since -- base-4.11.0.0. Should it be implemented manually, since -- mappend is a synonym for (<>), it is expected that -- the two functions are defined the same way. In a future GHC release -- mappend will be removed from Monoid. mappend :: Monoid a => a -> a -> a -- | Fold a list using the monoid. -- -- For most types, the default definition for mconcat will be -- used, but the function is included in the class definition so that an -- optimized version can be provided for specific types. -- --

--   >>> mconcat ["Hello", " ", "Haskell", "!"]
--   "Hello Haskell!"
--

mconcat :: Monoid a => [a] -> a data Bool False :: Bool True :: Bool -- | A String is a list of characters. String constants in Haskell -- are values of type String. -- -- See Data.List for operations on lists. type String = [Char] -- | The character type Char is an enumeration whose values -- represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. -- characters, see http://www.unicode.org/ for details). This set -- extends the ISO 8859-1 (Latin-1) character set (the first 256 -- characters), which is itself an extension of the ASCII character set -- (the first 128 characters). A character literal in Haskell has type -- Char. -- -- To convert a Char to or from the corresponding Int value -- defined by Unicode, use toEnum and fromEnum from the -- Enum class respectively (or equivalently ord and -- chr). data Char -- | Double-precision floating point numbers. It is desirable that this -- type be at least equal in range and precision to the IEEE -- double-precision type. data Double -- | Single-precision floating point numbers. It is desirable that this -- type be at least equal in range and precision to the IEEE -- single-precision type. data Float -- | A fixed-precision integer type with at least the range [-2^29 .. -- 2^29-1]. The exact range for a given implementation can be -- determined by using minBound and maxBound from the -- Bounded class. data Int -- | Arbitrary precision integers. In contrast with fixed-size integral -- types such as Int, the Integer type represents the -- entire infinite range of integers. -- -- Integers are stored in a kind of sign-magnitude form, hence do not -- expect two's complement form when using bit operations. -- -- If the value is small (fit into an Int), IS constructor -- is used. Otherwise Integer and IN constructors are used -- to store a BigNat representing respectively the positive or the -- negative value magnitude. -- -- Invariant: Integer and IN are used iff value doesn't fit -- in IS data Integer -- | The Maybe type encapsulates an optional value. A value of type -- Maybe a either contains a value of type a -- (represented as Just a), or it is empty (represented -- as Nothing). Using Maybe is a good way to deal with -- errors or exceptional cases without resorting to drastic measures such -- as error. -- -- The Maybe type is also a monad. It is a simple kind of error -- monad, where all errors are represented by Nothing. A richer -- error monad can be built using the Either type. data Maybe a Nothing :: Maybe a Just :: a -> Maybe a data Ordering LT :: Ordering EQ :: Ordering GT :: Ordering -- | Arbitrary-precision rational numbers, represented as a ratio of two -- Integer values. A rational number may be constructed using the -- % operator. type Rational = Ratio Integer -- | A value of type IO a is a computation which, when -- performed, does some I/O before returning a value of type a. -- -- There is really only one way to "perform" an I/O action: bind it to -- Main.main in your program. When your program is run, the I/O -- will be performed. It isn't possible to perform I/O from an arbitrary -- function, unless that function is itself in the IO monad and -- called at some point, directly or indirectly, from Main.main. -- -- IO is a monad, so IO actions can be combined using -- either the do-notation or the >> and >>= -- operations from the Monad class. data IO a -- | A Word is an unsigned integral type, with the same size as -- Int. data Word -- | The Either type represents values with two possibilities: a -- value of type Either a b is either Left -- a or Right b. -- -- The Either type is sometimes used to represent a value which is -- either correct or an error; by convention, the Left constructor -- is used to hold an error value and the Right constructor is -- used to hold a correct value (mnemonic: "right" also means "correct"). -- --

Examples

-- -- The type Either String Int is the type -- of values which can be either a String or an Int. The -- Left constructor can be used only on Strings, and the -- Right constructor can be used only on Ints: -- --

--   >>> let s = Left "foo" :: Either String Int
--   
--   >>> s
--   Left "foo"
--   
--   >>> let n = Right 3 :: Either String Int
--   
--   >>> n
--   Right 3
--   
--   >>> :type s
--   s :: Either String Int
--   
--   >>> :type n
--   n :: Either String Int
--

-- -- The fmap from our Functor instance will ignore -- Left values, but will apply the supplied function to values -- contained in a Right: -- --

--   >>> let s = Left "foo" :: Either String Int
--   
--   >>> let n = Right 3 :: Either String Int
--   
--   >>> fmap (*2) s
--   Left "foo"
--   
--   >>> fmap (*2) n
--   Right 6
--

-- -- The Monad instance for Either allows us to chain -- together multiple actions which may fail, and fail overall if any of -- the individual steps failed. First we'll write a function that can -- either parse an Int from a Char, or fail. -- --

--   >>> import Data.Char ( digitToInt, isDigit )
--   
--   >>> :{
--       let parseEither :: Char -> Either String Int
--           parseEither c
--             | isDigit c = Right (digitToInt c)
--             | otherwise = Left "parse error"
--   
--   >>> :}
--

-- -- The following should work, since both '1' and '2' -- can be parsed as Ints. -- --

--   >>> :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x <- parseEither '1'
--             y <- parseEither '2'
--             return (x + y)
--   
--   >>> :}
--

-- --

--   >>> parseMultiple
--   Right 3
--

-- -- But the following should fail overall, since the first operation where -- we attempt to parse 'm' as an Int will fail: -- --

--   >>> :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x <- parseEither 'm'
--             y <- parseEither '2'
--             return (x + y)
--   
--   >>> :}
--

-- --

--   >>> parseMultiple
--   Left "parse error"
--

data Either a b Left :: a -> Either a b Right :: b -> Either a b -- | The computation writeFile file str function writes the -- string str, to the file file. writeFile :: FilePath -> String -> IO () -- | The readLn function combines getLine and readIO. readLn :: Read a => IO a -- | The readIO function is similar to read except that it -- signals parse failure to the IO monad instead of terminating -- the program. readIO :: Read a => String -> IO a -- | The readFile function reads a file and returns the contents of -- the file as a string. The file is read lazily, on demand, as with -- getContents. readFile :: FilePath -> IO String -- | The same as putStr, but adds a newline character. putStrLn :: String -> IO () -- | Write a string to the standard output device (same as hPutStr -- stdout). putStr :: String -> IO () -- | Write a character to the standard output device (same as -- hPutChar stdout). putChar :: Char -> IO () -- | The interact function takes a function of type -- String->String as its argument. The entire input from the -- standard input device is passed to this function as its argument, and -- the resulting string is output on the standard output device. interact :: (String -> String) -> IO () -- | Read a line from the standard input device (same as hGetLine -- stdin). getLine :: IO String -- | The getContents operation returns all user input as a single -- string, which is read lazily as it is needed (same as -- hGetContents stdin). getContents :: IO String -- | Read a character from the standard input device (same as -- hGetChar stdin). getChar :: IO Char -- | The computation appendFile file str function appends -- the string str, to the file file. -- -- Note that writeFile and appendFile write a literal -- string to a file. To write a value of any printable type, as with -- print, use the show function to convert the value to a -- string first. -- --

--   main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
--

appendFile :: FilePath -> String -> IO () -- | Raise an IOException in the IO monad. ioError :: IOError -> IO a -- | File and directory names are values of type String, whose -- precise meaning is operating system dependent. Files can be opened, -- yielding a handle which can then be used to operate on the contents of -- that file. type FilePath = String -- | The Haskell 2010 type for exceptions in the IO monad. Any I/O -- operation may raise an IOException instead of returning a -- result. For a more general type of exception, including also those -- that arise in pure code, see Exception. -- -- In Haskell 2010, this is an opaque type. type IOError = IOException -- | Construct an IOException value with a string describing the -- error. The fail method of the IO instance of the -- Monad class raises a userError, thus: -- --

--   instance Monad IO where
--     ...
--     fail s = ioError (userError s)
--

userError :: String -> IOError -- | Evaluate each monadic action in the structure from left to right, and -- ignore the results. For a version that doesn't ignore the results see -- sequence. -- -- sequence_ is just like sequenceA_, but specialised to -- monadic actions. sequence_ :: (Foldable t, Monad m) => t (m a) -> m () -- | or returns the disjunction of a container of Bools. For the -- result to be False, the container must be finite; True, -- however, results from a True value finitely far from the left -- end. -- --

Examples

-- -- Basic usage: -- --

--   >>> or []
--   False
--

-- --

--   >>> or [True]
--   True
--

-- --

--   >>> or [False]
--   False
--

-- --

--   >>> or [True, True, False]
--   True
--

-- --

--   >>> or (True : repeat False) -- Infinite list [True,False,False,False,...
--   True
--

-- --

--   >>> or (repeat False)
--   * Hangs forever *
--

or :: Foldable t => t Bool -> Bool -- | notElem is the negation of elem. -- --

Examples

-- -- Basic usage: -- --

--   >>> 3 `notElem` []
--   True
--

-- --

--   >>> 3 `notElem` [1,2]
--   True
--

-- --

--   >>> 3 `notElem` [1,2,3,4,5]
--   False
--

-- -- For infinite structures, notElem terminates if the value exists -- at a finite distance from the left side of the structure: -- --

--   >>> 3 `notElem` [1..]
--   False
--

-- --

--   >>> 3 `notElem` ([4..] ++ [3])
--   * Hangs forever *
--

notElem :: (Foldable t, Eq a) => a -> t a -> Bool infix 4 `notElem` -- | Map each element of a structure to a monadic action, evaluate these -- actions from left to right, and ignore the results. For a version that -- doesn't ignore the results see mapM. -- -- mapM_ is just like traverse_, but specialised to monadic -- actions. mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () -- | Map a function over all the elements of a container and concatenate -- the resulting lists. -- --

Examples

-- -- Basic usage: -- --

--   >>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
--   [1,2,3,10,11,12,100,101,102,1000,1001,1002]
--

-- --

--   >>> concatMap (take 3) (Just [1..])
--   [1,2,3]
--

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] -- | The concatenation of all the elements of a container of lists. -- --

Examples

-- -- Basic usage: -- --

--   >>> concat (Just [1, 2, 3])
--   [1,2,3]
--

-- --

--   >>> concat (Left 42)
--   []
--

-- --

--   >>> concat [[1, 2, 3], [4, 5], [6], []]
--   [1,2,3,4,5,6]
--

concat :: Foldable t => t [a] -> [a] -- | Determines whether any element of the structure satisfies the -- predicate. -- --

Examples

-- -- Basic usage: -- --

--   >>> any (> 3) []
--   False
--

-- --

--   >>> any (> 3) [1,2]
--   False
--

-- --

--   >>> any (> 3) [1,2,3,4,5]
--   True
--

-- --

--   >>> any (> 3) [1..]
--   True
--

-- --

--   >>> any (> 3) [0, -1..]
--   * Hangs forever *
--

any :: Foldable t => (a -> Bool) -> t a -> Bool -- | and returns the conjunction of a container of Bools. For the -- result to be True, the container must be finite; False, -- however, results from a False value finitely far from the left -- end. -- --

Examples

-- -- Basic usage: -- --

--   >>> and []
--   True
--

-- --

--   >>> and [True]
--   True
--

-- --

--   >>> and [False]
--   False
--

-- --

--   >>> and [True, True, False]
--   False
--

-- --

--   >>> and (False : repeat True) -- Infinite list [False,True,True,True,...
--   False
--

-- --

--   >>> and (repeat True)
--   * Hangs forever *
--

and :: Foldable t => t Bool -> Bool -- | Determines whether all elements of the structure satisfy the -- predicate. -- --

Examples

-- -- Basic usage: -- --

--   >>> all (> 3) []
--   True
--

-- --

--   >>> all (> 3) [1,2]
--   False
--

-- --

--   >>> all (> 3) [1,2,3,4,5]
--   False
--

-- --

--   >>> all (> 3) [1..]
--   False
--

-- --

--   >>> all (> 3) [4..]
--   * Hangs forever *
--

all :: Foldable t => (a -> Bool) -> t a -> Bool -- | words breaks a string up into a list of words, which were -- delimited by white space. -- --

--   >>> words "Lorem ipsum\ndolor"
--   ["Lorem","ipsum","dolor"]
--

words :: String -> [String] -- | unwords is an inverse operation to words. It joins words -- with separating spaces. -- --

--   >>> unwords ["Lorem", "ipsum", "dolor"]
--   "Lorem ipsum dolor"
--

unwords :: [String] -> String -- | unlines is an inverse operation to lines. It joins -- lines, after appending a terminating newline to each. -- --

--   >>> unlines ["Hello", "World", "!"]
--   "Hello\nWorld\n!\n"
--

unlines :: [String] -> String -- | lines breaks a string up into a list of strings at newline -- characters. The resulting strings do not contain newlines. -- -- Note that after splitting the string at newline characters, the last -- part of the string is considered a line even if it doesn't end with a -- newline. For example, -- --

--   >>> lines ""
--   []
--

-- --

--   >>> lines "\n"
--   [""]
--

-- --

--   >>> lines "one"
--   ["one"]
--

-- --

--   >>> lines "one\n"
--   ["one"]
--

-- --

--   >>> lines "one\n\n"
--   ["one",""]
--

-- --

--   >>> lines "one\ntwo"
--   ["one","two"]
--

-- --

--   >>> lines "one\ntwo\n"
--   ["one","two"]
--

-- -- Thus lines s contains at least as many elements as -- newlines in s. lines :: String -> [String] -- | equivalent to readsPrec with a precedence of 0. reads :: Read a => ReadS a -- | The read function reads input from a string, which must be -- completely consumed by the input process. read fails with an -- error if the parse is unsuccessful, and it is therefore -- discouraged from being used in real applications. Use readMaybe -- or readEither for safe alternatives. -- --

--   >>> read "123" :: Int
--   123
--

-- --

--   >>> read "hello" :: Int
--   *** Exception: Prelude.read: no parse
--

read :: Read a => String -> a -- | Case analysis for the Either type. If the value is -- Left a, apply the first function to a; if it -- is Right b, apply the second function to b. -- --

Examples

-- -- We create two values of type Either String -- Int, one using the Left constructor and another -- using the Right constructor. Then we apply "either" the -- length function (if we have a String) or the "times-two" -- function (if we have an Int): -- --

--   >>> let s = Left "foo" :: Either String Int
--   
--   >>> let n = Right 3 :: Either String Int
--   
--   >>> either length (*2) s
--   3
--   
--   >>> either length (*2) n
--   6
--

either :: (a -> c) -> (b -> c) -> Either a b -> c -- | readParen True p parses what p parses, -- but surrounded with parentheses. -- -- readParen False p parses what p -- parses, but optionally surrounded with parentheses. readParen :: Bool -> ReadS a -> ReadS a -- | The lex function reads a single lexeme from the input, -- discarding initial white space, and returning the characters that -- constitute the lexeme. If the input string contains only white space, -- lex returns a single successful `lexeme' consisting of the -- empty string. (Thus lex "" = [("","")].) If there is -- no legal lexeme at the beginning of the input string, lex fails -- (i.e. returns []). -- -- This lexer is not completely faithful to the Haskell lexical syntax in -- the following respects: -- --

Qualified names are not handled properly
Octal and hexadecimal numerics are not recognized as a single -- token
Comments are not treated properly

lex :: ReadS String -- | A parser for a type a, represented as a function that takes a -- String and returns a list of possible parses as -- (a,String) pairs. -- -- Note that this kind of backtracking parser is very inefficient; -- reading a large structure may be quite slow (cf ReadP). type ReadS a = String -> [(a, String)] odd :: Integral a => a -> Bool -- | lcm x y is the smallest positive integer that both -- x and y divide. lcm :: Integral a => a -> a -> a -- | gcd x y is the non-negative factor of both x -- and y of which every common factor of x and -- y is also a factor; for example gcd 4 2 = 2, -- gcd (-4) 6 = 2, gcd 0 4 = 4. -- gcd 0 0 = 0. (That is, the common divisor -- that is "greatest" in the divisibility preordering.) -- -- Note: Since for signed fixed-width integer types, abs -- minBound < 0, the result may be negative if one of the -- arguments is minBound (and necessarily is if the other -- is 0 or minBound) for such types. gcd :: Integral a => a -> a -> a even :: Integral a => a -> Bool -- | raise a number to an integral power (^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 ^^ -- | raise a number to a non-negative integral power (^) :: (Num a, Integral b) => a -> b -> a infixr 8 ^ -- | The shows functions return a function that prepends the -- output String to an existing String. This allows -- constant-time concatenation of results using function composition. type ShowS = String -> String -- | equivalent to showsPrec with a precedence of 0. shows :: Show a => a -> ShowS -- | utility function converting a String to a show function that -- simply prepends the string unchanged. showString :: String -> ShowS -- | utility function that surrounds the inner show function with -- parentheses when the Bool parameter is True. showParen :: Bool -> ShowS -> ShowS -- | utility function converting a Char to a show function that -- simply prepends the character unchanged. showChar :: Char -> ShowS -- | The zipWith3 function takes a function which combines three -- elements, as well as three lists and returns a list of the function -- applied to corresponding elements, analogous to zipWith. It is -- capable of list fusion, but it is restricted to its first list -- argument and its resulting list. -- --

--   zipWith3 (,,) xs ys zs == zip3 xs ys zs
--   zipWith3 f [x1,x2,x3..] [y1,y2,y3..] [z1,z2,z3..] == [f x1 y1 z1, f x2 y2 z2, f x3 y3 z3..]
--

zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] -- | <math>. zipWith generalises zip by zipping with -- the function given as the first argument, instead of a tupling -- function. -- --

--   zipWith (,) xs ys == zip xs ys
--   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
--

-- -- For example, zipWith (+) is applied to two lists to -- produce the list of corresponding sums: -- --

--   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
--   [5,7,9]
--

-- -- zipWith is right-lazy: -- --

--   >>> let f = undefined
--   
--   >>> zipWith f [] undefined
--   []
--

-- -- zipWith is capable of list fusion, but it is restricted to its -- first list argument and its resulting list. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] -- | zip3 takes three lists and returns a list of triples, analogous -- to zip. It is capable of list fusion, but it is restricted to -- its first list argument and its resulting list. zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] -- | The unzip3 function takes a list of triples and returns three -- lists, analogous to unzip. -- --

--   >>> unzip3 []
--   ([],[],[])
--   
--   >>> unzip3 [(1, 'a', True), (2, 'b', False)]
--   ([1,2],"ab",[True,False])
--

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) -- | unzip transforms a list of pairs into a list of first -- components and a list of second components. -- --

--   >>> unzip []
--   ([],[])
--   
--   >>> unzip [(1, 'a'), (2, 'b')]
--   ([1,2],"ab")
--

unzip :: [(a, b)] -> ([a], [b]) -- | takeWhile, applied to a predicate p and a list -- xs, returns the longest prefix (possibly empty) of -- xs of elements that satisfy p. -- --

--   >>> takeWhile (< 3) [1,2,3,4,1,2,3,4]
--   [1,2]
--   
--   >>> takeWhile (< 9) [1,2,3]
--   [1,2,3]
--   
--   >>> takeWhile (< 0) [1,2,3]
--   []
--

takeWhile :: (a -> Bool) -> [a] -> [a] -- | take n, applied to a list xs, returns the -- prefix of xs of length n, or xs itself if -- n >= length xs. -- --

--   >>> take 5 "Hello World!"
--   "Hello"
--   
--   >>> take 3 [1,2,3,4,5]
--   [1,2,3]
--   
--   >>> take 3 [1,2]
--   [1,2]
--   
--   >>> take 3 []
--   []
--   
--   >>> take (-1) [1,2]
--   []
--   
--   >>> take 0 [1,2]
--   []
--

-- -- It is an instance of the more general genericTake, in which -- n may be of any integral type. take :: Int -> [a] -> [a] -- | <math>. Extract the elements after the head of a list, which -- must be non-empty. -- --

--   >>> tail [1, 2, 3]
--   [2,3]
--   
--   >>> tail [1]
--   []
--   
--   >>> tail []
--   *** Exception: Prelude.tail: empty list
--

tail :: [a] -> [a] -- | span, applied to a predicate p and a list xs, -- returns a tuple where first element is longest prefix (possibly empty) -- of xs of elements that satisfy p and second element -- is the remainder of the list: -- --

--   >>> span (< 3) [1,2,3,4,1,2,3,4]
--   ([1,2],[3,4,1,2,3,4])
--   
--   >>> span (< 9) [1,2,3]
--   ([1,2,3],[])
--   
--   >>> span (< 0) [1,2,3]
--   ([],[1,2,3])
--

-- -- span p xs is equivalent to (takeWhile p xs, -- dropWhile p xs) span :: (a -> Bool) -> [a] -> ([a], [a]) -- | <math>. scanr1 is a variant of scanr that has no -- starting value argument. -- --

--   >>> scanr1 (+) [1..4]
--   [10,9,7,4]
--   
--   >>> scanr1 (+) []
--   []
--   
--   >>> scanr1 (-) [1..4]
--   [-2,3,-1,4]
--   
--   >>> scanr1 (&&) [True, False, True, True]
--   [False,False,True,True]
--   
--   >>> scanr1 (||) [True, True, False, False]
--   [True,True,False,False]
--   
--   >>> force $ scanr1 (+) [1..]
--   *** Exception: stack overflow
--

scanr1 :: (a -> a -> a) -> [a] -> [a] -- | <math>. scanr is the right-to-left dual of scanl. -- Note that the order of parameters on the accumulating function are -- reversed compared to scanl. Also note that -- --

--   head (scanr f z xs) == foldr f z xs.
--

-- --

--   >>> scanr (+) 0 [1..4]
--   [10,9,7,4,0]
--   
--   >>> scanr (+) 42 []
--   [42]
--   
--   >>> scanr (-) 100 [1..4]
--   [98,-97,99,-96,100]
--   
--   >>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
--   ["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]
--   
--   >>> force $ scanr (+) 0 [1..]
--   *** Exception: stack overflow
--

scanr :: (a -> b -> b) -> b -> [a] -> [b] -- | <math>. scanl1 is a variant of scanl that has no -- starting value argument: -- --

--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--

-- --

--   >>> scanl1 (+) [1..4]
--   [1,3,6,10]
--   
--   >>> scanl1 (+) []
--   []
--   
--   >>> scanl1 (-) [1..4]
--   [1,-1,-4,-8]
--   
--   >>> scanl1 (&&) [True, False, True, True]
--   [True,False,False,False]
--   
--   >>> scanl1 (||) [False, False, True, True]
--   [False,False,True,True]
--   
--   >>> scanl1 (+) [1..]
--   * Hangs forever *
--

scanl1 :: (a -> a -> a) -> [a] -> [a] -- | <math>. scanl is similar to foldl, but returns a -- list of successive reduced values from the left: -- --

--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--

-- -- Note that -- --

--   last (scanl f z xs) == foldl f z xs
--

-- --

--   >>> scanl (+) 0 [1..4]
--   [0,1,3,6,10]
--   
--   >>> scanl (+) 42 []
--   [42]
--   
--   >>> scanl (-) 100 [1..4]
--   [100,99,97,94,90]
--   
--   >>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
--   ["foo","afoo","bafoo","cbafoo","dcbafoo"]
--   
--   >>> scanl (+) 0 [1..]
--   * Hangs forever *
--

scanl :: (b -> a -> b) -> b -> [a] -> [b] -- | reverse xs returns the elements of xs in -- reverse order. xs must be finite. -- --

--   >>> reverse []
--   []
--   
--   >>> reverse [42]
--   [42]
--   
--   >>> reverse [2,5,7]
--   [7,5,2]
--   
--   >>> reverse [1..]
--   * Hangs forever *
--

reverse :: [a] -> [a] -- | replicate n x is a list of length n with -- x the value of every element. It is an instance of the more -- general genericReplicate, in which n may be of any -- integral type. -- --

--   >>> replicate 0 True
--   []
--   
--   >>> replicate (-1) True
--   []
--   
--   >>> replicate 4 True
--   [True,True,True,True]
--

replicate :: Int -> a -> [a] -- | repeat x is an infinite list, with x the -- value of every element. -- --

--   >>> take 20 $ repeat 17
--   [17,17,17,17,17,17,17,17,17...
--

repeat :: a -> [a] -- | <math>. lookup key assocs looks up a key in an -- association list. -- --

--   >>> lookup 2 []
--   Nothing
--   
--   >>> lookup 2 [(1, "first")]
--   Nothing
--   
--   >>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]
--   Just "second"
--

lookup :: Eq a => a -> [(a, b)] -> Maybe b -- | <math>. Extract the last element of a list, which must be finite -- and non-empty. -- --

--   >>> last [1, 2, 3]
--   3
--   
--   >>> last [1..]
--   * Hangs forever *
--   
--   >>> last []
--   *** Exception: Prelude.last: empty list
--

last :: [a] -> a -- | iterate f x returns an infinite list of repeated -- applications of f to x: -- --

--   iterate f x == [x, f x, f (f x), ...]
--

-- -- Note that iterate is lazy, potentially leading to thunk -- build-up if the consumer doesn't force each iterate. See -- iterate' for a strict variant of this function. -- --

--   >>> take 10 $ iterate not True
--   [True,False,True,False...
--   
--   >>> take 10 $ iterate (+3) 42
--   [42,45,48,51,54,57,60,63...
--

iterate :: (a -> a) -> a -> [a] -- | <math>. Return all the elements of a list except the last one. -- The list must be non-empty. -- --

--   >>> init [1, 2, 3]
--   [1,2]
--   
--   >>> init [1]
--   []
--   
--   >>> init []
--   *** Exception: Prelude.init: empty list
--

init :: [a] -> [a] -- | <math>. Extract the first element of a list, which must be -- non-empty. -- --

--   >>> head [1, 2, 3]
--   1
--   
--   >>> head [1..]
--   1
--   
--   >>> head []
--   *** Exception: Prelude.head: empty list
--

head :: [a] -> a -- | dropWhile p xs returns the suffix remaining after -- takeWhile p xs. -- --

--   >>> dropWhile (< 3) [1,2,3,4,5,1,2,3]
--   [3,4,5,1,2,3]
--   
--   >>> dropWhile (< 9) [1,2,3]
--   []
--   
--   >>> dropWhile (< 0) [1,2,3]
--   [1,2,3]
--

dropWhile :: (a -> Bool) -> [a] -> [a] -- | drop n xs returns the suffix of xs after the -- first n elements, or [] if n >= length -- xs. -- --

--   >>> drop 6 "Hello World!"
--   "World!"
--   
--   >>> drop 3 [1,2,3,4,5]
--   [4,5]
--   
--   >>> drop 3 [1,2]
--   []
--   
--   >>> drop 3 []
--   []
--   
--   >>> drop (-1) [1,2]
--   [1,2]
--   
--   >>> drop 0 [1,2]
--   [1,2]
--

-- -- It is an instance of the more general genericDrop, in which -- n may be of any integral type. drop :: Int -> [a] -> [a] -- | cycle ties a finite list into a circular one, or equivalently, -- the infinite repetition of the original list. It is the identity on -- infinite lists. -- --

--   >>> cycle []
--   *** Exception: Prelude.cycle: empty list
--   
--   >>> take 20 $ cycle [42]
--   [42,42,42,42,42,42,42,42,42,42...
--   
--   >>> take 20 $ cycle [2, 5, 7]
--   [2,5,7,2,5,7,2,5,7,2,5,7...
--

cycle :: [a] -> [a] -- | break, applied to a predicate p and a list -- xs, returns a tuple where first element is longest prefix -- (possibly empty) of xs of elements that do not satisfy -- p and second element is the remainder of the list: -- --

--   >>> break (> 3) [1,2,3,4,1,2,3,4]
--   ([1,2,3],[4,1,2,3,4])
--   
--   >>> break (< 9) [1,2,3]
--   ([],[1,2,3])
--   
--   >>> break (> 9) [1,2,3]
--   ([1,2,3],[])
--

-- -- break p is equivalent to span (not . -- p). break :: (a -> Bool) -> [a] -> ([a], [a]) -- | List index (subscript) operator, starting from 0. It is an instance of -- the more general genericIndex, which takes an index of any -- integral type. -- --

--   >>> ['a', 'b', 'c'] !! 0
--   'a'
--   
--   >>> ['a', 'b', 'c'] !! 2
--   'c'
--   
--   >>> ['a', 'b', 'c'] !! 3
--   *** Exception: Prelude.!!: index too large
--   
--   >>> ['a', 'b', 'c'] !! (-1)
--   *** Exception: Prelude.!!: negative index
--

(!!) :: [a] -> Int -> a infixl 9 !! -- | The maybe function takes a default value, a function, and a -- Maybe value. If the Maybe value is Nothing, the -- function returns the default value. Otherwise, it applies the function -- to the value inside the Just and returns the result. -- --

Examples

-- -- Basic usage: -- --

--   >>> maybe False odd (Just 3)
--   True
--

-- --

--   >>> maybe False odd Nothing
--   False
--

-- -- Read an integer from a string using readMaybe. If we succeed, -- return twice the integer; that is, apply (*2) to it. If -- instead we fail to parse an integer, return 0 by default: -- --

--   >>> import Text.Read ( readMaybe )
--   
--   >>> maybe 0 (*2) (readMaybe "5")
--   10
--   
--   >>> maybe 0 (*2) (readMaybe "")
--   0
--

-- -- Apply show to a Maybe Int. If we have Just n, -- we want to show the underlying Int n. But if we have -- Nothing, we return the empty string instead of (for example) -- "Nothing": -- --

--   >>> maybe "" show (Just 5)
--   "5"
--   
--   >>> maybe "" show Nothing
--   ""
--

maybe :: b -> (a -> b) -> Maybe a -> b -- | An infix synonym for fmap. -- -- The name of this operator is an allusion to $. Note the -- similarities between their types: -- --

--    ($)  ::              (a -> b) ->   a ->   b
--   (<$>) :: Functor f => (a -> b) -> f a -> f b
--

-- -- Whereas $ is function application, <$> is function -- application lifted over a Functor. -- --

Examples

-- -- Convert from a Maybe Int to a Maybe -- String using show: -- --

--   >>> show <$> Nothing
--   Nothing
--   
--   >>> show <$> Just 3
--   Just "3"
--

-- -- Convert from an Either Int Int to an -- Either Int String using show: -- --

--   >>> show <$> Left 17
--   Left 17
--   
--   >>> show <$> Right 17
--   Right "17"
--

-- -- Double each element of a list: -- --

--   >>> (*2) <$> [1,2,3]
--   [2,4,6]
--

-- -- Apply even to the second element of a pair: -- --

--   >>> even <$> (2,2)
--   (2,True)
--

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 <$> -- | uncurry converts a curried function to a function on pairs. -- --

Examples

-- --

--   >>> uncurry (+) (1,2)
--   3
--

-- --

--   >>> uncurry ($) (show, 1)
--   "1"
--

-- --

--   >>> map (uncurry max) [(1,2), (3,4), (6,8)]
--   [2,4,8]
--

uncurry :: (a -> b -> c) -> (a, b) -> c -- | curry converts an uncurried function to a curried function. -- --

Examples

-- --

--   >>> curry fst 1 2
--   1
--

curry :: ((a, b) -> c) -> a -> b -> c -- | the same as flip (-). -- -- Because - is treated specially in the Haskell grammar, -- (- e) is not a section, but an application of -- prefix negation. However, (subtract -- exp) is equivalent to the disallowed section. subtract :: Num a => a -> a -> a -- | until p f yields the result of applying f -- until p holds. until :: (a -> Bool) -> (a -> a) -> a -> a -- | Identity function. -- --

--   id x = x
--

id :: a -> a -- | flip f takes its (first) two arguments in the reverse -- order of f. -- --

--   >>> flip (++) "hello" "world"
--   "worldhello"
--

flip :: (a -> b -> c) -> b -> a -> c -- | const x is a unary function which evaluates to x for -- all inputs. -- --

--   >>> const 42 "hello"
--   42
--

-- --

--   >>> map (const 42) [0..3]
--   [42,42,42,42]
--

const :: a -> b -> a -- | asTypeOf is a type-restricted version of const. It is -- usually used as an infix operator, and its typing forces its first -- argument (which is usually overloaded) to have the same type as the -- second. asTypeOf :: a -> a -> a -- | Same as >>=, but with the arguments interchanged. (=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 =<< -- | Function composition. (.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 . -- | Strict (call-by-value) application operator. It takes a function and -- an argument, evaluates the argument to weak head normal form (WHNF), -- then calls the function with that value. ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 $! -- | A special case of error. It is expected that compilers will -- recognize this and insert error messages which are more appropriate to -- the context in which undefined appears. undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a -- | A variant of error that does not produce a stack trace. errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a -- | error stops execution and displays an error message. error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a -- | Boolean "and", lazy in the second argument (&&) :: Bool -> Bool -> Bool infixr 3 && -- | Boolean "not" not :: Bool -> Bool -- | Boolean "or", lazy in the second argument (||) :: Bool -> Bool -> Bool infixr 2 || class AbelianGroup a zero :: AbelianGroup a => a (+) :: AbelianGroup a => a -> a -> a infixl 6 + class AbelianGroup a => AbelianGroupZ a isZero :: AbelianGroupZ a => a -> Bool class AbelianGroupZ a => Ring a (*) :: Ring a => a -> a -> a infixl 7 * class (AbelianGroupZ a) => RingP a mul :: RingP a => Bool -> a -> a -> Pair a data Pair a (:/:) :: a -> a -> Pair a [leftOf] :: Pair a -> a [rightOf] :: Pair a -> a infixl 2 :/: select :: Bool -> [a] -> Pair [a] onlyLeft :: [a] -> Pair [a] onlyRight :: [a] -> Pair [a] newtype O f g a O :: f (g a) -> O f g a [fromO] :: O f g a -> f (g a) sum :: AbelianGroup a => [a] -> a mulDefault :: RingP a => a -> a -> a instance GHC.Show.Show (f (g a)) => GHC.Show.Show (Algebra.RingUtils.O f g a) instance Algebra.RingUtils.AbelianGroupZ (f (g a)) => Algebra.RingUtils.AbelianGroupZ (Algebra.RingUtils.O f g a) instance Algebra.RingUtils.AbelianGroup (f (g a)) => Algebra.RingUtils.AbelianGroup (Algebra.RingUtils.O f g a) instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Algebra.RingUtils.O f g) instance Algebra.RingUtils.Ring GHC.Types.Int instance Algebra.RingUtils.AbelianGroupZ GHC.Types.Int instance Algebra.RingUtils.AbelianGroupZ a => Algebra.RingUtils.AbelianGroupZ (Data.Pair.Pair a) instance Algebra.RingUtils.AbelianGroup GHC.Types.Int instance Algebra.RingUtils.AbelianGroup a => Algebra.RingUtils.AbelianGroup (Data.Pair.Pair a) instance Algebra.RingUtils.AbelianGroup GHC.Types.Bool module Data.Matrix.Quad data Shape Bin :: Shape -> Shape -> Shape Leaf :: Shape data Shape' :: Shape -> * [Bin'] :: !Int -> Shape' s -> Shape' s' -> Shape' (Bin s s') [Leaf'] :: Shape' Leaf data SomeShape [S] :: Shape' s -> SomeShape data Mat :: Shape -> Shape -> * -> * [Quad] :: !Mat x1 y1 a -> !Mat x2 y1 a -> !Mat x1 y2 a -> !Mat x2 y2 a -> Mat (Bin x1 x2) (Bin y1 y2) a [Zero] :: Mat x y a [One] :: !a -> Mat Leaf Leaf a [Row] :: Mat x1 Leaf a -> Mat x2 Leaf a -> Mat (Bin x1 x2) Leaf a [Col] :: Mat Leaf y1 a -> Mat Leaf y2 a -> Mat Leaf (Bin y1 y2) a data Vec :: Shape -> * -> * [Z] :: Vec s a [O] :: a -> Vec Leaf a [:!] :: Vec s a -> Vec s' a -> Vec (Bin s s') a row :: forall {x1 :: Shape} {a} {x2 :: Shape}. Mat x1 'Leaf a -> Mat x2 'Leaf a -> Mat ('Bin x1 x2) 'Leaf a col :: Mat Leaf y1 a -> Mat Leaf y2 a -> Mat Leaf (Bin y1 y2) a quad :: forall {x1 :: Shape} {y1 :: Shape} {a} {x2 :: Shape} {y2 :: Shape}. Mat x1 y1 a -> Mat x2 y1 a -> Mat x1 y2 a -> Mat x2 y2 a -> Mat ('Bin x1 x2) ('Bin y1 y2) a one :: AbelianGroupZ a => a -> Mat Leaf Leaf a (.+.) :: AbelianGroupZ a => Mat x y a -> Mat x y a -> Mat x y a mult :: RingP a => Bool -> Mat x y a -> Mat z x a -> Mat z y (Pair a) trav :: AbelianGroupZ a => Mat y x (Pair a) -> Pair (Mat y x a) q0 :: Mat (Bin x x') (Bin y y') a closeDisjointP :: RingP a => Bool -> Mat x x a -> Mat y x (Pair a) -> Mat y y a -> Pair (Mat y x a) showR :: Mat x y a -> String bin' :: Shape' s -> Shape' s' -> Shape' (Bin s s') mkShape :: Int -> SomeShape mkSing :: AbelianGroupZ a => Shape' x -> Shape' y -> a -> Mat x y a data SomeTri a [T] :: Shape' s -> Pair (Mat s s a) -> SomeTri a type Q a = SomeTri a mkUpDiag :: AbelianGroupZ a => [a] -> Shape' s -> Mat s s a close :: RingP a => Bool -> Mat s s (Pair a) -> Pair (Mat s s a) mkTree :: RingP a => [Pair a] -> SomeTri a quad' :: forall {f} {x1 :: Shape} {y1 :: Shape} {a} {x2 :: Shape} {y2 :: Shape}. Applicative f => f (Mat x1 y1 a) -> f (Mat x2 y1 a) -> f (Mat x1 y2 a) -> f (Mat x2 y2 a) -> f (Mat ('Bin x1 x2) ('Bin y1 y2) a) mergein :: RingP a => Bool -> SomeTri a -> Pair a -> SomeTri a -> SomeTri a -- | A variant of zipWith on vectors zw :: (AbelianGroup a, AbelianGroup b) => (a -> b -> c) -> Vec y a -> Vec y b -> Vec y c -- | Lookup in a vector lk :: AbelianGroup a => Int -> Shape' x -> Vec x a -> a -- | Linearize a matrix lin' :: AbelianGroup a => Mat x y a -> Vec y (Vec x a) -- | Contents of a vector contents :: Shape' x -> Vec x a -> [(Int, a)] first :: (t -> a) -> (t, b) -> (a, b) second :: (t -> b) -> (a, t) -> (a, b) data Path :: Shape -> * [Here] :: Path Leaf [Low] :: Path s -> Path (Bin s s') [High] :: Path s -> Path (Bin s' s) (<||>) :: Maybe (a, Path x) -> Maybe (a, Path x') -> Maybe (a, Path (Bin x x')) -- | What is, and where is the rightmost non-zero element on a given line -- of the matrix? rightmostOnLine :: Path y -> Mat x y a -> Maybe (a, Path x) -- | Is this the rightmost path? isRightmost :: Path x -> Bool results' :: AbelianGroup a => Mat y y a -> Path y -> [(Path y, a, Path y)] results :: AbelianGroupZ a => SomeTri a -> [(Int, a, Int)] leftMost :: Shape' s -> Path s fromPath :: Shape' y -> Path y -> Int root' :: AbelianGroup a => Mat x y a -> a root :: AbelianGroup p => SomeTri p -> p single :: AbelianGroupZ a => Pair a -> SomeTri a square2 :: AbelianGroupZ a => Pair a -> SomeTri a square3 :: RingP a => Bool -> Pair a -> Pair a -> SomeTri a sz' :: Shape' s -> Int (|+|) :: [[a]] -> [[a]] -> [[a]] (-+-) :: [a] -> [a] -> [a] lin :: AbelianGroup a => Shape' x -> Shape' y -> Mat x y a -> [[a]] sparse :: AbelianGroup a => Shape' x -> Shape' y -> Mat x y a -> [(Int, Int, a)] shiftX :: forall {s :: Shape} {b} {c}. Shape' s -> [(Int, b, c)] -> [(Int, b, c)] shiftY :: forall {s :: Shape} {a} {c}. Shape' s -> [(a, Int, c)] -> [(a, Int, c)] fingerprint :: AbelianGroupZ a => SomeTri a -> [[Char]] scatterplot :: AbelianGroup a => SomeTri a -> [Char] instance Algebra.RingUtils.AbelianGroup a => Algebra.RingUtils.AbelianGroup (Data.Matrix.Quad.Vec x a) instance Algebra.RingUtils.AbelianGroupZ a => Algebra.RingUtils.AbelianGroup (Data.Matrix.Quad.Mat x y a) module Data.Matrix.Class fingerprint :: (AbelianGroupZ a, Matrix m) => m a -> [[Char]] (***) :: (t -> a) -> (t -> b) -> (t, t) -> (a, b) data Dimension XD :: Dimension YD :: Dimension quad :: (AbelianGroup a, Matrix m) => m a -> m a -> m a -> m a -> m a nextDim :: Dimension -> Dimension type Extent = (Int, Int) ext :: Dimension -> (a, a) -> a glueExt :: (AbelianGroup a, AbelianGroup b) => Dimension -> (a, b) -> (a, b) -> (a, b) splitExt :: Num b => Dimension -> b -> (b, b) -> ((b, b), (b, b)) class Matrix m at :: (Matrix m, AbelianGroupZ a) => Int -> Int -> m a -> a extent :: Matrix m => m a -> Extent -- | Sigleton matrix singleton :: (Matrix m, AbelianGroupZ a) => a -> m a glue :: (Matrix m, AbelianGroup a) => Dimension -> m a -> m a -> m a split :: (Matrix m, AbelianGroupZ a) => Dimension -> Int -> m a -> (m a, m a) zeroMatrix :: (Matrix m, AbelianGroup a) => Int -> Int -> m a (<|>) :: (AbelianGroup a, Matrix m) => m a -> m a -> m a (<->) :: (AbelianGroup a, Matrix m) => m a -> m a -> m a countColumns :: Matrix m => m a -> Int countRows :: Matrix m => m a -> Int chopLastColumn :: (AbelianGroupZ a, Matrix m) => m a -> m a chopFirstRow :: (AbelianGroupZ a, Matrix m) => m a -> m a chopFirstColumn :: (AbelianGroupZ a, Matrix m) => m a -> m a chopLastRow :: (AbelianGroupZ a, Matrix m) => m a -> m a lastColumn :: (AbelianGroupZ a, Matrix m) => m a -> m a firstRow :: (AbelianGroupZ a, Matrix m) => m a -> m a instance GHC.Show.Show Data.Matrix.Class.Dimension instance GHC.Classes.Eq Data.Matrix.Class.Dimension instance Data.Matrix.Class.Matrix m => Data.Matrix.Class.Matrix (Algebra.RingUtils.O Data.Pair.Pair m) module Parsing.Chart fingerprint :: AbelianGroupZ a => SomeTri a -> [[Char]] mkTree2 :: RingP a => Bool -> [Pair a] -> Q a mkTree :: RingP a => [Pair a] -> Q a mkTree' :: RingP a => [Pair a] -> Q a type Set a = [a] type MT2 a = Q a genXPM :: [[Char]] -> String root :: AbelianGroup p => SomeTri p -> p mergein :: RingP a => Bool -> SomeTri a -> Pair a -> SomeTri a -> SomeTri a single :: AbelianGroupZ a => Pair a -> SomeTri a instance Algebra.RingUtils.AbelianGroup (Parsing.Chart.Set a) instance Algebra.RingUtils.AbelianGroupZ (Parsing.Chart.Set a) module Parsing.TestProgram type Verbosity = Int putStrV :: Verbosity -> String -> IO () mainTest :: forall category token. (RingP [(category, Any)], Eq category) => ((category, Any) -> String) -> (Bool -> token -> Pair [(category, Any)]) -> (String -> [token]) -> (token -> (Int, Int)) -> (category -> String) -> (category -> [category]) -> IO () pairs :: [a] -> [(a, a)] resSz :: Num a => (a, b, a) -> a