- Standard combinators
- Boolean functions
- Character functions
- Standard type classes
- Standard numerical functions
- Standard list processing functions
- List breaking functions
- Text processing:
- Merging and sorting lists:
- zip and zipWith families of functions:
- Formatted output
- Miscellaneous
- A trimmed down version of the Haskell Text class
- I/O functions and definitions

Copyright Mark P Jones 1991-1994. Copyright Don Stewart, 2009

Functional programming environment, Version 2.30 Standard prelude for use of overloaded values using type classes. Based on the Haskell standard prelude version 1.2.

- strict :: (t -> a) -> t -> a
- const :: a -> b -> a
- id :: a -> a
- curry :: ((a, b) -> c) -> a -> b -> c
- uncurry :: (a -> b -> c) -> (a, b) -> c
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- fst3 :: (a, b, c) -> a
- snd3 :: (a, b, c) -> b
- thd3 :: (a, b, c) -> c
- (.) :: (b -> c) -> (a -> b) -> a -> c
- flip :: (a -> b -> c) -> b -> a -> c
- ($) :: (a -> b) -> a -> b
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- and :: [Bool] -> Bool
- or :: [Bool] -> Bool
- any :: (a -> Bool) -> [a] -> Bool
- all :: (a -> Bool) -> [a] -> Bool
- otherwise :: Bool
- ord :: Char -> Int
- chr :: Int -> Char
- isAscii :: Char -> Bool
- isControl :: Char -> Bool
- isPrint :: Char -> Bool
- isSpace :: Char -> Bool
- isUpper :: Char -> Bool
- isLower :: Char -> Bool
- isAlpha :: Char -> Bool
- isDigit :: Char -> Bool
- isAlphanum :: Char -> Bool
- minChar :: Char
- maxChar :: Char
- (==) :: Eq a => a -> a -> Bool
- (/=) :: Eq a => a -> a -> Bool
- (<) :: 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
- range :: Ix a => (a, a) -> [a]
- index :: Ix a => (a, a) -> a -> Int
- inRange :: Ix a => (a, a) -> a -> Bool
- enumFrom :: Enum a => a -> [a]
- enumFromThen :: Enum a => a -> a -> [a]
- enumFromTo :: Enum a => a -> a -> [a]
- enumFromThenTo :: Enum a => a -> a -> a -> [a]
- (+) :: Num a => a -> a -> a
- (-) :: Num a => a -> a -> a
- (*) :: Num a => a -> a -> a
- (/) :: Num a => a -> a -> a
- negate :: Num a => a -> a
- fromInteger_ :: Num a => Int -> a
- sin :: Float -> Float
- asin :: Float -> Float
- cos :: Float -> Float
- acos :: Float -> Float
- tan :: Float -> Float
- atan :: Float -> Float
- log :: Float -> Float
- exp :: Float -> Float
- sqrt :: Float -> Float
- atan2 :: Float -> Float
- truncate :: Float -> Int
- pi :: Float
- div :: Int -> Int -> Int
- quot :: Int -> Int -> Int
- rem :: Int -> Int -> Int
- mod :: Int -> Int -> Int
- subtract :: Num a => a -> a -> a
- even :: Int -> Bool
- odd :: Int -> Bool
- gcd :: Int -> Int -> Int
- lcm :: Int -> Int -> Int
- (^) :: Num a => a -> Int -> a
- abs :: (Num a, Ord a) => a -> a
- signum :: (Num a, Ord a) => a -> Int
- sum :: Num a => [a] -> a
- product :: Num a => [a] -> a
- sums :: Num a => [a] -> [a]
- products :: Num a => [a] -> [a]
- head :: [a] -> a
- last :: [a] -> a
- tail :: [a] -> [a]
- init :: [a] -> [a]
- (++) :: [a] -> [a] -> [a]
- genericLength :: Num a => [b] -> a
- length :: [a] -> Int
- (!!) :: [a] -> Int -> a
- iterate :: (a -> a) -> a -> [a]
- repeat :: a -> [a]
- cycle :: [a] -> [a]
- copy :: Int -> a -> [a]
- nub :: Eq a => [a] -> [a]
- reverse :: [a] -> [a]
- elem :: Eq a => a -> [a] -> Bool
- notElem :: Eq a => a -> [a] -> Bool
- maximum :: Ord a => [a] -> a
- minimum :: Ord a => [a] -> a
- concat :: [[a]] -> [a]
- transpose :: [[a]] -> [[a]]
- null :: [a] -> Bool
- (\\) :: Eq a => [a] -> [a] -> [a]
- map :: (a -> b) -> [a] -> [b]
- filter :: (a -> Bool) -> [a] -> [a]
- foldl :: (a -> b -> a) -> a -> [b] -> a
- foldl1 :: (a -> a -> a) -> [a] -> a
- foldl' :: (a -> b -> a) -> a -> [b] -> a
- scanl :: (a -> b -> a) -> a -> [b] -> [a]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanl' :: (a -> b -> a) -> a -> [b] -> [a]
- foldr :: (a -> b -> b) -> b -> [a] -> b
- foldr1 :: (a -> a -> a) -> [a] -> a
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- take :: Int -> [a] -> [a]
- drop :: Int -> [a] -> [a]
- splitAt :: Int -> [a] -> ([a], [a])
- takeWhile :: (a -> Bool) -> [a] -> [a]
- takeUntil :: (a -> Bool) -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- break :: (a -> Bool) -> [a] -> ([a], [a])
- lines :: String -> [String]
- words :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String
- merge :: Ord a => [a] -> [a] -> [a]
- sort :: Ord a => [a] -> [a]
- insert :: Ord a => a -> [a] -> [a]
- qsort :: Ord a => [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- unzip :: [(a, b)] -> ([a], [b])
- cjustify :: Int -> String -> String
- ljustify :: Int -> String -> String
- rjustify :: Int -> String -> String
- space :: Int -> String
- layn :: [String] -> String
- until :: (a -> Bool) -> (a -> a) -> a -> a
- until' :: (a -> Bool) -> (a -> a) -> a -> [a]
- error :: [Char] -> a
- undefined :: a
- asTypeOf :: a -> a -> a
- type ShowS = String -> String
- showsPrec :: Text a => Int -> a -> ShowS
- showList :: Text a => [a] -> ShowS
- shows :: Text a => a -> ShowS
- show :: Text a => a -> String
- showChar :: Char -> ShowS
- showString :: String -> ShowS
- stdin :: [Char]
- stdout :: [Char]
- stderr :: [Char]
- stdecho :: [Char]
- data Request
- data Response
- data IOError
- type Dialogue = [Response] -> [Request]
- type SuccCont = Dialogue
- type StrCont = String -> Dialogue
- type StrListCont = [String] -> Dialogue
- type FailCont = IOError -> Dialogue
- done :: Dialogue
- readFile :: String -> FailCont -> StrCont -> Dialogue
- writeFile :: String -> String -> FailCont -> SuccCont -> Dialogue
- appendFile :: String -> String -> FailCont -> SuccCont -> Dialogue
- readChan :: String -> FailCont -> StrCont -> Dialogue
- appendChan :: String -> String -> FailCont -> SuccCont -> Dialogue
- echo :: Bool -> FailCont -> SuccCont -> Dialogue
- getArgs :: FailCont -> StrListCont -> Dialogue
- getProgName :: FailCont -> StrCont -> Dialogue
- getEnv :: String -> FailCont -> StrCont -> Dialogue
- strDispatch :: (IOError -> [Response] -> t) -> (String -> [Response] -> t) -> [Response] -> t
- succDispatch :: (IOError -> [Response] -> t) -> ([Response] -> t) -> [Response] -> t
- strListDispatch :: (IOError -> [Response] -> t) -> ([String] -> [Response] -> t) -> [Response] -> t
- abort :: FailCont
- exit :: FailCont
- print :: Text a => a -> Dialogue
- prints :: Text a => a -> String -> Dialogue
- interact :: (String -> String) -> Dialogue
- run :: (String -> String) -> Dialogue
- openfile :: String -> String
- help :: [Char]

# Documentation

__________ __________ __________ __________ ________ / _______/ / ____ / / _______/ / _______/ / ____ \ / / _____ / / / / / /______ / /______ / /___/ / / / /_ / / / / / / _______/ / _______/ / __ __/ / /___/ / / /___/ / / / / /______ / / \ \ /_________/ /_________/ /__/ /_________/ /__/ \__\

Functional programming environment, Version 2.30 Copyright Mark P Jones 1991-1994.

Standard prelude for use of overloaded values using type classes. Based on the Haskell standard prelude version 1.2.

# Standard combinators

# Boolean functions

# Character functions

isAlphanum :: Char -> BoolSource

# Standard type classes

enumFromThen :: Enum a => a -> a -> [a]Source

enumFromTo :: Enum a => a -> a -> [a]Source

enumFromThenTo :: Enum a => a -> a -> a -> [a]Source

fromInteger_ :: Num a => Int -> aSource

# Standard numerical functions

# Standard list processing functions

genericLength :: Num a => [b] -> aSource

null provides a simple and efficient way of determining whether a given list is empty, without using (==) and hence avoiding a constraint of the form Eq [a].

(\\) :: Eq a => [a] -> [a] -> [a]Source

(\) is used to remove the first occurrence of each element in the second list from the first list. It is a kind of inverse of (++) in the sense that (xs ++ ys) \ xs = ys for any finite list xs of proper values xs.

map :: (a -> b) -> [a] -> [b]Source

map f xs applies the function f to each element of the list xs returning the corresponding list of results. filter p xs returns the sublist of xs containing those elements which satisfy the predicate p.

foldl :: (a -> b -> a) -> a -> [b] -> aSource

Fold primitives: The foldl and scanl functions, variants foldl1 and scanl1 for non-empty lists, and strict variants foldl' scanl' describe common patterns of recursion over lists. Informally:

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

etc...

The functions foldr, scanr and variants foldr1, scanr1 are duals of these functions:

foldr f a xs = foldl (flip f) a (reverse xs) for finite lists xs.

# List breaking functions

take :: Int -> [a] -> [a]Source

List breaking functions:

take n xs returns the first n elements of xs drop n xs returns the remaining elements of xs splitAt n xs = (take n xs, drop n xs)

takeWhile p xs returns the longest initial segment of xs whose elements satisfy p dropWhile p xs returns the remaining portion of the list span p xs = (takeWhile p xs, dropWhile p xs)

takeUntil p xs returns the list of elements upto and including the first element of xs which satisfies p

# Text processing:

lines :: String -> [String]Source

Text processing: lines s returns the list of lines in the string s. words s returns the list of words in the string s. unlines ls joins the list of lines ls into a single string with lines separated by newline characters. unwords ws joins the list of words ws into a single string with words separated by spaces.

# Merging and sorting lists:

# zip and zipWith families of functions:

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]Source

zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]Source

# Formatted output

# Miscellaneous

# A trimmed down version of the Haskell Text class

showString :: String -> ShowSSource

# I/O functions and definitions

The Dialogue, Request, Response and IOError datatypes are now builtin:

type StrListCont = [String] -> DialogueSource

getArgs :: FailCont -> StrListCont -> DialogueSource

getProgName :: FailCont -> StrCont -> DialogueSource