c4fc5e5b7bb8848e3aa27e32f999a07cb82203a0
[ghc.git] / ghc / docs / users_guide / vs_haskell.lit
1 %************************************************************************
2 %*                                                                      *
3 \section[vs-Haskell-defn]{Haskell~1.2 vs.~Glasgow Haskell~0.26: language non-compliance}
4 \index{GHC vs the Haskell 1.2 language}
5 \index{Haskell 1.2 language vs GHC}
6 %*                                                                      *
7 %************************************************************************
8
9 This section lists Glasgow Haskell infelicities in its implementation
10 of Haskell~1.2.  See also the ``when things go wrong'' section
11 (\sectionref{wrong}) for information about crashes, space leaks, and
12 other undesirable phenomena.
13
14 The limitations here are listed in Haskell-Report order (roughly).
15 %Limitations related to Glasgow extensions (unboxed numbers, etc.) are
16 %given thereafter (\sectionref{infelicities-Glasgow-exts}).
17
18 %************************************************************************
19 %*                                                                      *
20 \subsection[infelicities-exprs-pats]{Expressions and patterns}
21 %*                                                                      *
22 %************************************************************************
23
24 \begin{description}
25 %-------------------------------------------------------------------
26 \item[Some valid irrefutable patterns are rejected:]
27 As syntax errors; just put parentheses around them.
28
29 %-------------------------------------------------------------------
30 \item[Very long @String@ constants:]
31 May not go through.  If you add a ``string gap'' every
32 few thousand characters, then the strings can be as long
33 as you like.
34
35 Bear in mind that string gaps and the \tr{-cpp}\index{-cpp option}
36 option don't mix.  The C-preprocessor may munch the backslashes.
37
38 %-------------------------------------------------------------------
39 \item[Very long literal lists:]
40 These may tickle a ``yacc stack overflow'' error in the parser.
41 (It depends on the Yacc used to build your parser.)
42 \end{description}
43
44 %************************************************************************
45 %*                                                                      *
46 \subsection[infelicities-decls]{Declarations and bindings}
47 %*                                                                      *
48 %************************************************************************
49
50 \begin{description}
51 %-------------------------------------------------------------------
52 \item[Contexts on @data@ declarations are ignored:]
53 Not that they do much, anyway...  This won't wreck your life.
54 (We still [vaguely] plan to add them, however.)
55
56 %-------------------------------------------------------------------
57 \item[Location of instance declarations is unchecked:]
58 We don't check that instance declarations occur either in the module
59 where the class is declared or the module where the data type is
60 declared.  This shouldn't hurt you.
61
62 For better or worse, we {\em do} check if you try to declare a Prelude
63 instance (Prelude class, Prelude type; e.g., \tr{instance Num Bool})
64 in one of your own modules.  For some reason, people like to do this!
65 (But it is not legal Haskell.)
66
67 %-------------------------------------------------------------------
68 \item[Derived instances of @Text@ for infix constructors:]
69 All the carry-on about derived @readsPrec@ and @showsPrec@ for infix
70 constructors---we don't do it (yet).  We treat them the same way as
71 all other constructors.
72
73 %-------------------------------------------------------------------
74 \item[Derived instances of @Binary@:]
75 We don't.  (We don't do anything @Binary@ish.)
76 \end{description}
77
78 %************************************************************************
79 %*                                                                      *
80 \subsection[infelicities-Modules]{Module system and interface files}
81 %*                                                                      *
82 %************************************************************************
83
84 \begin{description}
85 %-------------------------------------------------------------------
86 \item[Duplicates in a `renaming' list:]
87 Are not reported.
88
89 %-------------------------------------------------------------------
90 \item[Duplicates in an `import' declaration:]
91 These are reported as errors, which some might argue they shouldn't
92 be.  We reckon it's a feature, not a bug.
93
94 %-------------------------------------------------------------------
95 \item[Export of `renamed' class methods:]
96 Willnae work.  That is: you import a class, renaming one or more
97 methods; then export that class---the renaming of the methods {\em
98 will not} propagate.
99
100 (Otherwise, `renaming'---disgusting though it may be---should work.)
101
102 %-------------------------------------------------------------------
103 \item[Fixities/precedences following `renamed' entities that are exported:]
104 No chance.
105
106 %-------------------------------------------------------------------
107 \item[\tr{import Foo ()} vs \tr{import Foo}:]
108 GHC cannot tell the difference (!).
109
110 Given that the only module on which you might want to do the former is
111 \tr{import Prelude ()}, there are probably much bigger gremlins that
112 would jump out and bite you if the import {\em did} work.  Besides
113 which, you can achieve the same result with
114 \tr{-fno-implicit-prelude}.\index{-fno-implicit-prelude option}
115
116 %-------------------------------------------------------------------
117 \item[Some selective import/export checking not done:]
118 On selective import and export of type-constructors/classes in
119 which the data-constructors/methods are named explicitly:
120 it'll work; it's just that every conceivable paranoia
121 check won't be done.
122
123 %-------------------------------------------------------------------
124 \item[Some Prelude entities cannot be hidden:]
125 For example, this doesn't work:
126 \begin{verbatim}
127 import Prelude hiding (readParen)
128 \end{verbatim}
129 That's because there are a few should-be-hideable Prelude entities
130 which need to appear by magic for derived instances.  They are
131 \tr{(&&)}, \tr{(.)}, \tr{lex}, \tr{map}, \tr{not}, \tr{readParen},
132 \tr{showParen}, and \tr{showString}.  SIGH.
133
134 %-------------------------------------------------------------------
135 \item[\tr{M..} exports vs multiply-imported entities:]
136 If an entity \tr{foo} is imported from several interfaces, as in...
137 \begin{verbatim}
138 import A1 (foo); import A2 (foo); import A3 (foo)
139 \end{verbatim}
140 ... and you then do a ``dot dot'' export of \tr{A1} (for example), it
141 will be {\em pure luck} if \tr{foo} gets exported.  This is very sad.
142
143 Workaround: export \tr{foo} explicitly.
144
145 %-------------------------------------------------------------------
146 \item[\tr{M..} with Prelude interfaces:]
147 Doing \tr{Prelude<something>..} in an export list; don't even think
148 it.
149
150 %-------------------------------------------------------------------
151 \item[Export of Prelude types/classes must be explicit:]
152
153 If you want to export a data type, type synonym or class from a
154 Prelude module (its name starts with `Prelude'), then it must be
155 listed explicitly in the export list.  If you say:
156
157 \begin{verbatim}
158 module PreludeMeGently ( PreludeMeGently.. , other_stuff ) where ..
159 \end{verbatim}
160
161 then the classes/types in \tr{PreludeMeGently} will {\em not} be
162 exported; just add them to the export list.  (This shortcoming is only
163 likely to affect people writing their own Prelude modules.)
164
165 %-------------------------------------------------------------------
166 \item[Can't export primitives types (e.g., \tr{Int#}):]
167
168 Don't even try...
169
170 %-------------------------------------------------------------------
171 \item[Naming errors with \tr{-O} but not without:]
172
173 Documentation by example---Consider a module with these imports:
174
175 \begin{verbatim}
176 ... various imports ...
177 import Prettyterm       -- desired import
178
179 import Pretty           -- sadly-needed import
180 \end{verbatim}
181
182 The \tr{import Pretty} is required because it defines a type
183 \tr{Pretty.Doc} which is mentioned in \tr{import Prettyterm}.
184 (Extremely sad, but them's the rules.)
185
186 But without \tr{-O}, GHC uses its \tr{-fuse-get-mentioned-vars} hack
187 (for speed), trying to avoid looking at parts of interfaces that have
188 no relevance to this module.  As it happens, the thing in
189 \tr{Prettyterm} that mentions \tr{Pretty.Doc} is not used here, so
190 this module will go through without \tr{import Pretty}.  Nice, but
191 wrong.
192 \end{description}
193
194 %************************************************************************
195 %*                                                                      *
196 \subsection[infelicities-numbers]{Numbers, basic types, and built-in classes}
197 %*                                                                      *
198 %************************************************************************
199
200 \begin{description}
201 %-------------------------------------------------------------------
202 % now in glasgow_exts
203 %\item[@fromInt@ method in class @Num@:]
204 % (Non-standard.) We support it, as does HBC.
205
206 %-------------------------------------------------------------------
207 \item[Very large/small fractional constants:]
208 (i.e., with a decimal point somewhere) GHC does not check that these
209 are out of range (e.g., for a @Float@), and bad things will inevitably
210 follow.  To be corrected.
211
212 This problem does {\em not} exist for integral constants.
213
214 For very large/small fractional constants near the limits of your
215 floating-point precision, things may go wrong.  (It's better than it
216 used to be.)  Please report any such bugs.
217
218 %-------------------------------------------------------------------
219 \item[Unchecked arithmetic:]
220 Arguably {\em not} an infelicity, but... Bear in mind that operations
221 on \tr{Int}, \tr{Float}, and \tr{Double} numbers are {\em unchecked}
222 for overflow, underflow, and other sad occurrences.
223
224 Use \tr{Integer}, \tr{Rational}, etc., numeric types if this stuff keeps you
225 awake at night.
226
227 %-------------------------------------------------------------------
228 \item[Multiply-defined array elements---not checked:]
229 This code fragment {\em should} elicit a fatal error, but it does not:
230 \begin{verbatim}
231 main = print (array (1,1) [ 1:=2, 1:=3 ])
232 \end{verbatim}
233
234 %-------------------------------------------------------------------
235 \item[Support for @Binary@ whatnot:]
236 We don't.
237 \end{description}
238
239 %************************************************************************
240 %*                                                                      *
241 \subsection[infelicities-IO]{Dialogue I/O}
242 %*                                                                      *
243 %************************************************************************
244
245 Dialogue-style I/O---still the default for GHC---is on its way out
246 (see the stuff about ``monadic I/O for Haskell~1.3''), so we probably
247 won't fix these shortcomings.
248
249 \begin{description}
250 %-------------------------------------------------------------------
251 \item[Support for @Dialogue@ I/O:]
252 We do not yet support all @Requests@, notably:
253 @ReadBinFile@,
254 @WriteBinFile@,
255 @AppendBinFile@,
256 @StatusFile@,
257 @ReadBinChan@,
258 @AppendBinChan@,
259 @StatusChan@,
260 @SetEnv@.  Also, we do not support the optional I/O @Requests@.
261
262 \item[@AppendChan@ and @ReadChan@ requests:]
263 The former only works for \tr{stdout} and \tr{stderr}; the
264 latter only for \tr{stdin}.
265
266 \item[@Echo@ request:]
267 We don't do anything at all.
268 \end{description}
269
270 %************************************************************************
271 %*                                                                      *
272 \subsection[infelicities-Prelude]{In Prelude support}
273 %*                                                                      *
274 %************************************************************************
275
276 \begin{description}
277 %-------------------------------------------------------------------
278 \item[Arbitrary-sized tuples:]
279 Plain old tuples of arbitrary size {\em do} work.
280 Note that lots
281 of overloading can give rise to large tuples ``under the hood'' of
282 your program.
283
284 HOWEVER: standard instances for tuples (@Eq@, @Ord@, @Ix@, and
285 @Binary@) are available {\em only} up to 5-tuples; except @Binary@,
286 which we don't do at all.
287
288 These limitations are easily subvertible, so please ask if you get
289 stuck on them.
290 \end{description}
291
292 %************************************************************************
293 %*                                                                      *
294 %\subsection[infelicities-Glasgow-exts]{In Glasgow extensions}
295 %*                                                                      *
296 %************************************************************************
297
298 %\begin{description}
299 %-------------------------------------------------------------------
300 %\item[Glasgow extensions not well ``packaged'':]
301 %We would rather give you tidy interfaces to the primitive extensions
302 %that GHC provides.  For example, instead of your having to muck around
303 %with...
304 %\begin{verbatim}
305 %    ... _ccall_ fflush ``stderr'' `thenIO_Int_#` ...
306 %\end{verbatim}
307 %... (all very grimy); you should be able to import a \tr{LibC.hi}, and
308 %pretend that @fflush@ is really a Haskell function!
309
310 %This problem will be fixed when Haskell~1.3 comes into existence, and
311 %we implement it.
312
313 %-------------------------------------------------------------------
314 %\item[@ArrRef@s of @Int#@s, @Float#@s, @Double#@s:]
315 %Are not in yet, but will be.  (Easy to add if you're desperate.)
316 %\end{description}
317
318 %************************************************************************
319 %*                                                                      *
320 \section[vs-Haskell-1.3]{Haskell~1.3 DRAFT vs.~Glasgow Haskell~0.26}
321 \index{GHC vs the DRAFT Haskell 1.3 language}
322 \index{Haskell 1.3 language DRAFT vs GHC}
323 %*                                                                      *
324 %************************************************************************
325
326 There is work afoot on ``Haskell~1.3,'' a substantial revision of
327 the Haskell~1.2 language.
328
329 Haskell 1.3 is NOT a standard; it is NOT even a DRAFT standard.  As of
330 June 1995, there exists a 1.3 PROPOSAL, which will CERTAINLY change.
331 Therefore, the ``1.3 things'' we ``support'' may change ARBITRARILY
332 much, and we won't even be mildly apologetic about breaking programs
333 that use ``1.3'' facilities.
334
335 That said, there are two categories of ``1.3'' things that we commend
336 to you.
337 \begin{itemize}
338 \item
339 Things virtually certain to end up in any 1.3~standard.  An example is
340 the \tr{Maybe} type.
341 \item
342 Wobblier things which are so much better than their 1.2 equivalents
343 that you will want to use them.  We mean: monadic I/O.
344
345 The basic I/O functions are ``unlikely'' to change and so are
346 reasonably safe to adopt.  (But see WARNING above...)
347 \end{itemize}
348
349 To use our 1.3 code, you should compile {\em and link} using a
350 \tr{-fhaskell-1.3}\index{-fhaskell-1.3 option} flag.
351
352 %************************************************************************
353 %*                                                                      *
354 \subsection[duffer-1-3]{Duffer's guide for converting 1.2 I/O to 1.3 I/O}
355 \index{I/O---converting 1.2 to 1.3}
356 \index{Dialogue I/O--converting to 1.3}
357 \index{1.2 I/O---converting to 1.3}
358 %*                                                                      *
359 %************************************************************************
360
361 Here is our ``crib sheet'' for converting 1.2 I/O to 1.3.  In most cases,
362 it's really easy.
363 \begin{enumerate}
364 \item
365 Change \tr{readChan stdin} to \tr{hGetContents stdin}.
366 \item
367 Change \tr{appendChan stdout} to \tr{putStr}, which is equivalent to
368 \tr{hPutStr stdout}.
369 Change \tr{appendChan stderr} to \tr{hPutStr stderr}.
370 \item
371 You need to \tr{import LibSystem} if you used @getArgs@, @getEnv@,
372 or @getProgName@.
373 \item
374 Assuming continuation-style @Dialogue@ code, change \tr{... exit done $}
375 to \tr{... >>}.  Change \tr{... exit $ \ foo ->} to \tr{... >>= \ foo ->}.
376 \item
377 If you had any functions named \tr{(>>)}, \tr{(>>=)}, or \tr{return},
378 change them to something else.
379 \end{enumerate}
380
381 %************************************************************************
382 %*                                                                      *
383 \subsection[nonio-1-3]{Non-I/O things from the 1.3-DRAFT proposal}
384 %*                                                                      *
385 %************************************************************************
386
387 Besides the I/O stuff, you also get these things when you use the
388 \tr{-fhaskell-1.3}\index{-fhaskell-1.3 option} flag.
389
390 Once again: ANY of thing might CHANGE COMPLETELY before we have ``1.3
391 for real.''
392
393 \begin{verbatim}
394 data Either a b = Left a | Right b deriving (Text, Eq, Ord)
395
396 data Maybe a = Nothing | Just a deriving (Eq, Ord, Text)
397
398 thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
399 thenMaybe Nothing _ = Nothing
400 thenMaybe (Just x) f = f x
401
402 curry   :: ((a,b) -> c) -> a -> b -> c
403 curry f x y = f (x,y)
404
405 uncurry :: (a -> b -> c) -> (a,b) -> c
406 uncurry f (x,y) = f x y
407 \end{verbatim}
408 \index{Maybe type (Haskell 1.3)}
409 \index{Either type (Haskell 1.3)}
410 \index{curry function (Haskell 1.3)}
411 \index{uncurry function (Haskell 1.3)}
412
413 %************************************************************************
414 %*                                                                      *
415 \subsection[io-1-3]{Vs~1.3 monadic I/O}
416 \index{GHC vs the DRAFT 1.3 I/O proposal}
417 \index{DRAFT 1.3 I/O proposal vs GHC}
418 %*                                                                      *
419 %************************************************************************
420
421 The most notable improvement in Haskell~1.3 is its I/O, with a shift to
422 ``monadic-style'' I/O.
423
424 We still offer direct access to the so-called \tr{PrimIO} monad, via
425 the \tr{PreludeGlaST} interface.  This is NON-STANDARD, an extension.
426 This interface is described in \Sectionref{io-1-3-prim-interface}.
427
428 The old \tr{PreludePrimIO} interface is DEAD.
429
430 The even-older \tr{PreludeGlaIO} interface is DEADER.
431
432 %************************************************************************
433 %*                                                                      *
434 \subsubsection[io-1-3-shortcomings]{Known shortcomings in monadic I/O}
435 %*                                                                      *
436 %************************************************************************
437
438 Before you begin with ``1.3-style'' monadic I/O, you might as well
439 know the known shortcomings of our implementation, as at 0.26.
440
441 The error type is called \tr{IOError13}, rather than \tr{IOError}
442 \index{IOError13 vs IOError}
443 (which is still the 1.2 type).  (Prelude types cannot be renamed,
444 so...)  You probably shouldn't be messing with \tr{IOError} much,
445 anyway.
446
447 Some of the 1.3 I/O code, notably the Extremely Cool \tr{LibPosix}
448 stuff, is relatively untested.  Go for it, but be wary...
449 \index{LibPosix bugs}
450 \index{bugs, LibPosix}
451
452 %************************************************************************
453 %*                                                                      *
454 \subsubsection[io-1-3-main-interface]{1.3-style monadic I/O}
455 %*                                                                      *
456 %************************************************************************
457
458 To use our 1.3 I/O, you should compile {\em and link} using a
459 \tr{-fhaskell-1.3}\index{-fhaskell-1.3 option} flag.
460
461 You should consult the PROPOSED 1.3-I/O standard.  GHC~0.26 implements
462 the ``December 1994'' draft, which we distribute in
463 \tr{ghc/docs/io-1.3/}.
464
465 Alternatively, you could grab the ``June 1995'' draft, from
466 \tr{pub/haskell/report/}, on \tr{ftp.dcs.glasgow.ac.uk}.  The main
467 December--June change that you need to know about is: many of the I/O
468 functions have been removed from \tr{Prelude*} interfaces (no import
469 required) and put into \tr{Lib*} interfaces (import required).
470
471 GHC~0.26 still provides the I/O functions via \tr{Prelude.hi} (no
472 import required).  Ignore the ``June draft'' pleadings for
473 \tr{import LibIO}, and you'll be fine.
474
475 {\em There is no guarantee that the final 1.3 proposal will look
476 anything like the current DRAFT.}  It ain't a standard until the fat
477 committee sings.
478
479 For interaction with our non-standard \tr{PrimIO}, including
480 \tr{_ccall_}s.  we also provide:
481 \begin{verbatim}
482 -- impedance matching stuff
483 ioToPrimIO      :: IO a -> PrimIO a
484 \end{verbatim}
485
486 %************************************************************************
487 %*                                                                      *
488 \subsubsection[io-1-3-prim-interface]{Access to the \tr{PrimIO} monad}
489 \index{PrimIO monad (Glasgow extension)}
490 \index{I/O, primitive (Glasgow extension)}
491 %*                                                                      *
492 %************************************************************************
493
494 In what we have implemented, \tr{PrimIO} is the
495 handle-the-errors-yourself monad (NB: used for C-calls and such);
496 whereas \tr{IO} is the 1.3-ish we-handle-errors-for-you monad.
497
498 Should you may need to play with the \tr{PrimIO} monad directly, you
499 can import \tr{PreludeGlaST}.
500
501 NB: You used to get this stuff from the \tr{PreludePrimIO} interface,
502 which is now deceased.  As of 0.26, you get all things
503 state-transforming from the \tr{PreludeGlaST} interface.
504
505 The usual monadic stuff for \tr{PrimIO}:
506 \begin{verbatim}
507 returnPrimIO    :: a -> PrimIO a
508 thenPrimIO      :: PrimIO a -> (a -> PrimIO b) -> PrimIO b
509 seqPrimIO       :: PrimIO a -> PrimIO b -> PrimIO b
510 fixPrimIO       :: (a -> PrimIO a) -> PrimIO a
511 foldrPrimIO     :: (a -> b -> PrimIO b) -> PrimIO b -> [a] -> PrimIO b
512 listPrimIO      :: [PrimIO a] -> PrimIO [a]
513 mapPrimIO       :: (a -> PrimIO b) -> [a] -> PrimIO [b]
514 mapAndUnzipPrimIO :: (a -> PrimIO (b,c)) -> [a] -> PrimIO ([b],[c])
515 forkPrimIO      :: PrimIO a -> PrimIO a
516
517 unsafePerformPrimIO     :: PrimIO a -> a
518 unsafeInterleavePrimIO  :: PrimIO a -> PrimIO a
519   -- and they are not called "unsafe" for nothing!
520 \end{verbatim}
521
522 And some other stuff:
523 \begin{verbatim}
524 data _FILE  -- corresponds to a "FILE *" in C
525             -- in classes Eq, _CCallable, and _CReturnable
526
527 fclose  :: _FILE -> PrimIO Int
528 fdopen  :: Int -> String -> PrimIO _FILE
529 fflush  :: _FILE -> PrimIO Int
530 fopen   :: String -> String -> PrimIO _FILE
531 fread   :: Int -> Int -> _FILE -> PrimIO (Int, _ByteArray Int)
532 freopen :: String -> String -> _FILE -> PrimIO _FILE
533 fwrite  :: _ByteArray Int -> Int -> Int -> _FILE -> PrimIO Int
534
535 -- please AVOID using these (They will probably die)
536 appendChanPrimIO :: String -> String -> PrimIO ()
537 appendFilePrimIO :: String -> String -> PrimIO ()
538 getArgsPrimIO    :: PrimIO [String]
539 readChanPrimIO   :: String -> PrimIO String
540 \end{verbatim}
541
542 %************************************************************************
543 %*                                                                      *
544 \subsubsection[own-mainPrimIO]{Using your own @mainPrimIO@}
545 \index{mainPrimIO, rolling your own}
546 %*                                                                      *
547 %************************************************************************
548
549 Normally, the GHC runtime system begins things by called an internal
550 function @mainPrimIO :: PrimIO ()@ which, in turn, fires up
551 @dialogueToIO :: Dialogue -> IO ()@, linking in {\em your} @Main.main@
552 to provide the @Dialogue@.
553
554 (If you give a \tr{-fhaskell-1.3} flag, then a {\em different}
555 @mainPrimIO@ will be linked in---that's why it is important to link
556 with \tr{-fhaskell-1.3}...)
557
558 To subvert the above process, you need only provide
559 a @mainPrimIO :: PrimIO ()@ of your own
560 (in a module named \tr{Main}).  Do {\em not} use a \tr{-fhaskell-1.3} flag!
561
562 Here's a little example, stolen from Alastair Reid:
563 \begin{verbatim}
564 module Main ( mainPrimIO ) where
565
566 import PreludeGlaST
567
568 mainPrimIO :: PrimIO ()
569 mainPrimIO = 
570          sleep 5                                `seqPrimIO`
571          _ccall_ printf "%d\n" (14::Int)
572
573 sleep :: Int -> PrimIO ()
574 sleep t = _ccall_ sleep t
575 \end{verbatim}