Repository : ssh://darcs.haskell.org//srv/darcs/ghc

On branch  : master

http://hackage.haskell.org/trac/ghc/changeset/9d7182fb010dc807045cb20c7b592dee5782fac8

>---------------------------------------------------------------

commit 9d7182fb010dc807045cb20c7b592dee5782fac8
Author: Ian Lynagh <i...@well-typed.com>
Date:   Tue Nov 13 20:47:10 2012 +0000

    Remove the nonexistent lazy primop, and follow move from GHC.Base to 
GHC.Magic

>---------------------------------------------------------------

 compiler/basicTypes/MkId.lhs    |    2 +-
 compiler/prelude/primops.txt.pp |   20 --------------------
 2 files changed, 1 insertions(+), 21 deletions(-)

diff --git a/compiler/basicTypes/MkId.lhs b/compiler/basicTypes/MkId.lhs
index 15f971a..345d8a6 100644
--- a/compiler/basicTypes/MkId.lhs
+++ b/compiler/basicTypes/MkId.lhs
@@ -887,7 +887,7 @@ unsafeCoerceName  = mkWiredInIdName gHC_PRIM (fsLit 
"unsafeCoerce#") unsafeCoerc
 nullAddrName      = mkWiredInIdName gHC_PRIM (fsLit "nullAddr#")     
nullAddrIdKey      nullAddrId
 seqName           = mkWiredInIdName gHC_PRIM (fsLit "seq")           seqIdKey  
         seqId
 realWorldName     = mkWiredInIdName gHC_PRIM (fsLit "realWorld#")    
realWorldPrimIdKey realWorldPrimId
-lazyIdName        = mkWiredInIdName gHC_BASE (fsLit "lazy")         lazyIdKey  
         lazyId
+lazyIdName        = mkWiredInIdName gHC_MAGIC (fsLit "lazy")         lazyIdKey 
          lazyId
 coercionTokenName = mkWiredInIdName gHC_PRIM (fsLit "coercionToken#") 
coercionTokenIdKey coercionTokenId
 \end{code}
 
diff --git a/compiler/prelude/primops.txt.pp b/compiler/prelude/primops.txt.pp
index 63b6009..92d3354 100644
--- a/compiler/prelude/primops.txt.pp
+++ b/compiler/prelude/primops.txt.pp
@@ -2068,26 +2068,6 @@ pseudoop   "seq"
    { Evaluates its first argument to head normal form, and then returns its 
second
        argument as the result. }
 
-pseudoop   "lazy"
-   a -> a
-   { The {\tt lazy} function restrains strictness analysis a little. The call
-       {\tt (lazy e)} means the same as {\tt e}, but {\tt 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 {\tt lazy} are inlined to be the identity function.
-
-       This behaviour is occasionally useful when controlling evaluation order.
-       Notably, {\tt lazy} is used in the library definition of {\tt 
Control.Parallel.par}:
-
-       {\tt par :: a -> b -> b}
-
-       {\tt par x y = case (par\# x) of \_ -> lazy y}
-
-       If {\tt lazy} were not lazy, {\tt par} would look strict in {\tt y} 
which
-       would defeat the whole purpose of {\tt par}.
-
-       Like {\tt seq}, the argument of {\tt lazy} can have an unboxed type. }
-
 primtype Any k
        { The type constructor {\tt Any} is type to which you can unsafely 
coerce any
        lifted type, and back. 



_______________________________________________
Cvs-ghc mailing list
Cvs-ghc@haskell.org
http://www.haskell.org/mailman/listinfo/cvs-ghc

Reply via email to