prim (empty) → 0.1.0.0

raw patch · 90 files changed

+2063/−0 lines, 90 filesdep +ghc-primdep +microbase

Dependencies added: ghc-prim, microbase

Files

• CHANGELOG.md +0/−0
• README.md +22/−0
• prim.cabal +73/−0
• src/Any.hs +20/−0
• src/Array.hs +24/−0
• src/Array/Array.hs +29/−0
• src/Array/Array/Array.hs +12/−0
• src/Array/Array/Byte.hs +12/−0
• src/Array/Boxed.hs +106/−0
• src/Array/Byte.hs +113/−0
• src/Array/Byte/Pinned.hs +19/−0
• src/Array/Byte/Unpinned.hs +5/−0
• src/Array/Char.hs +19/−0
• src/Array/Char8.hs +13/−0
• src/Array/F32.hs +11/−0
• src/Array/F64.hs +11/−0
• src/Array/I16.hs +18/−0
• src/Array/I32.hs +18/−0
• src/Array/I64.hs +63/−0
• src/Array/I8.hs +13/−0
• src/Array/Ref/Stable.hs +19/−0
• src/Array/Small.hs +112/−0
• src/Array/U16.hs +19/−0
• src/Array/U32.hs +18/−0
• src/Array/U64.hs +18/−0
• src/Array/U8.hs +11/−0
• src/B16.hs +19/−0
• src/B32.hs +20/−0
• src/B64.hs +59/−0
• src/B8.hs +17/−0
• src/BCO.hs +10/−0
• src/Char.hs +13/−0
• src/Coerce.hs +11/−0
• src/Compact.hs +39/−0
• src/Enum.hs +10/−0
• src/Exception.hs +12/−0
• src/Exception/Mask.hs +21/−0
• src/F32.hs +39/−0
• src/F64.hs +43/−0
• src/I16.hs +1/−0
• src/I32.hs +1/−0
• src/I64.hs +109/−0
• src/I8.hs +1/−0
• src/Nat.hs +2/−0
• src/Optimizer.hs +5/−0
• src/Prelude.hs +40/−0
• src/Proxy.hs +8/−0
• src/RTS/Block.hs +10/−0
• src/RTS/Prefetch/Any.hs +7/−0
• src/RTS/Prefetch/Array.hs +8/−0
• src/RTS/Prefetch/Array/M.hs +8/−0
• src/RTS/Prefetch/Ref.hs +8/−0
• src/Ref.hs +8/−0
• src/Ref/Boxed.hs +40/−0
• src/Ref/Byte.hs +38/−0
• src/Ref/Char.hs +11/−0
• src/Ref/Char8.hs +11/−0
• src/Ref/F32.hs +11/−0
• src/Ref/F64.hs +11/−0
• src/Ref/I16.hs +11/−0
• src/Ref/I32.hs +11/−0
• src/Ref/I64.hs +11/−0
• src/Ref/I8.hs +11/−0
• src/Ref/Lock.hs +37/−0
• src/Ref/Ref/Byte.hs +12/−0
• src/Ref/Ref/Stable.hs +12/−0
• src/Ref/STM.hs +20/−0
• src/Ref/Stable.hs +12/−0
• src/Ref/Stable/Name.hs +10/−0
• src/Ref/U16.hs +11/−0
• src/Ref/U32.hs +11/−0
• src/Ref/U64.hs +11/−0
• src/Ref/U8.hs +11/−0
• src/Ref/Weak.hs +24/−0
• src/ST.hs +7/−0
• src/ST/IO.hs +9/−0
• src/ST/IO/STM.hs +21/−0
• src/Spark.hs +16/−0
• src/Stock.hs +4/−0
• src/String.hs +8/−0
• src/String/C.hs +3/−0
• src/String/C/Latin.hs +115/−0
• src/String/C/UTF8.hs +39/−0
• src/String/List.hs +43/−0
• src/Syntax/ImplicitParam.hs +2/−0
• src/Thread.hs +59/−0
• src/U16.hs +1/−0
• src/U32.hs +2/−0
• src/U64.hs +69/−0
• src/U8.hs +1/−0

@@ -0,0 +1,22 @@+# PRIM+This library reorganizes `ghc-prim` in a sane but conservative way+, without adding any fancy tricks like overloading or extra functions.+It's meant as a foundation for low-level programming in haskell, as well as (eventually),+a comprehensive home for documentation on ghc magic.++# Module Structure++  Modules live at the toplevel and do not consider the global package ecosystem, for modularity.+It is intended to use cabal mixins or PackageImports to appropriately avoid collisions downstream.+Modules are granular, intending to represent a particular usable component such as a single datatype or class.+Modules for internal types are nested under the module they group closest with,+while modules for common types like Refs and Arrays are anti-nested with the root exposing their types.++# Export Structure++  Types and constructors with the same name as the module, as well as all operators are meant to be imported unqualified.+All other identifiers are meant to be imported qualified. The common pattern is: ++```haskell+import Compact (Compact)+import Compact qualified

@@ -0,0 +1,73 @@+cabal-version: 2.4+name: prim+homepage: https://github.com/daig/prim#readme+version: 0.1.0.0+category: Prelude+synopsis: An ergonomic but conservative interface to ghc-prim+description: +      This library reorganizes @ghc-prim@ in a sane but conservative way +  , without adding any fancy tricks like overloading or extra functions.+  It's meant as a foundation for low-level programming in haskell, as well as (eventually),+  a comprehensive home for documentation on ghc magic.++stability: cursed+bug-reports: https://github.com/daig/prim/issues+author: Dai+maintainer: daig@sodality.cc+copyright: 2020 Sodality+license: MIT++extra-source-files:+  README.md+  CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/daig/prim+++library +  default-language: Haskell2010+  default-extensions: MagicHash, UnboxedTuples+                    , KindSignatures, PolyKinds, ConstraintKinds, TypeOperators, RankNTypes+                    , BlockArguments+  hs-source-dirs: src+  other-modules: Prelude+  reexported-modules: GHC.Tuple as Tuple+  exposed-modules: Char+                 , I64, I32, I16, I8+                 , U64, U32, U16, U8+                 , B8, B16, B32, B64+                 , F64, F32+                 , ST,ST.IO, ST.IO.STM+                 , Ref+                 , Ref.Weak, Ref.Stable, Ref.Stable.Name, Ref.Byte+                 , Ref.Char8, Ref.Char+                 , Ref.I64, Ref.I32, Ref.I16, Ref.I8+                 , Ref.U64, Ref.U32, Ref.U16, Ref.U8+                 , Ref.F32, Ref.F64+                 , Ref.Ref.Byte, Ref.Ref.Stable+                 , Ref.Boxed, Ref.STM, Ref.Lock+                 , Array, Array.Small, Array.Boxed+                 , Array.Byte, Array.Byte.Pinned, Array.Byte.Unpinned+                 , Array.Char, Array.Char8+                 , Array.F32, Array.F64+                 , Array.I64, Array.I32, Array.I16, Array.I8+                 , Array.U64, Array.U32, Array.U16, Array.U8+                 , Array.Ref.Stable+                 , Array.Array, Array.Array.Byte, Array.Array.Array+                 , Thread+                 , Compact+                 , Proxy+                 , Coerce+                 , Exception, Exception.Mask+                 , Spark+                 , Enum+                 , Any, BCO+                 , RTS.Block, Optimizer+                 , RTS.Prefetch.Any, RTS.Prefetch.Ref, RTS.Prefetch.Array, RTS.Prefetch.Array.M+                 , String, String.C, String.C.Latin, String.C.UTF8, String.List+                 , Nat+                 , Stock+                 , Syntax.ImplicitParam+  build-depends: ghc-prim ^>= 0.6.1, microbase

@@ -0,0 +1,20 @@+module Any (module Any, Any, seq) where+import qualified Ref+import qualified Array+import GHC.Types as X (Any)++eq# :: a -> a -> B+eq# = reallyUnsafePtrEquality#++fromRef :: Ref.Byte -> (# a #)+fromRef = addrToAny#++-- | Must be run on an evaluated value, not a thunk+toRef# :: a -> IO Ref.Byte+toRef# = anyToAddr#++unpackClosure :: a -> (# Ref.Byte, Array.Byte, Array.Boxed b #)+unpackClosure = unpackClosure# ++getApStackVal :: a -> I64 -> (# I64, b #)+getApStackVal = getApStackVal#

@@ -0,0 +1,24 @@+-- | Types for arrays+{-# language NoImplicitPrelude #-}+module Array where+import GHC.Prim++type Boxed = Array#+type Unlifted = ArrayArray#+type Small = SmallArray#+type Byte = ByteArray#++type I64 = ByteArray#+type I32 = ByteArray#+type I16 = ByteArray#+type I8 = ByteArray#++type U64 = ByteArray#+type U32 = ByteArray#+type U16 = ByteArray#+type U8 = ByteArray#++type F32 = ByteArray#+type F64 = ByteArray#++type StablePtr = ByteArray#

@@ -0,0 +1,29 @@+-- | /Unlifted/ arrays, containing strictly evaluated pointers.+-- Unlike "Array.Byte", these store pointers, but like it, they're guarenteed not to be bottom.+-- Eg. We cannot store an 'Addr', because it might be null, but we can store "Array.Byte.Array",+-- and more "Array.Array"+module Array.Array where++type A = ArrayArray#+type M = MutableArrayArray#++new :: I64 -> ST s (M s)+new = newArrayArray#++eq :: M s -> M s -> B+eq = sameMutableArrayArray#++freeze## :: M s -> ST s A+freeze## = unsafeFreezeArrayArray#++size :: A -> I64+size = sizeofArrayArray#++sizeM :: M s -> I64+sizeM = sizeofMutableArrayArray#++copy# :: A -> I64 -> M s -> I64 -> I64 -> ST_ s+copy# = copyArrayArray#++copyM# :: M s -> I64 -> M s -> I64 -> I64 -> ST_ s+copyM# = copyMutableArrayArray#

@@ -0,0 +1,12 @@+module Array.Array.Array where+import qualified Array+import Array.Array++index# :: A -> I64 -> Array.Unlifted+index# = indexArrayArrayArray#++read# :: M s -> I64 -> ST s Array.Unlifted+read# = readArrayArrayArray#++write# :: M s -> I64 -> Array.Unlifted -> ST_ s+write# = writeArrayArrayArray#

@@ -0,0 +1,12 @@+module Array.Array.Byte where+import qualified Array+import Array.Array++index# :: A -> I64 -> Array.Byte+index# = indexByteArrayArray#++read# :: M s -> I64 -> ST s Array.Byte+read# = readByteArrayArray#++write# :: M s -> I64 -> Array.Byte -> ST_ s+write# = writeByteArrayArray#

@@ -0,0 +1,106 @@+module Array.Boxed where+import qualified Array++type A = Array#+type M = MutableArray#+++new :: I64 -> a -> ST s (M s a)+new = newArray#++eq :: M s a -> M s a -> B+eq = sameMutableArray#++read :: M s a -> I64 -> ST s a+read = readArray#++write :: M s a -> I64 -> a -> ST_ s+write = writeArray#++-- | Number of elements+size :: A a -> I64+size = sizeofArray#++-- | Read from the specified index of an immutable array.+-- The result is packaged into an unboxed unary tuple; the result itself is not yet evaluated.+-- Pattern matching on the tuple forces the indexing of the array to happen+-- but does not evaluate the element itself. Evaluating the thunk prevents+-- additional thunks from building up on the heap. Avoiding these thunks, in turn,+-- reduces references to the argument array, allowing it to be garbage collected more promptly.+-- Warning: this can fail with an unchecked exception.+index# :: A a -> I64 -> (# a #)+index# = indexArray#++-- | Make a mutable array immutable, without copying.+freeze## :: M s a -> ST s (A a)+freeze## = unsafeFreezeArray#++-- | Make an immutable array mutable, without copying.+thaw## :: A a -> ST s (M s a)+thaw## = unsafeThawArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copy# :: A a -- ^ source+      -> I64 -- ^ source offset+      -> M s a -- ^ destination+      -> I64 -- ^ destination offset+      -> I64 -- ^ number of elements to copy+      -> ST_ s+copy# = copyArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copyM# :: M s a -- ^ source+       -> I64 -- ^ source offset+       -> M s a -- ^ destination+       -> I64 -- ^ destination offset+       -> I64 -- ^ number of elements to copy+       -> ST_ s+copyM# = copyMutableArray#++-- | Create a new array with the elements from the source array.+-- The provided array must fully contain the specified range, but this is not checked.+--+-- Warning: this can fail with an unchecked exception.+clone# :: A a+       -> I64 -- ^ Source offset+       -> I64 -- ^ number of elements to copy+       -> A a+clone# = cloneArray#++-- | Create a new array with the elements from the source array.+-- The provided array must fully contain the specified range, but this is not checked.+--+-- Warning: this can fail with an unchecked exception.+cloneM# :: M s a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (M s a)+cloneM# = cloneMutableArray#++freeze# :: M s a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (A a)+freeze# = freezeArray#++thaw# ::  A a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (M s a)+thaw# = thawArray#++cas# :: M s a+    -> I64 -- ^ Source offset+    -> a -- ^ Expected old value+    -> a -- ^ New value+    -> ST s (# B, a #) -- ^ Whether the swap failed, and the actual new value+cas# as o a0 a1 s0 = case casArray# as o a0 a1 s0 of+  (# s1, failed', a #) -> (# s1, (# failed', a #) #)

@@ -0,0 +1,113 @@+module Array.Byte where+import qualified Array+import qualified Ref++type A = Array.Byte+type M = MutableByteArray#++-- | Create a new uninitialized mutable byte array of specified size (in bytes),+-- in the specified state thread.+new :: I64 -> ST s (M s)+new = newByteArray#++eq :: M s -> M s -> B+eq = sameMutableByteArray#++shrink :: M s -> I64 -> ST_ s+shrink = shrinkMutableByteArray#++-- | Number of elements+size :: A -> I64+size = sizeofByteArray#++-- | Number of elements. Must be in @ST@ because of possible resizes.+sizeM :: M s -> ST s I64+sizeM = getSizeofMutableByteArray#++-- | Make a mutable array immutable, without copying.+freeze## :: M s -> ST s (A)+freeze## = unsafeFreezeByteArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copy# :: A -- ^ source+      -> I64 -- ^ source offset+      -> M s -- ^ destination+      -> I64 -- ^ destination offset+      -> I64 -- ^ number of elements to copy+      -> ST_ s+copy# = copyByteArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copyM# :: M s -- ^ source+       -> I64 -- ^ source offset+       -> M s -- ^ destination+       -> I64 -- ^ destination offset+       -> I64 -- ^ number of elements to copy+       -> ST_ s+copyM# = copyMutableByteArray#++-- | Copy a range of the @A@ to the memory range starting at the @Ref.Byte@.+-- The @A@ and the memory region at @Ref.Byte@ must fully contain the specified ranges, but this is not checked.+-- The @Ref.Byte@ must not point into the @A@ (e.g. if the @A@ were pinned), but this is not checked either. +--+-- Warning: this can fail with an unchecked exception.+copyToRef# :: A -- ^ source+            -> I64 -- ^ source offset+            -> Ref.Byte -- ^ destination+            -> I64 -- ^ number of elements to copy+            -> ST_ s+copyToRef# = copyByteArrayToAddr#++-- | Copy a range of the @A@ to the memory range starting at the @Ref.Byte@.+-- The @A@ and the memory region at @Ref.Byte@ must fully contain the specified ranges, but this is not checked.+-- The @Ref.Byte@ must not point into the @A@ (e.g. if the @A@ were pinned), but this is not checked either. +--+-- Warning: this can fail with an unchecked exception.+copyToRefM# :: M s -- ^ source+             -> I64 -- ^ source offset+             -> Ref.Byte -- ^ destination+             -> I64 -- ^ number of elements to copy+             -> ST_ s+copyToRefM# = copyMutableByteArrayToAddr#++-- |Copy a memory range starting at the @Ref.Byte@ to the specified range in the+--    @Mutable@. The memory region at @Ref.Byte@ and the @A@ must fully+--    contain the specified ranges, but this is not checked. The @Ref.Byte@ must not+--    point into the @Mutable@ (e.g. if the @Mutable@ were pinned),+--    but this is not checked either.+--+--    Warning: This can fail with an unchecked exception.+copyFromRef# :: Ref.Byte -- ^ source+              -> M s -- ^ destination+              -> I64 -- ^ destination offset+              -> I64 -- ^ number of elements to copy+              -> ST_ s+copyFromRef# = copyAddrToByteArray#++-- | Set a slice to the specified byte.+set :: M s+    -> I64 -- ^ slice start offset+    -> I64 -- ^ slice length in bytes+    -> I64 -- ^ the byte to set them to+    -> ST_ s+set = setByteArray#++++-- | Lexicographic comparison.+-- Warning: Both arrays mus fully contain the specified ranges, but this is not checked.+compare# :: A -- ^ source1+         -> I64 -- ^ source1 offset+         -> A -- ^ source2+         -> I64 -- ^ source2 offset+         -> I64 -- ^ number of bytes to compare+         -> I64 -- ^ a number less-than, equal-to, or greater-than @0#@+compare# = compareByteArrays#

@@ -0,0 +1,19 @@+module Array.Byte.Pinned where+import qualified Ref+import Array.Byte hiding (new)++new :: I64 -> ST s (M s)+new = newPinnedByteArray#++-- TODO: add docs for which arg is which+newAligned :: I64 -> I64 -> ST s (M s)+newAligned = newAlignedPinnedByteArray#++pinned' :: A -> B+pinned' = isByteArrayPinned#++pinnedM' :: M s -> B+pinnedM' = isMutableByteArrayPinned#++contents :: A -> Ref.Byte+contents = byteArrayContents#

@@ -0,0 +1,5 @@+module Array.Byte.Unpinned where+import Array.Byte++resize :: M s -> I64 -> ST s (M s)+resize = resizeMutableByteArray#

@@ -0,0 +1,19 @@+module Array.Char where+import Array.Byte++index# :: A+       -> I64 -- Offset in 4-byte words+       -> Char+index# = indexWideCharArray#++index## :: A+        -> I64 -- Offset in bytes+        -> Char+index## = indexWord8ArrayAsWideChar#+++read# :: M s -> I64 -> ST s Char+read# = readWideCharArray#++write# :: M s -> I64 -> Char -> ST_ s+write# = writeWideCharArray#

@@ -0,0 +1,13 @@+module Array.Char8 where+import Array.Byte++index# :: A+       -> I64 -- ^ offset in bytes+       -> Char8#+index# = indexCharArray#++read# :: M s -> I64 -> ST s Char8#+read# = readCharArray#++write# :: M s -> I64 -> Char8# -> ST_ s+write# = writeCharArray#

@@ -0,0 +1,11 @@+module Array.F32 where+import Array.Byte++index# :: A -> I64 -> F32+index# = indexFloatArray#++read# :: M s -> I64 -> ST s F32+read# = readFloatArray#++write# :: M s -> I64 -> F32 -> ST_ s+write# = writeFloatArray#

@@ -0,0 +1,11 @@+module Array.F64 where+import Array.Byte++index# :: A -> I64 -> F64+index# = indexDoubleArray#++read# :: M s -> I64 -> ST s F64+read# = readDoubleArray#++write# :: M s -> I64 -> F64 -> ST_ s+write# = writeDoubleArray#

@@ -0,0 +1,18 @@+module Array.I16 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> I16+index# = indexInt16Array#++index## :: A+        -> I64 -- Offset in bytes+        -> I16+index## = indexWord8ArrayAsInt16#++read# :: M s -> I64 -> ST s I16+read# = readInt16Array#++write# :: M s -> I64 -> I16 -> ST_ s+write# = writeInt16Array#

@@ -0,0 +1,18 @@+module Array.I32 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> I32+index# = indexInt32Array#++index## :: A+        -> I64 -- Offset in bytes+        -> I32+index## = indexWord8ArrayAsInt32#++read# :: M s -> I64 -> ST s I32+read# = readInt32Array#++write# :: M s -> I64 -> I32 -> ST_ s+write# = writeInt32Array#

@@ -0,0 +1,63 @@+module Array.I64 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> I64+index# = indexInt64Array#++index## :: A+        -> I64 -- Offset in bytes+        -> I64+index## = indexWord8ArrayAsInt64#++read#, readA# :: M s -> I64 -> ST s I64+read# = readIntArray#+readA# = atomicReadIntArray#+++write#,writeA# :: M s -> I64 -> I64 -> ST_ s+write# = writeIntArray#+writeA# = atomicWriteIntArray#++cas# :: M s+    -> I64 -- ^ Source offset+    -> I64 -- ^ Expected old value+    -> I64 -- ^ New value+    -> ST s I64 -- ^ The actual old value+cas# = casIntArray#++fetchAdd :: M s -- ^ Source+         -> I64 -- ^ Source offset+         -> I64 -- ^ Value to add+         -> ST s I64 -- ^ The old value+fetchAdd = fetchAddIntArray#++fetchSub :: M s -- ^ Source+         -> I64 -- ^ Source offset+         -> I64 -- ^ Value to subtract+         -> ST s I64 -- ^ The old value+fetchSub = fetchSubIntArray#++fetchAnd :: M s -- ^ Source+         -> I64 -- ^ Source offset+         -> I64 -- ^ Value to bitwise @and@+         -> ST s I64 -- ^ The old value+fetchAnd = fetchAndIntArray#++fetchNand :: M s -- ^ Source+          -> I64 -- ^ Source offset+          -> I64 -- ^ Value to bitwise @nand@+          -> ST s I64 -- ^ The old value+fetchNand = fetchNandIntArray#+fetchOr  :: M s -- ^ Source+         -> I64 -- ^ Source offset+         -> I64 -- ^ Value to bitwise @or@+         -> ST s I64 -- ^ The old value+fetchOr = fetchOrIntArray#++fetchXor :: M s -- ^ Source+         -> I64 -- ^ Source offset+         -> I64 -- ^ Value to bitwise @xor@+         -> ST s I64 -- ^ The old value+fetchXor = fetchXorIntArray#

@@ -0,0 +1,13 @@+module Array.I8 where+import Array.Byte++index# :: A+       -> I64 -- ^ Offset in elments+       -> I8+index# = indexInt8Array#++read# :: M s -> I64 -> ST s I8+read# = readInt8Array#++write# :: M s -> I64 -> I8 -> ST_ s+write# = writeInt8Array#

@@ -0,0 +1,19 @@+module Array.Ref.Stable where+import Array.Byte+import qualified Ref++index# :: A+       -> I64 -- Offset in elments+       -> Ref.Stable a+index# = indexStablePtrArray#++index## :: A+        -> I64 -- Offset in bytes+        -> Ref.Stable a+index## = indexWord8ArrayAsStablePtr#++read# :: M s -> I64 -> ST s (Ref.Stable a)+read# = readStablePtrArray#++write# :: M s -> I64 -> Ref.Stable a -> ST_ s+write# = writeStablePtrArray#

@@ -0,0 +1,112 @@+module Array.Small where+import Prelude hiding (Array)++type A = SmallArray#+type M = SmallMutableArray#++new :: I64 -> a -> ST s (M s a)+new = newSmallArray#++eq :: M s a -> M s a -> B+eq = sameSmallMutableArray#++shrink :: M s a -> I64 -> ST_ s+shrink = shrinkSmallMutableArray#++read :: M s a -> I64 -> ST s a+read = readSmallArray#++write :: M s a -> I64 -> a -> ST_ s+write = writeSmallArray#++-- | Number of elements+size :: A a -> I64+size = sizeofSmallArray#++-- | Number of elements. Must be in @ST@ because of possible resizes.+sizeM# :: M s a -> ST s I64+sizeM# = getSizeofSmallMutableArray#++-- | Read from the specified index of an immutable array.+-- The result is packaged into an unboxed unary tuple; the result itself is not yet evaluated.+-- Pattern matching on the tuple forces the indexing of the array to happen+-- but does not evaluate the element itself. Evaluating the thunk prevents+-- additional thunks from building up on the heap. Avoiding these thunks, in turn,+-- reduces references to the argument array, allowing it to be garbage collected more promptly.+-- Warning: this can fail with an unchecked exception.+index# :: A a -> I64 -> (# a #)+index# = indexSmallArray#++-- | Make a mutable array immutable, without copying.+freeze## :: M s a -> ST s (A a)+freeze## = unsafeFreezeSmallArray#++-- | Make an immutable array mutable, without copying.+thaw## :: A a -> ST s (M s a)+thaw## = unsafeThawSmallArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copy# :: A a -- ^ source+      -> I64 -- ^ source offset+      -> M s a -- ^ destination+      -> I64 -- ^ destination offset+      -> I64 -- ^ number of elements to copy+      -> ST_ s+copy# = copySmallArray#++-- | Copy the elements from the source array to the destination array.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.+--+-- Warning: this can fail with an unchecked exception.+copyM# :: M s a -- ^ source+       -> I64 -- ^ source offset+       -> M s a -- ^ destination+       -> I64 -- ^ destination offset+       -> I64 -- ^ number of elements to copy+       -> ST_ s+copyM# = copySmallMutableArray#++-- | Create a new array with the elements from the source array.+-- The provided array must fully contain the specified range, but this is not checked.+--+-- Warning: this can fail with an unchecked exception.+clone# :: A a+       -> I64 -- ^ Source offset+       -> I64 -- ^ number of elements to copy+       -> A a+clone# = cloneSmallArray#++-- | Create a new array with the elements from the source array.+-- The provided array must fully contain the specified range, but this is not checked.+--+-- Warning: this can fail with an unchecked exception.+cloneM# :: M s a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (M s a)+cloneM# = cloneSmallMutableArray#++freeze# :: M s a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (A a)+freeze# = freezeSmallArray#++thaw# ::  A a+        -> I64 -- ^ Source offset+        -> I64 -- ^ number of elements to copy+        -> ST s (M s a)+thaw# = thawSmallArray#++cas :: M s a+    -> I64 -- ^ Source offset+    -> a -- ^ Expected old value+    -> a -- ^ New value+    -> ST s (# B, a #) -- ^ Whether the swap failed, and the actual new value+cas as o a0 a1 s0 = case casSmallArray# as o a0 a1 s0 of+  (# s1, failed', a #) -> (# s1, (# failed', a #) #)

@@ -0,0 +1,19 @@+module Array.U16 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> U16+index# = indexWord16Array#++index## :: A+        -> I64 -- Offset in bytes+        -> U16+index## = indexWord8ArrayAsWord16#+++read# :: M s -> I64 -> ST s U16+read# = readWord8Array#++write# :: M s -> I64 -> U16 -> ST_ s+write# = writeWord8Array#

@@ -0,0 +1,18 @@+module Array.U32 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> U32+index# = indexWord32Array#++index## :: A+        -> I64 -- Offset in bytes+        -> U32+index## = indexWord8ArrayAsWord32#++read# :: M s -> I64 -> ST s U32+read# = readWord32Array#++write# :: M s -> I64 -> U32 -> ST_ s+write# = writeWord32Array#

@@ -0,0 +1,18 @@+module Array.U64 where+import Array.Byte++index# :: A+       -> I64 -- Offset in elments+       -> U64+index# = indexWord64Array#++index## :: A+        -> I64 -- Offset in bytes+        -> U64+index## = indexWord8ArrayAsWord64#++read# :: M s -> I64 -> ST s U64+read# = readWord8Array#++write# :: M s -> I64 -> U64 -> ST_ s+write# = writeWord8Array#

@@ -0,0 +1,11 @@+module Array.U8 where+import Array.Byte++index# :: A -> I64 -> U8+index# = indexWord8Array#++read# :: M s -> I64 -> ST s U8+read# = readWord8Array#++write# :: M s -> I64 -> U8 -> ST_ s+write# = writeWord8Array#

@@ -0,0 +1,19 @@+module B16 (B16, module B16) where++fromU64 :: U64 -> B16+fromU64 = narrow16Word#++-- | Count the number of set bits+popCnt,clz,ctz :: B16 -> B16+popCnt = popCnt16#; clz = clz16#; ctz = ctz16#++byteSwap :: B16 -> B16+byteSwap = byteSwap16#+pext :: B16 -> U64 -> B16+pext y x = pext16# x y+pdep :: B16 -> U64 -> U64+pdep y x = pdep16# x y++-- | Reverse the order of the bits.+reverse :: B16 -> B16+reverse = bitReverse16#

@@ -0,0 +1,20 @@+module B32 (B32, module B32) where++fromU64 :: U64 -> B32+fromU64 = narrow32Word#++-- | Count the number of set bits+popCnt,clz,ctz :: B32 -> B32+popCnt = popCnt32#; clz = clz32#; ctz = ctz32#++byteSwap :: B32 -> B32+byteSwap = byteSwap32#++pext :: B32 -> U64 -> B32+pext y x = pext32# x y+pdep :: B32 -> U64 -> U64+pdep y x = pdep32# x y++-- | Reverse the order of the bits.+reverse :: B32 -> B32+reverse = bitReverse32#

@@ -0,0 +1,59 @@+module B64 (B64, module B64) where+import qualified GHC.Types as GHC++eq, ne :: B64 -> B64 -> B+eq x y = eqWord# x y+ne x y = neWord# x y++fromInt :: Int -> B64+fromInt = int2Word#+toInt :: B64 -> Int+toInt = word2Int#++toF32 :: B64 -> F32+toF32 = word2Float#+toF64 :: B64 -> F64+toF64 = word2Double#++toU8 :: B64 -> U8+toU8 = narrow8Word#+toU16 :: B64 -> U16+toU16 = narrow16Word#+toU32 :: B64 -> U32+toU32 = narrow32Word#++toB8 :: B64 -> B8+toB8 = narrow8Word#+toB16 :: B64 -> B16+toB16 = narrow16Word#+toB32 :: B64 -> B32+toB32 = narrow32Word#++and,or,xor :: B64 -> B64 -> B64+and = and#+or = or#+xor = xor#+not :: B64 -> B64+not = not#++-- | Shift left.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.+shiftL#, shiftRL# :: Int -> B64 -> B64+shiftL# i w = uncheckedShiftL# w i++-- |Shift right logical.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.+shiftRL# i w = uncheckedShiftRL# w i++-- | Count the number of set bits+popCnt,clz,ctz :: B64 -> U8+popCnt = popCnt#; clz = clz#; ctz = ctz#++byteSwap :: B64 -> B64+byteSwap = byteSwap#+pdep, pext :: B64 -> B64 -> B64+pdep y x = pdep# x y; pext y x = pext# x y++-- | Reverse the order of the bits.+reverse :: B64 -> B64+reverse = bitReverse#

@@ -0,0 +1,17 @@+module B8 (B8, module B8) where++fromU64 :: U64 -> B8+fromU64 = narrow8Word#++-- | Count the number of set bits+popCnt,clz,ctz :: B8 -> B8+popCnt = popCnt8#; clz = clz8#; ctz = ctz8#++pext :: B8 -> U64 -> B8+pext y x = pext8# x y+pdep :: B8 -> U64 -> U64+pdep y x = pdep8# x y++-- | Reverse the order of the bits.+reverse :: B8 -> B8+reverse = bitReverse8#

@@ -0,0 +1,10 @@+module BCO where+import qualified Array++type BCO = BCO#++mkApUpd0 :: BCO -> (# a #)+mkApUpd0 = mkApUpd0#++new :: Array.Byte -> Array.Byte -> Array.Boxed a -> I64 -> Array.Byte -> ST s BCO+new = newBCO#

@@ -0,0 +1,13 @@+module Char where++gt y x = gtChar# x y+ge y x = geChar# x y+lt y x = ltChar# x y+le y x = leChar# x y+eq x y = eqChar# x y+ne x y = neChar# x y++fromInt :: Int -> Char+fromInt = chr#+toInt :: Char -> Int+toInt = ord#

@@ -0,0 +1,11 @@+module Coerce where+import qualified Prelude as GHC+import qualified GHC.Types as GHC++type (=#) = GHC.Coercible++coerce :: forall b a. a =# b => a -> b+coerce = GHC.coerce++coerce# :: forall b a. a -> b+coerce# = GHC.unsafeCoerce#

@@ -0,0 +1,39 @@+module Compact where+import qualified Ref++type Compact = Compact#+type Block# = (# Ref.Byte, U64 #)++new :: U64 -> IO Compact+new = compactNew#+resize :: Compact -> U64 -> IO_+resize = compactResize#+elem' :: a -> Compact -> IO B+elem' a c = compactContains# c a++elemOfAny' :: a -> IO B+elemOfAny' = compactContainsAny#++-- | The address and size (in bytes) of the first block of a @Compact@+head :: Compact -> IO Block#+head c s0 = case compactGetFirstBlock# c s0 of+  (# s1, a, n #) -> (# s1, (# a, n #) #)++next :: Compact -> Ref.Byte -> IO Block#+next c a0 s0 = case compactGetNextBlock# c a0 s0 of+  (# s1, a1, n #) -> (# s1, (# a1, n #) #)++allocate :: Block# -> IO Ref.Byte+allocate (# a, n #) = compactAllocateBlock# n a++fixup :: Ref.Byte -> Ref.Byte -> IO (# Compact, Ref.Byte #)+fixup b0 root s0 = case compactFixupPointers# b0 root s0 of+  (# s1, c, b1 #) -> (# s1, (# c, b1 #) #)++insert, insertShared :: a -> Compact -> IO a+insert a c = compactAdd# c a+insertShared a c = compactAddWithSharing# c a++size :: Compact -> IO U64+size = compactSize#+

@@ -0,0 +1,10 @@+{-# language ScopedTypeVariables, RankNTypes, TypeApplications #-}+module Enum+  (-- | Must be evaluated, not a thunk+   dataToTag# +  -- | @a@ must be an enum type+  ,tagToEnum#+  ) where++-- Note we can't fiddle with tagToEnum# eg to rename+-- because of ghc magic prefenting it used at higher order

@@ -0,0 +1,12 @@+module Exception where++-- | Can only catch values with an @Exception@ instance.+catch# :: IO a -> (e -> IO a) -> IO a+catch# = Prelude.catch#++-- | Raising values other than type @SomeException@ leads to segfault+raise# :: e -> a+raise# = Prelude.raise#+-- | Raising values other than type @SomeException@ leads to segfault+raiseIO# :: e -> IO a+raiseIO# = Prelude.raiseIO#

@@ -0,0 +1,21 @@+{-# language PatternSynonyms #-}+module Exception.Mask where+import Prelude hiding (State#)++async :: IO a -> IO a+async = maskAsyncExceptions#++uninterruptible :: IO a -> IO a+uninterruptible = maskUninterruptible#++state :: IO State#+state = getMaskingState#++type State# = I64++pattern Unmasked :: State#+pattern Unmasked = 0#+pattern Uninterruptible :: State#+pattern Uninterruptible = 1#+pattern Interruptible :: State#+pattern Interruptible = 2#

@@ -0,0 +1,39 @@+module F32 (F32, module F32) where++add,sub,mul,div :: F32 -> F32 -> F32+add y x = plusFloat# x y+sub y x = minusFloat# x y+mul y x = timesFloat# x y+div y x = divideFloat# x y++negate,abs,exp,log,sqrt,sin,cos,tan,asin,acos,atan,sinh,cosh,tanh :: F32 -> F32+negate = negateFloat#+abs = fabsFloat#+exp = expFloat#; log = logFloat#+sqrt = sqrtFloat#+sin = sinFloat#; cos = cosFloat#; tan = tanFloat#+asin = asinFloat#; acos = acosFloat#; atan = atanFloat#+sinh = sinhFloat#; cosh = coshFloat#; tanh = tanhFloat#++pow :: F32 -> F32 -> F32+pow y x = powerFloat# x y++gt,ge,lt,le,eq,ne :: F32 -> F32 -> B+gt y x = gtFloat# x y+ge y x = geFloat# x y+lt y x = ltFloat# x y+le y x = leFloat# x y+eq x y = eqFloat# x y+ne x y = neFloat# x y++toInt :: F32 -> I64+toInt = float2Int#+fromInt:: I64 -> F32+fromInt = int2Float#+toF64 :: F32 -> F64+toF64 = float2Double#+fromF64 :: F64 -> F32+fromF64 = double2Float#++decodeI64 :: F32 -> (# I64, I64 #)+decodeI64 = decodeFloat_Int#

@@ -0,0 +1,43 @@+module F64 (F64, module F64) where++add,sub,mul,div :: F64 -> F64 -> F64+add y x = x +## y+sub y x = x -## y+-- | Low word of signed integer multiply+mul y x = x *## y+div y x = x /## y+negate,abs,exp,log,sqrt,sin,cos,tan,asin,acos,atan,sinh,cosh,tanh :: F64 -> F64+negate = negateDouble#+abs = fabsDouble#+exp = expDouble#; log = logDouble#+sqrt = sqrtDouble#+sin = sinDouble#; cos = cosDouble#; tan = tanDouble#+asin = asinDouble#; acos = acosDouble#; atan = atanDouble#+sinh = sinhDouble#; cosh = coshDouble#; tanh = tanhDouble#++pow :: F64 -> F64 -> F64+pow y x = x **## y++decode2Int :: F64 -> (# Int, U64, U64, Int #)+decode2Int = decodeDouble_2Int#  +decodeI64 :: F64 -> (# Int, Int #)+decodeI64 = decodeDouble_Int64#+++gt y x = x >## y+ge y x = x >=## y+lt y x = x <## y+le y x = x <=## y+eq x y = x ==## y+ne x y = x /=## y++fromInt :: Int -> F64+fromInt = int2Double#+toInt :: F64 -> Int+toInt = double2Int#+fromU64 :: U64 -> F64+fromU64 = word2Double#+toF32 :: F64 -> F32+toF32 = double2Float#+fromF32 :: F32 -> F64+fromF32 = float2Double#

@@ -0,0 +1,1 @@+module I16 (I16) where

@@ -0,0 +1,1 @@+module I32 (I32) where

@@ -0,0 +1,109 @@+module I64 (I64, module I64) where+import qualified GHC.Types ++add,sub,mul, quot, rem :: I64 -> I64 -> I64+add y x = x +# y+sub y x = x -# y+-- | Low word of signed integer multiply+mul y x = x *# y+-- |Return non-zero if there is any possibility that the upper word of a+--     signed integer multiply might contain useful information.  Return+--     zero only if you are completely sure that no overflow can occur.+--     On a 32-bit platform, the recommended implementation is to do a+--     32 x 32 -> 64 signed multiply, and subtract result[63:32] from+--     (result[31] >>signed 31).  If this is zero, meaning that the+--     upper word is merely a sign extension of the lower one, no+--     overflow can occur.+--+--     On a 64-bit platform it is not always possible to+--     acquire the top 64 bits of the result.  Therefore, a recommended+--     implementation is to take the absolute value of both operands, and+--     return 0 iff bits[63:31] of them are zero, since that means that their+--     magnitudes fit within 31 bits, so the magnitude of the product must fit+--     into 62 bits.+--+--     If in doubt, return non-zero, but do make an effort to create the+--     correct answer for small args, since otherwise the performance of+--     @(*) :: I64eger -> I64eger -> I64eger@ will be poor.+mulMayOflo :: I64 -> I64 -> B+mulMayOflo x y = mulIntMayOflo# x y+negate :: I64 -> I64+negate = negateInt#+-- | Rounds towards zero. The behavior is undefined if the first argument is zero.+quot y x = quotInt# x y+-- |Satisfies @(add (rem y x) (mul y (quot y x)) == x@. The+--     behavior is undefined if the first argument is zero.+rem y x = remInt# x y+quotRem :: I64 -> I64 -> (# I64, I64 #)+-- | Rounds towards zero+quotRem y x = quotRemInt# x y++addC, subC :: I64 -> I64 -> (# I64, B #)+-- |Add signed integers reporting overflow.+--           First member of result is the sum truncated to an @I64@;+--           second member is zero if the true sum fits in an @I64@,+--           nonzero if overflow occurred (the sum is either too large+--           or too small to fit in an @I64@).+addC y x = addIntC# x y+-- |Subtract signed integers reporting overflow.+--           First member of result is the difference truncated to an @I64@;+--           second member is zero if the true difference fits in an @I64@,+--           nonzero if overflow occurred (the difference is either too large+--           or too small to fit in an @I64@).+subC y x = subIntC# x y++gt,ge,lt,le,eq,ne :: I64 -> I64 -> B+gt y x = x ># y+ge y x = x >=# y+lt y x = x <# y+le y x = x <=# y+eq x y = x ==# y+ne x y = x /=# y++toU64 :: I64 -> U64+toU64 = int2Word#+fromU64 :: U64 -> I64+fromU64 = word2Int#++toF32 :: I64 -> F32+toF32 = int2Float#+toF64 :: I64 -> F64+toF64 = int2Double#++toI8 :: I64 -> I8+toI8 = narrow8Int#+toI16 :: I64 -> I16+toI16 = narrow16Int#+toI32 :: I64 -> I32+toI32 = narrow32Int#++++-- |Shift right arithmetic.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++shiftRA# :: I64 -> I64 -> I64+shiftRA# = uncheckedIShiftRA#+++-- * Bitwise operations included for completeness, but signed bit operations should never be used.++{-# DEPRECATED shiftL#, shiftRL#, and, or, xor "Don't use signed bitwise operations, prefer U64 instead" #-}++-- | Shift left.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.+shiftL# :: I64 -> I64 -> I64+shiftL# = uncheckedIShiftL# ++-- |Shift right logical.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++shiftRL# :: I64 -> I64 -> I64+shiftRL# = uncheckedIShiftRL#+and, or, xor :: I64 -> I64 -> I64+and = andI#+or = orI#+xor = xorI#++not :: I64 -> I64+not = notI#

@@ -0,0 +1,1 @@+module I8 (I8) where

@@ -0,0 +1,2 @@+module Nat (Nat) where+import GHC.Types

@@ -0,0 +1,5 @@+module Optimizer (module X) where+import GHC.Magic as X+import GHC.Types as X (SPEC(..))++

@@ -0,0 +1,40 @@+{-# OPTIONS_HADDOCK not-home  #-}+{-# language TypeOperators #-}+module Prelude (module Prelude, module X) where+import GHC.Prim as X+import           GHC.Types as X (TYPE)+import qualified GHC.Types as GHC+import ST as X (ST,ST_)+import ST.IO as X++-- TODO: use hsboot instead of this file+-- TODO: add safe versions of the sized numbers++type Char = Char#+type Char8# = Char#++type Int = Int#+type I64 = Int#+type I32 = Int#+type I16 = Int#+type I8 = Int#++type U8 = Word#+type U16 = Word#+type U32 = Word#+type U64 = Word#++type B = Int#+type B8 = Word#+type B16 = Word#+type B32 = Word#+type B64 = Word#++type F32 = Float#+type F64 = Double#++type Maybe# (a :: TYPE r) = (# B, a #)+++type T = GHC.Type+type C = GHC.Constraint

@@ -0,0 +1,8 @@+{-# language PatternSynonyms #-}+module Proxy where++type Proxy = Proxy#++-- | Hack to expose 'proxy#'+pattern Proxy :: Proxy a+pattern Proxy <- proxy# where Proxy = proxy#

@@ -0,0 +1,10 @@+module RTS.Block where++delay :: I64 {- ^ microseconds to wait -} -> ST_ s+delay = delay#++-- TODO: use a convenience type for file descriptors once you understand how they work.+waitRead,waitWrite :: I64 -> ST_ s+waitRead = waitRead#+waitWrite = waitWrite#+

@@ -0,0 +1,7 @@+module RTS.Prefetch.Any where++t0, t1, t2, t3 :: a -> ST_ s+t0 = prefetchValue0#+t1 = prefetchValue1#+t2 = prefetchValue2#+t3 = prefetchValue3#

@@ -0,0 +1,8 @@+module RTS.Prefetch.Array where+import qualified Array++t0, t1, t2, t3 :: Array.Byte -> I64 {- ^ offset -} -> ST_ s+t0 = prefetchByteArray0#+t1 = prefetchByteArray1#+t2 = prefetchByteArray2#+t3 = prefetchByteArray3#

@@ -0,0 +1,8 @@+module RTS.Prefetch.Array.M where+import qualified Array.Byte++t0, t1, t2, t3 :: Array.Byte.M s -> I64 {- ^ offset -} -> ST_ s+t0 = prefetchMutableByteArray0#+t1 = prefetchMutableByteArray1#+t2 = prefetchMutableByteArray2#+t3 = prefetchMutableByteArray3#

@@ -0,0 +1,8 @@+module RTS.Prefetch.Ref where+import qualified Ref++t0, t1, t2, t3 :: Ref.Byte -> I64 {- ^ offset -} -> ST_ s+t0 = prefetchAddr0#+t1 = prefetchAddr1#+t2 = prefetchAddr2#+t3 = prefetchAddr3#

@@ -0,0 +1,8 @@+module Ref where++type Byte = Addr#+type Weak = Weak#+type Stable = StablePtr#+type Boxed = MutVar#+type STM = TVar#+type Lock = MVar#

@@ -0,0 +1,40 @@+module Ref.Boxed where+import qualified Ref++type Ref = MutVar#++new :: a -> ST s (Ref s a)+new = newMutVar#++read :: Ref s a -> ST s a+read = readMutVar#++write :: Ref s a -> a -> ST_ s+write = writeMutVar#++eq :: Ref s a -> Ref s a -> B+eq = sameMutVar#++-- | Modify the contents of a @Ref.Boxed@, returning the previous contents and the result of applying the given function to the previous contents. Note that this isn't strictly speaking the correct type for this function; it should really be MutVar# s a -> (a -> (a,b)) -> State# s -> (# State# s, a, (a, b) #), but we don't know about pairs here.+-- +-- Warning: this can fail with an unchecked exception.+++modify :: Ref s a+       -> (a -> b)+       -> ST s (# a, b #) -- ^ Previous contents and the result of applying the function+modify r f s0 = case atomicModifyMutVar2# r f s0 of+  (# s1, old, new #) -> (# s1, (# old, new #) #)++modify_ :: Ref s a+        -> (a -> a)+        -> ST s (# a, a #) -- ^ Previous contents and the result of applying the function+modify_ r f s0 = case atomicModifyMutVar2# r f s0 of+  (# s1, old, new #) -> (# s1, (# old, new #) #)++cas :: Ref s a+    -> a -- ^ expected old value+    -> a -- ^ new value+    -> ST s (# B, a #) -- ^ Whether the swap failed, and the actual new value+cas r old new s0 = case casMutVar# r old new s0 of+  (# s1, failed', a #) -> (# s1, (# failed', a #) #)

@@ -0,0 +1,38 @@+{-# language PatternSynonyms #-}+module Ref.Byte where++type Ref = Addr#++-- | hack to expose nullAddr#+pattern Null :: Ref+pattern Null <- nullAddr# where Null = nullAddr#++add :: I64 -> Ref -> Ref+add i a = plusAddr# a i++sub :: Ref -> Ref -> I64+sub a0 a1 = minusAddr# a1 a0++rem :: I64 -> Ref -> I64+rem i a = remAddr# a i++toI64 :: Ref -> I64+toI64 = addr2Int#+fromI64 :: I64 -> Ref+fromI64 = int2Addr#+{-# DEPRECATED toI64, fromI64 "This operation is strongly deprecated" #-}++gt,ge,lt,le,eq,ne :: Ref -> Ref -> B+gt y x = gtAddr# x y+ge y x = geAddr# x y+lt y x = ltAddr# x y+le y x = leAddr# x y+eq x y = eqAddr# x y+ne x y = neAddr# x y++toAny :: Ref-> (# a #)+toAny = addrToAny#++-- | Must be run on an evaluated value, not a thunk+fromAny# :: a -> IO Ref+fromAny# = anyToAddr#

@@ -0,0 +1,11 @@+module Ref.Char where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> Char+index# = indexWideCharOffAddr#++read# :: Ref -> I64 -> ST s Char+read# = readWideCharOffAddr#++write# :: Ref -> I64 -> Char -> ST_ s+write# = writeWideCharOffAddr#

@@ -0,0 +1,11 @@+module Ref.Char8 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> Char8#+index# = indexCharOffAddr#++read# :: Ref -> I64 -> ST s Char8#+read# = readCharOffAddr#++write# :: Ref -> I64 -> Char8# -> ST_ s+write# = writeCharOffAddr#

@@ -0,0 +1,11 @@+module Ref.F32 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> F32+index# = indexFloatOffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s F32+read# = readFloatOffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> F32 -> ST_ s+write# = writeFloatOffAddr#

@@ -0,0 +1,11 @@+module Ref.F64 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> F64+index# = indexDoubleOffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s F64+read# = readDoubleOffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> F64 -> ST_ s+write# = writeDoubleOffAddr#

@@ -0,0 +1,11 @@+module Ref.I16 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> I16+index# = indexInt16OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s I16+read# = readInt16OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> I16 -> ST_ s+write# = writeInt16OffAddr#

@@ -0,0 +1,11 @@+module Ref.I32 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> I32+index# = indexInt32OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s I32+read# = readInt32OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> I32 -> ST_ s+write# = writeInt32OffAddr#

@@ -0,0 +1,11 @@+module Ref.I64 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> I64+index# = indexInt64OffAddr#++read# :: Ref -> I64 -> ST s I64+read# = readInt64OffAddr#++write# :: Ref -> I64 -> I64 -> ST_ s+write# = writeInt64OffAddr#

@@ -0,0 +1,11 @@+module Ref.I8 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> I8+index# = indexInt8OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s I8+read# = readInt8OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> I8 -> ST_ s+write# = writeInt8OffAddr#

@@ -0,0 +1,37 @@+module Ref.Lock where++type Ref = MVar#++eq :: Ref s a -> Ref s a -> B+eq = sameMVar#++empty' :: Ref s a -> ST s B+empty' = isEmptyMVar#++-- | A new empty @Ref@+new :: ST s (Ref s a)+new = newMVar#++-- | Block until the @Ref@ is full/unlocked, then atomically take the value and lock it.+take :: Ref s a -> ST s a+take = takeMVar#++-- | Take the current value if it exists and lock the @Ref@+take' :: Ref s a -> ST s (Maybe# a) {- ^ The value if the @Ref@ was full/unlocked -}+take' r s0 = case tryTakeMVar# r s0 of+  (# s1, full', a #) -> (# s1, (# full', a #) #)++-- | Block until the @Ref@ is full/unlocked, then read the value but don't lock it.+read :: Ref s a -> ST s a+read = readMVar#++-- | Take the current value if it exists but don't lock the @Ref@+read' :: Ref s a -> ST s (Maybe# a) {- ^ The value if the @Ref@ was full/unlocked -}+read' r s0 = case tryReadMVar# r s0 of+  (# s1, full', a #) -> (# s1, (# full', a #) #)++write :: Ref s a -> a -> ST_ s+write = putMVar#++write' :: Ref s a -> a -> ST s B {- ^ whether the write succeeded -}+write' = tryPutMVar#

@@ -0,0 +1,12 @@+module Ref.Ref.Byte where+import qualified Ref+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> Ref.Byte+index# = indexAddrOffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s Ref.Byte+read# = readAddrOffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> Ref.Byte -> ST_ s+write# = writeAddrOffAddr#

@@ -0,0 +1,12 @@+module Ref.Ref.Stable where+import qualified Ref+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> Ref.Stable a+index# = indexStablePtrOffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s (Ref.Stable a)+read# = readStablePtrOffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> Ref.Stable a -> ST_ s+write# = writeStablePtrOffAddr#

@@ -0,0 +1,20 @@+module Ref.STM where++type Ref = TVar#++eq :: Ref s a -> Ref s a -> B+eq = sameTVar#++new :: a -> ST s (Ref s a)+new = newTVar#++read, readIO :: Ref s a -> ST s a+read = readTVar#+-- | Read a @Ref.STM@ outside the transaction, without annotating the STM ledger.+-- Much faster than 'read'.+readIO = readTVarIO#++write :: Ref s a -> a -> ST_ s+write = writeTVar#++

@@ -0,0 +1,12 @@+module Ref.Stable where++type Ref = StablePtr#++new :: a -> IO (Ref a)+new = makeStablePtr#++deref :: Ref a -> IO a+deref = deRefStablePtr#++eq :: Ref a -> Ref a -> B+eq = eqStablePtr#

@@ -0,0 +1,10 @@+module Ref.Stable.Name where++type Ref = StableName#++new :: a -> IO (Ref a)+new = makeStableName#+eq :: Ref a -> Ref a -> B+eq = eqStableName#+toInt :: Ref a -> I64+toInt = stableNameToInt#

@@ -0,0 +1,11 @@+module Ref.U16 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> U16+index# = indexWord16OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s U16+read# = readWord16OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> U16 -> ST_ s+write# = writeWord16OffAddr#

@@ -0,0 +1,11 @@+module Ref.U32 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> U32+index# = indexWord32OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s U32+read# = readWord32OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> U32 -> ST_ s+write# = writeWord32OffAddr#

@@ -0,0 +1,11 @@+module Ref.U64 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> U64+index# = indexWord64OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s U64+read# = readWord64OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> U64 -> ST_ s+write# = writeWord64OffAddr#

@@ -0,0 +1,11 @@+module Ref.U8 where+import Ref.Byte++index# :: Ref -> I64 {- ^ Offset in elments -} -> U8+index# = indexWord8OffAddr#++read# :: Ref -> I64 {- ^ Offset in elements -} -> ST s U8+read# = readWord8OffAddr#++write# :: Ref -> I64 {- ^ Offset in elements -} -> U8 -> ST_ s+write# = writeWord8OffAddr#

@@ -0,0 +1,24 @@+module Ref.Weak where+import qualified Ref++type Ref = Weak#++new :: k -> v -> IO x -> IO (Ref v)+new = mkWeak# ++newNoFinalizer :: k -> v -> IO (Ref v)+newNoFinalizer = mkWeakNoFinalizer#++addFinalizer :: Ref.Byte -> Ref.Byte -> B -> Ref.Byte -> Ref v -> IO B+addFinalizer = addCFinalizerToWeak#++deref :: Ref v -> IO (Maybe# v)+deref w s0 = case deRefWeak# w s0 of+  (# s1, alive', v #) -> (# s1, (# alive', v #) #)++finalize :: Ref v -> IO (Maybe# (IO x))+finalize w s0 = case finalizeWeak# w s0 of+  (# s1, alive', finalizer #) -> (# s1, (# alive', finalizer #) #)++touch :: k -> IO_+touch = touch#

@@ -0,0 +1,7 @@+{-# language NoImplicitPrelude #-}+module ST ( ST, ST_) where+import GHC.Prim (State#, TYPE )++type Token = State#+type ST_ s = Token s -> Token s+type ST s (a :: TYPE r) = Token s -> (# Token s, a #)

@@ -0,0 +1,9 @@+{-# language NoImplicitPrelude #-}+module ST.IO where+import GHC.Prim (RealWorld,TYPE)+import ST (ST,ST_)+++type (☸) = RealWorld+type IO (a :: TYPE r) = ST (☸) a+type IO_ = ST_ (☸)

@@ -0,0 +1,21 @@+{-# language NoImplicitPrelude #-}+module ST.IO.STM where+import ST.IO+import GHC.Prim++type STM (a :: TYPE r) = IO a+type STM_ = IO_++atomically :: STM a -> IO a+atomically = atomically#++-- | Retry execution of the current memory transaction because it has seen values in TVars which mean that it should not continue (e.g. the TVars represent a shared buffer that is now empty).+-- The implementation may block the thread until one of the TVars that it has read from has been updated.+retry :: STM a+retry = retry#++catch :: STM a -> (e -> STM a) -> STM a+catch = catchSTM#++catch_ :: STM a -> STM a -> STM a+catch_ = catchRetry#

@@ -0,0 +1,16 @@+module Spark where++par :: a -> I64+par = par#+{-# DEPRECATED par "Use 'spark#' instead" #-}+spark, seq :: a -> ST s a+spark = spark#+seq = seq#+-- | Get the next spark from the job queue and number of remaining(?) sparks+-- TODO: verify the I64 argument meaning+get :: ST s (# I64, a #)+get s0 = case getSpark# s0 of (# s1, n, a #) -> (# s1, (# n, a #) #)++num :: ST s I64+num = numSparks#+

@@ -0,0 +1,4 @@+{-| Description : Stock datatypes and classes -}+module Stock (module X) where+import GHC.Types as X (Bool(..),Char(..),Int(..),Word(..),Float(..),Double(..),IO(..),Ordering(..))+import GHC.Classes as X (Eq(..),Ord(..))

@@ -0,0 +1,8 @@+module String where+import qualified GHC.Types++-- | Null terminated C-style Strings+type C# = Addr#++-- | Boxed Linked list of @Char@+type List = [GHC.Types.Char]

@@ -0,0 +1,3 @@+module String.C where++type S = Addr#

@@ -0,0 +1,115 @@+{-# language BangPatterns #-}+module String.C.Latin where+import qualified String+import String.C+import Prelude hiding (Char)+import GHC.Types (Char(..),isTrue#,Bool(..))++--------------------------------------------------------------------------+-- Unpacking C strings+-----------------------------------------------------------------------------++-- This code is needed for virtually all programs, since it's used for+-- unpacking the strings of error messages.++-- Used to be in GHC.Base, but was moved to ghc-prim because the new generics+-- stuff uses Strings in the representation, so to give representations for+-- ghc-prim types we need unpack#++{- Note [Inlining unpack#]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There's really no point in ever inlining things like unpack# as the loop+doesn't specialise in an interesting way and we can't deforest the list+constructors (we'd want to use foldr# for this). Moreover, it's+pretty small, so there's a danger that it'll be inlined at every literal, which+is a waste.++Moreover, inlining early may interfere with a variety of rules that are supposed+to match unpack#,++ * BuiltInRules in PrelRules.hs; e.g.+       eqString (unpack# (Lit s1)) (unpack# (Lit s2)+          = s1 == s2++ * unpacking rules; e.g. in GHC.Base,+       unpack# a+          = build (foldr# a)++ * stream fusion rules; e.g. in the `text` library,+       unstream (S.map safe (S.streamList (GHC.unpack# a)))+          = unpack# a++Moreover, we want to make it CONLIKE, so that:++* the rules in PrelRules will fire when the string is let-bound.+  E.g. the eqString rule in PrelRules+   eqString (unpack# (Lit s1)) (unpack# (Lit s2) = s1==s2++* exprIsConApp_maybe will see the string when we have+     let x = unpack# "foo"#+     ...(case x of algs)...++All of this goes for unpackUtf8# too.+-}+++unpack# :: S -> String.List+{-# NOINLINE CONLIKE unpack# #-}+unpack# addr+  = unpack 0#+  where+    unpack nh+      | isTrue# (ch `eqChar#` '\0'#) = []+      | True                         = C# ch : unpack (nh +# 1#)+      where+        !ch = indexCharOffAddr# addr nh++unpackAppend# :: S -> String.List -> String.List+{-# NOINLINE unpackAppend# #-}+     -- See the NOINLINE note on unpack#+unpackAppend# addr rest+  = unpack 0#+  where+    unpack nh+      | isTrue# (ch `eqChar#` '\0'#) = rest+      | True                         = C# ch : unpack (nh +# 1#)+      where+        !ch = indexCharOffAddr# addr nh++foldr# :: S -> (Char  -> a -> a) -> a -> a++-- Usually the unpack-list rule turns foldr# into unpack#++-- It also has a BuiltInRule in PrelRules.hs:+--      foldr# "foo" c (foldr# "baz" c n)+--        =  foldr# "foobaz" c n++{-# NOINLINE foldr# #-}+-- At one stage I had NOINLINE [0] on the grounds that, unlike+-- unpack#, there *is* some point in inlining+-- foldr#, because we get better code for the+-- higher-order function call.  BUT there may be a lot of+-- literal strings, and making a separate 'unpack' loop for+-- each is highly gratuitous.  See nofib/real/anna/PrettyPrint.++foldr# addr f z+  = unpack 0#+  where+    unpack nh+      | isTrue# (ch `eqChar#` '\0'#) = z+      | True                         = C# ch `f` unpack (nh +# 1#)+      where+        !ch = indexCharOffAddr# addr nh++-- There's really no point in inlining this for the same reasons as+-- unpack. See Note [Inlining unpack#] above for details.+unpackN# :: S -> Int# -> String.List+{-# NOINLINE unpackN# #-}+unpackN# _addr 0#   = []+unpackN#  addr len# = unpack [] (len# -# 1#)+    where+     unpack acc i#+      | isTrue# (i# <# 0#)  = acc+      | True                =+         case indexCharOffAddr# addr i# of+            ch -> unpack (C# ch : acc) (i# -# 1#)

@@ -0,0 +1,39 @@+{-# language BangPatterns #-}+module String.C.UTF8 where+import qualified String+import String.C+import Prelude hiding (Char)+import GHC.Types (Char(..),isTrue#,Bool(..))++-- There's really no point in inlining this for the same reasons as+-- unpack. See Note [Inlining unpack#] above for details.+unpack# :: S -> String.List+{-# NOINLINE CONLIKE unpack# #-}+unpack# addr+  = unpack 0#+  where+    -- We take care to strictly evaluate the character decoding as+    -- indexCharOffAddr# is marked with the can_fail flag and+    -- consequently GHC won't evaluate the expression unless it is absolutely+    -- needed.+    unpack nh+      | isTrue# (ch `eqChar#` '\0'#  ) = []+      | isTrue# (ch `leChar#` '\x7F'#) = C# ch : unpack (nh +# 1#)+      | isTrue# (ch `leChar#` '\xDF'#) =+          let !c = C# (chr# (((ord# ch                                  -# 0xC0#) `uncheckedIShiftL#`  6#) +#+                              (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#)))+          in c : unpack (nh +# 2#)+      | isTrue# (ch `leChar#` '\xEF'#) =+          let !c = C# (chr# (((ord# ch                                  -# 0xE0#) `uncheckedIShiftL#` 12#) +#+                             ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#`  6#) +#+                              (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#)))+          in c : unpack (nh +# 3#)+      | True                           =+          let !c = C# (chr# (((ord# ch                                  -# 0xF0#) `uncheckedIShiftL#` 18#) +#+                             ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12#) +#+                             ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#`  6#) +#+                              (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#)))+          in c : unpack (nh +# 4#)+      where+        !ch = indexCharOffAddr# addr nh+

@@ -0,0 +1,43 @@+{-# language UnliftedFFITypes #-}+module String.List where+import qualified GHC.Types++type S = [GHC.Types.Char]++debugLn :: S -> GHC.Types.IO ()+debugLn xs = GHC.Types.IO (\s0 ->+                 case mkMBA xs s0 of+                 (# s1, mba #) ->+                     case c_debugLn mba of+                     GHC.Types.IO f -> f s1)++debugErrLn :: S -> GHC.Types.IO ()+debugErrLn xs = GHC.Types.IO (\s0 ->+                    case mkMBA xs s0 of+                    (# s1, mba #) ->+                        case c_debugErrLn mba of+                        GHC.Types.IO f -> f s1)++foreign import ccall unsafe "debugLn"+    c_debugLn :: MutableByteArray# RealWorld -> GHC.Types.IO ()++foreign import ccall unsafe "debugErrLn"+    c_debugErrLn :: MutableByteArray# RealWorld -> GHC.Types.IO ()++mkMBA :: S -> IO (MutableByteArray# RealWorld)+mkMBA xs s0 = -- Start with 1 so that we have space to put in a \0 at+              -- the end+              case len 1# xs of+              l ->+                  case newByteArray# l s0 of+                  (# s1, mba #) ->+                      case write mba 0# xs s1 of+                      s2 -> (# s2, mba #)+    where len l [] = l+          len l (_ : xs') = len (l +# 1#) xs'++          write mba offset [] s = writeCharArray# mba offset '\0'# s+          write mba offset (GHC.Types.C# x : xs') s+              = case writeCharArray# mba offset x s of+                s' ->+                    write mba (offset +# 1#) xs' s'

@@ -0,0 +1,2 @@+module Syntax.ImplicitParam (module X) where+import GHC.Classes as X (IP(..))

@@ -0,0 +1,59 @@+{-# language PatternSynonyms #-}+module Thread where+import qualified Ref++type Id = ThreadId#++-- | The physical capability (Hardware thread) a 'Thread' is running on+type Cap = I64++fork :: a -> IO Id+fork = fork#+forkOn :: Cap -> a -> IO Id+forkOn u = forkOn# u+-- | Kill a thread with the given exception (toException)+kill# :: Id -> a -> IO_+kill# = killThread#+yield :: IO_+yield = yield#+here :: IO Id+here = myThreadId#+-- | Label a thread with the given cstring pointer+label# :: Id -> Ref.Byte -> IO_+label# = labelThread#+bound' :: IO B+bound' = isCurrentThreadBound#+-- TODO: put this somewhere else+noDuplicate :: ST_ s+noDuplicate = noDuplicate#+status :: Id -> IO (# Status, Cap, B #)+status n s = case threadStatus# n s of+  (# s', status, cap, bound' #) -> (# s', (# status, cap, bound' #) #)++-- * Constants for why_blocked field of a TSO from rts/Constants.h+type Status = Int#+pattern Running = 0#+pattern BlockedOnMVar = 1#+pattern BlockedOnBlackHole = 2#+pattern BlockedOnRead = 3#+pattern BlockedOnWrite = 4#+pattern BlockedOnDelay = 5#+pattern BlockedOnSTM = 6#+-- | Win32 only+pattern BlockedOnDoProc = 7#++-- | Only relevant for THREADED_RTS+pattern BlockedOnCCall = 10#+-- | Same as @BlockedOnCCall@ but permit killing the worker thread.+-- Only relevant for THREADED_RTS+pattern BlockedOnCCall_Interruptible = 11#++-- | Involved in a message tsent to tso->msg_cap+pattern BlockedOnMsgThrowTo = 12#++-- | The thread is not on any run queues, but can be woken up by @tryWakeupThread()@+pattern ThreadMigrating = 13#++-- TODO: There should be more here, like ThreadFinished. Figure out the numbering++

@@ -0,0 +1,1 @@+module U16 (U16) where

@@ -0,0 +1,2 @@+module U32 (U32) where+

@@ -0,0 +1,69 @@+module U64 (U64, module U64) where+import qualified GHC.Types as GHC++add,sub,mul, quot, rem :: U64 -> U64 -> U64+add y x = plusWord# x y+sub y x = minusWord# x y+mul y x = timesWord# x y++-- |Add unsigned integers, with the high part (carry) in the first+--           component of the returned pair and the low part in the second+--           component of the pair. See also @addC@.+add2 :: U64 -> U64 -> (# U64, U64 #)+add2 y x = plusWord2# x y++-- | Rounds towards zero. The behavior is undefined if the first argument is zero.+quot y x = quotWord# x y++-- |Satisfies @(add (rem y x) (mul y (quot y x)) == x@. The+--     behavior is undefined if the first argument is zero.+rem y x = remWord# x y++-- | Rounds towards zero+quotRem :: U64 -> U64 -> (# U64, U64 #)+quotRem y x = quotRemWord# x y+-- |Add signed integers reporting overflow.+--           First member of result is the sum truncated to an @U64@;+--           second member is zero if the true sum fits in an @U64@,+--           nonzero if overflow occurred (the sum is either too large+--           or too small to fit in an @U64@).+addC, subC :: U64 -> U64 -> (# U64, B #)+addC y x = addWordC# x y+-- |Subtract signed integers reporting overflow.+--           First member of result is the difference truncated to an @U64@;+--           second member is zero if the true difference fits in an @U64@,+--           nonzero if overflow occurred (the difference is either too large+--           or too small to fit in an @U64@).+subC y x = subWordC# x y++gt,ge,lt,le,eq,ne :: U64 -> U64 -> B+gt y x = gtWord# x y+ge y x = geWord# x y+lt y x = ltWord# x y+le y x = leWord# x y+eq x y = eqWord# x y+ne x y = neWord# x y++fromInt :: Int -> U64+fromInt = int2Word#+toInt :: U64 -> Int+toInt = word2Int#++toF32 :: U64 -> F32+toF32 = word2Float#+toF64 :: U64 -> F64+toF64 = word2Double#++toU8 :: U64 -> U8+toU8 = narrow8Word#+toU16 :: U64 -> U16+toU16 = narrow16Word#+toU32 :: U64 -> U32+toU32 = narrow32Word#++toB8 :: U64 -> B8+toB8 = narrow8Word#+toB16 :: U64 -> B16+toB16 = narrow16Word#+toB32 :: U64 -> B32+toB32 = narrow32Word#

@@ -0,0 +1,1 @@+module U8 (U8) where