1f712098bb94fe79d5cbe7b17f5ef56d0fc4b4d2
[haskell-report.git] / report / prelude-index.idx
1 <title> Haskell 98 Prelude Index </title>
2 <body bgcolor="##ffffff"><i>The Haskell 98 Report</i><br>
3 <a href="index.html">top</a><hr>
4
5 <h3> Index of the Haskell 98 Prelude </h3>
6
7 <h4> Types and Synonyms </h4>
8 Instances which are not defined by Haskell code the Prelude (a ... is used)
9 are not hyperlinked.
10 <p>
11 <pre>
12 data #T() = ()  deriving (Eq, Ord, Enum, Bounded) #S6.1.5
13       Instances: #IRead#() #IShow#()
14 data #T[a] = [] | a : [a]  deriving (Eq, Ord) #S6.1.3
15       Instances: #IRead#[a] #IShow#[a] #IFunctor#[a] #IMonad#[a]
16 data #T(a,b) = (a,b) deriving (Eq, Ord, Bounded) #S6.1.4 
17       Instances: #IRead#(a,b) #IShow#(a,b)
18 data a->b #S6.1.6
19 data #TBool = False | True deriving (Eq, Ord, Enum, Read, Show, Bounded) #S6.1.1
20 data #TChar #S6.1.2
21        Instances: Eq Ord #IEnum#Char #IRead#Char #IShow#Char 
22 data #TDouble #S6.4 
23        Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
24 data #TEither a b  e=  Left a | Right b deriving (Eq, Ord, Read, Show) #S6.1.8
25 type #TFilePath =  String #S7.1
26 data #TFloat #S6.4
27        Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
28 data #TInt #S6.4
29        Instances: Eq Ord Enum Read Show Num Real Integral Bounded
30 data #TInteger #S6.4
31        Instances: Eq Ord Enum Read Show Num Real Integral
32 data #TIO a #S6.1.7
33        Instances: #IFunctor#IO Monad
34 data #TIOError #S6.1.7
35        Instances: Show Eq
36 data #TMaybe a  =  Nothing | Just a deriving (Eq, Ord, Read, Show) #S6.1.8
37         Instances: #IFunctor#Maybe #IMonad#Maybe
38 data #TOrdering = LT | EQ | GT  deriving (Eq, Ord, Enum, Read, Show, Bounded) #S6.1.8
39 type #TReadS a = String -> [(a,String)] #S6.3.3
40 type #TShowS = String -> String #S6.3.3
41 type #TString = [Char] #S6.1.2
42 </pre>
43
44 <h4> Constructors </h4>
45 <pre>
46 #L[]#T[a]
47 #L:#T[a]
48 #L(,)#T(a,b)
49 #LEQ#TOrdering
50 #LFalse#TBool
51 #LGT#TOrdering
52 #LJust#TMaybe
53 #LLeft#TEither
54 #LLT#TOrdering
55 #LNothing#TMaybe
56 #LRight#TEither
57 #LTrue#TBool
58
59 </pre>
60
61 <h4> Classes </h4>
62 <pre>
63 class                             #TBounded a    #S6.3.7
64 class                             #TEnum a       #S6.3.4
65 class                             #TEq a         #S6.3.1
66 class           (Fractional a) => #TFloating a   #S6.4
67 class                  (Num a) => #TFractional a #S6.4
68 class                             #TFunctor f    #S6.3.5
69 class         (Real a, Enum a) => #TIntegral a   #S6.4
70 class                             #TMonad m      #S6.3.6
71 class           (Eq a, Show a) => #TNum a        #S6.4
72 class                   (Eq a) => #TOrd a        #S6.3.2
73 class                             #TRead a       #S6.3.3
74 class           (Num a, Ord a) => #TReal a       #S6.4
75 class (RealFrac a, Floating a) => #TRealFloat a  #S6.4  
76 class   (Real a, Fractional a) => #TRealFrac a   #S6.4
77 class                             #TShow a       #S6.3.3 
78
79 </pre>
80 <h4> Functions and Methods </h4>
81 <table>
82 #table
83 #V(!!)             :: [a] -> Int -> a #&[0,1,2] !! 1 = 1
84 #V($)              :: (a -> b) -> a -> b #&f x $ g y = f x (g y)    
85 #V($!)             :: (a -> b) -> (a -> b) #&#S6.2
86 #V(&&)             :: Bool -> Bool -> Bool #&Boolean `and'
87 #V(||)             :: Bool -> Bool -> Bool #&Boolean `or'
88 #V(*)              :: Num a => a -> a -> a 
89 #V(**)             :: Floating a => a -> a -> a 
90 #V(+)              :: Num a => a -> a -> a
91 #V(++)             :: [a] -> [a] -> [a] #&"abc" ++ "def" = "abcdef"
92 #V(-)              :: Num a => a -> a -> a 
93 #V(.)              :: (b -> c) -> (a -> b) -> a -> c #&Function composition
94 #V(/)              :: Fractional a => a -> a -> a 
95 #V(/=)             :: Eq a => a -> a -> Bool #&not equal
96 #V(<)              :: Ord a => a -> a -> Bool 
97 #V(<=)             :: Ord a => a -> a -> Bool 
98 #V(==)             :: Eq a => a -> a -> Bool 
99 #V(=<<)            :: Monad a => (a -> m b) -> m a -> m b  #&Monadic binding #S6.3.6
100 #V(>)              :: Ord a => a -> a -> Bool 
101 #V(>=)             :: Ord a => a -> a -> Bool 
102 #V(>>)             :: Monad m => m a -> m b -> m b #&Monadic binding #S6.3.6
103 #V(>>=)            :: Monad m => m a -> (a -> m b) -> m b #&Monadic binding #S6.3.6
104 #V(^)              :: (Num a, Integral b) => a -> b -> a 
105 #V(^^)             :: (Fractional a, Integral b) => a -> b -> a #&negative exponent allowed
106 #Vabs              :: Num a => a -> a 
107 #Vacos             :: Floating a => a -> a 
108 #Vacosh            :: Floating a => a -> a 
109 #Vall              :: (a -> Bool) -> [a] -> Bool #&all (/= 'a') "cba" = False
110 #Vand              :: [Bool] -> Bool #&and [True, True, True] = True
111 #Vany              :: (a -> Bool) -> [a] -> Bool #&any (== 'c') "abc" = True
112 #VappendFile       :: FilePath -> String -> IO ()
113 #VapplyM           :: Monad m => (a -> m b) -> m a -> m b
114 #VasTypeOf         :: a -> a -> a #&Sort of a type cast
115 #Vasin             :: Floating a => a -> a 
116 #Vasinh            :: Floating a => a -> a 
117 #Vatan             :: Floating a => a -> a 
118 #Vatan2            :: RealFrac a => a -> a 
119 #Vatanh            :: Floating a => a -> a 
120 #Vbreak            :: (a -> Bool) -> [a] -> ([a], [a]) #&break (<2) [1,2,3] = ([1],[2,3])
121 #Vcatch            :: IO a -> (IOError -> IO a) -> IO a 
122 #Vceiling          :: (RealFrac a, Integral b) => a -> b 
123 #Vcompare          :: Ord a => a -> a -> Ordering 
124 #Vconcat           :: MonadPlus m => [m a] -> m a #&concat ["a","bc","d"] = "abcd"
125 #VconcatMap        :: (a -> [b]) -> [a] -> [b]
126 #Vconst            :: a -> b -> a
127 #Vcos              :: Floating a => a -> a 
128 #Vcosh             :: Floating a => a -> a 
129 #Vcurry            :: ((a, b) -> c) -> a -> b -> c
130 #Vcycle            :: [a] -> [a] #&cycle "abc" = "abcabcabc ..."
131 #VdecodeFloat      :: RealFloat a => a -> (Integer, Int) 
132 #Vdiv              :: Integral a => a -> a -> a 
133 #VdivMod           :: Integral a => a -> a -> (a, a) 
134 #Vdrop             :: Int -> [a] -> [a] #&drop 2 "abcd" = "cd"
135 #VdropWhile        :: (a -> Bool) -> [a] -> [a] #&dropWhile (>3) [5,3,5] = [3,5]
136 #Veither           :: (a -> c) -> (b -> c) -> Either a b -> c
137 #Velem             :: Eq a => a -> [a] -> Bool #&'a' `elem` "abc" = True
138 #VencodeFloat      :: RealFloat a => Integer -> Int -> a 
139 #VenumFrom         :: Enum a => a -> [a] #&[n..]
140 #VenumFromThen     :: Enum a => a -> a -> [a] #&[m,n..]
141 #VenumFromThenTo   :: Enum a => a -> a -> a -> [a] #&[m,n..o]
142 #VenumFromTo       :: Enum a => a -> a -> [a] #&[m..n]
143 #Verror            :: String -> a #& #S3.1
144 #Veven             :: Integral a => a -> Bool
145 #Vexp              :: Floating a => a -> a 
146 #Vexponent         :: RealFloat a => a -> Int 
147 #Vfail             :: Monad m => String -> m a
148 #Vfilter           :: (a -> Bool) -> [a] -> [a]
149 #Vflip             :: (a -> b -> c) -> (b -> a -> c)
150 #VfloatDigits      :: RealFloat a => a -> Int 
151 #VfloatRadix       :: RealFloat a => a -> Integer 
152 #VfloatRange       :: RealFloat a => a -> (Int, Int) 
153 #Vfloor            :: (RealFrac a, Integral b) => a -> b 
154 #Vfmap             :: Functor f => (a -> b) -> f a -> f b
155 #Vfoldl            :: (a -> b -> a) -> a -> [b] -> a #&foldl (+) 0 [a,b,c] = ((0+a)+b)+c
156 #Vfoldl1           :: (a -> a -> a) -> [a] -> a #&foldl1 (+) [a,b,c] = (a+b)+c
157 #Vfoldr            :: (a -> b -> b) -> b -> [a] -> b #&foldr (+) 0 [a,b,c] = a+(b+(c+0))
158 #Vfoldr1           :: (a -> a -> a) -> [a] -> a #&foldr1 (+) [a,b,c] = a+(b+c)
159 #VfromEnum         :: Enum a => a -> Int 
160 #VfromInteger      :: Num a => Integer -> a #&#S3.2
161 #VfromIntegral     :: (Integral a, Num b) => a -> b
162 #VfromRational     :: Fractional a => Rational -> a #&#S3.2
163 #Vfst              :: (a, b) -> a
164 #Vgcd              :: (Integral a) => a -> a -> a
165 #VgetChar          :: IO Char #&eof generates an IOError
166 #VgetContents      :: IO String
167 #VgetLine          :: IO String #&eof generates an IOError
168 #Vhead             :: [a] -> a
169 #Vid               :: a -> a
170 #Vinit             :: [a] -> [a]#&init "abcd" = "abc"
171 #Vinteract         :: (String -> String) -> IO ()
172 #VioError          :: IOError -> IO a 
173 #VisDenormalized   :: RealFloat a => a -> Bool 
174 #VisIEEE           :: RealFloat a => a -> Bool 
175 #VisInfinite       :: RealFloat a => a -> Bool 
176 #VisNaN            :: RealFloat a => a -> Bool 
177 #VisNegativeZero   :: RealFloat a => a -> Bool 
178 #Viterate          :: (a -> a) -> a -> [a] #&iterate (++ " ") "" = ["", " ", "  ",...]
179 #Vlast             :: [a] -> a #&last "abcde" = "e"
180 #Vlcm              :: Integral a => a -> a -> a
181 #Vlength           :: [a] -> Int #&length "Abc" = 3
182 #Vlex              :: ReadS String #&lex "abc def" = [("abc"," def")]
183 #Vlines            :: String -> [String]
184 #Vlog              :: Floating a => a -> a 
185 #VlogBase          :: Floating a => a -> a -> a 
186 #Vlookup           :: Eq a => a -> [(a, b)] -> Maybe b
187 #Vmap              :: (a -> b) -> [a] -> [b] 
188 #VmapM             :: Monad m => (a -> m b) -> [a] -> m [b]
189 #VmapM_            :: Monad m => (a -> m b) -> [a] -> m ()
190 #Vmax              :: Ord a => a -> a -> a 
191 #VmaxBound         :: Bounded a => a 
192 #Vmaximum          :: Ord a => [a] -> a
193 #Vmaybe            :: b -> (a -> b) -> Maybe a -> b #&maybe 0 (+1) (Just 1) = 2
194 #Vmin              :: Ord a => a -> a -> a 
195 #VminBound         :: Bounded a => a 
196 #Vminimum          :: Ord a => [a] -> a
197 #Vmod              :: Integral a => a -> a -> a 
198 #Vnegate           :: Num a => a -> a 
199 #Vnot              :: Bool -> Bool
200 #VnotElem          :: Eq a => a -> [a] -> Bool
201 #Vnull             :: [a] -> Bool
202 #Vodd              :: Integral a => a -> Bool
203 #Vor               :: [Bool] -> Bool
204 #Votherwise        :: Bool
205 #Vpi               :: Floating a => a 
206 #Vpred             :: Enum a => a -> a #&pred True = False
207 #Vprint            :: Show a => a -> IO () #&adds a newline
208 #Vproduct          :: Num a => [a] -> a
209 #VproperFraction   :: (RealFrac a, Integral b) => a -> (b, a) 
210 #VputChar          :: Char -> IO ()
211 #VputStr           :: String -> IO ()
212 #VputStrLn         :: String -> IO () #&adds a newline
213 #Vquot             :: Integral a => a -> a -> a 
214 #VquotRem          :: Integral a => a -> a -> (a, a) 
215 #Vread             :: Read a => String -> a
216 #VreadFile         :: FilePath -> IO String
217 #VreadIO           :: Read a => String -> IO a #&fails with IOError
218 #VreadList         :: Read a => ReadS [a]
219 #VreadLn           :: Read a => IO a
220 #VreadParen        :: Bool -> ReadS a -> ReadS a
221 #Vreads            :: Read a => ReadS a #&reads "1 2" :: [(Int,String)] = [(1," 2")]
222 #VreadsPrec        :: Read a => Int -> ReadS a
223 #VrealToFrac       :: (Real a, Fractional b) => a -> b
224 #Vrecip            :: Fractional a => a -> a 
225 #Vrem              :: Integral a => a -> a -> a 
226 #Vrepeat           :: a -> [a] #&repeat 'a' = "aaaaaaaaa..."
227 #Vreplicate        :: Int -> a -> [a] #&replicate 4 'a' = "aaaa"
228 #Vreturn           :: Monad m => a -> m a 
229 #Vreverse          :: [a] -> [a] #&reverse "abc" = "cba"
230 #Vround            :: (RealFrac a, Integral b) => a -> b 
231 #VscaleFloat       :: RealFloat a => Int -> a -> a 
232 #Vscanl            :: (a -> b -> a) -> a -> [b] -> [a] #&scanl (+) 0 [1,2,3] = [0,1,3,6]
233 #Vscanl1           :: (a -> a -> a) -> [a] -> [a] #&scanl1 (+) [1,2,3] = [1,3,6]
234 #Vscanr            :: (a -> b -> b) -> b -> [a] -> [b] #&scanr (+) 0 [1,2,3] = [6,5,3,0]
235 #Vscanr1           :: (a -> a -> a) -> [a] -> [a] #&scanr1 (+) [1,2,3] = [6,5,3]
236 #Vseq              :: a -> b -> b #&#S6.2
237 #Vsequence         :: Monad m => [m a] -> m [a] 
238 #Vsequence_        :: Monad m => [m a] -> m () #&do operations in sequence
239 #Vshow             :: Show a => a -> String #&#S6.3.3
240 #VshowChar         :: Char -> ShowS
241 #VshowList         :: Show a => [a] -> ShowS
242 #VshowParen        :: Bool -> ShowS -> ShowS
243 #VshowString       :: String -> ShowS
244 #Vshows            :: Show a => a -> ShowS #&#S6.3.3
245 #VshowsPrec        :: Show a => Int -> a -> ShowS #&#S6.3.3
246 #Vsignificand      :: RealFloat a => a -> a 
247 #Vsignum           :: Num a => a -> a 
248 #Vsin              :: Floating a => a -> a 
249 #Vsinh             :: Floating a => a -> a 
250 #Vsnd              :: (a, b) -> b
251 #Vspan             :: (a -> Bool) -> [a] -> ([a], [a]) #&span isAlpha "ab cd" = ("ab"," cd")
252 #VsplitAt          :: Int -> [a] -> ([a], [a]) #&splitAt 2 "abcdef" = ("ab","cdef")
253 #Vsqrt             :: Floating a => a -> a 
254 #Vsubtract         :: Num a => a -> a -> a
255 #Vsucc             :: Enum a => a -> a #&succ False = True
256 #Vsum              :: Num a => [a] -> a #&sum [1,2,3] = 6
257 #Vtail             :: [a] -> [a] #&tail "abc" = "bc"
258 #Vtake             :: Int -> [a] -> [a] #&take 3 "abcde" = "abc"
259 #VtakeWhile        :: (a -> Bool) -> [a] -> [a] #&takeWhile (> 2) [3,2,1] = [3]
260 #Vtan              :: Floating a => a -> a 
261 #Vtanh             :: Floating a => a -> a 
262 #VtoEnum           :: Enum a => Int -> a #&toEnum 0 :: Bool = False
263 #VtoInteger        :: Integral a => a -> Integer 
264 #VtoRational       :: Real a => a -> Rational 
265 #Vtruncate         :: (RealFrac a, Integral b) => a -> b 
266 #Vuncurry          :: (a -> b -> c) -> ((a, b) -> c)
267 #Vundefined        :: a #&#S3.1
268 #Vunlines          :: [String] -> String
269 #Vuntil            :: (a -> Bool) -> (a -> a) -> a -> a #&until (> 3) (+ 2) 0 = 4
270 #Vunwords          :: [String] -> String
271 #Vunzip            :: [(a, b)] -> ([a], [b]) #&unzip [('a','b'),('c','d')] = ("ac",bd")
272 #Vunzip3           :: [(a, b, c)] -> ([a], [b], [c])
273 #VuserError        :: String  -> IOError
274 #Vwords            :: String -> [String] #&words "ab d as+3" = ["ab","d","as+3"]
275 #VwriteFile        :: FilePath -> String -> IO ()
276 #Vzip              :: [a] -> [b] -> [(a, b)] #&zip "abc" "de" = [('a','d'), ('b',e')]
277 #Vzip3             :: [a] -> [b] -> [c] -> [(a, b, c)]
278 #VzipWith          :: (a -> b -> c) -> [a] -> [b] -> [c] #&zipWith (+) [1,2] [3,4] = [4,6]
279 #VzipWith3         :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
280 #endtable
281 </table>