remove now-unused usage information (#1003)

[ghc-hetmet.git] / compiler / prelude / primops.txt.pp

diff --git a/compiler/prelude/primops.txt.pp b/compiler/prelude/primops.txt.pp
index 6e0a13d..a326739 100644 (file)
--- a/compiler/prelude/primops.txt.pp
+++ b/compiler/prelude/primops.txt.pp
@@ -48,7 +48,7 @@
 -- text between curly brackets.  This is a kludge to enable 
 -- processors of this file to easily get hold of simple info
 -- (eg, out_of_line), whilst avoiding parsing complex expressions
 -- text between curly brackets.  This is a kludge to enable 
 -- processors of this file to easily get hold of simple info
 -- (eg, out_of_line), whilst avoiding parsing complex expressions

--- needed for strictness and usage info.
+-- needed for strictness info.

 
 defaults
    has_side_effects = False
 
 defaults
    has_side_effects = False

@@ -57,7 +57,6 @@ defaults
    needs_wrapper    = False
    can_fail         = False
    strictness       = { \ arity -> mkStrictSig (mkTopDmdType (replicate arity lazyDmd) TopRes) }
    needs_wrapper    = False
    can_fail         = False
    strictness       = { \ arity -> mkStrictSig (mkTopDmdType (replicate arity lazyDmd) TopRes) }

-   usage            = { nomangle other }

 
 -- Currently, documentation is produced using latex, so contents of
 -- description fields should be legal latex. Descriptions can contain
 
 -- Currently, documentation is produced using latex, so contents of
 -- description fields should be legal latex. Descriptions can contain

@@ -733,46 +732,36 @@ primop  NewArrayOp "newArray#" GenPrimOp
     in the specified state thread,
     with each element containing the specified initial value.}
    with
     in the specified state thread,
     with each element containing the specified initial value.}
    with

-   usage       = { mangle NewArrayOp [mkP, mkM, mkP] mkM }

    out_of_line = True
 
 primop  SameMutableArrayOp "sameMutableArray#" GenPrimOp
    MutArr# s a -> MutArr# s a -> Bool
    out_of_line = True
 
 primop  SameMutableArrayOp "sameMutableArray#" GenPrimOp
    MutArr# s a -> MutArr# s a -> Bool

-   with
-   usage = { mangle SameMutableArrayOp [mkP, mkP] mkM }

 
 primop  ReadArrayOp "readArray#" GenPrimOp
    MutArr# s a -> Int# -> State# s -> (# State# s, a #)
    {Read from specified index of mutable array. Result is not yet evaluated.}
 
 primop  ReadArrayOp "readArray#" GenPrimOp
    MutArr# s a -> Int# -> State# s -> (# State# s, a #)
    {Read from specified index of mutable array. Result is not yet evaluated.}

-   with
-   usage = { mangle ReadArrayOp [mkM, mkP, mkP] mkM }

 
 primop  WriteArrayOp "writeArray#" GenPrimOp
    MutArr# s a -> Int# -> a -> State# s -> State# s
    {Write to specified index of mutable array.}
    with
 
 primop  WriteArrayOp "writeArray#" GenPrimOp
    MutArr# s a -> Int# -> a -> State# s -> State# s
    {Write to specified index of mutable array.}
    with

-   usage            = { mangle WriteArrayOp [mkM, mkP, mkM, mkP] mkR }

    has_side_effects = True
 
 primop  IndexArrayOp "indexArray#" GenPrimOp
    Array# a -> Int# -> (# a #)
    {Read from specified index of immutable array. Result is packaged into
     an unboxed singleton; the result itself is not yet evaluated.}
    has_side_effects = True
 
 primop  IndexArrayOp "indexArray#" GenPrimOp
    Array# a -> Int# -> (# a #)
    {Read from specified index of immutable array. Result is packaged into
     an unboxed singleton; the result itself is not yet evaluated.}

-   with
-   usage = { mangle  IndexArrayOp [mkM, mkP] mkM }

 
 primop  UnsafeFreezeArrayOp "unsafeFreezeArray#" GenPrimOp
    MutArr# s a -> State# s -> (# State# s, Array# a #)
    {Make a mutable array immutable, without copying.}
    with
 
 primop  UnsafeFreezeArrayOp "unsafeFreezeArray#" GenPrimOp
    MutArr# s a -> State# s -> (# State# s, Array# a #)
    {Make a mutable array immutable, without copying.}
    with

-   usage            = { mangle UnsafeFreezeArrayOp [mkM, mkP] mkM }

    has_side_effects = True
 
 primop  UnsafeThawArrayOp  "unsafeThawArray#" GenPrimOp
    Array# a -> State# s -> (# State# s, MutArr# s a #)
    {Make an immutable array mutable, without copying.}
    with
    has_side_effects = True
 
 primop  UnsafeThawArrayOp  "unsafeThawArray#" GenPrimOp
    Array# a -> State# s -> (# State# s, MutArr# s a #)
    {Make an immutable array mutable, without copying.}
    with

-   usage       = { mangle UnsafeThawArrayOp [mkM, mkP] mkM }

    out_of_line = True
 
 ------------------------------------------------------------------------
    out_of_line = True
 
 ------------------------------------------------------------------------

@@ -1199,26 +1188,20 @@ primop  NewMutVarOp "newMutVar#" GenPrimOp
    a -> State# s -> (# State# s, MutVar# s a #)
    {Create {\tt MutVar\#} with specified initial value in specified state thread.}
    with
    a -> State# s -> (# State# s, MutVar# s a #)
    {Create {\tt MutVar\#} with specified initial value in specified state thread.}
    with

-   usage       = { mangle NewMutVarOp [mkM, mkP] mkM }

    out_of_line = True
 
 primop  ReadMutVarOp "readMutVar#" GenPrimOp
    MutVar# s a -> State# s -> (# State# s, a #)
    {Read contents of {\tt MutVar\#}. Result is not yet evaluated.}
    out_of_line = True
 
 primop  ReadMutVarOp "readMutVar#" GenPrimOp
    MutVar# s a -> State# s -> (# State# s, a #)
    {Read contents of {\tt MutVar\#}. Result is not yet evaluated.}

-   with
-   usage = { mangle ReadMutVarOp [mkM, mkP] mkM }

 
 primop  WriteMutVarOp "writeMutVar#"  GenPrimOp
    MutVar# s a -> a -> State# s -> State# s
    {Write contents of {\tt MutVar\#}.}
    with
 
 primop  WriteMutVarOp "writeMutVar#"  GenPrimOp
    MutVar# s a -> a -> State# s -> State# s
    {Write contents of {\tt MutVar\#}.}
    with

-   usage            = { mangle WriteMutVarOp [mkM, mkM, mkP] mkR }

    has_side_effects = True
 
 primop  SameMutVarOp "sameMutVar#" GenPrimOp
    MutVar# s a -> MutVar# s a -> Bool
    has_side_effects = True
 
 primop  SameMutVarOp "sameMutVar#" GenPrimOp
    MutVar# s a -> MutVar# s a -> Bool

-   with
-   usage = { mangle SameMutVarOp [mkP, mkP] mkM }

 
 -- not really the right type, but we don't know about pairs here.  The
 -- correct type is
 
 -- not really the right type, but we don't know about pairs here.  The
 -- correct type is

@@ -1228,7 +1211,6 @@ primop  SameMutVarOp "sameMutVar#" GenPrimOp
 primop  AtomicModifyMutVarOp "atomicModifyMutVar#" GenPrimOp
    MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
    with
 primop  AtomicModifyMutVarOp "atomicModifyMutVar#" GenPrimOp
    MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
    with

-   usage = { mangle AtomicModifyMutVarOp [mkP, mkM, mkP] mkM }

    has_side_effects = True
    out_of_line = True
 
    has_side_effects = True
    out_of_line = True
 

@@ -1245,8 +1227,6 @@ primop  CatchOp "catch#" GenPrimOp
        -- Catch is actually strict in its first argument
        -- but we don't want to tell the strictness
        -- analyser about that!
        -- Catch is actually strict in its first argument
        -- but we don't want to tell the strictness
        -- analyser about that!

-   usage = { mangle CatchOp [mkM, mkM . (inFun CatchOp mkM mkM), mkP] mkM }
-        --     [mkO, mkO . (inFun mkM mkO)] mkO

         -- might use caught action multiply
    out_of_line = True
 
         -- might use caught action multiply
    out_of_line = True
 

@@ -1255,7 +1235,6 @@ primop  RaiseOp "raise#" GenPrimOp
    with
    strictness  = { \ arity -> mkStrictSig (mkTopDmdType [lazyDmd] BotRes) }
       -- NB: result is bottom
    with
    strictness  = { \ arity -> mkStrictSig (mkTopDmdType [lazyDmd] BotRes) }
       -- NB: result is bottom

-   usage       = { mangle RaiseOp [mkM] mkM }

    out_of_line = True
 
 -- raiseIO# needs to be a primop, because exceptions in the IO monad
    out_of_line = True
 
 -- raiseIO# needs to be a primop, because exceptions in the IO monad

@@ -1362,7 +1341,6 @@ primop  NewMVarOp "newMVar#"  GenPrimOp
    State# s -> (# State# s, MVar# s a #)
    {Create new {\tt MVar\#}; initially empty.}
    with
    State# s -> (# State# s, MVar# s a #)
    {Create new {\tt MVar\#}; initially empty.}
    with

-   usage       = { mangle NewMVarOp [mkP] mkR }

    out_of_line = True
 
 primop  TakeMVarOp "takeMVar#" GenPrimOp
    out_of_line = True
 
 primop  TakeMVarOp "takeMVar#" GenPrimOp

@@ -1370,7 +1348,6 @@ primop  TakeMVarOp "takeMVar#" GenPrimOp
    {If {\tt MVar\#} is empty, block until it becomes full.
    Then remove and return its contents, and set it empty.}
    with
    {If {\tt MVar\#} is empty, block until it becomes full.
    Then remove and return its contents, and set it empty.}
    with

-   usage            = { mangle TakeMVarOp [mkM, mkP] mkM }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1379,7 +1356,6 @@ primop  TryTakeMVarOp "tryTakeMVar#" GenPrimOp
    {If {\tt MVar\#} is empty, immediately return with integer 0 and value undefined.
    Otherwise, return with integer 1 and contents of {\tt MVar\#}, and set {\tt MVar\#} empty.}
    with
    {If {\tt MVar\#} is empty, immediately return with integer 0 and value undefined.
    Otherwise, return with integer 1 and contents of {\tt MVar\#}, and set {\tt MVar\#} empty.}
    with

-   usage            = { mangle TryTakeMVarOp [mkM, mkP] mkM }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1388,7 +1364,6 @@ primop  PutMVarOp "putMVar#" GenPrimOp
    {If {\tt MVar\#} is full, block until it becomes empty.
    Then store value arg as its new contents.}
    with
    {If {\tt MVar\#} is full, block until it becomes empty.
    Then store value arg as its new contents.}
    with

-   usage            = { mangle PutMVarOp [mkM, mkM, mkP] mkR }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1397,20 +1372,16 @@ primop  TryPutMVarOp "tryPutMVar#" GenPrimOp
    {If {\tt MVar\#} is full, immediately return with integer 0.
     Otherwise, store value arg as {\tt MVar\#}'s new contents, and return with integer 1.}
    with
    {If {\tt MVar\#} is full, immediately return with integer 0.
     Otherwise, store value arg as {\tt MVar\#}'s new contents, and return with integer 1.}
    with

-   usage            = { mangle TryPutMVarOp [mkM, mkM, mkP] mkR }

    has_side_effects = True
    out_of_line      = True
 
 primop  SameMVarOp "sameMVar#" GenPrimOp
    MVar# s a -> MVar# s a -> Bool
    has_side_effects = True
    out_of_line      = True
 
 primop  SameMVarOp "sameMVar#" GenPrimOp
    MVar# s a -> MVar# s a -> Bool

-   with
-   usage = { mangle SameMVarOp [mkP, mkP] mkM }

 
 primop  IsEmptyMVarOp "isEmptyMVar#" GenPrimOp
    MVar# s a -> State# s -> (# State# s, Int# #)
    {Return 1 if {\tt MVar\#} is empty; 0 otherwise.}
    with
 
 primop  IsEmptyMVarOp "isEmptyMVar#" GenPrimOp
    MVar# s a -> State# s -> (# State# s, Int# #)
    {Return 1 if {\tt MVar\#} is empty; 0 otherwise.}
    with

-   usage = { mangle IsEmptyMVarOp [mkP, mkP] mkM }

    out_of_line = True
 
 ------------------------------------------------------------------------
    out_of_line = True
 
 ------------------------------------------------------------------------

@@ -1473,7 +1444,7 @@ section "Concurrency primitives"
 ------------------------------------------------------------------------
 
 primtype State# s
 ------------------------------------------------------------------------
 
 primtype State# s

-       { {\tt State#} is the primitive, unlifted type of states.  It has
+       { {\tt State\#} is the primitive, unlifted type of states.  It has

        one type parameter, thus {\tt State\# RealWorld}, or {\tt State\# s},
        where s is a type variable. The only purpose of the type parameter
        is to keep different state threads separate.  It is represented by
        one type parameter, thus {\tt State\# RealWorld}, or {\tt State\# s},
        where s is a type variable. The only purpose of the type parameter
        is to keep different state threads separate.  It is represented by

@@ -1482,7 +1453,7 @@ primtype State# s
 primtype RealWorld
        { {\tt RealWorld} is deeply magical.  It is {\it primitive}, but it is not
        {\it unlifted} (hence {\tt ptrArg}).  We never manipulate values of type
 primtype RealWorld
        { {\tt RealWorld} is deeply magical.  It is {\it primitive}, but it is not
        {\it unlifted} (hence {\tt ptrArg}).  We never manipulate values of type

-       {\tt RealWorld}; it's only used in the type system, to parameterise {\tt State#}. }
+       {\tt RealWorld}; it's only used in the type system, to parameterise {\tt State\#}. }

 
 primtype ThreadId#
        {(In a non-concurrent implementation, this can be a singleton
 
 primtype ThreadId#
        {(In a non-concurrent implementation, this can be a singleton

@@ -1492,21 +1463,18 @@ primtype ThreadId#
 primop  ForkOp "fork#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
    with
 primop  ForkOp "fork#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
    with

-   usage            = { mangle ForkOp [mkO, mkP] mkR }

    has_side_effects = True
    out_of_line      = True
 
 primop  ForkOnOp "forkOn#" GenPrimOp
    Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
    with
    has_side_effects = True
    out_of_line      = True
 
 primop  ForkOnOp "forkOn#" GenPrimOp
    Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
    with

-   usage            = { mangle ForkOnOp [mkO, mkP] mkR }

    has_side_effects = True
    out_of_line      = True
 
 primop  KillThreadOp "killThread#"  GenPrimOp
    ThreadId# -> a -> State# RealWorld -> State# RealWorld
    with
    has_side_effects = True
    out_of_line      = True
 
 primop  KillThreadOp "killThread#"  GenPrimOp
    ThreadId# -> a -> State# RealWorld -> State# RealWorld
    with

-   usage            = { mangle KillThreadOp [mkP, mkM, mkP] mkR }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1532,6 +1500,11 @@ primop  IsCurrentThreadBoundOp "isCurrentThreadBound#" GenPrimOp
    with
    out_of_line = True
 
    with
    out_of_line = True
 

+primop  NoDuplicateOp "noDuplicate#" GenPrimOp
+   State# RealWorld -> State# RealWorld
+   with
+   out_of_line = True
+

 ------------------------------------------------------------------------
 section "Weak pointers"
 ------------------------------------------------------------------------
 ------------------------------------------------------------------------
 section "Weak pointers"
 ------------------------------------------------------------------------

@@ -1543,14 +1516,12 @@ primtype Weak# b
 primop  MkWeakOp "mkWeak#" GenPrimOp
    o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
    with
 primop  MkWeakOp "mkWeak#" GenPrimOp
    o -> b -> c -> State# RealWorld -> (# State# RealWorld, Weak# b #)
    with

-   usage            = { mangle MkWeakOp [mkZ, mkM, mkM, mkP] mkM }

    has_side_effects = True
    out_of_line      = True
 
 primop  DeRefWeakOp "deRefWeak#" GenPrimOp
    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
    with
    has_side_effects = True
    out_of_line      = True
 
 primop  DeRefWeakOp "deRefWeak#" GenPrimOp
    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
    with

-   usage            = { mangle DeRefWeakOp [mkM, mkP] mkM }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1558,9 +1529,6 @@ primop  FinalizeWeakOp "finalizeWeak#" GenPrimOp
    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, 
               (State# RealWorld -> (# State# RealWorld, () #)) #)
    with
    Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, 
               (State# RealWorld -> (# State# RealWorld, () #)) #)
    with

-   usage            = { mangle FinalizeWeakOp [mkM, mkP] 
-                               (mkR . (inUB FinalizeWeakOp 
-                                            [id,id,inFun FinalizeWeakOp mkR mkM])) }

    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

@@ -1580,14 +1548,12 @@ primtype StableName# a
 primop  MakeStablePtrOp "makeStablePtr#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
    with
 primop  MakeStablePtrOp "makeStablePtr#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
    with

-   usage            = { mangle MakeStablePtrOp [mkM, mkP] mkM }

    has_side_effects = True
    out_of_line      = True
 
 primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
    StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
    with
    has_side_effects = True
    out_of_line      = True
 
 primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
    StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
    with

-   usage            = { mangle DeRefStablePtrOp [mkM, mkP] mkM }

    needs_wrapper    = True
    has_side_effects = True
    out_of_line      = True
    needs_wrapper    = True
    has_side_effects = True
    out_of_line      = True

@@ -1595,26 +1561,20 @@ primop  DeRefStablePtrOp "deRefStablePtr#" GenPrimOp
 primop  EqStablePtrOp "eqStablePtr#" GenPrimOp
    StablePtr# a -> StablePtr# a -> Int#
    with
 primop  EqStablePtrOp "eqStablePtr#" GenPrimOp
    StablePtr# a -> StablePtr# a -> Int#
    with

-   usage            = { mangle EqStablePtrOp [mkP, mkP] mkR }

    has_side_effects = True
 
 primop  MakeStableNameOp "makeStableName#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
    with
    has_side_effects = True
 
 primop  MakeStableNameOp "makeStableName#" GenPrimOp
    a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
    with

-   usage            = { mangle MakeStableNameOp [mkZ, mkP] mkR }

    needs_wrapper    = True
    has_side_effects = True
    out_of_line      = True
 
 primop  EqStableNameOp "eqStableName#" GenPrimOp
    StableName# a -> StableName# a -> Int#
    needs_wrapper    = True
    has_side_effects = True
    out_of_line      = True
 
 primop  EqStableNameOp "eqStableName#" GenPrimOp
    StableName# a -> StableName# a -> Int#

-   with
-   usage = { mangle EqStableNameOp [mkP, mkP] mkR }

 
 primop  StableNameToIntOp "stableNameToInt#" GenPrimOp
    StableName# a -> Int#
 
 primop  StableNameToIntOp "stableNameToInt#" GenPrimOp
    StableName# a -> Int#

-   with
-   usage = { mangle StableNameToIntOp [mkP] mkR }

 
 ------------------------------------------------------------------------
 section "Unsafe pointer equality"
 
 ------------------------------------------------------------------------
 section "Unsafe pointer equality"

@@ -1623,8 +1583,6 @@ section "Unsafe pointer equality"
 
 primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
    a -> a -> Int#
 
 primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
    a -> a -> Int#

-   with
-   usage = { mangle ReallyUnsafePtrEqualityOp [mkZ, mkZ] mkR }

 
 ------------------------------------------------------------------------
 section "Parallelism"
 
 ------------------------------------------------------------------------
 section "Parallelism"

@@ -1633,7 +1591,6 @@ section "Parallelism"
 primop  ParOp "par#" GenPrimOp
    a -> Int#
    with
 primop  ParOp "par#" GenPrimOp
    a -> Int#
    with

-   usage            = { mangle ParOp [mkO] mkR }

       -- Note that Par is lazy to avoid that the sparked thing
       -- gets evaluted strictly, which it should *not* be
    has_side_effects = True
       -- Note that Par is lazy to avoid that the sparked thing
       -- gets evaluted strictly, which it should *not* be
    has_side_effects = True

@@ -1647,37 +1604,31 @@ primop  ParOp "par#" GenPrimOp
 primop  ParGlobalOp  "parGlobal#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with
 primop  ParGlobalOp  "parGlobal#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with

-   usage            = { mangle ParGlobalOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 primop  ParLocalOp  "parLocal#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with
    has_side_effects = True
 
 primop  ParLocalOp  "parLocal#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with

-   usage            = { mangle ParLocalOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 primop  ParAtOp  "parAt#"  GenPrimOp
    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
    with
    has_side_effects = True
 
 primop  ParAtOp  "parAt#"  GenPrimOp
    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
    with

-   usage            = { mangle ParAtOp [mkO, mkZ, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 primop  ParAtAbsOp  "parAtAbs#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with
    has_side_effects = True
 
 primop  ParAtAbsOp  "parAtAbs#"  GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with

-   usage            = { mangle ParAtAbsOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 primop  ParAtRelOp  "parAtRel#" GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with
    has_side_effects = True
 
 primop  ParAtRelOp  "parAtRel#" GenPrimOp
    a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#
    with

-   usage            = { mangle ParAtRelOp [mkO, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
    with
    has_side_effects = True
 
 primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
    b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#
    with

-   usage            = { mangle ParAtForNowOp [mkO, mkZ, mkP, mkP, mkP, mkP, mkM] mkM }

    has_side_effects = True
 
 -- copyable# and noFollow# are yet to be implemented (for GpH)
    has_side_effects = True
 
 -- copyable# and noFollow# are yet to be implemented (for GpH)

@@ -1685,13 +1636,11 @@ primop  ParAtForNowOp  "parAtForNow#" GenPrimOp
 --primop  CopyableOp  "copyable#" GenPrimOp
 --   a -> Int#
 --   with
 --primop  CopyableOp  "copyable#" GenPrimOp
 --   a -> Int#
 --   with

---   usage            = { mangle CopyableOp [mkZ] mkR }

 --   has_side_effects = True
 --
 --primop  NoFollowOp "noFollow#" GenPrimOp
 --   a -> Int#
 --   with
 --   has_side_effects = True
 --
 --primop  NoFollowOp "noFollow#" GenPrimOp
 --   a -> Int#
 --   with

---   usage            = { mangle NoFollowOp [mkZ] mkR }

 --   has_side_effects = True
 
 
 --   has_side_effects = True
 
 

@@ -1733,16 +1682,20 @@ primop  NewBCOOp "newBCO#" GenPrimOp
    has_side_effects = True
    out_of_line      = True
 
    has_side_effects = True
    out_of_line      = True
 

-primop  InfoPtrOp "infoPtr#" GenPrimOp
-   a -> Addr#
+primop  UnpackClosureOp "unpackClosure#" GenPrimOp
+   a -> (# Addr#, Array# b, ByteArr# #)

    with
    out_of_line = True
 
    with
    out_of_line = True
 

-primop  ClosurePayloadOp "closurePayload#" GenPrimOp
-   a -> (# Array# b, ByteArr# #)
+primop  GetApStackValOp "getApStackVal#" GenPrimOp
+   a -> Int# -> (# Int#, b #)

    with
    out_of_line = True
 
    with
    out_of_line = True
 

+primop GetStackFrame "getStackFrame#" GenPrimOp
+   ThreadId# -> Int# -> (# Int#, Int# #)
+   with
+   out_of_line = True

 
 ------------------------------------------------------------------------
 section "Etc" 
 
 ------------------------------------------------------------------------
 section "Etc" 

@@ -1756,11 +1709,11 @@ pseudoop   "seq"
 
 pseudoop   "inline"
    a -> a
 
 pseudoop   "inline"
    a -> a

-   { The call {\tt(inline f)} arranges that f is inlined, regardless of its size.
-       More precisely, the call {\tt(inline f)} rewrites to the right-hand side of
+   { The call {\tt (inline f)} arranges that f is inlined, regardless of its size.
+       More precisely, the call {\tt (inline f)} rewrites to the right-hand side of

        {\tt 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.
        {\tt 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.

-       {\ttINLINE} pragmas in User's Guide, Section 7.10.3, "INLINE and NOINLINE
+       {\tt INLINE} pragmas in User's Guide, Section 7.10.3, "INLINE and NOINLINE

        pragmas").
 
        This inlining occurs regardless of the argument to the call or the size of
        pragmas").
 
        This inlining occurs regardless of the argument to the call or the size of

@@ -1787,8 +1740,9 @@ pseudoop   "lazy"
        This behaviour is occasionally useful when controlling evaluation order.
        Notably, {\tt lazy} is used in the library definition of {\tt Control.Parallel.par}:
 
        This behaviour is occasionally useful when controlling evaluation order.
        Notably, {\tt lazy} is used in the library definition of {\tt Control.Parallel.par}:
 

-       >    par :: a -> b -> b
-       >    par x y = case (par# x) of { _ -> lazy y }
+       {\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}.
 
        If {\tt lazy} were not lazy, {\tt par} would look strict in {\tt y} which
        would defeat the whole purpose of {\tt par}.

@@ -1808,7 +1762,7 @@ primtype Any a
        It's also used to instantiate un-constrained type variables after type
        checking.  For example
 
        It's also used to instantiate un-constrained type variables after type
        checking.  For example
 

-       >       length Any []
+       {\tt length Any []}

 
        Annoyingly, we sometimes need {\tt Any}s of other kinds, such as {\tt (* -> *)} etc.
        This is a bit like tuples.   We define a couple of useful ones here,
 
        Annoyingly, we sometimes need {\tt Any}s of other kinds, such as {\tt (* -> *)} etc.
        This is a bit like tuples.   We define a couple of useful ones here,