X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=docs%2Fusers_guide%2Fglasgow_exts.xml;h=285785879f6f57d6dfc334a87bf00df998082daf;hb=18928fea8c5ab8fadeacec48890baf558c64f8c8;hp=053c4a93e1226d139051ba994f016b1dee1d632a;hpb=0ee3de0a4ed263648599dee5d94e00585c5584a2;p=ghc-hetmet.git
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index 053c4a9..2857858 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -717,9 +717,11 @@ qualifier list has just one element, a boolean expression.
The recursive do-notation (also known as mdo-notation) is implemented as described in
-"A recursive do for Haskell",
-Levent Erkok, John Launchbury",
+A recursive do for Haskell,
+by Levent Erkok, John Launchbury,
Haskell Workshop 2002, pages: 29-37. Pittsburgh, Pennsylvania.
+This paper is essential reading for anyone making non-trivial use of mdo-notation,
+and we do not repeat it here.
The do-notation of Haskell does not allow recursive bindings,
@@ -750,11 +752,18 @@ class Monad m => MonadFix m where
The function mfix
-dictates how the required recursion operation should be performed. If recursive bindings are required for a monad,
-then that monad must be declared an instance of the MonadFix class.
-For details, see the above mentioned reference.
+dictates how the required recursion operation should be performed. For example,
+justOnes desugars as follows:
+
+justOnes = mfix (\xs' -> do { xs <- Just (1:xs'); return xs }
+
+For full details of the way in which mdo is typechecked and desugared, see
+the paper A recursive do for Haskell.
+In particular, GHC implements the segmentation technique described in Section 3.2 of the paper.
+If recursive bindings are required for a monad,
+then that monad must be declared an instance of the MonadFix class.
The following instances of MonadFix are automatically provided: List, Maybe, IO.
Furthermore, the Control.Monad.ST and Control.Monad.ST.Lazy modules provide the instances of the MonadFix class
for Haskell's internal state monad (strict and lazy, respectively).
@@ -2810,9 +2819,24 @@ Suppose that from the RHS of f we get the constraint
GHC does not commit to instance (C), because in a particular
call of f, b might be instantiate
to Int, in which case instance (D) would be more specific still.
-So GHC rejects the program. If you add the flag ,
+So GHC rejects the program.
+(If you add the flag ,
GHC will instead pick (C), without complaining about
-the problem of subsequent instantiations.
+the problem of subsequent instantiations.)
+
+
+Notice that we gave a type signature to f, so GHC had to
+check that f has the specified type.
+Suppose instead we do not give a type signature, asking GHC to infer
+it instead. In this case, GHC will refrain from
+simplifying the constraint C Int [Int] (for the same reason
+as before) but, rather than rejecting the program, it will infer the type
+
+ f :: C Int b => [b] -> [b]
+
+That postpones the question of which instance to pick to the
+call site for f
+by which time more is known about the type b.
The willingness to be overlapped or incoherent is a property of
@@ -6356,112 +6380,10 @@ r) ->
Special built-in functions
-GHC has a few built-in funcions with special behaviour,
-described in this section. All are exported by
-GHC.Exts.
-
-The seq function
-
-The function seq is as described in the Haskell98 Report.
-
- seq :: a -> b -> b
-
-It evaluates its first argument to head normal form, and then returns its
-second argument as the result. The reason that it is documented here is
-that, despite seq's polymorphism, its
-second argument can have an unboxed type, or
-can be an unboxed tuple; for example (seq x 4#)
-or (seq x (# p,q #)). This requires b
-to be instantiated to an unboxed type, which is not usually allowed.
-
-
-
-The inline function
-
-The inline function is somewhat experimental.
-
- inline :: a -> a
-
-The call (inline f) arranges that f
-is inlined, regardless of its size. More precisely, the call
-(inline f) rewrites to the right-hand side of f's
-definition.
-This allows the programmer to control inlining from
-a particular call site
-rather than the definition site of the function
-(c.f. INLINE pragmas ).
-
-
-This inlining occurs regardless of the argument to the call
-or the size of f's definition; it is unconditional.
-The main caveat is that f's definition must be
-visible to the compiler. That is, f must be
-let-bound in the current scope.
-If no inlining takes place, the inline function
-expands to the identity function in Phase zero; so its use imposes
-no overhead.
-
- If the function is defined in another
-module, GHC only exposes its inlining in the interface file if the
-function is sufficiently small that it might be
-inlined by the automatic mechanism. There is currently no way to tell
-GHC to expose arbitrarily-large functions in the interface file. (This
-shortcoming is something that could be fixed, with some kind of pragma.)
-
-
-
-The lazy function
-
-The lazy function restrains strictness analysis a little:
-
- lazy :: a -> a
-
-The call (lazy e) means the same as e,
-but lazy has a magical property so far as strictness
-analysis is concerned: it is lazy in its first argument,
-even though its semantics is strict. After strictness analysis has run,
-calls to lazy are inlined to be the identity function.
-
-
-This behaviour is occasionally useful when controlling evaluation order.
-Notably, lazy is used in the library definition of
-Control.Parallel.par:
-
- par :: a -> b -> b
- par x y = case (par# x) of { _ -> lazy y }
-
-If lazy were not lazy, par would
-look strict in y which would defeat the whole
-purpose of par.
-
-
-Like seq, the argument of lazy can have
-an unboxed type.
-
-
-
-
-The unsafeCoerce# function
-
-The function unsafeCoerce# allows you to side-step the
-typechecker entirely. It has type
-
- unsafeCoerce# :: a -> b
-
-That is, it allows you to coerce any type into any other type. If you use this
-function, you had better get it right, otherwise segmentation faults await.
-It is generally used when you want to write a program that you know is
-well-typed, but where Haskell's type system is not expressive enough to prove
-that it is well typed.
-
-
-The argument to unsafeCoerce# can have unboxed types,
-although extremely bad things will happen if you coerce a boxed type
-to an unboxed type.
-
-
-
-
+GHC has a few built-in funcions with special behaviour. These
+are now described in the module GHC.Prim
+in the library documentation.