base 4.17.2.1 → 4.18.0.0

raw patch · 140 files changed

+40368/−35772 lines, 140 filesdep ~ghc-primPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: ghc-prim

API changes (from Hackage documentation)

Files

• Control/Concurrent.hs +33/−2
• Control/Exception/Base.hs +33/−7
• Control/Monad/Fail.hs +5/−1
• Control/Monad/Fix.hs +1/−1
• Control/Monad/Zip.hs +1/−1
• Data/Array/Byte.hs +106/−40
• Data/Bifoldable1.hs +49/−0
• Data/Bifunctor.hs +21/−5
• Data/Char.hs +2/−2
• Data/Complex.hs +1/−0
• Data/Data.hs +9/−4
• Data/Foldable.hs +8/−2
• Data/Foldable1.hs +518/−0
• Data/Function.hs +29/−0
• Data/Functor/Classes.hs +75/−12
• Data/Functor/Compose.hs +28/−24
• Data/Functor/Product.hs +11/−20
• Data/Functor/Sum.hs +11/−17
• Data/Functor/Utils.hs +33/−2
• Data/IORef.hs +29/−13
• Data/List.hs +11/−2
• Data/List/NonEmpty.hs +52/−3
• Data/Monoid.hs +14/−2
• Data/OldList.hs +221/−55
• Data/Ord.hs +29/−3
• Data/Semigroup.hs +15/−1
• Data/Semigroup/Internal.hs +1/−1
• Data/String.hs +2/−20
• Data/Traversable.hs +46/−4
• Data/Type/Equality.hs +3/−3
• Data/Typeable.hs +10/−2
• Data/Typeable/Internal.hs +10/−2
• Data/Void.hs +2/−66
• Debug/Trace.hs +35/−0
• Foreign/C/ConstPtr.hs +45/−0
• Foreign/C/String.hs +1/−10
• Foreign/C/Types.hs +9/−1
• Foreign/Concurrent.hs +9/−4
• Foreign/Marshal/Array.hs +31/−1
• Foreign/Marshal/Pool.hs +23/−25
• Foreign/Storable.hs +6/−0
• GHC/ArrayArray.hs +3/−2
• GHC/Base.hs +117/−61
• GHC/ByteOrder.hs-boot +28/−0
• GHC/Conc.hs +1/−0
• GHC/Conc/IO.hs +25/−15
• GHC/Conc/POSIX.hs +6/−0
• GHC/Conc/Sync.hs +77/−30
• GHC/Conc/Sync.hs-boot +3/−1
• GHC/Conc/Windows.hs +10/−1
• GHC/Encoding/UTF8.hs +318/−0
• GHC/Enum.hs +62/−18
• GHC/Event.hs +5/−0
• GHC/Event/Control.hs +11/−0
• GHC/Event/Thread.hs +25/−0
• GHC/Event/TimerManager.hs +13/−0
• GHC/Event/Windows.hsc +10/−2
• GHC/Event/Windows/FFI.hsc +3/−3
• GHC/Event/Windows/Thread.hs +4/−0
• GHC/Exception.hs +1/−1
• GHC/Exception/Type.hs +3/−0
• GHC/Exts.hs +2/−0
• GHC/Fingerprint.hs +1/−1
• GHC/Float.hs +29/−21
• GHC/Foreign.hs +7/−3
• GHC/ForeignPtr.hs +14/−7
• GHC/Generics.hs +13/−1
• GHC/IO/Encoding.hs +5/−1
• GHC/IO/Encoding/CodePage/API.hs +6/−0
• GHC/IO/Encoding/Failure.hs +1/−1
• GHC/IO/Encoding/UTF8.hs +4/−0
• GHC/IO/FD.hs +33/−2
• GHC/IO/Handle/Internals.hs +32/−2
• GHC/IO/StdHandles.hs +1/−1
• GHC/IO/Unsafe.hs +1/−1
• GHC/IO/Windows/Paths.hs +1/−1
• GHC/IOPort.hs +1/−1
• GHC/IORef.hs +36/−5
• GHC/InfoProv.hsc +113/−0
• GHC/Ix.hs +33/−7
• GHC/JS/Prim.hs +332/−0
• GHC/JS/Prim/Internal.hs +56/−0
• GHC/JS/Prim/Internal/Build.hs +1470/−0
• GHC/List.hs +23/−25
• GHC/Num.hs +2/−0
• GHC/Pack.hs +5/−0
• GHC/Ptr.hs +1/−1
• GHC/Read.hs +6/−0
• GHC/Real.hs +94/−42
• GHC/ResponseFile.hs +1/−1
• GHC/Show.hs +3/−0
• GHC/Stable.hs +2/−0
• GHC/Stack/CCS.hsc +17/−72
• GHC/Stack/CloneStack.hs +6/−6
• GHC/StaticPtr.hs +1/−1
• GHC/Stats.hsc +17/−12
• GHC/TopHandler.hs +40/−8
• GHC/TypeLits.hs +242/−38
• GHC/TypeLits/Internal.hs +1/−1
• GHC/TypeNats.hs +161/−62
• GHC/TypeNats/Internal.hs +1/−1
• GHC/Unicode.hs +111/−65
• GHC/Unicode/Internal/Bits.hs +73/−0
• GHC/Unicode/Internal/Char/DerivedCoreProperties.hs +35/−0
• GHC/Unicode/Internal/Char/UnicodeData/GeneralCategory.hs too large to diff
• GHC/Unicode/Internal/Char/UnicodeData/SimpleLowerCaseMapping.hs +1458/−0
• GHC/Unicode/Internal/Char/UnicodeData/SimpleTitleCaseMapping.hs +1479/−0
• GHC/Unicode/Internal/Char/UnicodeData/SimpleUpperCaseMapping.hs +1475/−0
• GHC/Unicode/Internal/Version.hs +26/−0
• GHC/Weak.hs +10/−25
• GHC/Weak/Finalize.hs +81/−0
• GHC/Windows.hs +6/−0
• Numeric/Natural.hs +2/−0
• Prelude.hs +1/−1
• System/CPUTime.hsc +3/−0
• System/CPUTime/Javascript.hs +26/−0
• System/CPUTime/Posix/ClockGetTime.hsc +5/−2
• System/CPUTime/Posix/RUsage.hsc +12/−0
• System/CPUTime/Posix/Times.hsc +12/−0
• System/Environment.hs +2/−0
• System/Environment/ExecutablePath.hsc +15/−0
• System/Exit.hs +5/−7
• System/Info.hs +2/−0
• System/Posix/Internals.hs +246/−16
• System/Timeout.hs +5/−3
• Text/Printf.hs +1/−1
• Type/Reflection/Unsafe.hs +1/−1
• aclocal.m4 +2/−4
• base.cabal +48/−19
• cbits/WCsubst.c +0/−5238
• cbits/sysconf.c +0/−2
• changelog.md +73/−16
• configure +28942/−29529
• configure.ac +12/−1
• include/HsBase.h +2/−5
• include/HsBaseConfig.h.in +28/−0
• include/WCsubst.h +0/−20
• jsbits/base.js +839/−0
• jsbits/errno.js +102/−0
• jsbits/platform.js +111/−0

@@ -105,18 +105,26 @@      ) where +-- JavaScript platform doesn't support bound threads+#if !defined(javascript_HOST_ARCH)+#define SUPPORT_BOUND_THREADS+#endif+ import Control.Exception.Base as Exception  import GHC.Conc hiding (threadWaitRead, threadWaitWrite,                         threadWaitReadSTM, threadWaitWriteSTM)++#if defined(SUPPORT_BOUND_THREADS) import GHC.IO           ( unsafeUnmask, catchException ) import GHC.IORef        ( newIORef, readIORef, writeIORef ) import GHC.Base--import System.Posix.Types ( Fd ) import Foreign.StablePtr import Foreign.C.Types+#endif +import System.Posix.Types ( Fd )+ #if defined(mingw32_HOST_OS) import Foreign.C import System.IO@@ -250,6 +258,27 @@  -} +#if !defined(SUPPORT_BOUND_THREADS)+forkOS :: IO () -> IO ThreadId+forkOS _ = error "forkOS not supported on this architecture"++forkOSWithUnmask :: ((forall a . IO a -> IO a) -> IO ()) -> IO ThreadId+forkOSWithUnmask _ = error "forkOS not supported on this architecture"++isCurrentThreadBound :: IO Bool+isCurrentThreadBound = pure False++runInBoundThread :: IO a -> IO a+runInBoundThread action = action++runInUnboundThread :: IO a -> IO a+runInUnboundThread action = action++rtsSupportsBoundThreads :: Bool+rtsSupportsBoundThreads = False+#else++ -- | 'True' if bound threads are supported. -- If @rtsSupportsBoundThreads@ is 'False', 'isCurrentThreadBound' -- will always return 'False' and both 'forkOS' and 'runInBoundThread' will@@ -389,6 +418,8 @@  unsafeResult :: Either SomeException a -> IO a unsafeResult = either Exception.throwIO return++#endif  -- --------------------------------------------------------------------------- -- threadWaitRead/threadWaitWrite

@@ -42,6 +42,7 @@         RecUpdError(..),         ErrorCall(..),         TypeError(..), -- #10284, custom error type for deferred type errors+        NoMatchingContinuationPrompt(..),          -- * Throwing exceptions         throwIO,@@ -93,10 +94,11 @@         finally,          -- * Calls for GHC runtime-        recSelError, recConError, runtimeError,+        recSelError, recConError,+        impossibleError, impossibleConstraintError,         nonExhaustiveGuardsError, patError, noMethodBindingError,         typeError,-        nonTermination, nestedAtomically,+        nonTermination, nestedAtomically, noMatchingContinuationPrompt,   ) where  import           GHC.Base@@ -391,22 +393,42 @@  ----- +-- | Thrown when the program attempts a continuation capture, but no prompt with+-- the given prompt tag exists in the current continuation.+--+-- @since 4.18+data NoMatchingContinuationPrompt = NoMatchingContinuationPrompt++-- | @since 4.18+instance Show NoMatchingContinuationPrompt where+  showsPrec _ NoMatchingContinuationPrompt =+    showString "GHC.Exts.control0#: no matching prompt in the current continuation"++-- | @since 4.18+instance Exception NoMatchingContinuationPrompt++-----+ -- See Note [Compiler error functions] in ghc-prim:GHC.Prim.Panic-recSelError, recConError, runtimeError,-  nonExhaustiveGuardsError, patError, noMethodBindingError,-  typeError+recSelError, recConError, typeError,+  nonExhaustiveGuardsError, patError, noMethodBindingError         :: Addr# -> a   -- All take a UTF8-encoded C string  recSelError              s = throw (RecSelError ("No match in record selector "                                                  ++ unpackCStringUtf8# s))  -- No location info unfortunately-runtimeError             s = errorWithoutStackTrace (unpackCStringUtf8# s)                   -- No location info unfortunately- nonExhaustiveGuardsError s = throw (PatternMatchFail (untangle s "Non-exhaustive guards in")) recConError              s = throw (RecConError      (untangle s "Missing field in record construction")) noMethodBindingError     s = throw (NoMethodError    (untangle s "No instance nor default method for class operation")) patError                 s = throw (PatternMatchFail (untangle s "Non-exhaustive patterns in")) typeError                s = throw (TypeError        (unpackCStringUtf8# s)) ++impossibleError, impossibleConstraintError :: Addr# -> a+-- These two are used for impossible case alternatives, and lack location info+impossibleError             s = errorWithoutStackTrace (unpackCStringUtf8# s)+impossibleConstraintError   s = errorWithoutStackTrace (unpackCStringUtf8# s)++ -- GHC's RTS calls this nonTermination :: SomeException nonTermination = toException NonTermination@@ -414,3 +436,7 @@ -- GHC's RTS calls this nestedAtomically :: SomeException nestedAtomically = toException NestedAtomically++-- GHC's RTS calls this+noMatchingContinuationPrompt :: SomeException+noMatchingContinuationPrompt = toException NoMatchingContinuationPrompt

@@ -31,7 +31,7 @@ --   fail = {- ...fail implementation... -} -- @ ----- See <https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail>+-- See <https://gitlab.haskell.org/haskell/prime/-/wikis/libraries/proposals/monad-fail> -- for more details. -- -- @since 4.9.0.0@@ -60,6 +60,10 @@ -- @ -- fail _ = mzero -- @+--+-- @fail s@ should be an action that runs in the monad itself, not an+-- exception (except in instances of @MonadIO@).  In particular,+-- @fail@ should not be implemented in terms of @error@. -- -- @since 4.9.0.0 class Monad m => MonadFail m where

@@ -67,7 +67,7 @@ -- | @since 4.15 instance MonadFix Solo where     mfix f = let a = f (unSolo a) in a-             where unSolo (Solo x) = x+             where unSolo (MkSolo x) = x  -- | @since 2.01 instance MonadFix Maybe where

@@ -75,7 +75,7 @@ -- | @since 4.15.0.0 instance MonadZip Solo where     mzipWith = liftM2-    munzip (Solo (a, b)) = (Solo a, Solo b)+    munzip (MkSolo (a, b)) = (MkSolo a, MkSolo b)  -- | @since 4.8.0.0 instance MonadZip Dual where

@@ -22,17 +22,19 @@ import Data.Bits ((.&.), unsafeShiftR) import Data.Data (mkNoRepType, Data(..), Typeable) import qualified Data.Foldable as F+import Data.Maybe (fromMaybe) import Data.Semigroup-import GHC.Show (intToDigit) import GHC.Exts+import GHC.Num.Integer (Integer(..))+import GHC.Show (intToDigit) import GHC.ST (ST(..), runST) import GHC.Word (Word8(..)) --- | Boxed wrapper for 'ByteArray#'.+-- | Lifted wrapper for 'ByteArray#'. -- -- Since 'ByteArray#' is an unlifted type and not a member of kind 'Data.Kind.Type', -- things like @[ByteArray#]@ or @IO ByteArray#@ are ill-typed. To work around this--- inconvenience this module provides a standard boxed wrapper, inhabiting 'Data.Kind.Type'.+-- inconvenience this module provides a standard lifted wrapper, inhabiting 'Data.Kind.Type'. -- Clients are expected to use 'ByteArray' in higher-level APIs, -- but wrap and unwrap 'ByteArray' internally as they please -- and use functions from "GHC.Exts".@@ -40,11 +42,11 @@ -- @since 4.17.0.0 data ByteArray = ByteArray ByteArray# --- | Boxed wrapper for 'MutableByteArray#'.+-- | Lifted wrapper for 'MutableByteArray#'. -- -- Since 'MutableByteArray#' is an unlifted type and not a member of kind 'Data.Kind.Type', -- things like @[MutableByteArray#]@ or @IO MutableByteArray#@ are ill-typed. To work around this--- inconvenience this module provides a standard boxed wrapper, inhabiting 'Data.Kind.Type'.+-- inconvenience this module provides a standard lifted wrapper, inhabiting 'Data.Kind.Type'. -- Clients are expected to use 'MutableByteArray' in higher-level APIs, -- but wrap and unwrap 'MutableByteArray' internally as they please -- and use functions from "GHC.Exts".@@ -99,34 +101,52 @@ -- | Create a 'ByteArray' from a list of a known length. If the length --   of the list does not match the given length, this throws an exception. byteArrayFromListN :: Int -> [Word8] -> ByteArray-byteArrayFromListN n ys = runST $ do+byteArrayFromListN n ys+  | n >= 0 = runST $ do     marr <- newByteArray n     let go !ix [] = if ix == n           then return ()-          else error $ "Data.Array.Byte.byteArrayFromListN: list length less than specified size"+          else errorWithoutStackTrace $ "Data.Array.Byte.byteArrayFromListN: list length less than specified size"         go !ix (x : xs) = if ix < n           then do             writeByteArray marr ix x             go (ix + 1) xs-          else error $ "Data.Array.Byte.byteArrayFromListN: list length greater than specified size"+          else errorWithoutStackTrace $ "Data.Array.Byte.byteArrayFromListN: list length greater than specified size"     go 0 ys     unsafeFreezeByteArray marr+  | otherwise = errorWithoutStackTrace "Data.Array.Byte.ByteArrayFromListN: specified size is negative"  -- | Copy a slice of an immutable byte array to a mutable byte array. -- -- /Note:/ this function does not do bounds or overlap checking.-copyByteArray+unsafeCopyByteArray   :: MutableByteArray s -- ^ destination array   -> Int                -- ^ offset into destination array   -> ByteArray          -- ^ source array   -> Int                -- ^ offset into source array   -> Int                -- ^ number of bytes to copy   -> ST s ()-{-# INLINE copyByteArray #-}-copyByteArray (MutableByteArray dst#) (I# doff#) (ByteArray src#) (I# soff#) (I# sz#) =+{-# INLINE unsafeCopyByteArray #-}+unsafeCopyByteArray (MutableByteArray dst#) (I# doff#) (ByteArray src#) (I# soff#) (I# sz#) =   ST (\s# -> case copyByteArray# src# soff# dst# doff# sz# s# of     s'# -> (# s'#, () #)) +-- | Copy a slice from one mutable byte array to another+-- or to the same mutable byte array.+--+-- /Note:/ this function does not do bounds checking.+unsafeCopyMutableByteArray+  :: MutableByteArray s -- ^ destination array+  -> Int                -- ^ offset into destination array+  -> MutableByteArray s -- ^ source array+  -> Int                -- ^ offset into source array+  -> Int                -- ^ number of bytes to copy+  -> ST s ()+{-# INLINE unsafeCopyMutableByteArray #-}+unsafeCopyMutableByteArray (MutableByteArray dst#) (I# doff#) (MutableByteArray src#) (I# soff#) (I# sz#) =+  ST (\s# -> case copyMutableByteArray# src# soff# dst# doff# sz# s# of+    s'# -> (# s'#, () #))+ -- | @since 4.17.0.0 instance Data ByteArray where   toConstr _ = error "toConstr"@@ -167,8 +187,7 @@ -- | Do two byte arrays share the same pointer? sameByteArray :: ByteArray# -> ByteArray# -> Bool sameByteArray ba1 ba2 =-    case reallyUnsafePtrEquality# (unsafeCoerce# ba1 :: ()) (unsafeCoerce# ba2 :: ()) of-      r -> isTrue# r+    case sameByteArray# ba1 ba2 of r -> isTrue# r  -- | @since 4.17.0.0 instance Eq ByteArray where@@ -188,6 +207,7 @@ -- | Non-lexicographic ordering. This compares the lengths of -- the byte arrays first and uses a lexicographic ordering if -- the lengths are equal. Subject to change between major versions.+-- -- @since 4.17.0.0 instance Ord ByteArray where   ba1@(ByteArray ba1#) `compare` ba2@(ByteArray ba2#)@@ -206,17 +226,23 @@  -- | Append two byte arrays. appendByteArray :: ByteArray -> ByteArray -> ByteArray-appendByteArray a b = runST $ do-  marr <- newByteArray (sizeofByteArray a + sizeofByteArray b)-  copyByteArray marr 0 a 0 (sizeofByteArray a)-  copyByteArray marr (sizeofByteArray a) b 0 (sizeofByteArray b)+appendByteArray ba1 ba2 = runST $ do+  let n1 = sizeofByteArray ba1+      n2 = sizeofByteArray ba2+      totSz = fromMaybe (sizeOverflowError "appendByteArray")+                        (checkedIntAdd n1 n2)+  marr <- newByteArray totSz+  unsafeCopyByteArray marr 0  ba1 0 n1+  unsafeCopyByteArray marr n1 ba2 0 n2   unsafeFreezeByteArray marr  -- | Concatenate a list of 'ByteArray's. concatByteArray :: [ByteArray] -> ByteArray concatByteArray arrs = runST $ do-  let len = calcLength arrs 0-  marr <- newByteArray len+  let addLen acc arr = fromMaybe (sizeOverflowError "concatByteArray")+                                 (checkedIntAdd acc (sizeofByteArray arr))+      totLen = F.foldl' addLen 0 arrs+  marr <- newByteArray totLen   pasteByteArrays marr 0 arrs   unsafeFreezeByteArray marr @@ -224,39 +250,59 @@ pasteByteArrays :: MutableByteArray s -> Int -> [ByteArray] -> ST s () pasteByteArrays !_ !_ [] = return () pasteByteArrays !marr !ix (x : xs) = do-  copyByteArray marr ix x 0 (sizeofByteArray x)+  unsafeCopyByteArray marr ix x 0 (sizeofByteArray x)   pasteByteArrays marr (ix + sizeofByteArray x) xs --- | Compute total length of 'ByteArray's, increased by accumulator.-calcLength :: [ByteArray] -> Int -> Int-calcLength [] !n = n-calcLength (x : xs) !n = calcLength xs (sizeofByteArray x + n)- -- | An array of zero length. emptyByteArray :: ByteArray emptyByteArray = runST (newByteArray 0 >>= unsafeFreezeByteArray) --- | Replicate 'ByteArray' given number of times and concatenate all together.-replicateByteArray :: Int -> ByteArray -> ByteArray-replicateByteArray n arr = runST $ do-  marr <- newByteArray (n * sizeofByteArray arr)-  let go i = if i < n-        then do-          copyByteArray marr (i * sizeofByteArray arr) arr 0 (sizeofByteArray arr)-          go (i + 1)-        else return ()-  go 0+-- | Concatenates a given number of copies of an input ByteArray.+stimesPolymorphic :: Integral t => t -> ByteArray -> ByteArray+{-# INLINABLE stimesPolymorphic #-}+stimesPolymorphic nRaw !arr = case toInteger nRaw of+  IS nInt#+    | isTrue# (nInt# >#  0#) -> stimesPositiveInt (I# nInt#) arr+    | isTrue# (nInt# >=# 0#) -> emptyByteArray+      -- This check is redundant for unsigned types like Word.+      -- Using >=# intead of ==# may make it easier for GHC to notice that.+    | otherwise -> stimesNegativeErr+  IP _+    | sizeofByteArray arr == 0 -> emptyByteArray+    | otherwise -> stimesOverflowErr+  IN _ -> stimesNegativeErr++stimesNegativeErr :: ByteArray+stimesNegativeErr =+  errorWithoutStackTrace "stimes @ByteArray: negative multiplier"++stimesOverflowErr :: a+stimesOverflowErr = sizeOverflowError "stimes"++stimesPositiveInt :: Int -> ByteArray -> ByteArray+{-# NOINLINE stimesPositiveInt #-}+-- NOINLINE to prevent its duplication in specialisations of stimesPolymorphic+stimesPositiveInt n arr = runST $ do+  let inpSz = sizeofByteArray arr+      tarSz = fromMaybe stimesOverflowErr (checkedIntMultiply n inpSz)+  marr <- newByteArray tarSz+  unsafeCopyByteArray marr 0 arr 0 inpSz+  let+    halfTarSz = (tarSz - 1) `div` 2+    go copied+      | copied <= halfTarSz = do+          unsafeCopyMutableByteArray marr copied marr 0 copied+          go (copied + copied)+      | otherwise = unsafeCopyMutableByteArray marr copied marr 0 (tarSz - copied)+  go inpSz   unsafeFreezeByteArray marr  -- | @since 4.17.0.0 instance Semigroup ByteArray where   (<>) = appendByteArray   sconcat = mconcat . F.toList-  stimes i arr-    | itgr < 1 = emptyByteArray-    | itgr <= (fromIntegral (maxBound :: Int)) = replicateByteArray (fromIntegral itgr) arr-    | otherwise = error "Data.Array.Byte#stimes: cannot allocate the requested amount of memory"-    where itgr = toInteger i :: Integer+  {-# INLINE stimes #-}+  stimes = stimesPolymorphic  -- | @since 4.17.0.0 instance Monoid ByteArray where@@ -270,3 +316,23 @@   toList = byteArrayToList   fromList xs = byteArrayFromListN (length xs) xs   fromListN = byteArrayFromListN+++sizeOverflowError :: String -> a+sizeOverflowError fun+  = errorWithoutStackTrace $ "Data.Array.Byte." ++ fun ++ ": size overflow"+++-- TODO: Export these from a better home.++-- | Adds two @Int@s, returning @Nothing@ if this results in an overflow+checkedIntAdd :: Int -> Int -> Maybe Int+checkedIntAdd (I# x#) (I# y#) = case addIntC# x# y# of+  (# res, 0# #) -> Just (I# res)+  _ -> Nothing++-- | Multiplies two @Int@s, returning @Nothing@ if this results in an overflow+checkedIntMultiply :: Int -> Int -> Maybe Int+checkedIntMultiply (I# x#) (I# y#) = case timesInt2# x# y# of+  (# 0#, _hi, lo #) -> Just (I# lo)+  _ -> Nothing

@@ -0,0 +1,49 @@+-- |+-- Copyright: Edward Kmett, Oleg Grenrus+-- License: BSD-3-Clause+--++{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE Safe              #-}++module Data.Bifoldable1 where++import Control.Applicative (Const (..))+import Data.Bifoldable     (Bifoldable (..))+import Data.Semigroup      (Arg (..), Semigroup (..))+import Prelude             (Either (..), id)++class Bifoldable t => Bifoldable1 t where+     bifold1 :: Semigroup m => t m m -> m+     bifold1 = bifoldMap1 id id+     {-# INLINE bifold1 #-}++     bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> t a b -> m++instance Bifoldable1 Arg where+    bifoldMap1 f g (Arg a b) = f a <> g b++instance Bifoldable1 Either where+    bifoldMap1 f _ (Left a) = f a+    bifoldMap1 _ g (Right b) = g b+    {-# INLINE bifoldMap1 #-}++instance Bifoldable1 (,) where+    bifoldMap1 f g (a, b) = f a <> g b+    {-# INLINE bifoldMap1 #-}++instance Bifoldable1 ((,,) x) where+    bifoldMap1 f g (_,a,b) = f a <> g b+    {-# INLINE bifoldMap1 #-}++instance Bifoldable1 ((,,,) x y) where+    bifoldMap1 f g (_,_,a,b) = f a <> g b+    {-# INLINE bifoldMap1 #-}++instance Bifoldable1 ((,,,,) x y z) where+    bifoldMap1 f g (_,_,_,a,b) = f a <> g b+    {-# INLINE bifoldMap1 #-}++instance Bifoldable1 Const where+    bifoldMap1 f _ (Const a) = f a+    {-# INLINE bifoldMap1 #-}

@@ -1,5 +1,6 @@-{-# LANGUAGE Safe #-} {-# LANGUAGE CPP #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE Safe #-}  ----------------------------------------------------------------------------- -- |@@ -39,8 +40,12 @@ -- arguments are covariant. -- -- You can define a 'Bifunctor' by either defining 'bimap' or by--- defining both 'first' and 'second'.+-- defining both 'first' and 'second'. A partially applied 'Bifunctor'+-- must be a 'Functor' and the 'second' method must agree with 'fmap'.+-- From this it follows that: --+-- @'second' 'id' = 'id'@+-- -- If you supply 'bimap', you should ensure that: -- -- @'bimap' 'id' 'id' ≡ 'id'@@@ -64,8 +69,10 @@ -- 'second' (f '.' g) ≡ 'second' f '.' 'second' g -- @ --+-- Since 4.18.0.0 'Functor' is a superclass of 'Bifunctor.+-- -- @since 4.8.0.0-class Bifunctor p where+class (forall a. Functor (p a)) => Bifunctor p where     {-# MINIMAL bimap | first, second #-}      -- | Map over both arguments at the same time.@@ -113,8 +120,17 @@     second = bimap id  ---- | @since 4.8.0.0+-- | Class laws for tuples hold only up to laziness. Both+-- 'first' 'id' and 'second' 'id' are lazier than 'id' (and 'fmap' 'id'):+--+-- >>> first id (undefined :: (Int, Word)) `seq` ()+-- ()+-- >>> second id (undefined :: (Int, Word)) `seq` ()+-- ()+-- >>> id (undefined :: (Int, Word)) `seq` ()+-- *** Exception: Prelude.undefined+--+-- @since 4.8.0.0 instance Bifunctor (,) where     bimap f g ~(a, b) = (f a, g b) 

@@ -6,7 +6,7 @@ -- Module      :  Data.Char -- Copyright   :  (c) The University of Glasgow 2001 -- License     :  BSD-style (see the file libraries/base/LICENSE)--- +-- -- Maintainer  :  libraries@haskell.org -- Stability   :  stable -- Portability :  portable@@ -24,7 +24,7 @@     -- punctuation, symbols, separators (including spaces) and others     -- (including control characters).     , isControl, isSpace-    , isLower, isUpper, isAlpha, isAlphaNum, isPrint+    , isLower, isLowerCase, isUpper, isUpperCase, isAlpha, isAlphaNum, isPrint     , isDigit, isOctDigit, isHexDigit     , isLetter, isMark, isNumber, isPunctuation, isSymbol, isSeparator 

@@ -35,6 +35,7 @@          )  where +import Prelude hiding (Applicative(..)) import GHC.Base (Applicative (..)) import GHC.Generics (Generic, Generic1) import GHC.Float (Floating(..))

@@ -21,8 +21,6 @@ -- Stability   :  stable -- Portability :  non-portable (local universal quantification) ----- \"Scrap your boilerplate\" --- Generic programming in Haskell.  See--- <http://www.haskell.org/haskellwiki/Research_papers/Generics#Scrap_your_boilerplate.21>. -- This module provides the 'Data' class with its primitives for -- generic programming, along with instances for many datatypes. It -- corresponds to a merge between the previous "Data.Generics.Basics"@@ -30,8 +28,8 @@ -- not present in this module were moved to the -- @Data.Generics.Instances@ module in the @syb@ package. ----- For more information, please visit the new--- SYB wiki: <http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/SYB>.+-- \"Scrap your boilerplate\" --- Generic programming in Haskell.  See+-- <https://wiki.haskell.org/Research_papers/Generics#Scrap_your_boilerplate.21>. -- ----------------------------------------------------------------------------- @@ -142,6 +140,7 @@ import GHC.Real              -- So we can give Data instance for Ratio --import GHC.IOBase            -- So we can give Data instance for IO, Handle import GHC.Ptr               -- So we can give Data instance for Ptr+import Foreign.C.ConstPtr    -- So we can give Data instance for ConstPtr import GHC.ForeignPtr        -- So we can give Data instance for ForeignPtr import Foreign.Ptr (IntPtr(..), WordPtr(..))                              -- So we can give Data instance for IntPtr and WordPtr@@ -1189,6 +1188,9 @@ -- | @since 4.0.0.0 deriving instance (Data a, Data b) => Data (Either a b) +-- | @since 4.8.0.0+deriving instance Data Void+ -- | @since 4.0.0.0 deriving instance Data () @@ -1225,6 +1227,9 @@   gunfold _ _  = errorWithoutStackTrace "Data.Data.gunfold(Ptr)"   dataTypeOf _ = mkNoRepType "GHC.Ptr.Ptr"   dataCast1 x  = gcast1 x++-- | @since 4.18.0.0+deriving instance Data a => Data (ConstPtr a)  ------------------------------------------------------------------------------ 

@@ -1175,7 +1175,7 @@   where c m k = m >> k         {-# INLINE c #-} --- | The sum of a collection of actions, generalizing 'concat'.+-- | The sum of a collection of actions using '(<|>)', generalizing 'concat'. -- -- 'asum' is just like 'msum', but generalised to 'Alternative'. --@@ -1189,10 +1189,16 @@ {-# INLINE asum #-} asum = foldr (<|>) empty --- | The sum of a collection of actions, generalizing 'concat'.+-- | The sum of a collection of actions using '(<|>)', generalizing 'concat'. -- -- 'msum' is just like 'asum', but specialised to 'MonadPlus'. --+-- ==== __Examples__+--+-- Basic usage, using the 'MonadPlus' instance for 'Maybe':+--+-- >>> msum [Just "Hello", Nothing, Just "World"]+-- Just "Hello" msum :: (Foldable t, MonadPlus m) => t (m a) -> m a {-# INLINE msum #-} msum = asum

@@ -0,0 +1,518 @@+-- |+-- Copyright: Edward Kmett, Oleg Grenrus+-- License: BSD-3-Clause+--++{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitPrelude          #-}+{-# LANGUAGE PolyKinds                  #-}+{-# LANGUAGE ScopedTypeVariables        #-}+{-# LANGUAGE StandaloneDeriving         #-}+{-# LANGUAGE Trustworthy                #-}+{-# LANGUAGE TypeOperators              #-}++-- | A class of non-empty data structures that can be folded to a summary value.+module Data.Foldable1 (+    Foldable1(..),+    foldr1, foldr1',+    foldl1, foldl1',+    intercalate1,+    foldrM1,+    foldlM1,+    foldrMapM1,+    foldlMapM1,+    maximumBy,+    minimumBy,+    ) where++import Data.Foldable      (Foldable, foldlM, foldr)+import Data.List          (foldl, foldl')+import Data.List.NonEmpty (NonEmpty (..))+import Data.Semigroup+       (Dual (..), First (..), Last (..), Max (..), Min (..), Product (..),+       Semigroup (..), Sum (..))+import GHC.Tuple          (Solo (..))+import Prelude+       (Maybe (..), Monad (..), Ord, Ordering (..), id, seq, ($!), ($), (.),+       (=<<), flip, const, error)++import qualified Data.List.NonEmpty as NE++import Data.Complex (Complex (..))+import GHC.Generics+       (M1 (..), Par1 (..), Rec1 (..), V1, (:*:) (..), (:+:) (..), (:.:) (..))++import Data.Ord (Down (..))++import qualified Data.Monoid as Mon++-- Instances+import Data.Functor.Compose          (Compose (..))+import Data.Functor.Identity         (Identity (..))++import qualified Data.Functor.Product as Functor+import qualified Data.Functor.Sum     as Functor++-- coerce+import Data.Coerce (Coercible, coerce)++-- $setup+-- >>> import Prelude hiding (foldr1, foldl1, head, last, minimum, maximum)++-------------------------------------------------------------------------------+-- Foldable1 type class+-------------------------------------------------------------------------------++-- | Non-empty data structures that can be folded.+class Foldable t => Foldable1 t where+    {-# MINIMAL foldMap1 | foldrMap1 #-}++    -- At some point during design it was possible to define this class using+    -- only 'toNonEmpty'. But it seems a bad idea in general.+    --+    -- So currently we require either foldMap1 or foldrMap1+    --+    -- * foldMap1 defined using foldrMap1+    -- * foldrMap1 defined using foldMap1+    --+    -- One can always define an instance using the following pattern:+    --+    --     toNonEmpty = ...+    --     foldMap f     = foldMap f     . toNonEmpty+    --     foldrMap1 f g = foldrMap1 f g . toNonEmpty++    -- | Combine the elements of a structure using a semigroup.+    fold1 :: Semigroup m => t m -> m+    fold1 = foldMap1 id++    -- | Map each element of the structure to a semigroup,+    -- and combine the results.+    --+    -- >>> foldMap1 Sum (1 :| [2, 3, 4])+    -- Sum {getSum = 10}+    --+    foldMap1 :: Semigroup m => (a -> m) -> t a -> m+    foldMap1 f = foldrMap1 f (\a m -> f a <> m)++    -- | A variant of 'foldMap1' that is strict in the accumulator.+    --+    -- >>> foldMap1' Sum (1 :| [2, 3, 4])+    -- Sum {getSum = 10}+    --+    foldMap1' :: Semigroup m => (a -> m) -> t a -> m+    foldMap1' f = foldlMap1' f (\m a -> m <> f a)++    -- | List of elements of a structure, from left to right.+    --+    -- >>> toNonEmpty (Identity 2)+    -- 2 :| []+    --+    toNonEmpty :: t a -> NonEmpty a+    toNonEmpty = runNonEmptyDList . foldMap1 singleton++    -- | The largest element of a non-empty structure.+    --+    -- >>> maximum (32 :| [64, 8, 128, 16])+    -- 128+    --+    maximum :: Ord a => t a -> a+    maximum = getMax #. foldMap1' Max++    -- | The least element of a non-empty structure.+    --+    -- >>> minimum (32 :| [64, 8, 128, 16])+    -- 8+    --+    minimum :: Ord a => t a -> a+    minimum = getMin #. foldMap1' Min++    -- | The first element of a non-empty structure.+    --+    -- >>> head (1 :| [2, 3, 4])+    -- 1+    --+    head :: t a -> a+    head = getFirst #. foldMap1 First++    -- | The last element of a non-empty structure.+    --+    -- >>> last (1 :| [2, 3, 4])+    -- 4+    --+    last :: t a -> a+    last = getLast #. foldMap1 Last++    -- | Generalized 'foldr1'.+    foldrMap1 :: (a -> b) -> (a -> b -> b) -> t a -> b+    foldrMap1 f g xs =+        appFromMaybe (foldMap1 (FromMaybe #. h) xs) Nothing+      where+        h a Nothing  = f a+        h a (Just b) = g a b++    -- | Generalized 'foldl1''.+    foldlMap1' :: (a -> b) -> (b -> a -> b) -> t a -> b+    foldlMap1' f g xs =+        foldrMap1 f' g' xs SNothing+      where+        -- f' :: a -> SMaybe b -> b+        f' a SNothing  = f a+        f' a (SJust b) = g b a++        -- g' :: a -> (SMaybe b -> b) -> SMaybe b -> b+        g' a x SNothing  = x $! SJust (f a)+        g' a x (SJust b) = x $! SJust (g b a)++    -- | Generalized 'foldl1'.+    foldlMap1 :: (a -> b) -> (b -> a -> b) -> t a -> b+    foldlMap1 f g xs =+        appFromMaybe (getDual (foldMap1 ((Dual . FromMaybe) #. h) xs)) Nothing+      where+        h a Nothing  = f a+        h a (Just b) = g b a++    -- | Generalized 'foldr1''.+    foldrMap1' :: (a -> b) -> (a -> b -> b) -> t a -> b+    foldrMap1' f g xs =+        foldlMap1 f' g' xs SNothing+      where+        f' a SNothing  = f a+        f' a (SJust b) = g a b++        g' bb a SNothing  = bb $! SJust (f a)+        g' bb a (SJust b) = bb $! SJust (g a b)++-------------------------------------------------------------------------------+-- Combinators+-------------------------------------------------------------------------------++-- | Right-associative fold of a structure.+--+-- In the case of lists, 'foldr1', when applied to a binary operator,+-- and a list, reduces the list using the binary operator,+-- from right to left:+--+-- > foldr1 f [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn1 `f` xn )...)+--+-- Note that, since the head of the resulting expression is produced by+-- an application of the operator to the first element of the list,+-- 'foldr1' can produce a terminating expression from an infinite list.+--+-- For a general 'Foldable1' structure this should be semantically identical+-- to,+--+-- @foldr1 f = foldr1 f . 'toNonEmpty'@+--+foldr1 :: Foldable1 t => (a -> a -> a) -> t a -> a+foldr1 = foldrMap1 id+{-# INLINE foldr1 #-}++-- | Right-associative fold of a structure, but with strict application of+-- the operator.+--+foldr1' :: Foldable1 t => (a -> a -> a) -> t a -> a+foldr1' = foldrMap1' id+{-# INLINE foldr1' #-}++-- | Left-associative fold of a structure.+--+-- In the case of lists, 'foldl1', when applied to a binary+-- operator, and a list, reduces the list using the binary operator,+-- from left to right:+--+-- > foldl1 f [x1, x2, ..., xn] == (...((x1 `f` x2) `f`...) `f` xn+--+-- Note that to produce the outermost application of the operator the+-- entire input list must be traversed. This means that 'foldl1' will+-- diverge if given an infinite list.+--+-- Also note that if you want an efficient left-fold, you probably want to+-- use 'foldl1'' instead of 'foldl1'. The reason for this is that latter does+-- not force the "inner" results (e.g. @x1 \`f\` x2@ in the above example)+-- before applying them to the operator (e.g. to @(\`f\` x3)@). This results+-- in a thunk chain \(\mathcal{O}(n)\) elements long, which then must be+-- evaluated from the outside-in.+--+-- For a general 'Foldable1' structure this should be semantically identical+-- to,+--+-- @foldl1 f z = foldl1 f . 'toNonEmpty'@+--+foldl1 :: Foldable1 t => (a -> a -> a) -> t a -> a+foldl1 = foldlMap1 id+{-# INLINE foldl1 #-}++-- | Left-associative fold of a structure but with strict application of+-- the operator.+--+-- This ensures that each step of the fold is forced to weak head normal+-- form before being applied, avoiding the collection of thunks that would+-- otherwise occur. This is often what you want to strictly reduce a finite+-- list to a single, monolithic result (e.g. 'length').+--+-- For a general 'Foldable1' structure this should be semantically identical+-- to,+--+-- @foldl1' f z = foldl1 f . 'toNonEmpty'@+--+foldl1' :: Foldable1 t => (a -> a -> a) -> t a -> a+foldl1' = foldlMap1' id+{-# INLINE foldl1' #-}++-- | Insert an @m@ between each pair of @t m@.+--+-- >>> intercalate1 ", " $ "hello" :| ["how", "are", "you"]+-- "hello, how, are, you"+--+-- >>> intercalate1 ", " $ "hello" :| []+-- "hello"+--+-- >>> intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"]+-- "IAmFineYou?"+--+intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m+intercalate1 = flip intercalateMap1 id++intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m+intercalateMap1 j f = flip joinee j . foldMap1 (JoinWith . const . f)++-- | Monadic fold over the elements of a non-empty structure,+-- associating to the right, i.e. from right to left.+foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a+foldrM1 = foldrMapM1 return++-- | Map variant of 'foldrM1'.+foldrMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (a -> b -> m b) -> t a -> m b+foldrMapM1 g f = go . toNonEmpty+  where+    go (e:|es) =+      case es of+        []   -> g e+        x:xs -> f e =<< go (x:|xs)++-- | Monadic fold over the elements of a non-empty structure,+-- associating to the left, i.e. from left to right.+foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a+foldlM1 = foldlMapM1 return++-- | Map variant of 'foldlM1'.+foldlMapM1 :: (Foldable1 t, Monad m) => (a -> m b) -> (b -> a -> m b) -> t a -> m b+foldlMapM1 g f t = g x >>= \y -> foldlM f y xs+  where x:|xs = toNonEmpty t++-- | The largest element of a non-empty structure with respect to the+-- given comparison function.+maximumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a+maximumBy cmp = foldl1' max'+  where max' x y = case cmp x y of+                        GT -> x+                        _  -> y++-- | The least element of a non-empty structure with respect to the+-- given comparison function.+minimumBy :: Foldable1 t => (a -> a -> Ordering) -> t a -> a+minimumBy cmp = foldl1' min'+  where min' x y = case cmp x y of+                        GT -> y+                        _  -> x++-------------------------------------------------------------------------------+-- Auxiliary types+-------------------------------------------------------------------------------++-- | Used for default toNonEmpty implementation.+newtype NonEmptyDList a = NEDL { unNEDL :: [a] -> NonEmpty a }++instance Semigroup (NonEmptyDList a) where+  xs <> ys = NEDL (unNEDL xs . NE.toList . unNEDL ys)+  {-# INLINE (<>) #-}++-- | Create dlist with a single element+singleton :: a -> NonEmptyDList a+singleton = NEDL #. (:|)++-- | Convert a dlist to a non-empty list+runNonEmptyDList :: NonEmptyDList a -> NonEmpty a+runNonEmptyDList = ($ []) . unNEDL+{-# INLINE runNonEmptyDList #-}++-- | Used for foldrMap1 and foldlMap1 definitions+newtype FromMaybe b = FromMaybe { appFromMaybe :: Maybe b -> b }++instance Semigroup (FromMaybe b) where+    FromMaybe f <> FromMaybe g = FromMaybe (f . Just . g)++-- | Strict maybe, used to implement default foldlMap1' etc.+data SMaybe a = SNothing | SJust !a++-- | Used to implement intercalate1/Map+newtype JoinWith a = JoinWith {joinee :: (a -> a)}++instance Semigroup a => Semigroup (JoinWith a) where+  JoinWith a <> JoinWith b = JoinWith $ \j -> a j <> j <> b j++-------------------------------------------------------------------------------+-- Instances for misc base types+-------------------------------------------------------------------------------++instance Foldable1 NonEmpty where+    foldMap1 f (x :| xs) = go (f x) xs where+        go y [] = y+        go y (z : zs) = y <> go (f z) zs++    foldMap1' f (x :| xs) = foldl' (\m y -> m <> f y) (f x) xs++    toNonEmpty = id++    foldrMap1 g f (x :| xs) = go x xs where+        go y [] = g y+        go y (z : zs) = f y (go z zs)++    foldlMap1  g f (x :| xs) = foldl f (g x) xs+    foldlMap1' g f (x :| xs) = let gx = g x in gx `seq` foldl' f gx xs++    head = NE.head+    last = NE.last++instance Foldable1 Down where+    foldMap1 = coerce++instance Foldable1 Complex where+    foldMap1 f (x :+ y) = f x <> f y++    toNonEmpty (x :+ y) = x :| y : []++-------------------------------------------------------------------------------+-- Instances for tuples+-------------------------------------------------------------------------------++-- 3+ tuples are not Foldable/Traversable++instance Foldable1 Solo where+    foldMap1 f (MkSolo y) = f y+    toNonEmpty (MkSolo x) = x :| []+    minimum (MkSolo x) = x+    maximum (MkSolo x) = x+    head (MkSolo x) = x+    last (MkSolo x) = x++instance Foldable1 ((,) a) where+    foldMap1 f (_, y) = f y+    toNonEmpty (_, x) = x :| []+    minimum (_, x) = x+    maximum (_, x) = x+    head (_, x) = x+    last (_, x) = x++-------------------------------------------------------------------------------+-- Monoid / Semigroup instances+-------------------------------------------------------------------------------++instance Foldable1 Dual where+    foldMap1 = coerce++instance Foldable1 Sum where+    foldMap1 = coerce++instance Foldable1 Product where+    foldMap1 = coerce++instance Foldable1 Min where+    foldMap1 = coerce++instance Foldable1 Max where+    foldMap1 = coerce++instance Foldable1 First where+    foldMap1 = coerce++instance Foldable1 Last where+    foldMap1 = coerce++deriving instance (Foldable1 f) => Foldable1 (Mon.Alt f)++deriving instance (Foldable1 f) => Foldable1 (Mon.Ap f)++-------------------------------------------------------------------------------+-- GHC.Generics instances+-------------------------------------------------------------------------------++instance Foldable1 V1 where+    foldMap1 _ x = x `seq` error "foldMap1 @V1"++instance Foldable1 Par1 where+    foldMap1 = coerce++deriving instance Foldable1 f => Foldable1 (Rec1 f)++deriving instance Foldable1 f => Foldable1 (M1 i c f)++instance (Foldable1 f, Foldable1 g) => Foldable1 (f :+: g) where+    foldMap1 f (L1 x) = foldMap1 f x+    foldMap1 f (R1 y) = foldMap1 f y++instance (Foldable1 f, Foldable1 g) => Foldable1 (f :*: g) where+    foldMap1 f (x :*: y) = foldMap1 f x <> foldMap1 f y++instance (Foldable1 f, Foldable1 g) => Foldable1 (f :.: g) where+    foldMap1 f = foldMap1 (foldMap1 f) . unComp1++-------------------------------------------------------------------------------+-- Extra instances+-------------------------------------------------------------------------------++instance Foldable1 Identity where+    foldMap1      = coerce++    foldrMap1  g _ = coerce g+    foldrMap1' g _ = coerce g+    foldlMap1  g _ = coerce g+    foldlMap1' g _ = coerce g++    toNonEmpty (Identity x) = x :| []++    last    = coerce+    head    = coerce+    minimum = coerce+    maximum = coerce++-- | It would be enough for either half of a product to be 'Foldable1'.+-- Other could be 'Foldable'.+instance (Foldable1 f, Foldable1 g) => Foldable1 (Functor.Product f g) where+    foldMap1 f (Functor.Pair x y)    = foldMap1 f x <> foldMap1 f y+    foldrMap1 g f (Functor.Pair x y) = foldr f (foldrMap1 g f y) x++    head (Functor.Pair x _) = head x+    last (Functor.Pair _ y) = last y++instance (Foldable1 f, Foldable1 g) => Foldable1 (Functor.Sum f g) where+    foldMap1 f (Functor.InL x) = foldMap1 f x+    foldMap1 f (Functor.InR y) = foldMap1 f y++    foldrMap1 g f (Functor.InL x) = foldrMap1 g f x+    foldrMap1 g f (Functor.InR y) = foldrMap1 g f y++    toNonEmpty (Functor.InL x) = toNonEmpty x+    toNonEmpty (Functor.InR y) = toNonEmpty y++    head (Functor.InL x) = head x+    head (Functor.InR y) = head y+    last (Functor.InL x) = last x+    last (Functor.InR y) = last y++    minimum (Functor.InL x) = minimum x+    minimum (Functor.InR y) = minimum y+    maximum (Functor.InL x) = maximum x+    maximum (Functor.InR y) = maximum y++instance (Foldable1 f, Foldable1 g) => Foldable1 (Compose f g) where+    foldMap1 f = foldMap1 (foldMap1 f) . getCompose++    foldrMap1 f g = foldrMap1 (foldrMap1 f g) (\xs x -> foldr g x xs) . getCompose++    head = head . head . getCompose+    last = last . last . getCompose++(#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c+(#.) _f = coerce

@@ -25,9 +25,11 @@   , (&)   , fix   , on+  , applyWhen   ) where  import GHC.Base ( ($), (.), id, const, flip )+import Data.Bool ( Bool(..) )  infixl 0 `on` infixl 1 &@@ -120,6 +122,33 @@ -- @since 4.8.0.0 (&) :: a -> (a -> b) -> b x & f = f x++-- | 'applyWhen' applies a function to a value if a condition is true,+-- otherwise, it returns the value unchanged.+--+-- It is equivalent to @'flip' ('Data.Bool.bool' 'id')@.+--+-- Algebraic properties:+--+-- * @applyWhen 'True' = 'id'@+--+-- * @applyWhen 'False' f = 'id'@+--+-- @since 4.18.0.0+applyWhen :: Bool -> (a -> a) -> a -> a+applyWhen True  f x = f x+applyWhen False _ x = x+-- Proofs:+--+-- flip bool id = \q f -> bool id f q+-- = \q f -> case q of+--     True -> f = \x -> f x+--     False -> id = \x -> x ∎+--+-- applyWhen True = \f x -> f x+-- = \f -> \x -> f x = \f -> f = id ∎+--+-- applyWhen False f = \x -> x = id ∎  -- $setup -- >>> import Prelude

@@ -1,7 +1,10 @@ {-# LANGUAGE FlexibleContexts     #-}+{-# LANGUAGE DefaultSignatures    #-} {-# LANGUAGE InstanceSigs         #-} {-# LANGUAGE Safe                 #-}+{-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE QuantifiedConstraints #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Classes@@ -91,8 +94,18 @@  -- | Lifting of the 'Eq' class to unary type constructors. --+-- Any instance should be subject to the following law that canonicity+-- is preserved:+--+-- @liftEq (==)@ = @(==)@+--+-- This class therefore represents the generalization of 'Eq' by+-- decomposing its main method into a canonical lifting on a canonical+-- inner method, so that the lifting can be reused for other arguments+-- than the canonical one.+-- -- @since 4.9.0.0-class Eq1 f where+class (forall a. Eq a => Eq (f a)) => Eq1 f where     -- | Lift an equality test through the type constructor.     --     -- The function will usually be applied to an equality function,@@ -102,6 +115,10 @@     --     -- @since 4.9.0.0     liftEq :: (a -> b -> Bool) -> f a -> f b -> Bool+    default liftEq+        :: (f ~ f' c, Eq2 f', Eq c)+        => (a -> b -> Bool) -> f a -> f b -> Bool+    liftEq = liftEq2 (==)  -- | Lift the standard @('==')@ function through the type constructor. --@@ -111,8 +128,18 @@  -- | Lifting of the 'Ord' class to unary type constructors. --+-- Any instance should be subject to the following law that canonicity+-- is preserved:+--+-- @liftCompare compare@ = 'compare'+--+-- This class therefore represents the generalization of 'Ord' by+-- decomposing its main method into a canonical lifting on a canonical+-- inner method, so that the lifting can be reused for other arguments+-- than the canonical one.+-- -- @since 4.9.0.0-class (Eq1 f) => Ord1 f where+class (Eq1 f, forall a. Ord a => Ord (f a)) => Ord1 f where     -- | Lift a 'compare' function through the type constructor.     --     -- The function will usually be applied to a comparison function,@@ -122,6 +149,10 @@     --     -- @since 4.9.0.0     liftCompare :: (a -> b -> Ordering) -> f a -> f b -> Ordering+    default liftCompare+        :: (f ~ f' c, Ord2 f', Ord c)+        => (a -> b -> Ordering) -> f a -> f b -> Ordering+    liftCompare = liftCompare2 compare  -- | Lift the standard 'compare' function through the type constructor. --@@ -131,6 +162,22 @@  -- | Lifting of the 'Read' class to unary type constructors. --+-- Any instance should be subject to the following laws that canonicity+-- is preserved:+--+-- @liftReadsPrec readsPrec readList@ = 'readsPrec'+--+-- @liftReadList readsPrec readList@ = 'readList'+--+-- @liftReadPrec readPrec readListPrec@ = 'readPrec'+--+-- @liftReadListPrec readPrec readListPrec@ = 'readListPrec'+--+-- This class therefore represents the generalization of 'Read' by+-- decomposing it's methods into a canonical lifting on a canonical+-- inner method, so that the lifting can be reused for other arguments+-- than the canonical one.+-- -- Both 'liftReadsPrec' and 'liftReadPrec' exist to match the interface -- provided in the 'Read' type class, but it is recommended to implement -- 'Read1' instances using 'liftReadPrec' as opposed to 'liftReadsPrec', since@@ -145,7 +192,7 @@ -- For more information, refer to the documentation for the 'Read' class. -- -- @since 4.9.0.0-class Read1 f where+class (forall a. Read a => Read (f a)) => Read1 f where     {-# MINIMAL liftReadsPrec | liftReadPrec #-}      -- | 'readsPrec' function for an application of the type constructor@@ -219,14 +266,30 @@  -- | Lifting of the 'Show' class to unary type constructors. --+-- Any instance should be subject to the following laws that canonicity+-- is preserved:+--+-- @liftShowsPrec showsPrec showList@ = 'showsPrec'+--+-- @liftShowList showsPrec showList@ = 'showList'+--+-- This class therefore represents the generalization of 'Show' by+-- decomposing it's methods into a canonical lifting on a canonical+-- inner method, so that the lifting can be reused for other arguments+-- than the canonical one.+-- -- @since 4.9.0.0-class Show1 f where+class (forall a. Show a => Show (f a)) => Show1 f where     -- | 'showsPrec' function for an application of the type constructor     -- based on 'showsPrec' and 'showList' functions for the argument type.     --     -- @since 4.9.0.0     liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) ->         Int -> f a -> ShowS+    default liftShowsPrec+        :: (f ~ f' b, Show2 f', Show b)+        => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS+    liftShowsPrec = liftShowsPrec2 showsPrec showList      -- | 'showList' function for an application of the type constructor     -- based on 'showsPrec' and 'showList' functions for the argument type.@@ -248,7 +311,7 @@ -- | Lifting of the 'Eq' class to binary type constructors. -- -- @since 4.9.0.0-class Eq2 f where+class (forall a. Eq a => Eq1 (f a)) => Eq2 f where     -- | Lift equality tests through the type constructor.     --     -- The function will usually be applied to equality functions,@@ -268,7 +331,7 @@ -- | Lifting of the 'Ord' class to binary type constructors. -- -- @since 4.9.0.0-class (Eq2 f) => Ord2 f where+class (Eq2 f, forall a. Ord a => Ord1 (f a)) => Ord2 f where     -- | Lift 'compare' functions through the type constructor.     --     -- The function will usually be applied to comparison functions,@@ -302,7 +365,7 @@ -- For more information, refer to the documentation for the 'Read' class. -- -- @since 4.9.0.0-class Read2 f where+class (forall a. Read a => Read1 (f a)) => Read2 f where     {-# MINIMAL liftReadsPrec2 | liftReadPrec2 #-}      -- | 'readsPrec' function for an application of the type constructor@@ -385,7 +448,7 @@ -- | Lifting of the 'Show' class to binary type constructors. -- -- @since 4.9.0.0-class Show2 f where+class (forall a. Show a => Show1 (f a)) => Show2 f where     -- | 'showsPrec' function for an application of the type constructor     -- based on 'showsPrec' and 'showList' functions for the argument types.     --@@ -514,7 +577,7 @@  -- | @since 4.15 instance Eq1 Solo where-  liftEq eq (Solo a) (Solo b) = a `eq` b+  liftEq eq (MkSolo a) (MkSolo b) = a `eq` b  -- | @since 4.9.0.0 instance (Eq a) => Eq1 ((,) a) where@@ -522,7 +585,7 @@  -- | @since 4.15 instance Ord1 Solo where-  liftCompare cmp (Solo a) (Solo b) = cmp a b+  liftCompare cmp (MkSolo a) (MkSolo b) = cmp a b  -- | @since 4.9.0.0 instance (Ord a) => Ord1 ((,) a) where@@ -530,7 +593,7 @@  -- | @since 4.15 instance Read1 Solo where-    liftReadPrec rp _ = readData (readUnaryWith rp "Solo" Solo)+    liftReadPrec rp _ = readData (readUnaryWith rp "MkSolo" MkSolo)      liftReadListPrec = liftReadListPrecDefault     liftReadList     = liftReadListDefault@@ -544,7 +607,7 @@  -- | @since 4.15 instance Show1 Solo where-    liftShowsPrec sp _ d (Solo x) = showsUnaryWith sp "Solo" d x+    liftShowsPrec sp _ d (MkSolo x) = showsUnaryWith sp "MkSolo" d x  -- | @since 4.9.0.0 instance (Show a) => Show1 ((,) a) where

@@ -5,6 +5,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE Trustworthy #-}+{-# LANGUAGE StandaloneDeriving #-}  ----------------------------------------------------------------------------- -- |@@ -32,7 +33,7 @@ import Data.Data (Data) import Data.Type.Equality (TestEquality(..), (:~:)(..)) import GHC.Generics (Generic, Generic1)-import Text.Read (Read(..), readListDefault, readListPrecDefault)+import Text.Read (Read(..), ReadPrec, readListDefault, readListPrecDefault)  infixr 9 `Compose` @@ -47,6 +48,22 @@            , Monoid    -- ^ @since 4.16.0.0            ) +-- Instances of Prelude classes++-- | @since 4.18.0.0+deriving instance Eq (f (g a)) => Eq (Compose f g a)+-- | @since 4.18.0.0+deriving instance Ord (f (g a)) => Ord (Compose f g a)+-- | @since 4.18.0.0+instance Read (f (g a)) => Read (Compose f g a) where+    readPrec = liftReadPrecCompose readPrec++    readListPrec = readListPrecDefault+    readList     = readListDefault+-- | @since 4.18.0.0+instance Show (f (g a)) => Show (Compose f g a) where+    showsPrec = liftShowsPrecCompose showsPrec+ -- Instances of lifted Prelude classes  -- | @since 4.9.0.0@@ -60,8 +77,8 @@  -- | @since 4.9.0.0 instance (Read1 f, Read1 g) => Read1 (Compose f g) where-    liftReadPrec rp rl = readData $-        readUnaryWith (liftReadPrec rp' rl') "Compose" Compose+    liftReadPrec rp rl =+        liftReadPrecCompose (liftReadPrec rp' rl')       where         rp' = liftReadPrec     rp rl         rl' = liftReadListPrec rp rl@@ -71,32 +88,19 @@  -- | @since 4.9.0.0 instance (Show1 f, Show1 g) => Show1 (Compose f g) where-    liftShowsPrec sp sl d (Compose x) =-        showsUnaryWith (liftShowsPrec sp' sl') "Compose" d x+    liftShowsPrec sp sl =+        liftShowsPrecCompose (liftShowsPrec sp' sl')       where         sp' = liftShowsPrec sp sl         sl' = liftShowList sp sl --- Instances of Prelude classes---- | @since 4.9.0.0-instance (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) where-    (==) = eq1---- | @since 4.9.0.0-instance (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) where-    compare = compare1---- | @since 4.9.0.0-instance (Read1 f, Read1 g, Read a) => Read (Compose f g a) where-    readPrec = readPrec1--    readListPrec = readListPrecDefault-    readList     = readListDefault+-- The workhorse for Compose's Read and Read1 instances.+liftReadPrecCompose :: ReadPrec (f (g a)) -> ReadPrec (Compose f g a)+liftReadPrecCompose rp = readData $ readUnaryWith rp "Compose" Compose --- | @since 4.9.0.0-instance (Show1 f, Show1 g, Show a) => Show (Compose f g a) where-    showsPrec = showsPrec1+-- The workhorse for Compose's Show and Show1 instances.+liftShowsPrecCompose :: (Int -> f (g a) -> ShowS) -> Int -> Compose f g a -> ShowS+liftShowsPrecCompose sp d (Compose x) = showsUnaryWith sp "Compose" d x  -- Functor instances 

@@ -2,6 +2,7 @@ {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Product@@ -28,7 +29,7 @@ import Data.Data (Data) import Data.Functor.Classes import GHC.Generics (Generic, Generic1)-import Text.Read (Read(..), readListDefault, readListPrecDefault)+import Text.Read ()  -- | Lifted product of functors. data Product f g a = Pair (f a) (g a)@@ -37,6 +38,15 @@            , Generic1 -- ^ @since 4.9.0.0            ) +-- | @since 4.18.0.0+deriving instance (Eq (f a), Eq (g a)) => Eq (Product f g a)+-- | @since 4.18.0.0+deriving instance (Ord (f a), Ord (g a)) => Ord (Product f g a)+-- | @since 4.18.0.0+deriving instance (Read (f a), Read (g a)) => Read (Product f g a)+-- | @since 4.18.0.0+deriving instance (Show (f a), Show (g a)) => Show (Product f g a)+ -- | @since 4.9.0.0 instance (Eq1 f, Eq1 g) => Eq1 (Product f g) where     liftEq eq (Pair x1 y1) (Pair x2 y2) = liftEq eq x1 x2 && liftEq eq y1 y2@@ -58,25 +68,6 @@ instance (Show1 f, Show1 g) => Show1 (Product f g) where     liftShowsPrec sp sl d (Pair x y) =         showsBinaryWith (liftShowsPrec sp sl) (liftShowsPrec sp sl) "Pair" d x y---- | @since 4.9.0.0-instance (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)-    where (==) = eq1---- | @since 4.9.0.0-instance (Ord1 f, Ord1 g, Ord a) => Ord (Product f g a) where-    compare = compare1---- | @since 4.9.0.0-instance (Read1 f, Read1 g, Read a) => Read (Product f g a) where-    readPrec = readPrec1--    readListPrec = readListPrecDefault-    readList     = readListDefault---- | @since 4.9.0.0-instance (Show1 f, Show1 g, Show a) => Show (Product f g a) where-    showsPrec = showsPrec1  -- | @since 4.9.0.0 instance (Functor f, Functor g) => Functor (Product f g) where

@@ -2,6 +2,7 @@ {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE Safe #-}+{-# LANGUAGE StandaloneDeriving #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Sum@@ -25,7 +26,7 @@ import Data.Data (Data) import Data.Functor.Classes import GHC.Generics (Generic, Generic1)-import Text.Read (Read(..), readListDefault, readListPrecDefault)+import Text.Read ()  -- | Lifted sum of functors. data Sum f g a = InL (f a) | InR (g a)@@ -34,6 +35,15 @@            , Generic1 -- ^ @since 4.9.0.0            ) +-- | @since 4.18.0.0+deriving instance (Eq (f a), Eq (g a)) => Eq (Sum f g a)+-- | @since 4.18.0.0+deriving instance (Ord (f a), Ord (g a)) => Ord (Sum f g a)+-- | @since 4.18.0.0+deriving instance (Read (f a), Read (g a)) => Read (Sum f g a)+-- | @since 4.18.0.0+deriving instance (Show (f a), Show (g a)) => Show (Sum f g a)+ -- | @since 4.9.0.0 instance (Eq1 f, Eq1 g) => Eq1 (Sum f g) where     liftEq eq (InL x1) (InL x2) = liftEq eq x1 x2@@ -63,22 +73,6 @@         showsUnaryWith (liftShowsPrec sp sl) "InL" d x     liftShowsPrec sp sl d (InR y) =         showsUnaryWith (liftShowsPrec sp sl) "InR" d y---- | @since 4.9.0.0-instance (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) where-    (==) = eq1--- | @since 4.9.0.0-instance (Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a) where-    compare = compare1--- | @since 4.9.0.0-instance (Read1 f, Read1 g, Read a) => Read (Sum f g a) where-    readPrec = readPrec1--    readListPrec = readListPrecDefault-    readList     = readListDefault--- | @since 4.9.0.0-instance (Show1 f, Show1 g, Show a) => Show (Sum f g a) where-    showsPrec = showsPrec1  -- | @since 4.9.0.0 instance (Functor f, Functor g) => Functor (Sum f g) where

@@ -10,8 +10,8 @@ module Data.Functor.Utils where  import Data.Coerce (Coercible, coerce)-import GHC.Base ( Applicative(..), Functor(..), Maybe(..), Monoid(..), Ord(..)-                , Semigroup(..), ($), otherwise )+import GHC.Base ( Applicative(..), Functor(..), Maybe(..), Monad (..)+                , Monoid(..), Ord(..), Semigroup(..), ($), liftM, otherwise ) import qualified GHC.List as List  -- We don't expose Max and Min because, as Edward Kmett pointed out to me,@@ -94,6 +94,37 @@         let (s', y) = ky s             (s'', x) = kx s'         in (s'', f x y)++-- | A state transformer monad parameterized by the state and inner monad.+-- The implementation is copied from the transformers package with the+-- return tuple swapped.+--+-- @since 4.18.0.0+newtype StateT s m a = StateT { runStateT :: s -> m (s, a) }++-- | @since 4.18.0.0+instance Monad m => Functor (StateT s m) where+    fmap = liftM+    {-# INLINE fmap #-}++-- | @since 4.18.0.0+instance Monad m => Applicative (StateT s m) where+    pure a = StateT $ \ s -> return (s, a)+    {-# INLINE pure #-}+    StateT mf <*> StateT mx = StateT $ \ s -> do+        (s', f) <- mf s+        (s'', x) <- mx s'+        return (s'', f x)+    {-# INLINE (<*>) #-}+    m *> k = m >>= \_ -> k+    {-# INLINE (*>) #-}++-- | @since 4.18.0.0+instance (Monad m) => Monad (StateT s m) where+    m >>= k  = StateT $ \ s -> do+        (s', a) <- runStateT m s+        runStateT (k a) s'+    {-# INLINE (>>=) #-}  -- See Note [Function coercion] (#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)

@@ -46,7 +46,9 @@ mkWeakIORef r@(IORef (STRef r#)) (IO finalizer) = IO $ \s ->     case mkWeak# r# r finalizer s of (# s1, w #) -> (# s1, Weak w #) --- |Mutate the contents of an 'IORef'.+-- |Mutate the contents of an 'IORef', combining 'readIORef' and 'writeIORef'.+-- This is not an atomic update, consider using 'atomicModifyIORef' when+-- operating in a multithreaded environment. -- -- Be warned that 'modifyIORef' does not apply the function strictly.  This -- means if the program calls 'modifyIORef' many times, but seldom uses the@@ -62,7 +64,9 @@ modifyIORef :: IORef a -> (a -> a) -> IO () modifyIORef ref f = readIORef ref >>= writeIORef ref . f --- |Strict version of 'modifyIORef'+-- |Strict version of 'modifyIORef'.+-- This is not an atomic update, consider using 'atomicModifyIORef'' when+-- operating in a multithreaded environment. -- -- @since 4.6.0.0 modifyIORef' :: IORef a -> (a -> a) -> IO ()@@ -90,13 +94,18 @@ -- -- Use 'atomicModifyIORef'' or 'atomicWriteIORef' to avoid this problem. --+-- This function imposes a memory barrier, preventing reordering;+-- see "Data.IORef#memmodel" for details.+-- atomicModifyIORef :: IORef a -> (a -> (a,b)) -> IO b atomicModifyIORef ref f = do   (_old, ~(_new, res)) <- atomicModifyIORef2 ref f   pure res --- | Variant of 'writeIORef' with the \"barrier to reordering\" property that--- 'atomicModifyIORef' has.+-- | Variant of 'writeIORef'. The prefix "atomic" relates to a fact that+-- it imposes a reordering barrier, similar to 'atomicModifyIORef'.+-- Such a write will not be reordered with other reads+-- or writes even on CPUs with weak memory model. -- -- @since 4.6.0.0 atomicWriteIORef :: IORef a -> a -> IO ()@@ -105,12 +114,16 @@   pure ()  {- $memmodel+  #memmodel# -  In a concurrent program, 'IORef' operations may appear out-of-order-  to another thread, depending on the memory model of the underlying-  processor architecture.  For example, on x86, loads can move ahead-  of stores, so in the following example:+  Most modern CPU achitectures (e.g. x86/64, ARM) have a memory model which allows+  threads to reorder reads with earlier writes to different locations,+  e.g. see <https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html the x86/64 architecture manual>,+  8.2.3.4 Loads May Be Reordered with Earlier Stores to Different Locations. +  Because of that, in a concurrent program, 'IORef' operations may appear out-of-order+  to another thread. In the following example:+   > import Data.IORef   > import Control.Monad (unless)   > import Control.Concurrent (forkIO, threadDelay)@@ -131,20 +144,23 @@    it is possible that the string @"critical section"@ is printed   twice, even though there is no interleaving of the operations of the-  two threads that allows that outcome.  The memory model of x86+  two threads that allows that outcome.  The memory model of x86/64   allows 'readIORef' to happen before the earlier 'writeIORef'. +  The ARM memory order model is typically even weaker than x86/64, allowing+  any reordering of reads and writes as long as they are independent+  from the point of view of the current thread.+   The implementation is required to ensure that reordering of memory   operations cannot cause type-correct code to go wrong.  In   particular, when inspecting the value read from an 'IORef', the   memory writes that created that value must have occurred from the   point of view of the current thread. -  'atomicModifyIORef' acts as a barrier to reordering.  Multiple-  'atomicModifyIORef' operations occur in strict program order.  An-  'atomicModifyIORef' is never observed to take place ahead of any+  'atomicWriteIORef', 'atomicModifyIORef' and 'atomicModifyIORef'' act+  as a barrier to reordering. Multiple calls to these functions+  occur in strict program order, never taking place ahead of any   earlier (in program order) 'IORef' operations, or after any later   'IORef' operations.  -}-

@@ -229,14 +229,23 @@ -- -- @since 4.8.0.0 ----- ==== __Examples__--- -- >>> isSubsequenceOf "GHC" "The Glorious Haskell Compiler" -- True -- >>> isSubsequenceOf ['a','d'..'z'] ['a'..'z'] -- True -- >>> isSubsequenceOf [1..10] [10,9..0] -- False+--+-- For the result to be 'True', the first list must be finite;+-- for the result to be 'False', the second list must be finite:+--+-- >>> [0,2..10] `isSubsequenceOf` [0..]+-- True+-- >>> [0..] `isSubsequenceOf` [0,2..10]+-- False+-- >>> [0,2..] `isSubsequenceOf` [0..]+-- * Hangs forever*+-- isSubsequenceOf :: (Eq a) => [a] -> [a] -> Bool isSubsequenceOf []    _                    = True isSubsequenceOf _     []                   = False

@@ -47,7 +47,9 @@    , sort        -- :: NonEmpty a -> NonEmpty a    , reverse     -- :: NonEmpty a -> NonEmpty a    , inits       -- :: Foldable f => f a -> NonEmpty a+   , inits1      -- :: NonEmpty a -> NonEmpty (NonEmpty a)    , tails       -- :: Foldable f => f a -> NonEmpty a+   , tails1      -- :: NonEmpty a -> NonEmpty (NonEmpty a)    , append      -- :: NonEmpty a -> NonEmpty a -> NonEmpty a    , appendList  -- :: NonEmpty a -> [a] -> NonEmpty a    , prependList -- :: [a] -> NonEmpty a -> NonEmpty a@@ -100,7 +102,7 @@                                       last, length, map, repeat, reverse,                                       scanl, scanl1, scanr, scanr1, span,                                       splitAt, tail, take, takeWhile,-                                      unzip, zip, zipWith, (!!))+                                      unzip, zip, zipWith, (!!), Applicative(..)) import qualified Prelude  import           Control.Applicative (Applicative (..), Alternative (many))@@ -215,14 +217,61 @@ map f ~(a :| as) = f a :| fmap f as  -- | The 'inits' function takes a stream @xs@ and returns all the--- finite prefixes of @xs@.+-- finite prefixes of @xs@, starting with the shortest. The result is+-- 'NonEmpty' because the result always contains the empty list as the first+-- element.+--+-- > inits [1,2,3] == [] :| [[1], [1,2], [1,2,3]]+-- > inits [1] == [] :| [[1]]+-- > inits [] == [] :| [] inits :: Foldable f => f a -> NonEmpty [a] inits = fromList . List.inits . Foldable.toList +-- | The 'inits1' function takes a 'NonEmpty' stream @xs@ and returns all the+-- 'NonEmpty' finite prefixes of @xs@, starting with the shortest.+--+-- > inits1 (1 :| [2,3]) == (1 :| []) :| [1 :| [2], 1 :| [2,3]]+-- > inits1 (1 :| []) == (1 :| []) :| []+--+-- @since 4.18+inits1 :: NonEmpty a -> NonEmpty (NonEmpty a)+inits1 =+  -- fromList is an unsafe function, but this usage should be safe, since:+  -- * `inits xs = [[], ..., init (init xs), init xs, xs]`+  -- * If `xs` is nonempty, it follows that `inits xs` contains at least one nonempty+  --   list, since `last (inits xs) = xs`.+  -- * The only empty element of `inits xs` is the first one (by the definition of `inits`)+  -- * Therefore, if we take all but the first element of `inits xs` i.e.+  --   `tail (inits xs)`, we have a nonempty list of nonempty lists+  fromList . Prelude.map fromList . List.tail . List.inits . Foldable.toList+ -- | The 'tails' function takes a stream @xs@ and returns all the--- suffixes of @xs@.+-- suffixes of @xs@, starting with the longest. The result is 'NonEmpty'+-- because the result always contains the empty list as the last element.+--+-- > tails [1,2,3] == [1,2,3] :| [[2,3], [3], []]+-- > tails [1] == [1] :| [[]]+-- > tails [] == [] :| [] tails   :: Foldable f => f a -> NonEmpty [a] tails = fromList . List.tails . Foldable.toList++-- | The 'tails1' function takes a 'NonEmpty' stream @xs@ and returns all the+-- non-empty suffixes of @xs@, starting with the longest.+--+-- > tails1 (1 :| [2,3]) == (1 :| [2,3]) :| [2 :| [3], 3 :| []]+-- > tails1 (1 :| []) == (1 :| []) :| []+--+-- @since 4.18+tails1 :: NonEmpty a -> NonEmpty (NonEmpty a)+tails1 =+  -- fromList is an unsafe function, but this usage should be safe, since:+  -- * `tails xs = [xs, tail xs, tail (tail xs), ..., []]`+  -- * If `xs` is nonempty, it follows that `tails xs` contains at least one nonempty+  --   list, since `head (tails xs) = xs`.+  -- * The only empty element of `tails xs` is the last one (by the definition of `tails`)+  -- * Therefore, if we take all but the last element of `tails xs` i.e.+  --   `init (tails xs)`, we have a nonempty list of nonempty lists+  fromList . Prelude.map fromList . List.init . List.tails . Foldable.toList  -- | @'insert' x xs@ inserts @x@ into the last position in @xs@ where it -- is still less than or equal to the next element. In particular, if the

@@ -122,13 +122,19 @@ -- @  --- | Maybe monoid returning the leftmost non-Nothing value.+-- | Maybe monoid returning the leftmost non-'Nothing' value. -- -- @'First' a@ is isomorphic to @'Alt' 'Maybe' a@, but precedes it -- historically. -- -- >>> getFirst (First (Just "hello") <> First Nothing <> First (Just "world")) -- Just "hello"+--+-- Beware that @Data.Monoid.@'First' is different from+-- @Data.Semigroup.@'Data.Semigroup.First'. The former returns the first non-'Nothing',+-- so @Data.Monoid.First Nothing <> x = x@. The latter simply returns the first value,+-- thus @Data.Semigroup.First Nothing <> x = Data.Semigroup.First Nothing@.+-- newtype First a = First { getFirst :: Maybe a }         deriving ( Eq          -- ^ @since 2.01                  , Ord         -- ^ @since 2.01@@ -151,13 +157,19 @@ instance Monoid (First a) where         mempty = First Nothing --- | Maybe monoid returning the rightmost non-Nothing value.+-- | Maybe monoid returning the rightmost non-'Nothing' value. -- -- @'Last' a@ is isomorphic to @'Dual' ('First' a)@, and thus to -- @'Dual' ('Alt' 'Maybe' a)@ -- -- >>> getLast (Last (Just "hello") <> Last Nothing <> Last (Just "world")) -- Just "world"+--+-- Beware that @Data.Monoid.@'Last' is different from+-- @Data.Semigroup.@'Data.Semigroup.Last'. The former returns the last non-'Nothing',+-- so @x <> Data.Monoid.Last Nothing = x@. The latter simply returns the last value,+-- thus @x <> Data.Semigroup.Last Nothing = Data.Semigroup.Last Nothing@.+-- newtype Last a = Last { getLast :: Maybe a }         deriving ( Eq          -- ^ @since 2.01                  , Ord         -- ^ @since 2.01

@@ -266,23 +266,25 @@ -- | The 'elemIndex' function returns the index of the first element -- in the given list which is equal (by '==') to the query element, -- or 'Nothing' if there is no such element.+-- For the result to be 'Nothing', the list must be finite. -- -- >>> elemIndex 4 [0..] -- Just 4-elemIndex       :: Eq a => a -> [a] -> Maybe Int-elemIndex x     = findIndex (x==)+elemIndex      :: Eq a => a -> [a] -> Maybe Int+elemIndex x xs = findIndex (x==) xs -- arity 2 so that we don't get a PAP; #21345  -- | The 'elemIndices' function extends 'elemIndex', by returning the -- indices of all elements equal to the query element, in ascending order. -- -- >>> elemIndices 'o' "Hello World" -- [4,7]-elemIndices     :: Eq a => a -> [a] -> [Int]-elemIndices x   = findIndices (x==)+elemIndices      :: Eq a => a -> [a] -> [Int]+elemIndices x xs = findIndices (x==) xs -- arity 2 so that we don't get a PAP; #21345  -- | The 'find' function takes a predicate and a list and returns the -- first element in the list matching the predicate, or 'Nothing' if -- there is no such element.+-- For the result to be 'Nothing', the list must be finite. -- -- >>> find (> 4) [1..] -- Just 5@@ -295,6 +297,7 @@ -- | The 'findIndex' function takes a predicate and a list and returns -- the index of the first element in the list satisfying the predicate, -- or 'Nothing' if there is no such element.+-- For the result to be 'Nothing', the list must be finite. -- -- >>> findIndex isSpace "Hello World!" -- Just 5@@ -325,23 +328,41 @@ -- -- >>> "Hello" `isPrefixOf` "Hello World!" -- True--- -- >>> "Hello" `isPrefixOf` "Wello Horld!" -- False+--+-- For the result to be 'True', the first list must be finite;+-- 'False', however, results from any mismatch:+--+-- >>> [0..] `isPrefixOf` [1..]+-- False+-- >>> [0..] `isPrefixOf` [0..99]+-- False+-- >>> [0..99] `isPrefixOf` [0..]+-- True+-- >>> [0..] `isPrefixOf` [0..]+-- * Hangs forever *+-- isPrefixOf              :: (Eq a) => [a] -> [a] -> Bool isPrefixOf [] _         =  True isPrefixOf _  []        =  False isPrefixOf (x:xs) (y:ys)=  x == y && isPrefixOf xs ys  -- | The 'isSuffixOf' function takes two lists and returns 'True' iff--- the first list is a suffix of the second. The second list must be--- finite.+-- the first list is a suffix of the second. -- -- >>> "ld!" `isSuffixOf` "Hello World!" -- True--- -- >>> "World" `isSuffixOf` "Hello World!" -- False+--+-- The second list must be finite; however the first list may be infinite:+--+-- >>> [0..] `isSuffixOf` [0..99]+-- False+-- >>> [0..99] `isSuffixOf` [0..]+-- * Hangs forever *+-- isSuffixOf              :: (Eq a) => [a] -> [a] -> Bool ns `isSuffixOf` hs      = maybe False id $ do       delta <- dropLengthMaybe ns hs@@ -383,9 +404,19 @@ -- -- >>> isInfixOf "Haskell" "I really like Haskell." -- True--- -- >>> isInfixOf "Ial" "I really like Haskell." -- False+--+-- For the result to be 'True', the first list must be finite;+-- for the result to be 'False', the second list must be finite:+--+-- >>> [20..50] `isInfixOf` [0..]+-- True+-- >>> [0..] `isInfixOf` [20..50]+-- False+-- >>> [0..] `isInfixOf` [0..]+-- * Hangs forever *+-- isInfixOf               :: (Eq a) => [a] -> [a] -> Bool isInfixOf needle haystack = any (isPrefixOf needle) (tails haystack) @@ -396,6 +427,12 @@ -- -- >>> nub [1,2,3,4,3,2,1,2,4,3,5] -- [1,2,3,4,5]+--+-- If the order of outputs does not matter and there exists @instance Ord a@,+-- it's faster to use+-- 'map' @Data.List.NonEmpty.@'Data.List.NonEmpty.head' . @Data.List.NonEmpty.@'Data.List.NonEmpty.group' . 'sort',+-- which takes only \(\mathcal{O}(n \log n)\) time.+-- nub                     :: (Eq a) => [a] -> [a] nub                     =  nubBy (==) @@ -454,56 +491,103 @@ -- | The '\\' function is list difference (non-associative). -- In the result of @xs@ '\\' @ys@, the first occurrence of each element of -- @ys@ in turn (if any) has been removed from @xs@.  Thus------ > (xs ++ ys) \\ xs == ys.+-- @(xs ++ ys) \\\\ xs == ys@. -- -- >>> "Hello World!" \\ "ell W" -- "Hoorld!" -- -- It is a special case of 'deleteFirstsBy', which allows the programmer -- to supply their own equality test.-+--+-- The second list must be finite, but the first may be infinite.+--+-- >>> take 5 ([0..] \\ [2..4])+-- [0,1,5,6,7]+-- >>> take 5 ([0..] \\ [2..])+-- * Hangs forever *+-- (\\)                    :: (Eq a) => [a] -> [a] -> [a] (\\)                    =  foldl (flip delete)  -- | The 'union' function returns the list union of the two lists.+-- It is a special case of 'unionBy', which allows the programmer to supply+-- their own equality test. -- For example, -- -- >>> "dog" `union` "cow" -- "dogcw" ----- Duplicates, and elements of the first list, are removed from the--- the second list, but if the first list contains duplicates, so will--- the result.--- It is a special case of 'unionBy', which allows the programmer to supply--- their own equality test.-+-- If equal elements are present in both lists, an element from the first list+-- will be used. If the second list contains equal elements, only the first one+-- will be retained:+--+-- >>> import Data.Semigroup+-- >>> union [Arg () "dog"] [Arg () "cow"]+-- [Arg () "dog"]+-- >>> union [] [Arg () "dog", Arg () "cow"]+-- [Arg () "dog"]+--+-- However if the first list contains duplicates, so will+-- the result:+--+-- >>> "coot" `union` "duck"+-- "cootduk"+-- >>> "duck" `union` "coot"+-- "duckot"+--+-- 'union' is productive even if both arguments are infinite.+-- union                   :: (Eq a) => [a] -> [a] -> [a] union                   = unionBy (==)  -- | The 'unionBy' function is the non-overloaded version of 'union'.+-- Both arguments may be infinite.+-- unionBy                 :: (a -> a -> Bool) -> [a] -> [a] -> [a] unionBy eq xs ys        =  xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs  -- | The 'intersect' function takes the list intersection of two lists.+-- It is a special case of 'intersectBy', which allows the programmer to+-- supply their own equality test. -- For example, -- -- >>> [1,2,3,4] `intersect` [2,4,6,8] -- [2,4] ----- If the first list contains duplicates, so will the result.+-- If equal elements are present in both lists, an element from the first list+-- will be used, and all duplicates from the second list quashed: ----- >>> [1,2,2,3,4] `intersect` [6,4,4,2]--- [2,2,4]+-- >>> import Data.Semigroup+-- >>> intersect [Arg () "dog"] [Arg () "cow", Arg () "cat"]+-- [Arg () "dog"] ----- It is a special case of 'intersectBy', which allows the programmer to--- supply their own equality test. If the element is found in both the first--- and the second list, the element from the first list will be used.-+-- However if the first list contains duplicates, so will the result.+--+-- >>> "coot" `intersect` "heron"+-- "oo"+-- >>> "heron" `intersect` "coot"+-- "o"+--+-- If the second list is infinite, 'intersect' either hangs+-- or returns its first argument in full. Otherwise if the first list+-- is infinite, 'intersect' might be productive:+--+-- >>> intersect [100..] [0..]+-- [100,101,102,103...+-- >>> intersect [0] [1..]+-- * Hangs forever *+-- >>> intersect [1..] [0]+-- * Hangs forever *+-- >>> intersect (cycle [1..3]) [2]+-- [2,2,2,2...+-- intersect               :: (Eq a) => [a] -> [a] -> [a] intersect               =  intersectBy (==)  -- | The 'intersectBy' function is the non-overloaded version of 'intersect'.+-- It is productive for infinite arguments only if the first one+-- is a subset of the second.+-- intersectBy             :: (a -> a -> Bool) -> [a] -> [a] -> [a] intersectBy _  [] _     =  [] intersectBy _  _  []    =  []@@ -547,6 +631,12 @@ -- -- >>> transpose [[10,11],[20],[],[30,31,32]] -- [[10,20,30],[11,31],[32]]+--+-- For this reason the outer list must be finite; otherwise 'transpose' hangs:+--+-- >>> transpose (repeat [])+-- * Hangs forever *+-- transpose :: [[a]] -> [[a]] transpose [] = [] transpose ([] : xss) = transpose xss@@ -681,7 +771,8 @@      GT -> y : insertBy cmp x ys'      _  -> x : ys --- | The 'maximumBy' function takes a comparison function and a list+-- | The 'maximumBy' function is the non-overloaded version of 'maximum',+-- which takes a comparison function and a list -- and returns the greatest element of the list by the comparison function. -- The list must be finite and non-empty. --@@ -697,7 +788,8 @@                                        GT -> x                                        _  -> y --- | The 'minimumBy' function takes a comparison function and a list+-- | The 'minimumBy' function is the non-overloaded version of 'minimum',+-- which takes a comparison function and a list -- and returns the least element of the list by the comparison function. -- The list must be finite and non-empty. --@@ -749,6 +841,7 @@                         where                            gl [] a     = a                            gl (_:xs) a = let a' = a + 1 in a' `seq` gl xs a'+{-# INLINABLE strictGenericLength #-}  -- | The 'genericTake' function is an overloaded version of 'take', which -- accepts any 'Integral' value as the number of elements to take.@@ -756,6 +849,7 @@ genericTake n _ | n <= 0 = [] genericTake _ []        =  [] genericTake n (x:xs)    =  x : genericTake (n-1) xs+{-# INLINABLE genericTake #-}  -- | The 'genericDrop' function is an overloaded version of 'drop', which -- accepts any 'Integral' value as the number of elements to drop.@@ -763,6 +857,7 @@ genericDrop n xs | n <= 0 = xs genericDrop _ []        =  [] genericDrop n (_:xs)    =  genericDrop (n-1) xs+{-# INLINABLE genericDrop #-}   -- | The 'genericSplitAt' function is an overloaded version of 'splitAt', which@@ -772,6 +867,7 @@ genericSplitAt _ []     =  ([],[]) genericSplitAt n (x:xs) =  (x:xs',xs'') where     (xs',xs'') = genericSplitAt (n-1) xs+{-# INLINABLE genericSplitAt #-}  -- | The 'genericIndex' function is an overloaded version of '!!', which -- accepts any 'Integral' value as the index.@@ -781,11 +877,13 @@  | n > 0     = genericIndex xs (n-1)  | otherwise = errorWithoutStackTrace "List.genericIndex: negative argument." genericIndex _ _      = errorWithoutStackTrace "List.genericIndex: index too large."+{-# INLINABLE genericIndex #-}  -- | The 'genericReplicate' function is an overloaded version of 'replicate', -- which accepts any 'Integral' value as the number of repetitions to make. genericReplicate        :: (Integral i) => i -> a -> [a] genericReplicate n x    =  genericTake n (repeat x)+{-# INLINABLE genericReplicate #-}  -- | The 'zip4' function takes four lists and returns a list of -- quadruples, analogous to 'zip'.@@ -1045,23 +1143,42 @@  -- | The 'deleteFirstsBy' function takes a predicate and two lists and -- returns the first list with the first occurrence of each element of--- the second list removed.+-- the second list removed. This is the non-overloaded version of '(\\)'.+--+-- The second list must be finite, but the first may be infinite.+-- deleteFirstsBy          :: (a -> a -> Bool) -> [a] -> [a] -> [a] deleteFirstsBy eq       =  foldl (flip (deleteBy eq))  -- | The 'group' function takes a list and returns a list of lists such -- that the concatenation of the result is equal to the argument.  Moreover,--- each sublist in the result contains only equal elements.  For example,+-- each sublist in the result is non-empty and all elements are equal+-- to the first one.  For example, -- -- >>> group "Mississippi" -- ["M","i","ss","i","ss","i","pp","i"] ----- It is a special case of 'groupBy', which allows the programmer to supply+-- 'group' is a special case of 'groupBy', which allows the programmer to supply -- their own equality test.+--+-- It's often preferable to use @Data.List.NonEmpty.@'Data.List.NonEmpty.group',+-- which provides type-level guarantees of non-emptiness of inner lists.+-- group                   :: Eq a => [a] -> [[a]] group                   =  groupBy (==)  -- | The 'groupBy' function is the non-overloaded version of 'group'.+--+-- When a supplied relation is not transitive, it is important+-- to remember that equality is checked against the first element in the group,+-- not against the nearest neighbour:+--+-- >>> groupBy (\a b -> b - a < 5) [0..19]+-- [[0,1,2,3,4],[5,6,7,8,9],[10,11,12,13,14],[15,16,17,18,19]]+--+-- It's often preferable to use @Data.List.NonEmpty.@'Data.List.NonEmpty.groupBy',+-- which provides type-level guarantees of non-emptiness of inner lists.+-- groupBy                 :: (a -> a -> Bool) -> [a] -> [[a]] groupBy _  []           =  [] groupBy eq (x:xs)       =  (x:ys) : groupBy eq zs@@ -1078,6 +1195,10 @@ -- -- In particular, -- @inits _|_ = [] : _|_@+--+-- 'inits' is semantically equivalent to @'map' 'reverse' . 'scanl' ('flip' (:)) []@,+-- but under the hood uses a queue to amortize costs of 'reverse'.+-- inits                   :: [a] -> [[a]] inits                   = map toListSB . scanl' snocSB emptySB {-# NOINLINE inits #-}@@ -1106,6 +1227,12 @@ -- -- >>> subsequences "abc" -- ["","a","b","ab","c","ac","bc","abc"]+--+-- This function is productive on infinite inputs:+--+-- >>> take 8 $ subsequences ['a'..]+-- ["","a","b","ab","c","ac","bc","abc"]+-- subsequences            :: [a] -> [[a]] subsequences xs         =  [] : nonEmptySubsequences xs @@ -1124,16 +1251,40 @@ -- -- >>> permutations "abc" -- ["abc","bac","cba","bca","cab","acb"]-permutations            :: [a] -> [[a]]-permutations xs0        =  xs0 : perms xs0 []+--+-- The 'permutations' function is maximally lazy:+-- for each @n@, the value of @'permutations' xs@ starts with those permutations+-- that permute @'take' n xs@ and keep @'drop' n xs@.+--+-- This function is productive on infinite inputs:+--+-- >>> take 6 $ map (take 3) $ permutations ['a'..]+-- ["abc","bac","cba","bca","cab","acb"]+--+-- Note that the order of permutations is not lexicographic.+-- It satisfies the following property:+--+-- > map (take n) (take (product [1..n]) (permutations ([1..n] ++ undefined))) == permutations [1..n]+--+permutations :: [a] -> [[a]]+-- See https://stackoverflow.com/questions/24484348/what-does-this-list-permutations-implementation-in-haskell-exactly-do/24564307#24564307+-- for the analysis of this rather cryptic implementation.+-- Related discussions:+-- * https://mail.haskell.org/pipermail/haskell-cafe/2021-December/134920.html+-- * https://mail.haskell.org/pipermail/libraries/2007-December/008788.html+permutations xs0 = xs0 : perms xs0 []   where+    perms :: forall a. [a] -> [a] -> [[a]]     perms []     _  = []     perms (t:ts) is = foldr interleave (perms ts (t:is)) (permutations is)-      where interleave    xs     r = let (_,zs) = interleave' id xs r in zs-            interleave' _ []     r = (ts, r)-            interleave' f (y:ys) r = let (us,zs) = interleave' (f . (y:)) ys r-                                     in  (y:us, f (t:y:us) : zs)+      where+        interleave :: [a] -> [[a]] -> [[a]]+        interleave xs r = let (_,zs) = interleave' id xs r in zs +        interleave' :: ([a] -> b) -> [a] -> [b] -> ([a], [b])+        interleave' _ []     r = (ts, r)+        interleave' f (y:ys) r = let (us,zs) = interleave' (f . (y:)) ys r+                                 in  (y:us, f (t:y:us) : zs)  ------------------------------------------------------------------------------ -- Quick Sort algorithm taken from HBC's QSort library.@@ -1147,12 +1298,22 @@ -- -- >>> sort [1,6,4,3,2,5] -- [1,2,3,4,5,6]+--+-- The argument must be finite.+-- sort :: (Ord a) => [a] -> [a]  -- | The 'sortBy' function is the non-overloaded version of 'sort'.+-- The argument must be finite. -- -- >>> sortBy (\(a,_) (b,_) -> compare a b) [(2, "world"), (4, "!"), (1, "Hello")] -- [(1,"Hello"),(2,"world"),(4,"!")]+--+-- The supplied comparison relation is supposed to be reflexive and antisymmetric,+-- otherwise, e. g., for @\_ _ -> GT@, the ordered list simply does not exist.+-- The relation is also expected to be transitive: if it is not then 'sortBy'+-- might fail to find an ordered permutation, even if it exists.+-- sortBy :: (a -> a -> Ordering) -> [a] -> [a]  #if defined(USE_REPORT_PRELUDE)@@ -1310,10 +1471,10 @@ #endif /* USE_REPORT_PRELUDE */  -- | Sort a list by comparing the results of a key function applied to each--- element.  @sortOn f@ is equivalent to @sortBy (comparing f)@, but has the+-- element.  @'sortOn' f@ is equivalent to @'sortBy' ('comparing' f)@, but has the -- performance advantage of only evaluating @f@ once for each element in the -- input list.  This is called the decorate-sort-undecorate paradigm, or--- Schwartzian transform.+-- <https://en.wikipedia.org/wiki/Schwartzian_transform Schwartzian transform>. -- -- Elements are arranged from lowest to highest, keeping duplicates in -- the order they appeared in the input.@@ -1321,6 +1482,8 @@ -- >>> sortOn fst [(2, "world"), (4, "!"), (1, "Hello")] -- [(1,"Hello"),(2,"world"),(4,"!")] --+-- The argument must be finite.+-- -- @since 4.8.0.0 sortOn :: Ord b => (a -> b) -> [a] -> [a] sortOn f =@@ -1397,35 +1560,29 @@ -- Functions on strings  -- | Splits the argument into a list of /lines/ stripped of their terminating--- @\n@ characters.  The @\n@ terminator is optional in a final non-empty+-- @\\n@ characters.  The @\\n@ terminator is optional in a final non-empty -- line of the argument string. -- -- For example: -- -- >>> lines ""           -- empty input contains no lines -- []--- -- >>> lines "\n"         -- single empty line -- [""]--- -- >>> lines "one"        -- single unterminated line -- ["one"]--- -- >>> lines "one\n"      -- single non-empty line -- ["one"]--- -- >>> lines "one\n\n"    -- second line is empty -- ["one",""]--- -- >>> lines "one\ntwo"   -- second line is unterminated -- ["one","two"]--- -- >>> lines "one\ntwo\n" -- two non-empty lines -- ["one","two"] ----- When the argument string is empty, or ends in a @\n@ character, it can be+-- When the argument string is empty, or ends in a @\\n@ character, it can be -- recovered by passing the result of 'lines' to the 'unlines' function.--- Otherwise, 'unlines' appends the missing terminating @\n@.  This makes+-- Otherwise, 'unlines' appends the missing terminating @\\n@.  This makes -- @unlines . lines@ /idempotent/: -- -- > (unlines . lines) . (unlines . lines) = (unlines . lines)@@ -1443,15 +1600,13 @@   where     cons ~(h, t)        =  h : t --- | Appends a @\n@ character to each input string, then concatenates the--- results. Equivalent to @'foldMap' (\s -> s '++' "\n")@.+-- | Appends a @\\n@ character to each input string, then concatenates the+-- results. Equivalent to @'foldMap' (\s -> s '++' "\\n")@. -- -- >>> unlines ["Hello", "World", "!"] -- "Hello\nWorld\n!\n" ----- = Note------ @'unlines' '.' 'lines' '/=' 'id'@ when the input is not @\n@-terminated:+-- Note that @'unlines' '.' 'lines' '/=' 'id'@ when the input is not @\\n@-terminated: -- -- >>> unlines . lines $ "foo\nbar" -- "foo\nbar\n"@@ -1466,10 +1621,14 @@ #endif  -- | 'words' breaks a string up into a list of words, which were delimited--- by white space.+-- by white space (as defined by 'isSpace'). This function trims any white spaces+-- at the beginning and at the end. -- -- >>> words "Lorem ipsum\ndolor" -- ["Lorem","ipsum","dolor"]+-- >>> words " foo bar "+-- ["foo","bar"]+-- words                   :: String -> [String] {-# NOINLINE [1] words #-} words s                 =  case dropWhile {-partain:Char.-}isSpace s of@@ -1491,11 +1650,18 @@              s' -> w `c` go s''                    where (w, s'') = break isSpace s' --- | 'unwords' is an inverse operation to 'words'.--- It joins words with separating spaces.+-- | 'unwords' joins words with separating spaces (U+0020 SPACE). -- -- >>> unwords ["Lorem", "ipsum", "dolor"] -- "Lorem ipsum dolor"+--+-- 'unwords' is neither left nor right inverse of 'words':+--+-- >>> words (unwords [" "])+-- []+-- >>> unwords (words "foo\nbar")+-- "foo bar"+-- unwords                 :: [String] -> String #if defined(USE_REPORT_PRELUDE) unwords []              =  ""

@@ -24,11 +24,11 @@    clamp,  ) where -import Data.Bits (Bits, FiniteBits)+import Data.Bits (Bits, FiniteBits, complement) import Foreign.Storable (Storable) import GHC.Ix (Ix) import GHC.Base-import GHC.Enum (Bounded(..))+import GHC.Enum (Bounded(..), Enum(..)) import GHC.Float (Floating, RealFloat) import GHC.Num import GHC.Read@@ -51,7 +51,7 @@ -- | -- > clamp (low, high) a = min high (max a low) ----- Function for ensursing the value @a@ is within the inclusive bounds given by+-- Function for ensuring the value @a@ is within the inclusive bounds given by -- @low@ and @high@. If it is, @a@ is returned unchanged. The result -- is otherwise @low@ if @a <= low@, or @high@ if @high <= a@. --@@ -132,6 +132,12 @@ -- | @since 4.6.0.0 instance Ord a => Ord (Down a) where     compare (Down x) (Down y) = y `compare` x+    Down x < Down y = y < x+    Down x > Down y = y > x+    Down x <= Down y = y <= x+    Down x >= Down y = y >= x+    min (Down x) (Down y) = Down (max y x)+    max (Down x) (Down y) = Down (min y x)  -- | Swaps @'minBound'@ and @'maxBound'@ of the underlying type. --@@ -139,6 +145,26 @@ instance Bounded a => Bounded (Down a) where     minBound = Down maxBound     maxBound = Down minBound++-- | Swaps @'succ'@ and @'pred'@ of the underlying type.+--+-- @since 4.18.0.0+instance (Enum a, Bounded a, Eq a) => Enum (Down a) where+    succ = fmap pred+    pred = fmap succ++    -- Here we use the fact that 'comparing (complement @Int)' behaves+    -- as an order-swapping `compare @Int`.+    fromEnum = complement . fromEnum . getDown+    toEnum = Down . toEnum . complement++    enumFrom (Down x)+        | x == minBound+        = [Down x] -- We can't rely on 'enumFromThen _ (pred @a minBound)` behaving nicely,+                   -- since 'enumFromThen _' might be strict and 'pred minBound' might throw+        | otherwise+        = coerce $ enumFromThen x (pred x)+    enumFromThen (Down x) (Down y) = coerce $ enumFromThen x y  -- | @since 4.11.0.0 instance Functor Down where

@@ -98,7 +98,7 @@   , ArgMax   ) where -import           Prelude             hiding (foldr1)+import           Prelude             hiding (foldr1, Applicative(..))  import GHC.Base (Semigroup(..)) @@ -357,6 +357,13 @@ instance Bitraversable Arg where   bitraverse f g (Arg a b) = Arg <$> f a <*> g b +-- |+-- Beware that @Data.Semigroup.@'First' is different from+-- @Data.Monoid.@'Data.Monoid.First'. The former simply returns the first value,+-- so @Data.Semigroup.First Nothing <> x = Data.Semigroup.First Nothing@.+-- The latter returns the first non-'Nothing',+-- thus @Data.Monoid.First Nothing <> x = x@.+-- newtype First a = First { getFirst :: a }   deriving ( Bounded  -- ^ @since 4.9.0.0            , Eq       -- ^ @since 4.9.0.0@@ -413,6 +420,13 @@ instance MonadFix First where   mfix f = fix (f . getFirst) +-- |+-- Beware that @Data.Semigroup.@'Last' is different from+-- @Data.Monoid.@'Data.Monoid.Last'. The former simply returns the last value,+-- so @x <> Data.Semigroup.Last Nothing = Data.Semigroup.Last Nothing@.+-- The latter returns the last non-'Nothing',+-- thus @x <> Data.Monoid.Last Nothing = x@.+-- newtype Last a = Last { getLast :: a }   deriving ( Bounded  -- ^ @since 4.9.0.0            , Eq       -- ^ @since 4.9.0.0

@@ -67,7 +67,7 @@         | y == 1 = x `mappend` z         | otherwise = g (x `mappend` x) (y `quot` 2) (x `mappend` z) -- See Note [Half of y - 1] --- this is used by the class definitionin GHC.Base;+-- this is used by the class definition in GHC.Base; -- it lives here to avoid cycles stimesDefault :: (Integral b, Semigroup a) => b -> a -> a stimesDefault y0 x0

@@ -37,26 +37,8 @@ import Data.Functor.Identity (Identity (Identity)) import Data.List (lines, words, unlines, unwords) --- | `IsString` is used in combination with the @-XOverloadedStrings@--- language extension to convert the literals to different string types.------ For example, if you use the [text](https://hackage.haskell.org/package/text) package,--- you can say------ @--- {-# LANGUAGE OverloadedStrings  #-}------ myText = "hello world" :: Text--- @------ Internally, the extension will convert this to the equivalent of------ @--- myText = fromString @Text ("hello world" :: String)--- @------ __Note:__ You can use @fromString@ in normal code as well,--- but the usual performance/memory efficiency problems with 'String' apply.+-- | Class for string-like datastructures; used by the overloaded string+--   extension (-XOverloadedStrings in GHC). class IsString a where     fromString :: String -> a 

@@ -28,8 +28,10 @@     -- * Utility functions     for,     forM,+    forAccumM,     mapAccumL,     mapAccumR,+    mapAccumM,     -- * General definitions for superclass methods     fmapDefault,     foldMapDefault,@@ -99,7 +101,7 @@ import Data.Foldable import Data.Functor import Data.Functor.Identity ( Identity(..) )-import Data.Functor.Utils ( StateL(..), StateR(..) )+import Data.Functor.Utils ( StateL(..), StateR(..), StateT(..), (#.) ) import Data.Monoid ( Dual(..), Sum(..), Product(..),                      First(..), Last(..), Alt(..), Ap(..) ) import Data.Ord ( Down(..) )@@ -482,6 +484,45 @@ -- See Note [Function coercion] in Data.Functor.Utils. mapAccumR f s t = coerce (traverse @t @(StateR s) @a @b) (flip f) t s +-- | The `mapAccumM` function behaves like a combination of `mapM` and+-- `mapAccumL` that traverses the structure while evaluating the actions+-- and passing an accumulating parameter from left to right.+-- It returns a final value of this accumulator together with the new structure.+-- The accummulator is often used for caching the intermediate results of a computation.+--+--  @since 4.18.0.0+--+-- ==== __Examples__+--+-- Basic usage:+--+-- >>> let expensiveDouble a = putStrLn ("Doubling " <> show a) >> pure (2 * a)+-- >>> :{+-- mapAccumM (\cache a -> case lookup a cache of+--     Nothing -> expensiveDouble a >>= \double -> pure ((a, double):cache, double)+--     Just double -> pure (cache, double)+--     ) [] [1, 2, 3, 1, 2, 3]+-- :}+-- Doubling 1+-- Doubling 2+-- Doubling 3+-- ([(3,6),(2,4),(1,2)],[2,4,6,2,4,6])+--+mapAccumM+  :: forall m t s a b. (Monad m, Traversable t)+  => (s -> a -> m (s, b))+  -> s -> t a -> m (s, t b)+mapAccumM f s t = coerce (mapM @t @(StateT s m) @a @b) (StateT #. flip f) t s++-- | 'forAccumM' is 'mapAccumM' with the arguments rearranged.+--+-- @since 4.18.0.0+forAccumM+  :: (Monad m, Traversable t)+  => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)+{-# INLINE forAccumM #-}+forAccumM s t f = mapAccumM f s t+ -- | This function may be used as a value for `fmap` in a `Functor` --   instance, provided that 'traverse' is defined. (Using --   `fmapDefault` with a `Traversable` instance defined only by@@ -573,8 +614,9 @@ -- -- When the traversable term is a simple variable or expression, and the -- monadic action to run is a non-trivial do block, it can be more natural to--- write the action last.  This idiom is supported by 'for' and 'forM', which--- are the flipped versions of 'traverse' and 'mapM', respectively.+-- write the action last.  This idiom is supported by 'for', 'forM', and+-- 'forAccumM' which are the flipped versions of 'traverse', 'mapM', and+-- 'mapAccumM' respectively.  ------------------ @@ -1426,7 +1468,7 @@ -- -- Since in fact __@'traverse' id@__ is just 'sequenceA' the above boils down -- to a rather concise definition of /transpose/, with [coercion](#coercion)--- used to implicily wrap and unwrap the @ZipList@ @newtype@ as neeed, giving+-- used to implicitly wrap and unwrap the @ZipList@ @newtype@ as needed, giving -- a function that operates on a list of lists: -- -- >>> {-# LANGUAGE ScopedTypeVariables #-}

@@ -152,14 +152,14 @@ -- The result should be @Just Refl@ if and only if the types applied to @f@ are -- equal: ----- @TestEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b@+-- @testEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b@ -- -- Typically, only singleton types should inhabit this class. In that case type -- argument equality coincides with term equality: ----- @TestEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b ⟺ x = y@+-- @testEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b ⟺ x = y@ ----- @isJust (TestEquality x y) = x == y@+-- @isJust (testEquality x y) = x == y@ -- -- Singleton types are not required, however, and so the latter two would-be -- laws are not in fact valid in general.

@@ -4,6 +4,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE Trustworthy #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeOperators #-}  -----------------------------------------------------------------------------@@ -56,6 +57,7 @@       -- * Type-safe cast     , cast     , eqT+    , heqT     , gcast                -- a generalisation of cast        -- * Generalized casts for higher-order kinds@@ -135,8 +137,14 @@ -- @since 4.7.0.0 eqT :: forall a b. (Typeable a, Typeable b) => Maybe (a :~: b) eqT-  | Just HRefl <- ta `I.eqTypeRep` tb = Just Refl-  | otherwise                         = Nothing+  | Just HRefl <- heqT @a @b = Just Refl+  | otherwise                = Nothing++-- | Extract a witness of heterogeneous equality of two types+--+-- @since 4.18.0.0+heqT :: forall a b. (Typeable a, Typeable b) => Maybe (a :~~: b)+heqT = ta `I.eqTypeRep` tb   where     ta = I.typeRep :: I.TypeRep a     tb = I.typeRep :: I.TypeRep b

@@ -182,8 +182,9 @@ *                                                                      * ********************************************************************* -} --- | A concrete representation of a (monomorphic) type.+-- | TypeRep is a concrete representation of a (monomorphic) type. -- 'TypeRep' supports reasonably efficient equality.+-- See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable type TypeRep :: k -> Type data TypeRep a where     -- The TypeRep of Type. See Note [Kind caching], Wrinkle 2@@ -214,8 +215,13 @@                , trAppKind :: !(TypeRep k2) }   -- See Note [Kind caching]             -> TypeRep (a b) -    -- | @TrFun fpr m a b@ represents a function type @a # m -> b@. We use this for+    -- | @TrFun fpr m a b@ represents a function type @a % m -> b@. We use this for     -- the sake of efficiency as functions are quite ubiquitous.+    -- A TrFun can represent `t1 -> t2` or `t1 -= t2`; but not  (a => b) or (a ==> b).+    -- See Note [No Typeable for polytypes or qualified types] in GHC.Tc.Instance.Class+    -- and Note [Function type constructors and FunTy] in GHC.Builtin.Types.Prim+    -- We do not represent the function TyCon (i.e. (->) vs (-=>)) explicitly;+    -- instead, the TyCon is implicit in the kinds of the arguments.     TrFun   :: forall (m :: Multiplicity) (r1 :: RuntimeRep) (r2 :: RuntimeRep)                       (a :: TYPE r1) (b :: TYPE r2).                { -- See Note [TypeRep fingerprints]@@ -830,6 +836,8 @@ showTypeable :: Int -> TypeRep (a :: k) -> ShowS showTypeable _ TrType = showChar '*' showTypeable _ rep+  | isListTyCon tc, [] <- tys =+    showString "[]"   | isListTyCon tc, [ty] <- tys =     showChar '[' . shows ty . showChar ']' 

@@ -1,8 +1,4 @@-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE EmptyCase #-}-{-# LANGUAGE EmptyDataDeriving #-}-{-# LANGUAGE Safe #-}+{-# LANGUAGE Trustworthy #-}  ----------------------------------------------------------------------------- -- |@@ -24,64 +20,4 @@     , vacuous     ) where -import Control.Exception-import Data.Data-import Data.Ix-import GHC.Generics-import Data.Semigroup (Semigroup(..), stimesIdempotent)---- $setup--- >>> import Prelude---- | Uninhabited data type------ @since 4.8.0.0-data Void deriving-  ( Eq      -- ^ @since 4.8.0.0-  , Data    -- ^ @since 4.8.0.0-  , Generic -- ^ @since 4.8.0.0-  , Ord     -- ^ @since 4.8.0.0-  , Read    -- ^ Reading a 'Void' value is always a parse error, considering-            -- 'Void' as a data type with no constructors.-            ---            -- @since 4.8.0.0-  , Show    -- ^ @since 4.8.0.0-  )---- | @since 4.8.0.0-instance Ix Void where-    range _     = []-    index _     = absurd-    inRange _   = absurd-    rangeSize _ = 0---- | @since 4.8.0.0-instance Exception Void---- | @since 4.9.0.0-instance Semigroup Void where-    a <> _ = a-    stimes = stimesIdempotent---- | Since 'Void' values logically don't exist, this witnesses the--- logical reasoning tool of \"ex falso quodlibet\".------ >>> let x :: Either Void Int; x = Right 5--- >>> :{--- case x of---     Right r -> r---     Left l  -> absurd l--- :}--- 5------ @since 4.8.0.0-absurd :: Void -> a-absurd a = case a of {}---- | If 'Void' is uninhabited then any 'Functor' that holds only--- values of type 'Void' is holding no values.--- It is implemented in terms of @fmap absurd@.------ @since 4.8.0.0-vacuous :: Functor f => f Void -> f a-vacuous = fmap absurd+import GHC.Base (Void, absurd, vacuous)

@@ -27,6 +27,8 @@         traceId,         traceShow,         traceShowId,+        traceWith,+        traceShowWith,         traceStack,         traceIO,         traceM,@@ -36,6 +38,7 @@         -- * Eventlog tracing         -- $eventlog_tracing         traceEvent,+        traceEventWith,         traceEventIO,         flushEventLog, @@ -164,6 +167,31 @@ traceShowId a = trace (show a) a  {-|+Like 'trace', but outputs the result of calling a function on the argument.++>>> traceWith fst ("hello","world")+hello+("hello","world")++@since 4.17.0.0+-}+traceWith :: (a -> String) -> a -> a+traceWith f a = trace (f a) a++{-|+Like 'traceWith', but uses 'show' on the result of the function to convert it to+a 'String'.++>>> traceShowWith length [1,2,3]+3+[1,2,3]++@since 4.17.0.0+-}+traceShowWith :: Show b => (a -> b) -> a -> a+traceShowWith f = traceWith (show . f)++{-| Like 'trace' but returning unit in an arbitrary 'Applicative' context. Allows for convenient use in do-notation. @@ -271,6 +299,13 @@ traceEventIO msg =   GHC.Foreign.withCString utf8 msg $ \(Ptr p) -> IO $ \s ->     case traceEvent# p s of s' -> (# s', () #)++-- | Like 'traceEvent', but emits the result of calling a function on its+-- argument.+--+-- @since 4.17.0.0+traceEventWith :: (a -> String) -> a -> a+traceEventWith f a = traceEvent (f a) a  -- $markers --

@@ -0,0 +1,45 @@+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE StandaloneKindSignatures #-}+{-# LANGUAGE Trustworthy #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  Foreign.C.ConstPtr+-- Copyright   :  (c) GHC Developers+-- License     :  BSD-style (see the file libraries/base/LICENSE)+--+-- Maintainer  :  ffi@haskell.org+-- Stability   :  provisional+-- Portability :  portable+--+-- This module provides typed @const@ pointers to foreign data. It is part+-- of the Foreign Function Interface (FFI).+--+-----------------------------------------------------------------------------++module Foreign.C.ConstPtr (+    ConstPtr(..)+) where++import GHC.Base+import GHC.Ptr+import GHC.Show++-- | A pointer with the C @const@ qualifier. For instance, an argument of type+-- @ConstPtr CInt@ would be marshalled as @const int*@.+--+-- While @const@-ness generally does not matter for @ccall@ imports (since+-- @const@ and non-@const@ pointers typically have equivalent calling+-- conventions), it does matter for @capi@ imports. See GHC #22043.+--+-- @since 4.18.0.0+--+type ConstPtr :: Type -> Type+type role ConstPtr phantom+newtype ConstPtr a = ConstPtr { unConstPtr :: Ptr a }+    deriving (Eq, Ord)++-- doesn't use record syntax+instance Show (ConstPtr a) where+    showsPrec d (ConstPtr p) = showParen (d > 10) $ showString "ConstPtr " . showsPrec 11 p

@@ -110,19 +110,10 @@  import {-# SOURCE #-} GHC.IO.Encoding import qualified GHC.Foreign as GHC+import GHC.Foreign (CString, CStringLen)  ----------------------------------------------------------------------------- -- Strings---- representation of strings in C--- ---------------------------------- | A C string is a reference to an array of C characters terminated by NUL.-type CString    = Ptr CChar---- | A string with explicit length information in bytes instead of a--- terminating NUL (allowing NUL characters in the middle of the string).-type CStringLen = (Ptr CChar, Int)  -- exported functions -- ------------------

@@ -21,6 +21,8 @@ -- ----------------------------------------------------------------------------- +#include <ghcplatform.h>+ module Foreign.C.Types         ( -- * Representations of C types           -- $ctypes@@ -176,9 +178,16 @@ -- | Haskell type representing the C @wchar_t@ type. -- /(The concrete types of "Foreign.C.Types#platform" are platform-specific.)/ INTEGRAL_TYPE(CWchar,"wchar_t",HTYPE_WCHAR_T)++#if defined(HTYPE_SIG_ATOMIC_T) -- | Haskell type representing the C @sig_atomic_t@ type. -- /(The concrete types of "Foreign.C.Types#platform" are platform-specific.)/+-- See Note [Lack of signals on wasm32-wasi]. INTEGRAL_TYPE(CSigAtomic,"sig_atomic_t",HTYPE_SIG_ATOMIC_T)+#else+newtype CSigAtomic = CSigAtomic Int32+    deriving newtype (Read, Show, ARITHMETIC_CLASSES, INTEGRAL_CLASSES, Ix)+#endif  -- | Haskell type representing the C @clock_t@ type. -- /(The concrete types of "Foreign.C.Types#platform" are platform-specific.)/@@ -259,4 +268,3 @@   corresponding bitwise operation in C on @t@.  -}-

@@ -38,11 +38,16 @@ -- -- ^Turns a plain memory reference into a foreign object by -- associating a finalizer - given by the monadic operation - with the--- reference.  The storage manager will start the finalizer, in a--- separate thread, some time after the last reference to the--- 'ForeignPtr' is dropped.  There is no guarantee of promptness, and+-- reference.+--+-- When finalization is triggered by GC, the storage manager will start the+-- finalizer, in a separate thread, some time after the last reference to the+-- @ForeignPtr@ is dropped.  There is __no guarantee of promptness__, and -- in fact there is no guarantee that the finalizer will eventually--- run at all.+-- run at all for GC-triggered finalization.+--+-- When finalization is triggered by explicitly calling @finalizeForeignPtr@,+-- the finalizer will run immediately on the current Haskell thread. -- -- Note that references from a finalizer do not necessarily prevent -- another object from being finalized.  If A's finalizer refers to B

@@ -76,6 +76,15 @@ import GHC.List import GHC.Base +{- Note [Specialising array operations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The functions in this module are all overloaded, and specialising them+is sometimes crucial for performance.  So they all have++* An INLINE pragma, so they outright inline+* An INLINEABLE pragma, so they can be specialised to the call site+-}+ -- allocation -- ---------- @@ -83,29 +92,34 @@ -- (like 'Foreign.Marshal.Alloc.malloc', but for multiple elements). -- mallocArray :: forall a . Storable a => Int -> IO (Ptr a)+{-# INLINE mallocArray #-} mallocArray  size = mallocBytes (size * sizeOf (undefined :: a))  -- |Like 'mallocArray', but add an extra position to hold a special -- termination element. -- mallocArray0      :: Storable a => Int -> IO (Ptr a)+{-# INLINE mallocArray0 #-} mallocArray0 size  = mallocArray (size + 1)  -- |Like 'mallocArray', but allocated memory is filled with bytes of value zero. -- callocArray :: forall a . Storable a => Int -> IO (Ptr a)+{-# INLINE callocArray #-} callocArray size = callocBytes (size * sizeOf (undefined :: a))  -- |Like 'callocArray0', but allocated memory is filled with bytes of value -- zero. -- callocArray0 :: Storable a => Int -> IO (Ptr a)+{-# INLINE callocArray0 #-} callocArray0 size  = callocArray (size + 1)  -- |Temporarily allocate space for the given number of elements -- (like 'Foreign.Marshal.Alloc.alloca', but for multiple elements). -- allocaArray :: forall a b . Storable a => Int -> (Ptr a -> IO b) -> IO b+{-# INLINE allocaArray #-} allocaArray size = allocaBytesAligned (size * sizeOf (undefined :: a))                                       (alignment (undefined :: a)) @@ -121,11 +135,13 @@ -- |Adjust the size of an array -- reallocArray :: forall a . Storable a => Ptr a -> Int -> IO (Ptr a)+{-# INLINE reallocArray #-} reallocArray ptr size = reallocBytes ptr (size * sizeOf (undefined :: a))  -- |Adjust the size of an array including an extra position for the end marker. -- reallocArray0          :: Storable a => Ptr a -> Int -> IO (Ptr a)+{-# INLINE reallocArray0 #-} reallocArray0 ptr size  = reallocArray ptr (size + 1)  @@ -136,6 +152,7 @@ -- is tail-recursive and so uses constant stack space. -- peekArray          :: Storable a => Int -> Ptr a -> IO [a]+{-# INLINEABLE peekArray #-} peekArray size ptr | size <= 0 = return []                  | otherwise = f (size-1) []   where@@ -145,6 +162,7 @@ -- |Convert an array terminated by the given end marker into a Haskell list -- peekArray0            :: (Storable a, Eq a) => a -> Ptr a -> IO [a]+{-# INLINEABLE peekArray0 #-} peekArray0 marker ptr  = do   size <- lengthArray0 marker ptr   peekArray size ptr@@ -152,6 +170,7 @@ -- |Write the list elements consecutive into memory -- pokeArray :: Storable a => Ptr a -> [a] -> IO ()+{-# INLINEABLE pokeArray #-} pokeArray ptr vals0 = go vals0 0#   where go [] _          = return ()         go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)@@ -160,6 +179,7 @@ -- given marker element -- pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO ()+{-# INLINEABLE pokeArray0 #-} pokeArray0 marker ptr vals0 = go vals0 0#   where go [] n#         = pokeElemOff ptr (I# n#) marker         go (val:vals) n# = do pokeElemOff ptr (I# n#) val; go vals (n# +# 1#)@@ -172,6 +192,7 @@ -- (like 'Foreign.Marshal.Utils.new', but for multiple elements). -- newArray      :: Storable a => [a] -> IO (Ptr a)+{-# INLINEABLE newArray #-} newArray vals  = do   ptr <- mallocArray (length vals)   pokeArray ptr vals@@ -181,6 +202,7 @@ -- sequence of storable values, where the end is fixed by the given end marker -- newArray0             :: Storable a => a -> [a] -> IO (Ptr a)+{-# INLINEABLE newArray0 #-} newArray0 marker vals  = do   ptr <- mallocArray0 (length vals)   pokeArray0 marker ptr vals@@ -190,12 +212,14 @@ -- (like 'Foreign.Marshal.Utils.with', but for multiple elements). -- withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b+{-# INLINE withArray #-} withArray vals = withArrayLen vals . const  -- |Like 'withArray', but the action gets the number of values -- as an additional parameter -- withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b+{-# INLINEABLE withArrayLen #-} withArrayLen vals f  =   allocaArray len $ \ptr -> do       pokeArray ptr vals@@ -206,11 +230,13 @@ -- |Like 'withArray', but a terminator indicates where the array ends -- withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b+{-# INLINE withArray0 #-} withArray0 marker vals = withArrayLen0 marker vals . const  -- |Like 'withArrayLen', but a terminator indicates where the array ends -- withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b+{-# INLINEABLE withArrayLen0 #-} withArrayLen0 marker vals f  =   allocaArray0 len $ \ptr -> do       pokeArray0 marker ptr vals@@ -225,13 +251,15 @@ -- first array (destination); the copied areas may /not/ overlap -- copyArray :: forall a . Storable a => Ptr a -> Ptr a -> Int -> IO ()+{-# INLINE copyArray #-} copyArray dest src size = copyBytes dest src (size * sizeOf (undefined :: a))  -- |Copy the given number of elements from the second array (source) into the -- first array (destination); the copied areas /may/ overlap -- moveArray :: forall a . Storable a => Ptr a -> Ptr a -> Int -> IO ()-moveArray  dest src size = moveBytes dest src (size * sizeOf (undefined :: a))+{-# INLINE moveArray #-}+moveArray dest src size = moveBytes dest src (size * sizeOf (undefined :: a))   -- finding the length@@ -240,6 +268,7 @@ -- |Return the number of elements in an array, excluding the terminator -- lengthArray0            :: (Storable a, Eq a) => a -> Ptr a -> IO Int+{-# INLINEABLE lengthArray0 #-} lengthArray0 marker ptr  = loop 0   where     loop i = do@@ -253,4 +282,5 @@ -- |Advance a pointer into an array by the given number of elements -- advancePtr :: forall a . Storable a => Ptr a -> Int -> Ptr a+{-# INLINE advancePtr #-} advancePtr ptr i = ptr `plusPtr` (i * sizeOf (undefined :: a))

@@ -46,19 +46,18 @@    pooledNewArray0 ) where -import GHC.Base              ( Int, Monad(..), (.), liftM, not )+import GHC.Base              ( Int, Monad(..) ) import GHC.Err               ( undefined ) import GHC.Exception         ( throw ) import GHC.IO                ( IO, mask, catchAny )-import GHC.IORef             ( IORef, newIORef, readIORef, writeIORef )-import GHC.List              ( elem, length )+import GHC.List              ( length ) import GHC.Num               ( Num(..) )+import GHC.Real              ( fromIntegral ) -import Data.OldList          ( delete )-import Foreign.Marshal.Alloc ( mallocBytes, reallocBytes, free )+import Foreign.C.Types       ( CSize(..) ) import Foreign.Marshal.Array ( pokeArray, pokeArray0 )-import Foreign.Marshal.Error ( throwIf )-import Foreign.Ptr           ( Ptr, castPtr )+import Foreign.Marshal.Utils ( moveBytes )+import Foreign.Ptr           ( Ptr ) import Foreign.Storable      ( Storable(sizeOf, poke) )  --------------------------------------------------------------------------------@@ -68,20 +67,18 @@  -- | A memory pool. -newtype Pool = Pool (IORef [Ptr ()])+newtype Pool = Pool (Ptr ())  -- | Allocate a fresh memory pool.  newPool :: IO Pool-newPool = liftM Pool (newIORef [])+newPool = c_newArena  -- | Deallocate a memory pool and everything which has been allocated in the -- pool itself.  freePool :: Pool -> IO ()-freePool (Pool pool) = readIORef pool >>= freeAll-   where freeAll []     = return ()-         freeAll (p:ps) = free p >> freeAll ps+freePool = c_arenaFree  -- | Execute an action with a fresh memory pool, which gets automatically -- deallocated (including its contents) after the action has finished.@@ -108,11 +105,7 @@ -- | Allocate the given number of bytes of storage in the pool.  pooledMallocBytes :: Pool -> Int -> IO (Ptr a)-pooledMallocBytes (Pool pool) size = do-   ptr <- mallocBytes size-   ptrs <- readIORef pool-   writeIORef pool (ptr:ptrs)-   return (castPtr ptr)+pooledMallocBytes pool size = c_arenaAlloc pool (fromIntegral size)  -- | Adjust the storage area for an element in the pool to the given size of -- the required type.@@ -120,16 +113,15 @@ pooledRealloc :: forall a . Storable a => Pool -> Ptr a -> IO (Ptr a) pooledRealloc pool ptr = pooledReallocBytes pool ptr (sizeOf (undefined :: a)) --- | Adjust the storage area for an element in the pool to the given size.+-- | Adjust the storage area for an element in the pool to the given size. Note+-- that the previously allocated space is still retained in the same 'Pool' and+-- will only be freed when the entire 'Pool' is freed.  pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a)-pooledReallocBytes (Pool pool) ptr size = do-   let cPtr = castPtr ptr-   _ <- throwIf (not . (cPtr `elem`)) (\_ -> "pointer not in pool") (readIORef pool)-   newPtr <- reallocBytes cPtr size-   ptrs <- readIORef pool-   writeIORef pool (newPtr : delete cPtr ptrs)-   return (castPtr newPtr)+pooledReallocBytes pool ptr size = do+   newPtr <- pooledMallocBytes pool size+   moveBytes newPtr ptr size+   return newPtr  -- | Allocate storage for the given number of elements of a storable type in the -- pool.@@ -185,3 +177,9 @@    ptr <- pooledMallocArray0 pool (length vals)    pokeArray0 marker ptr vals    return ptr++foreign import ccall unsafe "newArena" c_newArena :: IO Pool++foreign import ccall unsafe "arenaAlloc" c_arenaAlloc :: Pool -> CSize -> IO (Ptr a)++foreign import ccall unsafe "arenaFree" c_arenaFree :: Pool -> IO ()

@@ -1,5 +1,8 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE CPP, NoImplicitPrelude, ScopedTypeVariables, BangPatterns #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE StandaloneDeriving #-}  ----------------------------------------------------------------------------- -- |@@ -42,6 +45,7 @@ import GHC.Ptr import GHC.Base import GHC.Fingerprint.Type+import Foreign.C.ConstPtr import Data.Bits import GHC.Real @@ -280,3 +284,5 @@        pokeW64 (castPtr p0) 8 high       pokeW64 (castPtr p0 `plusPtr` 8) 8 low++deriving newtype instance Storable (ConstPtr a)

@@ -49,6 +49,7 @@   where  import GHC.Prim+import GHC.Prim.PtrEq ( unsafePtrEquality# ) import GHC.Types ( Type, UnliftedType, isTrue# ) import Unsafe.Coerce ( unsafeCoerce, unsafeCoerceUnlifted ) default ()@@ -148,8 +149,8 @@  -- | Compare the underlying pointers of two arrays of arrays. sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#-sameArrayArray# (ArrayArray# arr1) (ArrayArray# arr2) = reallyUnsafePtrEquality# arr1 arr2+sameArrayArray# (ArrayArray# arr1) (ArrayArray# arr2) = unsafePtrEquality# arr1 arr2  -- | Compare the underlying pointers of two mutable arrays of arrays. sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#-sameMutableArrayArray# (MutableArrayArray# marr1) (MutableArrayArray# marr2 ) = reallyUnsafePtrEquality# marr1 marr2+sameMutableArrayArray# (MutableArrayArray# marr1) (MutableArrayArray# marr2 ) = unsafePtrEquality# marr1 marr2

@@ -17,7 +17,7 @@                 copied to make GHC.Prim.hi  GHC.Base        Classes: Eq, Ord, Functor, Monad-                Types:   list, (), Int, Bool, Ordering, Char, String+                Types:   List, (), Int, Bool, Ordering, Char, String  Data.Tuple      Types: tuples, plus instances for GHC.Base classes @@ -65,6 +65,8 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DataKinds #-}+{-# LANGUAGE EmptyCase #-}+{-# LANGUAGE EmptyDataDeriving #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE NoImplicitPrelude #-}@@ -122,7 +124,7 @@ import GHC.Maybe import {-# SOURCE #-} GHC.IO (mkUserError, mplusIO) -import GHC.Tuple (Solo (..))     -- Note [Depend on GHC.Tuple]+import GHC.Tuple (Solo (MkSolo)) -- Note [Depend on GHC.Tuple] import GHC.Num.Integer ()        -- Note [Depend on GHC.Num.Integer]  -- for 'class Semigroup'@@ -162,10 +164,6 @@   Failed to load interface for ‘GHC.Num.Integer’     There are files missing in the ‘ghc-bignum’ package, -Note that this is only a problem with the make-based build system. Hadrian-doesn't interleave compilation of modules from separate packages and respects-the dependency between `base` and `ghc-bignum`.- To ensure that GHC.Num.Integer is there, we must ensure that there is a visible dependency on GHC.Num.Integer from every module in base.  We make GHC.Base depend on GHC.Num.Integer; and everything else either depends on GHC.Base,@@ -203,6 +201,37 @@ foldr = errorWithoutStackTrace "urk" #endif +-- | Uninhabited data type+--+-- @since 4.8.0.0+data Void deriving+  ( Eq      -- ^ @since 4.8.0.0+  , Ord     -- ^ @since 4.8.0.0+  )++-- | Since 'Void' values logically don't exist, this witnesses the+-- logical reasoning tool of \"ex falso quodlibet\".+--+-- >>> let x :: Either Void Int; x = Right 5+-- >>> :{+-- case x of+--     Right r -> r+--     Left l  -> absurd l+-- :}+-- 5+--+-- @since 4.8.0.0+absurd :: Void -> a+absurd a = case a of {}++-- | If 'Void' is uninhabited then any 'Functor' that holds only+-- values of type 'Void' is holding no values.+-- It is implemented in terms of @fmap absurd@.+--+-- @since 4.8.0.0+vacuous :: Functor f => f Void -> f a+vacuous = fmap absurd+ infixr 6 <>  -- | The class of semigroups (types with an associative binary operation).@@ -211,6 +240,12 @@ -- -- [Associativity] @x '<>' (y '<>' z) = (x '<>' y) '<>' z@ --+-- You can alternatively define `sconcat` instead of (`<>`), in which case the+-- laws are:+--+-- [Unit]: @'sconcat' ('pure' x) = x@+-- [Multiplication]: @'sconcat' ('join' xss) = 'sconcat' ('fmap' 'sconcat' xss)@+-- -- @since 4.9.0.0 class Semigroup a where         -- | An associative operation.@@ -218,6 +253,7 @@         -- >>> [1,2,3] <> [4,5,6]         -- [1,2,3,4,5,6]         (<>) :: a -> a -> a+        a <> b = sconcat (a :| [ b ])          -- | Reduce a non-empty list with '<>'         --@@ -248,7 +284,9 @@         stimes :: Integral b => b -> a -> a         stimes = stimesDefault +        {-# MINIMAL (<>) | sconcat #-} + -- | The class of monoids (types with an associative binary operation that -- has an identity).  Instances should satisfy the following: --@@ -257,6 +295,13 @@ -- [Associativity]  @x '<>' (y '<>' z) = (x '<>' y) '<>' z@ ('Semigroup' law) -- [Concatenation]  @'mconcat' = 'foldr' ('<>') 'mempty'@ --+-- You can alternatively define `mconcat` instead of `mempty`, in which case the+-- laws are:+--+-- [Unit]: @'mconcat' ('pure' x) = x@+-- [Multiplication]: @'mconcat' ('join' xss) = 'mconcat' ('fmap' 'mconcat' xss)@+-- [Subclass]: @'mconcat' ('toList' xs) = 'sconcat' xs@+-- -- The method names refer to the monoid of lists under concatenation, -- but there are many other instances. --@@ -271,7 +316,9 @@         --         -- >>> "Hello world" <> mempty         -- "Hello world"-        mempty  :: a+        mempty :: a+        mempty = mconcat []+        {-# INLINE mempty #-}          -- | An associative operation         --@@ -297,6 +344,8 @@         {-# INLINE mconcat #-}         -- INLINE in the hope of fusion with mconcat's argument (see !4890) +        {-# MINIMAL mempty | mconcat #-}+ -- | @since 4.9.0.0 instance Semigroup [a] where         (<>) = (++)@@ -312,6 +361,11 @@         mconcat xss = [x | xs <- xss, x <- xs] -- See Note: [List comprehensions and inlining] +-- | @since 4.9.0.0+instance Semigroup Void where+    a <> _ = a+    stimes _ a = a+ {- Note: [List comprehensions and inlining] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -363,12 +417,12 @@  -- | @since 4.15 instance Semigroup a => Semigroup (Solo a) where-  Solo a <> Solo b = Solo (a <> b)-  stimes n (Solo a) = Solo (stimes n a)+  MkSolo a <> MkSolo b = MkSolo (a <> b)+  stimes n (MkSolo a) = MkSolo (stimes n a)  -- | @since 4.15 instance Monoid a => Monoid (Solo a) where-  mempty = Solo mempty+  mempty = MkSolo mempty  -- | @since 4.9.0.0 instance (Semigroup a, Semigroup b) => Semigroup (a, b) where@@ -446,17 +500,17 @@  -- | @since 4.15 instance Applicative Solo where-  pure = Solo+  pure = MkSolo    -- Note: we really want to match strictly here. This lets us write,   -- for example,   --   -- forceSpine :: Foldable f => f a -> ()   -- forceSpine xs-  --   | Solo r <- traverse_ Solo xs+  --   | MkSolo r <- traverse_ MkSolo xs   --   = r-  Solo f <*> Solo x = Solo (f x)-  liftA2 f (Solo x) (Solo y) = Solo (f x y)+  MkSolo f <*> MkSolo x = MkSolo (f x)+  liftA2 f (MkSolo x) (MkSolo y) = MkSolo (f x y)  -- | For tuples, the 'Monoid' constraint on @a@ determines -- how the first values merge.@@ -473,7 +527,7 @@  -- | @since 4.15 instance Monad Solo where-  Solo x >>= f = f x+  MkSolo x >>= f = f x  -- | @since 4.9.0.0 instance Monoid a => Monad ((,) a) where@@ -505,6 +559,18 @@ instance (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) where     (u, v, w, a) >>= k = case k a of (u', v', w', b) -> (u <> u', v <> v', w <> w', b) +-- | @since 4.18.0.0+instance Functor ((,,,,) a b c d) where+    fmap f (a, b, c, d, e) = (a, b, c, d, f e)++-- | @since 4.18.0.0+instance Functor ((,,,,,) a b c d e) where+    fmap fun (a, b, c, d, e, f) = (a, b, c, d, e, fun f)++-- | @since 4.18.0.0+instance Functor ((,,,,,,) a b c d e f) where+    fmap fun (a, b, c, d, e, f, g) = (a, b, c, d, e, f, fun g)+ -- | @since 4.10.0.0 instance Semigroup a => Semigroup (IO a) where     (<>) = liftA2 (<>)@@ -583,6 +649,15 @@     -- The default definition is @'fmap' . 'const'@, but this may be     -- overridden with a more efficient version.     --+    -- ==== __Examples__+    --+    -- Perform a computation with 'Maybe' and replace the result with a+    -- constant value if it is 'Just':+    --+    -- >>> 'a' <$ Just 2+    -- Just 'a'+    -- >>> 'a' <$ Nothing+    -- Nothing     (<$)        :: a -> f b -> f a     (<$)        =  fmap . const @@ -739,10 +814,9 @@  -- | Lift a function to actions. -- Equivalent to Functor's `fmap` but implemented using only `Applicative`'s methods:--- `liftA f a = pure f <*> a`+-- @'liftA' f a = 'pure' f '<*>' a@ -- -- As such this function may be used to implement a `Functor` instance from an `Applicative` one.- -- -- ==== __Examples__ -- Using the Applicative instance for Lists:@@ -1026,12 +1100,12 @@  -- | @since 4.15 instance Functor Solo where-  fmap f (Solo a) = Solo (f a)+  fmap f (MkSolo a) = MkSolo (f a)    -- Being strict in the `Solo` argument here seems most consistent   -- with the concept behind `Solo`: always strict in the wrapper and lazy   -- in the contents.-  x <$ Solo _ = Solo x+  x <$ MkSolo _ = MkSolo x  -- | @since 2.01 instance Functor ((,) a) where@@ -1096,7 +1170,9 @@         some_v = liftA2 (:) v many_v  --- | @since 2.01+-- | Picks the leftmost 'Just' value, or, alternatively, 'Nothing'.+--+-- @since 2.01 instance Alternative Maybe where     empty = Nothing     Nothing <|> r = r@@ -1128,7 +1204,9 @@    mplus :: m a -> m a -> m a    mplus = (<|>) --- | @since 2.01+-- | Picks the leftmost 'Just' value, or, alternatively, 'Nothing'.+--+-- @since 2.01 instance MonadPlus Maybe  ---------------------------------------------@@ -1190,12 +1268,16 @@     {-# INLINE (>>) #-}     (>>) = (*>) --- | @since 2.01+-- | Combines lists by concatenation, starting from the empty list.+--+-- @since 2.01 instance Alternative [] where     empty = []     (<|>) = (++) --- | @since 2.01+-- | Combines lists by concatenation, starting from the empty list.+--+-- @since 2.01 instance MonadPlus []  {-@@ -1271,7 +1353,7 @@         -- when we disable the rule that expands (++) into foldr  -- The foldr/cons rule looks nice, but it can give disastrously--- bloated code when commpiling+-- bloated code when compiling --      array (a,b) [(1,2), (2,2), (3,2), ...very long list... ] -- i.e. when there are very very long literal lists -- So I've disabled it for now. We could have special cases@@ -1411,42 +1493,10 @@ -- Type Char and String ---------------------------------------------- --- | 'String' is an alias for a list of characters.------ String constants in Haskell are values of type 'String'.--- That means if you write a string literal like @"hello world"@,--- it will have the type @[Char]@, which is the same as @String@.------ __Note:__ You can ask the compiler to automatically infer different types--- with the @-XOverloadedStrings@ language extension, for example---  @"hello world" :: Text@. See t'Data.String.IsString' for more information.------ Because @String@ is just a list of characters, you can use normal list functions--- to do basic string manipulation. See "Data.List" for operations on lists.------ === __Performance considerations__------ @[Char]@ is a relatively memory-inefficient type.--- It is a linked list of boxed word-size characters, internally it looks something like:------ > ╭─────┬───┬──╮  ╭─────┬───┬──╮  ╭─────┬───┬──╮  ╭────╮--- > │ (:) │   │ ─┼─>│ (:) │   │ ─┼─>│ (:) │   │ ─┼─>│ [] │--- > ╰─────┴─┼─┴──╯  ╰─────┴─┼─┴──╯  ╰─────┴─┼─┴──╯  ╰────╯--- >         v               v               v--- >        'a'             'b'             'c'------ The @String@ "abc" will use @5*3+1 = 16@ (in general @5n+1@)--- words of space in memory.------ Furthermore, operations like '(++)' (string concatenation) are @O(n)@--- (in the left argument).+-- | A 'String' is a list of characters.  String constants in Haskell are values+-- of type 'String'. ----- For historical reasons, the @base@ library uses @String@ in a lot of places--- for the conceptual simplicity, but library code dealing with user-data--- should use the [text](https://hackage.haskell.org/package/text)--- package for Unicode text, or the the--- [bytestring](https://hackage.haskell.org/package/bytestring) package--- for binary data.+-- See "Data.List" for operations on lists. type String = [Char]  unsafeChr :: Int -> Char@@ -1610,12 +1660,18 @@     (>>)      = (*>)     (>>=)     = bindIO --- | @since 4.9.0.0+-- | Takes the first non-throwing 'IO' action\'s result.+-- 'empty' throws an exception.+--+-- @since 4.9.0.0 instance Alternative IO where     empty = failIO "mzero"     (<|>) = mplusIO --- | @since 4.9.0.0+-- | Takes the first non-throwing 'IO' action\'s result.+-- 'mzero' throws an exception.+--+-- @since 4.9.0.0 instance MonadPlus IO  returnIO :: a -> IO a

@@ -0,0 +1,28 @@+{-# LANGUAGE NoImplicitPrelude #-}++{-+This SOURCE-imported hs-boot module cuts a big dependency loop:++module ‘GHC.Stable’+imports module ‘GHC.Ptr’+imports module ‘Numeric’+imports module ‘GHC.Read’+imports module ‘GHC.Unicode’+imports module ‘GHC.Unicode.Internal.Char.UnicodeData.GeneralCategory’+imports module ‘GHC.Unicode.Internal.Bits’+imports module ‘GHC.ByteOrder’+imports module ‘GHC.Generics’+imports module ‘Data.Ord’+imports module ‘Foreign.Storable’+imports module ‘GHC.Stable’+-}++module GHC.ByteOrder where++import GHC.Types ()++data ByteOrder+    = BigEndian+    | LittleEndian++targetByteOrder :: ByteOrder

@@ -45,6 +45,7 @@         , yield         , labelThread         , mkWeakThreadId+        , listThreads          , ThreadStatus(..), BlockReason(..)         , threadStatus

@@ -65,12 +65,14 @@ import GHC.Conc.Windows (asyncRead, asyncWrite, asyncDoProc, asyncReadBA,                          asyncWriteBA, ConsoleEvent(..), win32ConsoleHandler,                          toWin32ConsoleEvent)-#else+#elif !defined(javascript_HOST_ARCH) import qualified GHC.Event.Thread as Event #endif  ensureIOManagerIsRunning :: IO ()-#if !defined(mingw32_HOST_OS)+#if defined(javascript_HOST_ARCH)+ensureIOManagerIsRunning = pure ()+#elif !defined(mingw32_HOST_OS) ensureIOManagerIsRunning = Event.ensureIOManagerIsRunning #else ensureIOManagerIsRunning = Windows.ensureIOManagerIsRunning@@ -89,7 +91,7 @@ #endif  ioManagerCapabilitiesChanged :: IO ()-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH) ioManagerCapabilitiesChanged = Event.ioManagerCapabilitiesChanged #else ioManagerCapabilitiesChanged = return ()@@ -103,7 +105,7 @@ -- that has been used with 'threadWaitRead', use 'closeFdWith'. threadWaitRead :: Fd -> IO () threadWaitRead fd-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)   | threaded  = Event.threadWaitRead fd #endif   | otherwise = IO $ \s ->@@ -119,7 +121,7 @@ -- that has been used with 'threadWaitWrite', use 'closeFdWith'. threadWaitWrite :: Fd -> IO () threadWaitWrite fd-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)   | threaded  = Event.threadWaitWrite fd #endif   | otherwise = IO $ \s ->@@ -133,7 +135,7 @@ -- in the file descriptor. threadWaitReadSTM :: Fd -> IO (Sync.STM (), IO ()) threadWaitReadSTM fd-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)   | threaded  = Event.threadWaitReadSTM fd #endif   | otherwise = do@@ -152,7 +154,7 @@ -- in the file descriptor. threadWaitWriteSTM :: Fd -> IO (Sync.STM (), IO ()) threadWaitWriteSTM fd-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)   | threaded  = Event.threadWaitWriteSTM fd #endif   | otherwise = do@@ -177,7 +179,7 @@             -> Fd            -- ^ File descriptor to close.             -> IO () closeFdWith close fd-#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)   | threaded  = Event.closeFdWith close fd #endif   | otherwise = close fd@@ -189,13 +191,16 @@ -- when the delay has expired, but the thread will never continue to -- run /earlier/ than specified. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- Consider using @Control.Concurrent.Thread.Delay.delay@ from @unbounded-delays@ package. threadDelay :: Int -> IO () threadDelay time #if defined(mingw32_HOST_OS)   | isWindowsNativeIO = Windows.threadDelay time   | threaded          = Windows.threadDelay time-#else-  | threaded          = Event.threadDelay time+#elif !defined(javascript_HOST_ARCH)+  | threaded  = Event.threadDelay time #endif   | otherwise         = IO $ \s ->         case time of { I# time# ->@@ -206,14 +211,19 @@ -- after a given number of microseconds. The caveats associated with -- 'threadDelay' also apply. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- registerDelay :: Int -> IO (TVar Bool)-registerDelay usecs+registerDelay _usecs #if defined(mingw32_HOST_OS)-  | isWindowsNativeIO = Windows.registerDelay usecs-  | threaded          = Windows.registerDelay usecs-#else-  | threaded          = Event.registerDelay usecs+  | isWindowsNativeIO = Windows.registerDelay _usecs+  | threaded          = Windows.registerDelay _usecs+#elif !defined(javascript_HOST_ARCH)+  | threaded          = Event.registerDelay _usecs #endif   | otherwise         = errorWithoutStackTrace "registerDelay: requires -threaded" +#if !defined(javascript_HOST_ARCH) foreign import ccall unsafe "rtsSupportsBoundThreads" threaded :: Bool+#endif

@@ -107,6 +107,9 @@ -- when the delay has expired, but the thread will never continue to -- run /earlier/ than specified. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- threadDelay :: Int -> IO () threadDelay time   | threaded  = waitForDelayEvent time@@ -117,6 +120,9 @@  -- | Set the value of returned TVar to True after a given number of -- microseconds. The caveats associated with threadDelay also apply.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes. -- registerDelay :: Int -> IO (TVar Bool) registerDelay usecs

@@ -4,6 +4,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE KindSignatures #-} {-# LANGUAGE Unsafe #-}  {-# OPTIONS_HADDOCK not-home #-}@@ -29,34 +30,44 @@  -- #not-home module GHC.Conc.Sync-        ( ThreadId(..)+        (+        -- * Threads+          ThreadId(..)         , showThreadId+        , myThreadId+        , killThread+        , throwTo+        , yield+        , labelThread+        , labelThreadByteArray#+        , mkWeakThreadId+        -- ** Queries+        , listThreads+        , threadLabel+        , ThreadStatus(..), BlockReason(..)+        , threadStatus+        , threadCapability          -- * Forking and suchlike         , forkIO         , forkIOWithUnmask         , forkOn         , forkOnWithUnmask++        -- * Capabilities         , numCapabilities         , getNumCapabilities         , setNumCapabilities         , getNumProcessors++        -- * Sparks         , numSparks         , childHandler-        , myThreadId-        , killThread-        , throwTo         , par         , pseq         , runSparks-        , yield-        , labelThread-        , mkWeakThreadId -        , ThreadStatus(..), BlockReason(..)-        , threadStatus-        , threadCapability-+        -- * PrimMVar         , newStablePtrPrimMVar, PrimMVar          -- * Allocation counter and quota@@ -101,15 +112,13 @@ import GHC.Base import {-# SOURCE #-} GHC.IO.Handle ( hFlush ) import {-# SOURCE #-} GHC.IO.StdHandles ( stdout )+import GHC.Encoding.UTF8 import GHC.Int import GHC.IO-import GHC.IO.Encoding.UTF8 import GHC.IO.Exception import GHC.Exception-import qualified GHC.Foreign import GHC.IORef import GHC.MVar-import GHC.Ptr import GHC.Real         ( fromIntegral ) import GHC.Show         ( Show(..), showParen, showString ) import GHC.Stable       ( StablePtr(..) )@@ -264,7 +273,7 @@ WARNING: Exceptions in the new thread will not be rethrown in the thread that created it. This means that you might be completely unaware of the problem if/when this happens.  You may want to use the-<hackage.haskell.org/package/async async> library instead.+<https://hackage.haskell.org/package/async async> library instead. -} forkIO :: IO () -> IO ThreadId forkIO action = IO $ \ s ->@@ -489,18 +498,19 @@ identifier will be used in the debugging output to make distinction of different threads easier (otherwise you only have the thread state object\'s address in the heap). It also emits an event to the RTS eventlog.--Other applications like the graphical Concurrent Haskell Debugger-(<http://www.informatik.uni-kiel.de/~fhu/chd/>) may choose to overload-'labelThread' for their purposes as well. -}- labelThread :: ThreadId -> String -> IO ()-labelThread (ThreadId t) str =-    GHC.Foreign.withCString utf8 str $ \(Ptr p) ->-    IO $ \ s ->-     case labelThread# t p s of s1 -> (# s1, () #)+labelThread t str =+    labelThreadByteArray# t (utf8EncodeByteArray# str) +-- | 'labelThreadByteArray#' sets the label of a thread to the given UTF-8+--  encoded string contained in a `ByteArray#`.+--+--  @since 4.18+labelThreadByteArray# :: ThreadId -> ByteArray# -> IO ()+labelThreadByteArray# (ThreadId t) str =+    IO $ \s -> case labelThread# t str s of s1 -> (# s1, () #)+ --      Nota Bene: 'pseq' used to be 'seq' --                 but 'seq' is now defined in GHC.Prim --@@ -529,6 +539,25 @@                       then (# s', () #)                       else p `seq` loop s' +-- | List the Haskell threads of the current process.+--+-- @since 4.18+listThreads :: IO [ThreadId]+listThreads = IO $ \s ->+    case listThreads# s of+      (# s', arr #) ->+        (# s', mapListArrayUnlifted ThreadId arr #)++mapListArrayUnlifted :: forall (a :: TYPE UnliftedRep) b. (a -> b) -> Array# a -> [b]+mapListArrayUnlifted f arr = go 0#+  where+    sz = sizeofArray# arr+    go i#+      | isTrue# (i# ==# sz) = []+      | otherwise = case indexArray# arr i# of+                      (# x #) -> f x : go (i# +# 1#)+{-# NOINLINE mapListArrayUnlifted #-}+ data BlockReason   = BlockedOnMVar         -- ^blocked on 'MVar'@@ -568,6 +597,7 @@            , Show -- ^ @since 4.3.0.0            ) +-- | Query the current execution status of a thread. threadStatus :: ThreadId -> IO ThreadStatus threadStatus (ThreadId t) = IO $ \s ->    case threadStatus# t s of@@ -598,6 +628,19 @@    case threadStatus# t s of      (# s', _, cap#, locked# #) -> (# s', (I# cap#, isTrue# (locked# /=# 0#)) #) +-- | Query the label of thread, returning 'Nothing' if the+-- thread's label has not been set.+--+-- @since 4.18+threadLabel :: ThreadId -> IO (Maybe String)+threadLabel (ThreadId t) = IO $ \s ->+    case threadLabel# t s of+      (# s', 1#, lbl #) ->+          let lbl' = utf8DecodeByteArray# lbl+          in (# s', Just lbl' #)+      (# s', 0#, _ #) -> (# s', Nothing #)+      _ -> error "threadLabel: impossible"+ -- | Make a weak pointer to a 'ThreadId'.  It can be important to do -- this if you want to hold a reference to a 'ThreadId' while still -- allowing the thread to receive the @BlockedIndefinitely@ family of@@ -622,10 +665,10 @@  data PrimMVar --- | Make a StablePtr that can be passed to the C function--- @hs_try_putmvar()@.  The RTS wants a 'StablePtr' to the underlying--- 'MVar#', but a 'StablePtr#' can only refer to lifted types, so we--- have to cheat by coercing.+-- | Make a 'StablePtr' that can be passed to the C function+-- @hs_try_putmvar()@.  The RTS wants a 'StablePtr' to the+-- underlying 'MVar#', but a 'StablePtr#' can only refer to+-- lifted types, so we have to cheat by coercing. newStablePtrPrimMVar :: MVar a -> IO (StablePtr PrimMVar) newStablePtrPrimMVar (MVar m) = IO $ \s0 ->   case makeStablePtr# (unsafeCoerce# m :: PrimMVar) s0 of@@ -690,12 +733,16 @@ returnSTM :: a -> STM a returnSTM x = STM (\s -> (# s, x #)) --- | @since 4.8.0.0+-- | Takes the first non-'retry'ing 'STM' action.+--+-- @since 4.8.0.0 instance Alternative STM where   empty = retry   (<|>) = orElse --- | @since 4.3.0.0+-- | Takes the first non-'retry'ing 'STM' action.+--+-- @since 4.3.0.0 instance MonadPlus STM  -- | Unsafely performs IO in the STM monad.  Beware: this is a highly

@@ -23,7 +23,8 @@           showThreadId,           ThreadStatus(..),           threadStatus,-          sharedCAF+          sharedCAF,+          labelThreadByteArray#         ) where  import GHC.Base@@ -68,3 +69,4 @@ showThreadId :: ThreadId -> String threadStatus :: ThreadId -> IO ThreadStatus sharedCAF :: a -> (Ptr a -> IO (Ptr a)) -> IO a+labelThreadByteArray# :: ThreadId -> ByteArray# -> IO ()

@@ -19,6 +19,9 @@  -- #not-home module GHC.Conc.Windows+#if defined(javascript_HOST_ARCH)+       () where+#else        ( ensureIOManagerIsRunning        , interruptIOManager @@ -95,12 +98,18 @@ -- when the delay has expired, but the thread will never continue to -- run /earlier/ than specified. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- threadDelay :: Int -> IO () threadDelay = POSIX.threadDelay <!> WINIO.threadDelay  -- | Set the value of returned TVar to True after a given number of -- microseconds. The caveats associated with threadDelay also apply. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- registerDelay :: Int -> IO (TVar Bool) registerDelay = POSIX.registerDelay <!> WINIO.registerDelay @@ -111,4 +120,4 @@ interruptIOManager :: IO () interruptIOManager = POSIX.interruptIOManager <!> WINIO.interruptIOManager -+#endif

@@ -0,0 +1,318 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE BangPatterns, MagicHash, UnboxedTuples, NoImplicitPrelude #-}+{-# OPTIONS_GHC -O2 -fno-warn-name-shadowing #-}++-- | Simple UTF-8 codecs supporting non-streaming encoding/decoding.+-- For encoding where codepoints may be broken across buffers,+-- see "GHC.IO.Encoding.UTF8".+--+-- This is one of several UTF-8 implementations provided by GHC; see Note+-- [GHC's many UTF-8 implementations] in "GHC.Encoding.UTF8" for an+-- overview.+--+module GHC.Encoding.UTF8+    ( -- * Decoding single characters+      utf8DecodeCharAddr#+    , utf8DecodeCharPtr+    , utf8DecodeCharByteArray#+      -- * Decoding strings+    , utf8DecodeByteArray#+    , utf8DecodeForeignPtr+      -- * Counting characters+    , utf8CountCharsByteArray#+      -- * Comparison+    , utf8CompareByteArray#+      -- * Encoding strings+    , utf8EncodePtr+    , utf8EncodeByteArray#+    , utf8EncodedLength+    ) where++import GHC.Types+import GHC.Base+import GHC.IO+import GHC.ST+import GHC.Word+import GHC.ForeignPtr+import GHC.Num+import GHC.Bits+import GHC.Real+import GHC.Ptr++{-+Note [GHC's many UTF-8 implementations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Currently GHC ships with at least five UTF-8 implementations:++a. the implementation used by GHC in `ghc-boot:GHC.Utils.Encoding`; this can be+   used at a number of types including `Addr#`, `ByteArray#`, `ForeignPtr`,+   `Ptr`, `ShortByteString`, and `ByteString`. Most of this can be removed in+   GHC 9.6+2, when the copies in `base` will become available to `ghc-boot`.++b. the copy of the `ghc-boot` definition now exported by `base:GHC.Encoding.UTF8`.+   This can be used at `Addr#`, `Ptr`, `ByteArray#`, and `ForeignPtr`.++c. the decoder used by `unpackCStringUtf8#` in `ghc-prim:GHC.CString`; this is+   specialised at `Addr#`.++d. the codec used by the IO subsystem in `base:GHC.IO.Encoding.UTF8`; this is+   specialised at `Addr#` but, unlike the above, supports recovery in the presence+   of partial codepoints (since in IO contexts codepoints may be broken across+   buffers)++e. the implementation provided by the `text` library++On its face, this seems a tad silly. On the other hand, these implementations do+materially differ from one another (e.g. in the types they support, the+detail in errors they can report, and the ability to recover from partial+codepoints). Consequently, it's quite unclear that further consolidation+would be worthwhile.++The most obvious opportunity is to move (b) into `ghc-prim` and use it to+implement (c) (namely `unpackCStringUtf8#` and friends). However, it's not+clear that this would be worthwhile as several of the types supported by (b)+are defined in `base`.+-}++-- We can't write the decoder as efficiently as we'd like without+-- resorting to unboxed extensions, unfortunately.  I tried to write+-- an IO version of this function, but GHC can't eliminate boxed+-- results from an IO-returning function.+--+-- We assume we can ignore overflow when parsing a multibyte character here.+-- To make this safe, we add extra sentinel bytes to unparsed UTF-8 sequences+-- before decoding them (see "GHC.Data.StringBuffer").++{-# INLINE utf8DecodeChar# #-}+-- | Decode a single codepoint from a byte buffer indexed by the given indexing+-- function.+utf8DecodeChar# :: (Int# -> Word#) -> (# Char#, Int# #)+utf8DecodeChar# indexWord8# =+  let !ch0 = word2Int# (indexWord8# 0#) in+  case () of+    _ | isTrue# (ch0 <=# 0x7F#) -> (# chr# ch0, 1# #)++      | isTrue# ((ch0 >=# 0xC0#) `andI#` (ch0 <=# 0xDF#)) ->+        let !ch1 = word2Int# (indexWord8# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        (# chr# (((ch0 -# 0xC0#) `uncheckedIShiftL#` 6#) +#+                  (ch1 -# 0x80#)),+           2# #)++      | isTrue# ((ch0 >=# 0xE0#) `andI#` (ch0 <=# 0xEF#)) ->+        let !ch1 = word2Int# (indexWord8# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        let !ch2 = word2Int# (indexWord8# 2#) in+        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else+        (# chr# (((ch0 -# 0xE0#) `uncheckedIShiftL#` 12#) +#+                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 6#)  +#+                  (ch2 -# 0x80#)),+           3# #)++     | isTrue# ((ch0 >=# 0xF0#) `andI#` (ch0 <=# 0xF8#)) ->+        let !ch1 = word2Int# (indexWord8# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        let !ch2 = word2Int# (indexWord8# 2#) in+        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else+        let !ch3 = word2Int# (indexWord8# 3#) in+        if isTrue# ((ch3 <# 0x80#) `orI#` (ch3 >=# 0xC0#)) then fail 3# else+        (# chr# (((ch0 -# 0xF0#) `uncheckedIShiftL#` 18#) +#+                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 12#) +#+                 ((ch2 -# 0x80#) `uncheckedIShiftL#` 6#)  +#+                  (ch3 -# 0x80#)),+           4# #)++      | otherwise -> fail 1#+  where+        -- all invalid sequences end up here:+        fail :: Int# -> (# Char#, Int# #)+        fail nBytes# = (# '\0'#, nBytes# #)+        -- '\xFFFD' would be the usual replacement character, but+        -- that's a valid symbol in Haskell, so will result in a+        -- confusing parse error later on.  Instead we use '\0' which+        -- will signal a lexer error immediately.++-- | Decode a single character at the given 'Addr#'.+utf8DecodeCharAddr# :: Addr# -> Int# -> (# Char#, Int# #)+utf8DecodeCharAddr# a# off# =+#if !MIN_VERSION_base(4,16,0)+    utf8DecodeChar# (\i# -> indexWord8OffAddr# a# (i# +# off#))+#else+    utf8DecodeChar# (\i# -> word8ToWord# (indexWord8OffAddr# a# (i# +# off#)))+#endif++-- | Decode a single codepoint starting at the given 'Ptr'.+utf8DecodeCharPtr :: Ptr Word8 -> (Char, Int)+utf8DecodeCharPtr !(Ptr a#) =+  case utf8DecodeCharAddr# a# 0# of+    (# c#, nBytes# #) -> ( C# c#, I# nBytes# )++-- | Decode a single codepoint starting at the given byte offset into a+-- 'ByteArray#'.+utf8DecodeCharByteArray# :: ByteArray# -> Int# -> (# Char#, Int# #)+utf8DecodeCharByteArray# ba# off# =+#if !MIN_VERSION_base(4,16,0)+    utf8DecodeChar# (\i# -> indexWord8Array# ba# (i# +# off#))+#else+    utf8DecodeChar# (\i# -> word8ToWord# (indexWord8Array# ba# (i# +# off#)))+#endif++{-# INLINE utf8Decode# #-}+utf8Decode# :: (IO ()) -> (Int# -> (# Char#, Int# #)) -> Int# -> IO [Char]+utf8Decode# retain decodeChar# len#+  = unpack 0#+  where+    unpack i#+        | isTrue# (i# >=# len#) = retain >> return []+        | otherwise =+            case decodeChar# i# of+              (# c#, nBytes# #) -> do+                rest <- unsafeDupableInterleaveIO $ unpack (i# +# nBytes#)+                return (C# c# : rest)++utf8DecodeForeignPtr :: ForeignPtr Word8 -> Int -> Int -> [Char]+utf8DecodeForeignPtr fp offset (I# len#)+  = unsafeDupablePerformIO $ do+      let !(Ptr a#) = unsafeForeignPtrToPtr fp `plusPtr` offset+      utf8Decode# (touchForeignPtr fp) (utf8DecodeCharAddr# a#) len#+-- Note that since utf8Decode# returns a thunk the lifetime of the+-- ForeignPtr actually needs to be longer than the lexical lifetime+-- withForeignPtr would provide here. That's why we use touchForeignPtr to+-- keep the fp alive until the last character has actually been decoded.++utf8DecodeByteArray# :: ByteArray# -> [Char]+utf8DecodeByteArray# ba#+  = unsafeDupablePerformIO $+      let len# = sizeofByteArray# ba# in+      utf8Decode# (return ()) (utf8DecodeCharByteArray# ba#) len#++utf8CompareByteArray# :: ByteArray# -> ByteArray# -> Ordering+utf8CompareByteArray# a1 a2 = go 0# 0#+   -- UTF-8 has the property that sorting by bytes values also sorts by+   -- code-points.+   -- BUT we use "Modified UTF-8" which encodes \0 as 0xC080 so this property+   -- doesn't hold and we must explicitly check this case here.+   -- Note that decoding every code point would also work but it would be much+   -- more costly.+   where+       !sz1 = sizeofByteArray# a1+       !sz2 = sizeofByteArray# a2+       go off1 off2+         | isTrue# ((off1 >=# sz1) `andI#` (off2 >=# sz2)) = EQ+         | isTrue# (off1 >=# sz1)                          = LT+         | isTrue# (off2 >=# sz2)                          = GT+         | otherwise =+#if !MIN_VERSION_base(4,16,0)+               let !b1_1 = indexWord8Array# a1 off1+                   !b2_1 = indexWord8Array# a2 off2+#else+               let !b1_1 = word8ToWord# (indexWord8Array# a1 off1)+                   !b2_1 = word8ToWord# (indexWord8Array# a2 off2)+#endif+               in case b1_1 of+                  0xC0## -> case b2_1 of+                     0xC0## -> go (off1 +# 1#) (off2 +# 1#)+#if !MIN_VERSION_base(4,16,0)+                     _      -> case indexWord8Array# a1 (off1 +# 1#) of+#else+                     _      -> case word8ToWord# (indexWord8Array# a1 (off1 +# 1#)) of+#endif+                        0x80## -> LT+                        _      -> go (off1 +# 1#) (off2 +# 1#)+                  _      -> case b2_1 of+#if !MIN_VERSION_base(4,16,0)+                     0xC0## -> case indexWord8Array# a2 (off2 +# 1#) of+#else+                     0xC0## -> case word8ToWord# (indexWord8Array# a2 (off2 +# 1#)) of+#endif+                        0x80## -> GT+                        _      -> go (off1 +# 1#) (off2 +# 1#)+                     _   | isTrue# (b1_1 `gtWord#` b2_1) -> GT+                         | isTrue# (b1_1 `ltWord#` b2_1) -> LT+                         | otherwise                     -> go (off1 +# 1#) (off2 +# 1#)++utf8CountCharsByteArray# :: ByteArray# -> Int+utf8CountCharsByteArray# ba = go 0# 0#+  where+    len# = sizeofByteArray# ba+    go i# n#+      | isTrue# (i# >=# len#) = I# n#+      | otherwise =+          case utf8DecodeCharByteArray# ba i# of+            (# _, nBytes# #) -> go (i# +# nBytes#) (n# +# 1#)++{-# INLINE utf8EncodeChar #-}+utf8EncodeChar :: (Int# -> Word8# -> State# s -> State# s)+               -> Char -> ST s Int+utf8EncodeChar write# c =+  let x = fromIntegral (ord c) in+  case () of+    _ | x > 0 && x <= 0x007f -> do+          write 0 x+          return 1+        -- NB. '\0' is encoded as '\xC0\x80', not '\0'.  This is so that we+        -- can have 0-terminated UTF-8 strings (see GHC.Base.unpackCStringUtf8).+      | x <= 0x07ff -> do+          write 0 (0xC0 .|. ((x `shiftR` 6) .&. 0x1F))+          write 1 (0x80 .|. (x .&. 0x3F))+          return 2+      | x <= 0xffff -> do+          write 0 (0xE0 .|. (x `shiftR` 12) .&. 0x0F)+          write 1 (0x80 .|. (x `shiftR` 6) .&. 0x3F)+          write 2 (0x80 .|. (x .&. 0x3F))+          return 3+      | otherwise -> do+          write 0 (0xF0 .|. (x `shiftR` 18))+          write 1 (0x80 .|. ((x `shiftR` 12) .&. 0x3F))+          write 2 (0x80 .|. ((x `shiftR` 6) .&. 0x3F))+          write 3 (0x80 .|. (x .&. 0x3F))+          return 4+  where+    {-# INLINE write #-}+    write (I# off#) (W# c#) = ST $ \s ->+#if !MIN_VERSION_base(4,16,0)+      case write# off# (narrowWord8# c#) s of+#else+      case write# off# (wordToWord8# c#) s of+#endif+        s -> (# s, () #)++utf8EncodePtr :: Ptr Word8 -> String -> IO ()+utf8EncodePtr (Ptr a#) str = go a# str+  where go !_   []   = return ()+        go a# (c:cs) = do+#if !MIN_VERSION_base(4,16,0)+          -- writeWord8OffAddr# was taking a Word#+          I# off# <- stToIO $ utf8EncodeChar (\i w -> writeWord8OffAddr# a# i (extendWord8# w)) c+#else+          I# off# <- stToIO $ utf8EncodeChar (writeWord8OffAddr# a#) c+#endif+          go (a# `plusAddr#` off#) cs++utf8EncodeByteArray# :: String -> ByteArray#+utf8EncodeByteArray# str = runRW# $ \s ->+  case utf8EncodedLength str         of { I# len# ->+  case newByteArray# len# s          of { (# s, mba# #) ->+  case go mba# 0# str                of { ST f_go ->+  case f_go s                        of { (# s, () #) ->+  case unsafeFreezeByteArray# mba# s of { (# _, ba# #) ->+  ba# }}}}}+  where+    go _ _ [] = return ()+    go mba# i# (c:cs) = do+#if !MIN_VERSION_base(4,16,0)+      -- writeWord8Array# was taking a Word#+      I# off# <- utf8EncodeChar (\j# w -> writeWord8Array# mba# (i# +# j#) (extendWord8# w)) c+#else+      I# off# <- utf8EncodeChar (\j# -> writeWord8Array# mba# (i# +# j#)) c+#endif+      go mba# (i# +# off#) cs++utf8EncodedLength :: String -> Int+utf8EncodedLength str = go 0 str+  where go !n [] = n+        go n (c:cs)+          | ord c > 0 && ord c <= 0x007f = go (n+1) cs+          | ord c <= 0x07ff = go (n+2) cs+          | ord c <= 0xffff = go (n+3) cs+          | otherwise       = go (n+4) cs

@@ -160,14 +160,14 @@     {-# INLINABLE enumFromThenTo #-}     enumFromThenTo x1 x2 y = map toEnum [fromEnum x1, fromEnum x2 .. fromEnum y] --- See Note [Stable Unfolding for list producers]-{-# INLINABLE boundedEnumFrom #-}+-- See Note [Inline Enum method helpers]+{-# INLINE boundedEnumFrom #-} -- Default methods for bounded enumerations boundedEnumFrom :: (Enum a, Bounded a) => a -> [a] boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)] --- See Note [Stable Unfolding for list producers]-{-# INLINABLE boundedEnumFromThen #-}+-- See Note [Inline Enum method helpers]+{-# INLINE boundedEnumFromThen #-} boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a] boundedEnumFromThen n1 n2   | i_n2 >= i_n1  = map toEnum [i_n1, i_n2 .. fromEnum (maxBound `asTypeOf` n1)]@@ -176,11 +176,55 @@     i_n1 = fromEnum n1     i_n2 = fromEnum n2 -{--Note [Stable Unfolding for list producers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+{- Note [Stable Unfolding for list producers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The INLINABLE/INLINE pragmas ensure that we export stable (unoptimised) unfoldings in the interface file so we can do list fusion at usage sites.++Related tickets: #15185, #8763, #18178.++Note [Inline Enum method helpers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The overloaded `numericEnumFrom` functions are used to abbreviate Enum+instances. We call them "method helpers".  For example, in GHC.Float:++  numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]+  mnumericEnumFromTo = ...blah...++  instance  Enum Double  where+     ...+    enumFromTo = numericEnumFromTo++Similarly with the overloaded `boundedEnumFrom` functions. E.g. in GHC.Word++  boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]+  boundedEnumFrom n = map toEnum [fromEnum n .. fromEnum (maxBound `asTypeOf` n)]++  instance Enum Word8 where+    ...+    enumFrom            = boundedEnumFrom++In both cases, it is super-important to specialise these overloaded+helper function (`numericEnumFromTo`, `boundedEnumFrom` etc) to the+particular type of the instance, else every use of that instance will+be inefficient.++Moreover (see Note [Stable Unfolding for list producers]) the helper+function is a list producer, so we want it to have a stable unfolding+to support fusion.++So we attach an INLINE pragma to them.++Alternatives might be+* An `INLINABLE` pragma on `numericEnumFromTo`, relying on the+  specialiser to create a specialised version.  But (a) if the+  instance method is marked INLINE we may get spurious INLINE+  loop-breaker warnings (#21343), and (b) specialision gains no extra+  sharing, because there is just one call at each type.++* Using `inline` at the call site+    enumFromTo = inline numericEnumFromTo+  But that means remembering to do this in multiple places. -}  ------------------------------------------------------------------------@@ -235,19 +279,19 @@     enumFromThenTo () () () = let many = ():many in many  instance Enum a => Enum (Solo a) where-    succ (Solo a) = Solo (succ a)-    pred (Solo a) = Solo (pred a)+    succ (MkSolo a) = MkSolo (succ a)+    pred (MkSolo a) = MkSolo (pred a) -    toEnum x = Solo (toEnum x)+    toEnum x = MkSolo (toEnum x) -    fromEnum (Solo x) = fromEnum x-    enumFrom (Solo x) = [Solo a | a <- enumFrom x]-    enumFromThen (Solo x) (Solo y) =-      [Solo a | a <- enumFromThen x y]-    enumFromTo (Solo x) (Solo y) =-      [Solo a | a <- enumFromTo x y]-    enumFromThenTo (Solo x) (Solo y) (Solo z) =-      [Solo a | a <- enumFromThenTo x y z]+    fromEnum (MkSolo x) = fromEnum x+    enumFrom (MkSolo x) = [MkSolo a | a <- enumFrom x]+    enumFromThen (MkSolo x) (MkSolo y) =+      [MkSolo a | a <- enumFromThen x y]+    enumFromTo (MkSolo x) (MkSolo y) =+      [MkSolo a | a <- enumFromTo x y]+    enumFromThenTo (MkSolo x) (MkSolo y) (MkSolo z) =+      [MkSolo a | a <- enumFromThenTo x y z]  deriving instance Bounded a => Bounded (Solo a) -- Report requires instances up to 15

@@ -1,5 +1,6 @@ {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE CPP #-}  -- ---------------------------------------------------------------------------- -- | This module provides scalable event notification for file@@ -10,6 +11,9 @@ -- ----------------------------------------------------------------------------  module GHC.Event+#if defined(javascript_HOST_ARCH)+    ( ) where+#else     ( -- * Types       EventManager     , TimerManager@@ -44,3 +48,4 @@                                updateTimeout, unregisterTimeout, TimerManager) import GHC.Event.Thread (getSystemEventManager, getSystemTimerManager) +#endif

@@ -26,6 +26,7 @@     , setNonBlockingFD     ) where +#include <ghcplatform.h> #include "EventConfig.h"  import GHC.Base@@ -145,6 +146,10 @@ io_MANAGER_WAKEUP = 0xff io_MANAGER_DIE    = 0xfe +#if !defined(HAVE_SIGNAL_H)+readControlMessage :: Control -> Fd -> IO ControlMessage+readControlMessage _ _ = errorWithoutStackTrace "readControlMessage"+#else foreign import ccall "__hscore_sizeof_siginfo_t"     sizeof_siginfo_t :: CSize @@ -180,6 +185,7 @@ #else             4096 #endif+#endif  sendWakeup :: Control -> IO () #if defined(HAVE_EVENTFD)@@ -229,5 +235,10 @@    c_eventfd_write :: CInt -> CULLong -> IO CInt #endif +#if defined(wasm32_HOST_ARCH)+c_setIOManagerWakeupFd :: CInt -> IO ()+c_setIOManagerWakeupFd _ = pure ()+#else foreign import ccall unsafe "setIOManagerWakeupFd"    c_setIOManagerWakeupFd :: CInt -> IO ()+#endif

@@ -1,7 +1,13 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE BangPatterns, NoImplicitPrelude #-} +#include <ghcplatform.h>+ module GHC.Event.Thread+#if defined(javascript_HOST_ARCH)+    ( ) where+#else     ( getSystemEventManager     , getSystemTimerManager     , ensureIOManagerIsRunning@@ -15,6 +21,8 @@     , registerDelay     , blockedOnBadFD -- used by RTS     ) where++ -- TODO: Use new Windows I/O manager import Control.Exception (finally, SomeException, toException) import Data.Foldable (forM_, mapM_, sequence_)@@ -55,6 +63,10 @@ -- There is no guarantee that the thread will be rescheduled promptly -- when the delay has expired, but the thread will never continue to -- run /earlier/ than specified.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- threadDelay :: Int -> IO () threadDelay usecs = mask_ $ do   mgr <- getSystemTimerManager@@ -65,6 +77,9 @@ -- | Set the value of returned TVar to True after a given number of -- microseconds. The caveats associated with threadDelay also apply. --+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- registerDelay :: Int -> IO (TVar Bool) registerDelay usecs = do   t <- atomically $ newTVar False@@ -414,9 +429,19 @@               tid <- restartPollLoop mgr i               writeIOArray eventManagerArray i (Just (tid,mgr)) +#if defined(wasm32_HOST_ARCH)+c_setIOManagerControlFd :: CUInt -> CInt -> IO ()+c_setIOManagerControlFd _ _ = pure ()++c_setTimerManagerControlFd :: CInt -> IO ()+c_setTimerManagerControlFd _ = pure ()+#else -- Used to tell the RTS how it can send messages to the I/O manager. foreign import ccall unsafe "setIOManagerControlFd"    c_setIOManagerControlFd :: CUInt -> CInt -> IO ()  foreign import ccall unsafe "setTimerManagerControlFd"    c_setTimerManagerControlFd :: CInt -> IO ()+#endif++#endif

@@ -7,6 +7,9 @@  -- TODO: use the new Windows IO manager module GHC.Event.TimerManager+#if defined(javascript_HOST_ARCH)+    () where+#else     ( -- * Types       TimerManager @@ -212,6 +215,10 @@ -- returned 'TimeoutKey' can be used to later unregister or update the -- timeout.  The timeout is automatically unregistered after the given -- time has passed.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- registerTimeout :: TimerManager -> Int -> TimeoutCallback -> IO TimeoutKey registerTimeout mgr us cb = do   !key <- newUnique (emUniqueSource mgr)@@ -231,6 +238,10 @@  -- | Update an active timeout to fire in the given number of -- microseconds.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- updateTimeout :: TimerManager -> TimeoutKey -> Int -> IO () updateTimeout mgr (TK key) us = do   expTime <- expirationTime us@@ -253,3 +264,5 @@                       -- minimum element didn't change.                       t0 /= t1                     _ -> True++#endif

@@ -68,7 +68,7 @@     module GHC.Event.Windows.ConsoleEvent ) where --- define DEBUG 1+-- #define DEBUG 1  -- #define DEBUG_TRACE 1 @@ -853,6 +853,10 @@ -- The timeout is automatically unregistered when it fires. -- -- The 'TimeoutCallback' will not be called more than once.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- {-# NOINLINE registerTimeout #-} registerTimeout :: Manager -> Int -> TimeoutCallback -> IO TimeoutKey registerTimeout mgr@Manager{..} uSrelTime cb = do@@ -866,6 +870,10 @@ -- | Update an active timeout to fire in the given number of seconds (from the -- time 'updateTimeout' is called), instead of when it was going to fire. -- This has no effect if the timeout has already fired.+--+-- Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes.+-- updateTimeout :: Manager -> TimeoutKey -> Seconds -> IO () updateTimeout mgr (TK key) relTime = do     now <- getTime (mgrClock mgr)@@ -1031,7 +1039,7 @@ -- before adding something to the work queue. -- -- Thread safety: This function atomically replaces outstanding events with--- a pointer to nullReq. This means it's safe (but potentially wastefull) to+-- a pointer to nullReq. This means it's safe (but potentially wasteful) to -- have two concurrent or parallel invocations on the same array. processCompletion :: Manager -> Int -> Maybe Seconds -> IO (Bool, Maybe Seconds) processCompletion Manager{..} n delay = do

@@ -263,7 +263,7 @@ -- | Tag type for @LPOVERLAPPED@. data OVERLAPPED --- | Tag type for the extended version of @OVERLAPPED@ containg some book+-- | Tag type for the extended version of @OVERLAPPED@ containing some book --   keeping information. data HASKELL_OVERLAPPED @@ -305,7 +305,7 @@ -- | Allocate a new -- <http://msdn.microsoft.com/en-us/library/windows/desktop/ms684342%28v=vs.85%29.aspx -- OVERLAPPED> structure on the unmanaged heap. This also zeros the memory to--- prevent the values inside the struct to be incorrectlt interpreted as data+-- prevent the values inside the struct to be incorrectly interpreted as data -- payload. -- -- We extend the overlapped structure with some extra book keeping information@@ -361,7 +361,7 @@ -- [2] https://docs.microsoft.com/en-us/windows/win32/sync/synchronization-and-overlapped-input-and-output -- -- As such we need to annotate all NativeHandles with a Boolean to indicate--- wether it's an asynchronous handle or not.+-- whether it's an asynchronous handle or not. -- This allows us to manually wait for the completion instead of relying -- on the I/O system to do the right thing.  As we have been using the -- buffers in async mode we may not have moved the file pointer on the kernel

@@ -19,6 +19,8 @@ interruptIOManager :: IO () interruptIOManager = interruptSystemManager +-- | Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes. threadDelay :: Int -> IO () threadDelay usecs = mask_ $ do     m <- newEmptyIOPort@@ -26,6 +28,8 @@     reg <- registerTimeout mgr usecs $ writeIOPort m () >> return ()     readIOPort m `onException` unregisterTimeout mgr reg +-- | Be careful not to exceed @maxBound :: Int@, which on 32-bit machines is only+-- 2147483647 μs, less than 36 minutes. registerDelay :: Int -> IO (TVar Bool) registerDelay usecs = do     t <- newTVarIO False

@@ -5,7 +5,7 @@            , RecordWildCards            , PatternSynonyms   #-}-{-# LANGUAGE TypeInType #-}+{-# LANGUAGE DataKinds, PolyKinds #-} {-# OPTIONS_HADDOCK not-home #-}  -----------------------------------------------------------------------------

@@ -143,6 +143,9 @@     displayException :: e -> String     displayException = show +-- | @since 4.8.0.0+instance Exception Void+ -- | @since 3.0 instance Exception SomeException where     toException se = se

@@ -48,6 +48,7 @@         -- ** Pointer comparison operations         -- See `Note [Pointer comparison operations]` in primops.txt.pp         reallyUnsafePtrEquality,+        unsafePtrEquality#,         eqStableName#,         sameArray#,         sameMutableArray#,@@ -59,6 +60,7 @@         sameMutVar#,         sameTVar#,         sameIOPort#,+        samePromptTag#,          -- ** Compat wrapper         atomicModifyMutVar#,

@@ -43,7 +43,7 @@ fingerprintFingerprints :: [Fingerprint] -> Fingerprint fingerprintFingerprints fs = unsafeDupablePerformIO $   withArrayLen fs $ \len p ->-    fingerprintData (castPtr p) (len * sizeOf (head fs))+    fingerprintData (castPtr p) (len * sizeOf (undefined :: Fingerprint))  fingerprintData :: Ptr Word8 -> Int -> IO Fingerprint fingerprintData buf len =

@@ -335,6 +335,9 @@ -- -- >>> 0/0 * (recip 0/0 :: Float) -- NaN+--+-- Additionally, because of @NaN@ this instance does not obey the left-inverse+-- law for 'toRational'/'fromRational'. instance  Fractional Float  where     (/) x y             =  divideFloat x y     {-# INLINE fromRational #-}@@ -342,7 +345,8 @@     recip x             =  1.0 / x  rationalToFloat :: Integer -> Integer -> Float-{-# NOINLINE [1] rationalToFloat #-}+{-# NOINLINE [0] rationalToFloat #-}+-- Re NOINLINE pragma, see Note [realToFrac natural-to-float] rationalToFloat n 0     | n == 0        = 0/0     | n < 0         = (-1)/0@@ -564,6 +568,9 @@ -- -- >>> 0/0 * (recip 0/0 :: Double) -- NaN+--+-- Additionally, because of @NaN@ this instance does not obey the left-inverse+-- law for 'toRational'/'fromRational'. instance  Fractional Double  where     (/) x y             =  divideDouble x y     {-# INLINE fromRational #-}@@ -571,7 +578,8 @@     recip x             =  1.0 / x  rationalToDouble :: Integer -> Integer -> Double-{-# NOINLINE [1] rationalToDouble #-}+{-# NOINLINE [0] rationalToDouble #-}+-- Re NOINLINE pragma, see Note [realToFrac natural-to-float] rationalToDouble n 0     | n == 0        = 0/0     | n < 0         = (-1)/0@@ -1482,6 +1490,25 @@  A few more details in #2251, and the patch message "Add RULES for realToFrac from Int".++Note [realToFrac natural-to-float]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider (realToFrac @Natural @Float ..dicts.. (NS lit#))+We want to constant-fold this.  For many types this is guaranteed+by a RULE for realToFrac: eg. RULE "realToFrac/Float->Double" above.++In case there is a similar rule, we do not inline realToFrac in stage 2.+But for whatever reason, there is no such RULE for Natural.  So in stage 1+we end up with+    rationalToFloat (integerFromNatural (NS lit))+and that turns into+    rationalToFloat (IS lit#) (IS 1#)++Now we'd have a BUILTIN constant folding rule for rationalToFloat; but+to allow that rule to fire reliably we should delay inlining rationalToFloat+until stage 0.  (It may get an inlining from CPR analysis.)++Hence the NOINLINE[0] rationalToFloat, and similarly rationalToDouble. -}  -- Utils@@ -1613,22 +1640,3 @@  "Word# -> Natural -> Double#"   forall x. naturalToDouble# (NS x) = word2Double# x #-}---- We don't have word64ToFloat/word64ToDouble primops (#23908), only--- word2Float/word2Double, so we can only perform these transformations when--- word-size is 64-bit.-#if WORD_SIZE_IN_BITS == 64-{-# RULES--"Int64# -> Integer -> Float#"-  forall x. integerToFloat# (integerFromInt64# x) = int2Float# (int64ToInt# x)--"Int64# -> Integer -> Double#"-  forall x. integerToDouble# (integerFromInt64# x) = int2Double# (int64ToInt# x)--"Word64# -> Integer -> Float#"-  forall x. integerToFloat# (integerFromWord64# x) = word2Float# (word64ToWord# x)--"Word64# -> Integer -> Double#"-  forall x. integerToDouble# (integerFromWord64# x) = word2Double# (word64ToWord# x) #-}-#endif

@@ -19,6 +19,7 @@  module GHC.Foreign (     -- * C strings with a configurable encoding+    CString, CStringLen,      -- conversion of C strings into Haskell strings     --@@ -74,8 +75,11 @@             | otherwise    = const (return ())  --- These definitions are identical to those in Foreign.C.String, but copied in here to avoid a cycle:+-- | A C string is a reference to an array of C characters terminated by NUL. type CString    = Ptr CChar++-- | A string with explicit length information in bytes instead of a+-- terminating NUL (allowing NUL characters in the middle of the string). type CStringLen = (Ptr CChar, Int)  -- exported functions@@ -301,7 +305,7 @@ first to the size check failing and *then* call the continuation. Making this evident to the compiler avoids historic space leaks. -In a previous interation of this code we had a pattern that, somewhat simplified,+In a previous iteration of this code we had a pattern that, somewhat simplified, looked like this:  go :: State -> (State -> IO a) -> IO a@@ -323,6 +327,6 @@ for `action` until `action` returns. Which in turn keeps alive the *whole* lazy list via `action` until the action has fully run. This went wrong in #20107, where the continuation kept an entire lazy bytestring alive-rather than allowing it to be incrementaly consumed and collected.+rather than allowing it to be incrementally consumed and collected. -} 

@@ -237,12 +237,17 @@ -- -- ^Turns a plain memory reference into a foreign object by -- associating a finalizer - given by the monadic operation - with the--- reference.  The storage manager will start the finalizer, in a--- separate thread, some time after the last reference to the--- @ForeignPtr@ is dropped.  There is no guarantee of promptness, and+-- reference.+--+-- When finalization is triggered by GC, the storage manager will start the+-- finalizer, in a separate thread, some time after the last reference to the+-- @ForeignPtr@ is dropped.  There is __no guarantee of promptness__, and -- in fact there is no guarantee that the finalizer will eventually--- run at all.+-- run at all for GC-triggered finalization. --+-- When finalization is triggered by explicitly calling @finalizeForeignPtr@,+-- the finalizer will run immediately on the current Haskell thread.+-- -- Note that references from a finalizer do not necessarily prevent -- another object from being finalized.  If A's finalizer refers to B -- (perhaps using 'touchForeignPtr', then the only guarantee is that@@ -402,8 +407,10 @@ -- object which have already been registered. -- -- This is a variant of @addForeignPtrFinalizer@, where the finalizer--- is an arbitrary @IO@ action.  When it is invoked, the finalizer--- will run in a new thread.+-- is an arbitrary @IO@ action.+-- When finalization is triggered by GC, the finalizer will run in a new thread.+-- When finalization is triggered by explicitly calling @finalizeForeignPtr@,+-- the finalizer will run immediately on the current Haskell thread. -- -- NB. Be very careful with these finalizers.  One common trap is that -- if a finalizer references another finalized value, it does not@@ -554,7 +561,7 @@ -- ^This function ensures that the foreign object in -- question is alive at the given place in the sequence of IO -- actions. However, this comes with a significant caveat: the contract above--- does not hold if GHC can demonstrate that the code preceeding+-- does not hold if GHC can demonstrate that the code preceding -- @touchForeignPtr@ diverges (e.g. by looping infinitely or throwing an -- exception). For this reason, you are strongly advised to use instead -- 'withForeignPtr' where possible.

@@ -746,7 +746,7 @@ import GHC.Ix      ( Ix ) import GHC.Base    ( Alternative(..), Applicative(..), Functor(..)                    , Monad(..), MonadPlus(..), NonEmpty(..), String, coerce-                   , Semigroup(..), Monoid(..) )+                   , Semigroup(..), Monoid(..), Void ) import GHC.Classes ( Eq(..), Ord(..) ) import GHC.Enum    ( Bounded, Enum ) import GHC.Read    ( Read(..) )@@ -1480,6 +1480,15 @@ newtype Generically1 f a where   Generically1 :: forall {k} f a. f a -> Generically1 @k f a +-- | @since 4.18.0.0+instance (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) where+   Generically1 x == Generically1 y = from1 x == from1 y+   Generically1 x /= Generically1 y = from1 x /= from1 y++-- | @since 4.18.0.0+instance (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) where+   Generically1 x `compare` Generically1 y = from1 x `compare` from1 y+ -- | @since 4.17.0.0 instance (Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) where   fmap :: (a -> a') -> (Generically1 f a -> Generically1 f a')@@ -1543,6 +1552,9 @@ -------------------------------------------------------------------------------- -- Derived instances --------------------------------------------------------------------------------++-- | @since 4.8.0.0+deriving instance Generic Void  -- | @since 4.6.0.0 deriving instance Generic [a]

@@ -180,7 +180,11 @@ -- N.B. initLocaleEncoding is exported for use in System.IO.localeEncoding. -- NOINLINE ensures that this result is shared. -#if !defined(mingw32_HOST_OS)+#if defined(javascript_HOST_ARCH)+initLocaleEncoding     = utf8+initFileSystemEncoding = utf8+initForeignEncoding    = utf8+#elif !defined(mingw32_HOST_OS) -- It is rather important that we don't just call Iconv.mkIconvEncoding here -- because some iconvs (in particular GNU iconv) will brokenly UTF-8 encode -- lone surrogates without complaint.

@@ -32,6 +32,10 @@  import System.Posix.Internals +#if defined(javascript_HOST_ARCH)+mkCodePageEncoding :: String+mkCodePageEncoding = ""+#else  c_DEBUG_DUMP :: Bool c_DEBUG_DUMP = False@@ -422,3 +426,5 @@             -- Must have interpreted all given bytes successfully             -- We need to iterate until we have consumed the complete contents of the buffer             Right wrote_elts -> go (bufferRemove n ibuf) (obuf { bufR = bufR obuf + wrote_elts })++#endif

@@ -61,7 +61,7 @@ -- Roundtripping is based on the ideas of PEP383. -- -- We used to use the range of private-use characters from 0xEF80 to--- 0xEFFF designated for "encoding hacks" by the ConScript Unicode Registery+-- 0xEFFF designated for "encoding hacks" by the ConScript Unicode Registry -- to encode these characters. -- -- However, people didn't like this because it means we don't get

@@ -18,6 +18,10 @@ -- -- UTF-8 Codec for the IO library --+-- This is one of several UTF-8 implementations provided by GHC; see Note+-- [GHC's many UTF-8 implementations] in "GHC.Encoding.UTF8" for an+-- overview.+-- -- Portions Copyright   : (c) Tom Harper 2008-2009, --                        (c) Bryan O'Sullivan 2009, --                        (c) Duncan Coutts 2009

@@ -177,7 +177,7 @@ -- file. If an exception occurs in @act1@, then the file will be closed. -- @act1@ /must not/ close the file itself. If it does so and then receives an -- exception, then the exception handler will attempt to close it again, which--- is impermissable.+-- is impermissible. -- -- @act2@ is performed with asynchronous exceptions masked. It is passed a -- function to restore the masking state and the result of @act1@.  It /must@@ -570,6 +570,10 @@  readRawBufferPtr :: String -> FD -> Ptr Word8 -> Int -> CSize -> IO Int readRawBufferPtr loc !fd !buf !off !len+#if defined(javascript_HOST_ARCH)+  = fmap fromIntegral . uninterruptibleMask_ $+    throwErrnoIfMinus1 loc (c_read (fdFD fd) (buf `plusPtr` off) len)+#else   | isNonBlocking fd = unsafe_read -- unsafe is ok, it can't block   | otherwise    = do r <- throwErrnoIfMinus1 loc                                 (unsafe_fdReady (fdFD fd) 0 0 0)@@ -583,10 +587,19 @@     read        = if threaded then safe_read else unsafe_read     unsafe_read = do_read (c_read (fdFD fd) (buf `plusPtr` off) len)     safe_read   = do_read (c_safe_read (fdFD fd) (buf `plusPtr` off) len)+#endif  -- return: -1 indicates EOF, >=0 is bytes read readRawBufferPtrNoBlock :: String -> FD -> Ptr Word8 -> Int -> CSize -> IO Int readRawBufferPtrNoBlock loc !fd !buf !off !len+#if defined(javascript_HOST_ARCH)+  = uninterruptibleMask_ $ do+      r <- throwErrnoIfMinus1 loc (c_read (fdFD fd) (buf `plusPtr` off) len)+      case r of+       (-1) -> return 0+       0    -> return (-1)+       n    -> return (fromIntegral n)+#else   | isNonBlocking fd  = unsafe_read -- unsafe is ok, it can't block   | otherwise    = do r <- unsafe_fdReady (fdFD fd) 0 0 0                       if r /= 0 then safe_read@@ -600,9 +613,14 @@                        n    -> return (fromIntegral n)    unsafe_read  = do_read (c_read (fdFD fd) (buf `plusPtr` off) len)    safe_read    = do_read (c_safe_read (fdFD fd) (buf `plusPtr` off) len)+#endif  writeRawBufferPtr :: String -> FD -> Ptr Word8 -> Int -> CSize -> IO CInt writeRawBufferPtr loc !fd !buf !off !len+#if defined(javascript_HOST_ARCH)+  = fmap fromIntegral . uninterruptibleMask_ $+    throwErrnoIfMinus1 loc (c_write (fdFD fd) (buf `plusPtr` off) len)+#else   | isNonBlocking fd = unsafe_write -- unsafe is ok, it can't block   | otherwise   = do r <- unsafe_fdReady (fdFD fd) 1 0 0                      if r /= 0@@ -615,9 +633,17 @@     write         = if threaded then safe_write else unsafe_write     unsafe_write  = do_write (c_write (fdFD fd) (buf `plusPtr` off) len)     safe_write    = do_write (c_safe_write (fdFD fd) (buf `plusPtr` off) len)+#endif  writeRawBufferPtrNoBlock :: String -> FD -> Ptr Word8 -> Int -> CSize -> IO CInt writeRawBufferPtrNoBlock loc !fd !buf !off !len+#if defined(javascript_HOST_ARCH)+  = uninterruptibleMask_ $ do+      r <- throwErrnoIfMinus1 loc (c_write (fdFD fd) (buf `plusPtr` off) len)+      case r of+        (-1) -> return 0+        n    -> return (fromIntegral n)+#else   | isNonBlocking fd = unsafe_write -- unsafe is ok, it can't block   | otherwise   = do r <- unsafe_fdReady (fdFD fd) 1 0 0                      if r /= 0 then write@@ -630,12 +656,15 @@     write         = if threaded then safe_write else unsafe_write     unsafe_write  = do_write (c_write (fdFD fd) (buf `plusPtr` off) len)     safe_write    = do_write (c_safe_write (fdFD fd) (buf `plusPtr` off) len)+#endif +#if !defined(javascript_HOST_ARCH) isNonBlocking :: FD -> Bool isNonBlocking fd = fdIsNonBlocking fd /= 0  foreign import ccall unsafe "fdReady"   unsafe_fdReady :: CInt -> CBool -> Int64 -> CBool -> IO CInt+#endif  #else /* mingw32_HOST_OS.... */ @@ -725,12 +754,14 @@  #endif +#if !defined(javascript_HOST_ARCH) foreign import ccall unsafe "rtsSupportsBoundThreads" threaded :: Bool+#endif  -- ----------------------------------------------------------------------------- -- utils -#if !defined(mingw32_HOST_OS)+#if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH) throwErrnoIfMinus1RetryOnBlock  :: String -> IO CSsize -> IO CSsize -> IO CSsize throwErrnoIfMinus1RetryOnBlock loc f on_block  =   do

@@ -440,9 +440,39 @@ handleFinalizer :: FilePath -> MVar Handle__ -> IO () handleFinalizer fp m = do   handle_ <- takeMVar m-  (handle_', _) <- hClose_help handle_+  (handle_', mb_exc) <- hClose_help handle_   putMVar m handle_'-  return ()+  case mb_exc of+    Just exc -> throwIO exc+    Nothing -> return ()++{-+   Note [Handling exceptions during Handle finalization]+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+   Handles which become unreachable are flushed closed automatically by the+   garbage collector, which calls 'GHC.IO.Handle.Internals.handleFinalizer'.+   However, numerous things can go wrong during this process. For instance,+   while we are flushing we may find that the handle's device is full. What to+   do in this case?++   For a long time we would simply ignore the failure. However, silently+   ignoring failures is rarely a good option. For this reason the+   'GHC.Weak.Finalizer.runFinalizerBatch' now catches exceptions and+   dispatches them to a notification action (which can be set via+   'GHC.Weak.Finalize.setFinalizerExceptionHandler').++   This then poses the question of what happens if the exception notification+   action itself throws an exception. We currently ignore such second-order+   exceptions.++   Note that stdout/stderr are handled a bit differently, since they are never+   finalized by the GC. Instead, 'GHC.TopHandler.flushStdHandles' explicitly+   catches exceptions from hFlush and dispatches them to the usual Weak+   finalization exception notifier.++   See #21336.++ -}  -- --------------------------------------------------------------------------- -- Allocating buffers

@@ -12,7 +12,7 @@ -- Stability   :  internal -- Portability :  non-portable ----- This model abtracts away the platform specific handles that can be toggled+-- This model abstracts away the platform specific handles that can be toggled -- through the RTS. -- -----------------------------------------------------------------------------

@@ -47,7 +47,7 @@ But if we were to define unsafePerformIO like this   unsafePerformIO (IO m) = case runRW# m of (# _, r #) -> r -then we'll push that `case` inside the arugment to runRW#, givign+then we'll push that `case` inside the argument to runRW#, giving   runRW# (\s -> case lockMemoTable s of s1 ->                 let r = f x in                 case updateMemoTable s1 of s2 ->

@@ -35,7 +35,7 @@  -- | This function converts Windows paths between namespaces. More specifically -- It converts an explorer style path into a NT or Win32 namespace.--- This has several caveats but they are caviats that are native to Windows and+-- This has several caveats but they are caveats that are native to Windows and -- not POSIX. See -- https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247.aspx. -- Anything else such as raw device paths we leave untouched.  The main benefit

@@ -96,7 +96,7 @@     writeIOPort ioport value  >>     return ioport --- |Atomically read the the contents of the 'IOPort'.  If the 'IOPort' is+-- |Atomically read the contents of the 'IOPort'.  If the 'IOPort' is -- currently empty, 'readIOPort' will wait until it is full.  After a -- 'readIOPort', the 'IOPort' is left empty. --

@@ -32,7 +32,27 @@ -- --------------------------------------------------------------------------- -- IORefs --- |A mutable variable in the 'IO' monad+-- |A mutable variable in the 'IO' monad.+--+-- >>> import Data.IORef+-- >>> r <- newIORef 0+-- >>> readIORef r+-- 0+-- >>> writeIORef r 1+-- >>> readIORef r+-- 1+-- >>> atomicWriteIORef r 2+-- >>> readIORef r+-- 2+-- >>> modifyIORef' r (+ 1)+-- >>> readIORef r+-- 3+-- >>> atomicModifyIORef' r (\a -> (a + 1, ()))+-- >>> readIORef r+-- 4+--+-- See also 'Data.STRef.STRef' and 'Control.Concurrent.MVar.MVar'.+-- newtype IORef a = IORef (STRef RealWorld a)   deriving Eq   -- ^ Pointer equality.@@ -43,15 +63,23 @@ newIORef    :: a -> IO (IORef a) newIORef v = stToIO (newSTRef v) >>= \ var -> return (IORef var) --- |Read the value of an 'IORef'+-- |Read the value of an 'IORef'.+--+-- Beware that the CPU executing a thread can reorder reads or writes+-- to independent locations. See "Data.IORef#memmodel" for more details. readIORef   :: IORef a -> IO a readIORef  (IORef var) = stToIO (readSTRef var) --- |Write a new value into an 'IORef'+-- |Write a new value into an 'IORef'.+--+-- This function does not create a memory barrier and can be reordered+-- with other independent reads and writes within a thread, which may cause issues+-- for multithreaded execution. In these cases, consider using 'Data.IORef.atomicWriteIORef'+-- instead. See "Data.IORef#memmodel" for more details. writeIORef  :: IORef a -> a -> IO () writeIORef (IORef var) v = stToIO (writeSTRef var v) --- Atomically apply a function to the contents of an 'IORef',+-- | Atomically apply a function to the contents of an 'IORef', -- installing its first component in the 'IORef' and returning -- the old contents and the result of applying the function. -- The result of the function application (the pair) is not forced.@@ -62,7 +90,7 @@   IO (\s -> case atomicModifyMutVar2# r# f s of               (# s', old, res #) -> (# s', (old, res) #)) --- Atomically apply a function to the contents of an 'IORef',+-- | Atomically apply a function to the contents of an 'IORef', -- installing its first component in the 'IORef' and returning -- the old contents and the result of applying the function. -- The result of the function application (the pair) is forced,@@ -115,6 +143,9 @@ -- -- will increment the 'IORef' and then throw an exception in the calling -- thread.+--+-- This function imposes a memory barrier, preventing reordering;+-- see "Data.IORef#memmodel" for details. -- -- @since 4.6.0.0 atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b

@@ -0,0 +1,113 @@+{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE NoImplicitPrelude #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  GHC.InfoProv+-- Copyright   :  (c) The University of Glasgow 2011+-- License     :  see libraries/base/LICENSE+--+-- Maintainer  :  cvs-ghc@haskell.org+-- Stability   :  internal+-- Portability :  non-portable (GHC Extensions)+--+-- Access to GHC's info-table provenance metadata.+--+-- @since 4.18.0.0+-----------------------------------------------------------------------------++module GHC.InfoProv+    ( InfoProv(..)+    , ipLoc+    , ipeProv+    , whereFrom+      -- * Internals+    , InfoProvEnt+    , peekInfoProv+    ) where++#include "Rts.h"++import GHC.Base+import GHC.Show+import GHC.Ptr (Ptr(..), plusPtr, nullPtr)+import GHC.Foreign (CString, peekCString)+import GHC.IO.Encoding (utf8)+import Foreign.Storable (peekByteOff)++data InfoProv = InfoProv {+  ipName :: String,+  ipDesc :: String,+  ipTyDesc :: String,+  ipLabel :: String,+  ipMod :: String,+  ipSrcFile :: String,+  ipSrcSpan :: String+} deriving (Eq, Show)++data InfoProvEnt++ipLoc :: InfoProv -> String+ipLoc ipe = ipSrcFile ipe ++ ":" ++ ipSrcSpan ipe++getIPE :: a -> IO (Ptr InfoProvEnt)+getIPE obj = IO $ \s ->+   case whereFrom## obj s of+     (## s', addr ##) -> (## s', Ptr addr ##)++ipeProv :: Ptr InfoProvEnt -> Ptr InfoProv+ipeProv p = (#ptr InfoProvEnt, prov) p++peekIpName, peekIpDesc, peekIpLabel, peekIpModule, peekIpSrcFile, peekIpSrcSpan, peekIpTyDesc :: Ptr InfoProv -> IO CString+peekIpName p    =  (# peek InfoProv, table_name) p+peekIpDesc p    =  (# peek InfoProv, closure_desc) p+peekIpLabel p   =  (# peek InfoProv, label) p+peekIpModule p  =  (# peek InfoProv, module) p+peekIpSrcFile p =  (# peek InfoProv, src_file) p+peekIpSrcSpan p =  (# peek InfoProv, src_span) p+peekIpTyDesc p  =  (# peek InfoProv, ty_desc) p++peekInfoProv :: Ptr InfoProv -> IO InfoProv+peekInfoProv infop = do+  name <- peekCString utf8 =<< peekIpName infop+  desc <- peekCString utf8 =<< peekIpDesc infop+  tyDesc <- peekCString utf8 =<< peekIpTyDesc infop+  label <- peekCString utf8 =<< peekIpLabel infop+  mod <- peekCString utf8 =<< peekIpModule infop+  file <- peekCString utf8 =<< peekIpSrcFile infop+  span <- peekCString utf8 =<< peekIpSrcSpan infop+  return InfoProv {+      ipName = name,+      ipDesc = desc,+      ipTyDesc = tyDesc,+      ipLabel = label,+      ipMod = mod,+      ipSrcFile = file,+      ipSrcSpan = span+    }++-- | Get information about where a value originated from.+-- This information is stored statically in a binary when `-finfo-table-map` is+-- enabled.  The source positions will be greatly improved by also enabled debug+-- information with `-g3`. Finally you can enable `-fdistinct-constructor-tables` to+-- get more precise information about data constructor allocations.+--+-- The information is collect by looking at the info table address of a specific closure and+-- then consulting a specially generated map (by `-finfo-table-map`) to find out where we think+-- the best source position to describe that info table arose from.+--+-- @since 4.16.0.0+whereFrom :: a -> IO (Maybe InfoProv)+whereFrom obj = do+  ipe <- getIPE obj+  -- The primop returns the null pointer in two situations at the moment+  -- 1. The lookup fails for whatever reason+  -- 2. -finfo-table-map is not enabled.+  -- It would be good to distinguish between these two cases somehow.+  if ipe == nullPtr+    then return Nothing+    else do+      infoProv <- peekInfoProv (ipeProv ipe)+      return $ Just infoProv

@@ -140,12 +140,30 @@ The default method for 'index' generates hoplelessIndexError, because Ix doesn't have Show as a superclass.  For particular base types we can do better, so we override the default method for index.--} --- Abstract these errors from the relevant index functions so that--- the guts of the function will be small enough to inline.+Note [indexError]+~~~~~~~~~~~~~~~~~+We abstract the guts of constructing an out-of-bounds error into `indexError`.+We give it a NOINLINE pragma, because we don't want to duplicate this+cold-path code. +We give it a SPECIALISE pragma because we really want it to take+its arguments unboxed, to avoid reboxing code in the caller, and+perhaps even some reboxing code in the hot path of a caller.+See Note [Boxity for bottoming functions] in GHC.Core.Opt.DmdAnal.++The SPECIALISE pragma means that at least the Int-indexed case+of indexError /will/ unbox its arguments.++The [2] phase is because if we don't give an activation we'll get+the one from the inline pragama (i.e. never) which is a bit silly.+See Note [Activation pragmas for SPECIALISE] in GHC.HsToCore.Binds.+-}++-- indexError: see Note [indexError] {-# NOINLINE indexError #-}+{-# SPECIALISE [2] indexError :: (Int,Int) -> Int -> String -> b #-}+ indexError :: Show a => (a,a) -> a -> String -> b indexError rng i tp   = errorWithoutStackTrace (showString "Ix{" . showString tp . showString "}.index: Index " .@@ -255,6 +273,14 @@     inRange (l,u) i = fromEnum i >= fromEnum l && fromEnum i <= fromEnum u  ----------------------------------------------------------------------+-- | @since 4.8.0.0+instance Ix Void where+    range _     = []+    index _     = absurd+    inRange _   = absurd+    rangeSize _ = 0++---------------------------------------------------------------------- -- | @since 2.01 instance Ix () where     {-# INLINE range #-}@@ -271,15 +297,15 @@     {-# SPECIALISE instance Ix (Solo Int) #-}      {-# INLINE range #-}-    range (Solo l, Solo u) =-      [ Solo i | i <- range (l,u) ]+    range (MkSolo l, MkSolo u) =+      [ MkSolo i | i <- range (l,u) ]      {-# INLINE unsafeIndex #-}-    unsafeIndex (Solo l, Solo u) (Solo i) =+    unsafeIndex (MkSolo l, MkSolo u) (MkSolo i) =       unsafeIndex (l,u) i      {-# INLINE inRange #-}-    inRange (Solo l, Solo u) (Solo i) =+    inRange (MkSolo l, MkSolo u) (MkSolo i) =       inRange (l, u) i      -- Default method for index

@@ -0,0 +1,332 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE JavaScriptFFI #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnboxedTuples #-}++module GHC.JS.Prim ( JSVal(..), JSVal#+                   , JSException(..)+                   , WouldBlockException(..)+#if defined(javascript_HOST_ARCH)+                  , toIO+                  , resolve+                  , resolveIO+                  , mkJSException+                  , fromJSString+                  , toJSString+                  , toJSArray+                  , fromJSArray+                  , fromJSInt+                  , toJSInt+                  , isNull+                  , isUndefined+                  , jsNull+                  , getProp+                  , getProp'+                  , getProp#+                  , unsafeGetProp+                  , unsafeGetProp'+                  , unsafeGetProp#+                  , unpackJSString#+                  , unpackJSStringUtf8#+                  , unsafeUnpackJSString#+                  , unsafeUnpackJSStringUtf8#+                  , unpackJSStringUtf8##+                  , unsafeUnpackJSStringUtf8##++#endif+                  ) where++import           Data.Typeable (Typeable)+import           Unsafe.Coerce (unsafeCoerce)++import           GHC.Prim+import qualified GHC.Exception as Ex+import qualified GHC.Exts as Exts+import qualified GHC.CString as GHC+import           GHC.IO++{-+  JSVal is a boxed type that can be used as FFI+  argument or result.+-}++#if defined(javascript_HOST_ARCH)+data JSVal  = JSVal ByteArray#+type JSVal# = ByteArray#+#else+data JSVal  = JSVal Addr#+type JSVal# = Addr#+#endif++{-+  When a JavaScript exception is raised inside+  a safe or interruptible foreign call, it is converted+  to a JSException+ -}+data JSException = JSException JSVal String+  deriving (Typeable)++instance Ex.Exception JSException++instance Show JSException where+  show (JSException _ xs) = "JavaScript exception: " ++ xs++#if defined(javascript_HOST_ARCH)++{-# NOINLINE toIO #-}+toIO :: Exts.Any -> IO Exts.Any+toIO x = pure x++{-# NOINLINE resolve #-}+resolve :: JSVal# -> JSVal# -> Exts.Any -> IO ()+resolve accept reject x = resolveIO accept reject (pure x)++{-# NOINLINE resolveIO #-}+resolveIO :: JSVal# -> JSVal# -> IO Exts.Any -> IO ()+resolveIO accept reject x =+  (x >>= evaluate >>= js_callback_any accept) `catch`+  (\(e::Ex.SomeException) -> do+    exceptionText <- evaluate (toJSString $ Ex.displayException e) `catch`+                         (\(_::Ex.SomeException) -> evaluate (toJSString "unknown exception"))+    js_callback_jsval reject exceptionText)++mkJSException :: JSVal -> IO JSException+mkJSException ref =+  return (JSException (unsafeCoerce ref) (fromJSString ref))++{- | Low-level conversion utilities for packages that cannot+     depend on ghcjs-base+ -}++{- | returns an empty string if the JSVal does not contain+     a string+ -}+fromJSString :: JSVal -> String+fromJSString = unsafeCoerce . js_fromJSString+{-# INLINE fromJSString #-}++toJSString :: String -> JSVal+toJSString = js_toJSString . unsafeCoerce . seqList+{-# INLINE [0] toJSString #-}+{-# RULES+"GHC.JS.PRIM toJSString/literal" forall a.+  toJSString (GHC.unpackCString# a) = JSVal (unsafeUnpackJSStringUtf8## a)+"GHC.JS.PRIM toJSString/literalUtf8" forall a.+  toJSString (GHC.unpackCStringUtf8# a) = JSVal (unsafeUnpackJSStringUtf8## a)+  #-}++fromJSArray :: JSVal -> IO [JSVal]+fromJSArray = unsafeCoerce . js_fromJSArray+{-# INLINE fromJSArray #-}++toJSArray :: [JSVal] -> IO JSVal+toJSArray = js_toJSArray . unsafeCoerce . seqList+{-# INLINE toJSArray #-}++{- | returns zero if the JSVal does not contain a number+ -}+fromJSInt :: JSVal -> Int+fromJSInt = js_fromJSInt+{-# INLINE fromJSInt #-}++toJSInt :: Int -> JSVal+toJSInt = js_toJSInt+{-# INLINE toJSInt #-}++isNull :: JSVal -> Bool+isNull = js_isNull+{-# INLINE isNull #-}++isUndefined :: JSVal -> Bool+isUndefined = js_isUndefined+{-# INLINE isUndefined #-}++jsNull :: JSVal+jsNull = js_null+{-# INLINE CONLIKE jsNull #-}++getProp :: JSVal -> String -> IO JSVal+getProp o p = js_getProp o (unsafeCoerce $ seqList p)+{-# INLINE [0] getProp #-}+{-# RULES+"GHC.JS.PRIM getProp/literal" forall o a.+  getProp o (GHC.unpackCString# a) = getProp# o a+"GHC.JS.PRIM getProp/literalUtf8" forall o a.+  getProp o (GHC.unpackCStringUtf8# a) = getPropUtf8# o a+  #-}++-- | only safe on immutable object+unsafeGetProp :: JSVal -> String -> JSVal+unsafeGetProp o p = js_unsafeGetProp o (unsafeCoerce $ seqList p)+{-# INLINE [0] unsafeGetProp #-}+{-# RULES+"GHC.JS.PRIM unsafeGetProp/literal" forall o a.+  unsafeGetProp o (GHC.unpackCString# a) = unsafeGetProp# o a+"GHC.JS.PRIM unsafeGetProp/literalUtf8" forall o a.+  unsafeGetProp o (GHC.unpackCStringUtf8# a) = unsafeGetPropUtf8# o a+  #-}++getProp' :: JSVal -> JSVal -> IO JSVal+getProp' o p = js_getProp' o p+{-# INLINE [0] getProp' #-}+{-# RULES+"GHC.JS.PRIM getProp'/literal" forall o a.+  getProp' o (unsafeUnpackJSString# a) = getProp# o a+"GHC.JS.PRIM getProp'/literalUtf8" forall o a.+  getProp' o (unsafeUnpackJSStringUtf8# a) = getPropUtf8# o a+  #-}++-- | only safe on immutable object+unsafeGetProp' :: JSVal -> JSVal -> JSVal+unsafeGetProp' o p = js_unsafeGetProp' o p+{-# INLINE [0] unsafeGetProp' #-}+{-# RULES+"GHC.JS.PRIM unsafeGetProp'/literal" forall o a.+  unsafeGetProp' o (unsafeUnpackJSString# a) = unsafeGetPropUtf8# o a+"GHC.JS.PRIM unsafeGetProp'/literalUtf8" forall o a.+  unsafeGetProp' o (unsafeUnpackJSStringUtf8# a) = unsafeGetPropUtf8# o a+  #-}+++-- | only safe on immutable Addr#+getProp# :: JSVal -> Addr# -> IO JSVal+getProp# (JSVal o) p = IO $+  \s -> case getPropUtf8## o p s of (# s', v #) -> (# s', JSVal v #)+{-# INLINE [0] getProp# #-}+-- js_getProp# o p++-- | only safe on immutable Addr#+getPropUtf8# :: JSVal -> Addr# -> IO JSVal+getPropUtf8# (JSVal o) p = IO $+  \s -> case getPropUtf8## o p s of (# s', v #) -> (# s', JSVal v #)+{-# INLINE [0] getPropUtf8# #-}++getPropUtf8## :: JSVal# -> Addr# -> State# s -> (# State# s, JSVal# #)+getPropUtf8## o p = js_getPropUtf8## o p+{-# NOINLINE getPropUtf8## #-}++-- | only safe on immutable Addr# and JSVal+unsafeGetProp# :: JSVal -> Addr# -> JSVal+unsafeGetProp# (JSVal o) p = JSVal (unsafeGetPropUtf8## o p)+{-# INLINE [0] unsafeGetProp# #-}++-- | only safe on immutable Addr# and JSVal+unsafeGetPropUtf8# :: JSVal -> Addr# -> JSVal+unsafeGetPropUtf8# (JSVal o) p = JSVal (unsafeGetPropUtf8## o p)+{-# INLINE [0] unsafeGetPropUtf8# #-}++unsafeGetPropUtf8## :: JSVal# -> Addr# -> JSVal#+unsafeGetPropUtf8## o p = js_unsafeGetPropUtf8## o p+{-# NOINLINE unsafeGetPropUtf8## #-}++unpackJSString# :: Addr# -> IO JSVal+unpackJSString# a = IO $+  \s -> case unpackJSStringUtf8## a s of (# s', v #) -> (# s', JSVal v #)+{-# INLINE [0] unpackJSString# #-}++unpackJSStringUtf8# :: Addr# -> IO JSVal+unpackJSStringUtf8# a = IO $+  \s -> case unpackJSStringUtf8## a s of (# s', v #) -> (# s', JSVal v #)+{-# INLINE [0] unpackJSStringUtf8# #-}++unpackJSStringUtf8## :: Addr# -> State# s -> (# State# s, JSVal# #)+unpackJSStringUtf8## a s = js_unpackJSStringUtf8## a s+{-# NOINLINE unpackJSStringUtf8## #-}++-- | only safe on immutable Addr#+unsafeUnpackJSString# :: Addr# -> JSVal+unsafeUnpackJSString# a = JSVal (unsafeUnpackJSStringUtf8## a)+  -- js_unsafeUnpackJSString# a+{-# INLINE [0] unsafeUnpackJSString# #-}++-- | only safe on immutable Addr#+unsafeUnpackJSStringUtf8# :: Addr# -> JSVal+unsafeUnpackJSStringUtf8# a = JSVal (unsafeUnpackJSStringUtf8## a)+{-# INLINE [0] unsafeUnpackJSStringUtf8# #-}++unsafeUnpackJSStringUtf8## :: Addr# -> JSVal#+unsafeUnpackJSStringUtf8## a = js_unsafeUnpackJSStringUtf8## a+{-# NOINLINE unsafeUnpackJSStringUtf8## #-}+++-- reduce the spine and all list elements to whnf+seqList :: [a] -> [a]+seqList xs = go xs `seq` xs+  where go (y:ys) = y `seq` go ys+        go []     = ()++foreign import javascript unsafe "(($1) => { return h$toHsString($1); })"+  js_fromJSString :: JSVal -> Exts.Any++foreign import javascript unsafe "(($1) => { return h$fromHsString($1); })"+  js_toJSString :: Exts.Any -> JSVal++foreign import javascript unsafe "(($1) => { return h$toHsListJSVal($1); })"+  js_fromJSArray :: JSVal -> IO Exts.Any++foreign import javascript unsafe "(($1) => { return h$fromHsListJSVal($1); })"+  js_toJSArray :: Exts.Any -> IO JSVal++foreign import javascript unsafe "(($1) => { return ($1 === null); })"+  js_isNull :: JSVal -> Bool++foreign import javascript unsafe "(($1) => { return ($1 === undefined); })"+  js_isUndefined :: JSVal -> Bool++foreign import javascript unsafe "(($1) => { return ($r = typeof($1) === 'number' ? ($1|0) : 0;); })"+  js_fromJSInt :: JSVal -> Int++foreign import javascript unsafe "(($1) => { return ($r = $1;); })"+  js_toJSInt :: Int -> JSVal++foreign import javascript unsafe "$r = null;"+  js_null :: JSVal++foreign import javascript unsafe "(($1,$2) => { return $1[h$fromHsString($2)]; })"+  js_getProp :: JSVal -> Exts.Any -> IO JSVal++foreign import javascript unsafe "(($1,$2) => { return $1[h$fromHsString($2)]; })"+  js_unsafeGetProp :: JSVal -> Exts.Any -> JSVal++foreign import javascript unsafe "(($1,$2) => { return $1[$2]; })"+  js_getProp' :: JSVal -> JSVal -> IO JSVal++foreign import javascript unsafe "(($1,$2) => { return $1[$2]; })"+  js_unsafeGetProp' :: JSVal -> JSVal -> JSVal++foreign import javascript unsafe "(($1,$2_1,$2_2) => { return $1[h$decodeUtf8z($2_1, $2_2)]; })"+  js_getPropUtf8## :: JSVal# -> Addr# -> State# s -> (# State# s, JSVal# #)++foreign import javascript unsafe "(($1,$2_1,$2_2) => { return $1[h$decodeUtf8z($2_1, $2_2)]; })"+  js_unsafeGetPropUtf8## :: JSVal# -> Addr# -> JSVal#++foreign import javascript unsafe "(($1_1,$1_2) => { return h$decodeUtf8z($1_1, $1_2); })"+  js_unpackJSStringUtf8## :: Addr# -> State# s -> (# State# s, JSVal# #)+++foreign import javascript unsafe "(($1_1, $1_2) => { return h$decodeUtf8z($1_1,$1_2); })"+  js_unsafeUnpackJSStringUtf8## :: Addr# -> JSVal#++foreign import javascript unsafe "(($1, $2) => { return $1($2); })"+  js_callback_any :: JSVal# -> Exts.Any -> IO ()++foreign import javascript unsafe "(($1, $2) => { return $1($2); })"+  js_callback_jsval :: JSVal# -> JSVal -> IO ()++#endif++{- | If a synchronous thread tries to do something that can only+     be done asynchronously, and the thread is set up to not+     continue asynchronously, it receives this exception.+ -}+data WouldBlockException = WouldBlockException+  deriving (Typeable)++instance Show WouldBlockException where+  show _ = "thread would block"++instance Ex.Exception WouldBlockException

@@ -0,0 +1,56 @@+{- | Code used by the RTS++ -}++module GHC.JS.Prim.Internal ( blockedIndefinitelyOnMVar+                            , blockedIndefinitelyOnSTM+                            , wouldBlock+                            , ignoreException+                            , setCurrentThreadResultException+                            , setCurrentThreadResultValue+                            ) where++import           Control.Exception++import           GHC.JS.Prim++wouldBlock :: SomeException+wouldBlock = toException WouldBlockException++blockedIndefinitelyOnMVar :: SomeException+blockedIndefinitelyOnMVar = toException BlockedIndefinitelyOnMVar++blockedIndefinitelyOnSTM :: SomeException+blockedIndefinitelyOnSTM = toException BlockedIndefinitelyOnSTM++ignoreException :: SomeException -> IO ()+ignoreException _ = return ()++setCurrentThreadResultException :: SomeException -> IO ()+setCurrentThreadResultException e+  | Just WouldBlockException <- fromException e =+      js_setCurrentThreadResultWouldBlock+  | Just (JSException v _) <- fromException e =+      js_setCurrentThreadResultJSException v+  | otherwise =+      js_setCurrentThreadResultHaskellException (toJSString (show e))++setCurrentThreadResultValue :: IO JSVal -> IO ()+setCurrentThreadResultValue x = js_setCurrentThreadResultValue =<< x++foreign import javascript unsafe+  "(() => { return h$setCurrentThreadResultWouldBlock; })"+  js_setCurrentThreadResultWouldBlock :: IO ()++foreign import javascript unsafe+  "(($1) => { return h$setCurrentThreadResultJSException($1); })"+  js_setCurrentThreadResultJSException :: JSVal -> IO ()++foreign import javascript unsafe+  "(($1) => { return h$setCurrentThreadResultHaskellException($1); })"+  js_setCurrentThreadResultHaskellException :: JSVal -> IO ()++foreign import javascript unsafe+  "(($1) => { return h$setCurrentThreadResultValue($1); })"+  js_setCurrentThreadResultValue :: JSVal -> IO ()+

@@ -0,0 +1,1470 @@+-- helpers for constructing JS objects that can be efficiently inlined as literals+-- no Template Haskell available yet, generated by utils/genBuildObject.hs+{-# LANGUAGE CPP #-}+#if !defined(javascript_HOST_ARCH)+module GHC.JS.Prim.Internal.Build () where+#else+{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI, GHCForeignImportPrim #-}+module GHC.JS.Prim.Internal.Build+  ( buildArrayI+  , buildArrayM+  , buildObjectI+  , buildObjectM+  , buildArrayI1+  , buildArrayI2+  , buildArrayI3+  , buildArrayI4+  , buildArrayI5+  , buildArrayI6+  , buildArrayI7+  , buildArrayI8+  , buildArrayI9+  , buildArrayI10+  , buildArrayI11+  , buildArrayI12+  , buildArrayI13+  , buildArrayI14+  , buildArrayI15+  , buildArrayI16+  , buildArrayI17+  , buildArrayI18+  , buildArrayI19+  , buildArrayI20+  , buildArrayI21+  , buildArrayI22+  , buildArrayI23+  , buildArrayI24+  , buildArrayI25+  , buildArrayI26+  , buildArrayI27+  , buildArrayI28+  , buildArrayI29+  , buildArrayI30+  , buildArrayI31+  , buildArrayI32+  , buildArrayM1+  , buildArrayM2+  , buildArrayM3+  , buildArrayM4+  , buildArrayM5+  , buildArrayM6+  , buildArrayM7+  , buildArrayM8+  , buildArrayM9+  , buildArrayM10+  , buildArrayM11+  , buildArrayM12+  , buildArrayM13+  , buildArrayM14+  , buildArrayM15+  , buildArrayM16+  , buildArrayM17+  , buildArrayM18+  , buildArrayM19+  , buildArrayM20+  , buildArrayM21+  , buildArrayM22+  , buildArrayM23+  , buildArrayM24+  , buildArrayM25+  , buildArrayM26+  , buildArrayM27+  , buildArrayM28+  , buildArrayM29+  , buildArrayM30+  , buildArrayM31+  , buildArrayM32+  , buildObjectI1+  , buildObjectI2+  , buildObjectI3+  , buildObjectI4+  , buildObjectI5+  , buildObjectI6+  , buildObjectI7+  , buildObjectI8+  , buildObjectI9+  , buildObjectI10+  , buildObjectI11+  , buildObjectI12+  , buildObjectI13+  , buildObjectI14+  , buildObjectI15+  , buildObjectI16+  , buildObjectI17+  , buildObjectI18+  , buildObjectI19+  , buildObjectI20+  , buildObjectI21+  , buildObjectI22+  , buildObjectI23+  , buildObjectI24+  , buildObjectI25+  , buildObjectI26+  , buildObjectI27+  , buildObjectI28+  , buildObjectI29+  , buildObjectI30+  , buildObjectI31+  , buildObjectI32+  , buildObjectM1+  , buildObjectM2+  , buildObjectM3+  , buildObjectM4+  , buildObjectM5+  , buildObjectM6+  , buildObjectM7+  , buildObjectM8+  , buildObjectM9+  , buildObjectM10+  , buildObjectM11+  , buildObjectM12+  , buildObjectM13+  , buildObjectM14+  , buildObjectM15+  , buildObjectM16+  , buildObjectM17+  , buildObjectM18+  , buildObjectM19+  , buildObjectM20+  , buildObjectM21+  , buildObjectM22+  , buildObjectM23+  , buildObjectM24+  , buildObjectM25+  , buildObjectM26+  , buildObjectM27+  , buildObjectM28+  , buildObjectM29+  , buildObjectM30+  , buildObjectM31+  , buildObjectM32+  ) where++import GHC.JS.Prim+import GHC.Exts+import Unsafe.Coerce+import System.IO.Unsafe++type O = JSVal -- object+type K = JSVal -- key+type V = JSVal -- value+type J = JSVal -- some JS value+type A = JSVal -- array++seqTupList :: [(a,b)] -> [(a,b)]+seqTupList xs = go xs `seq` xs+  where go ((y1,y2):ys) = y1 `seq` y2 `seq` go ys+        go []           = ()++foreign import javascript unsafe "$r = [];" js_emptyArrayI :: A++buildArrayI :: [J] -> A+buildArrayI xs = unsafePerformIO (toJSArray xs)+{-# INLINE [1] buildArrayI #-}+{-# RULES "buildArrayI/empty" buildArrayI [] = js_emptyArrayI #-}+{-# RULES "buildArrayI/buildArrayI1" forall x1. buildArrayI [x1] = buildArrayI1 x1 #-}+{-# RULES "buildArrayI/buildArrayI2" forall x1 x2. buildArrayI [x1,x2] = buildArrayI2 x1 x2 #-}+{-# RULES "buildArrayI/buildArrayI3" forall x1 x2 x3. buildArrayI [x1,x2,x3] = buildArrayI3 x1 x2 x3 #-}+{-# RULES "buildArrayI/buildArrayI4" forall x1 x2 x3 x4. buildArrayI [x1,x2,x3,x4] = buildArrayI4 x1 x2 x3 x4 #-}+{-# RULES "buildArrayI/buildArrayI5" forall x1 x2 x3 x4 x5. buildArrayI [x1,x2,x3,x4,x5] = buildArrayI5 x1 x2 x3 x4 x5 #-}+{-# RULES "buildArrayI/buildArrayI6" forall x1 x2 x3 x4 x5 x6. buildArrayI [x1,x2,x3,x4,x5,x6] = buildArrayI6 x1 x2 x3 x4 x5 x6 #-}+{-# RULES "buildArrayI/buildArrayI7" forall x1 x2 x3 x4 x5 x6 x7. buildArrayI [x1,x2,x3,x4,x5,x6,x7] = buildArrayI7 x1 x2 x3 x4 x5 x6 x7 #-}+{-# RULES "buildArrayI/buildArrayI8" forall x1 x2 x3 x4 x5 x6 x7 x8. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8] = buildArrayI8 x1 x2 x3 x4 x5 x6 x7 x8 #-}+{-# RULES "buildArrayI/buildArrayI9" forall x1 x2 x3 x4 x5 x6 x7 x8 x9. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9] = buildArrayI9 x1 x2 x3 x4 x5 x6 x7 x8 x9 #-}+{-# RULES "buildArrayI/buildArrayI10" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10] = buildArrayI10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 #-}+{-# RULES "buildArrayI/buildArrayI11" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11] = buildArrayI11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 #-}+{-# RULES "buildArrayI/buildArrayI12" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12] = buildArrayI12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 #-}+{-# RULES "buildArrayI/buildArrayI13" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13] = buildArrayI13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 #-}+{-# RULES "buildArrayI/buildArrayI14" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14] = buildArrayI14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 #-}+{-# RULES "buildArrayI/buildArrayI15" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15] = buildArrayI15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 #-}+{-# RULES "buildArrayI/buildArrayI16" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16] = buildArrayI16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 #-}+{-# RULES "buildArrayI/buildArrayI17" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17] = buildArrayI17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 #-}+{-# RULES "buildArrayI/buildArrayI18" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18] = buildArrayI18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 #-}+{-# RULES "buildArrayI/buildArrayI19" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19] = buildArrayI19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 #-}+{-# RULES "buildArrayI/buildArrayI20" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20] = buildArrayI20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 #-}+{-# RULES "buildArrayI/buildArrayI21" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21] = buildArrayI21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 #-}+{-# RULES "buildArrayI/buildArrayI22" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22] = buildArrayI22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 #-}+{-# RULES "buildArrayI/buildArrayI23" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23] = buildArrayI23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 #-}+{-# RULES "buildArrayI/buildArrayI24" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24] = buildArrayI24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 #-}+{-# RULES "buildArrayI/buildArrayI25" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25] = buildArrayI25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 #-}+{-# RULES "buildArrayI/buildArrayI26" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26] = buildArrayI26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 #-}+{-# RULES "buildArrayI/buildArrayI27" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27] = buildArrayI27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 #-}+{-# RULES "buildArrayI/buildArrayI28" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28] = buildArrayI28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 #-}+{-# RULES "buildArrayI/buildArrayI29" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29] = buildArrayI29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 #-}+{-# RULES "buildArrayI/buildArrayI30" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30] = buildArrayI30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 #-}+{-# RULES "buildArrayI/buildArrayI31" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31] = buildArrayI31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 #-}+{-# RULES "buildArrayI/buildArrayI32" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32. buildArrayI [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32] = buildArrayI32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 #-}++buildArrayI1 :: J -> A+buildArrayI1 x1 =+  js_buildArrayI1 x1+{-# INLINE buildArrayI1 #-}++foreign import javascript unsafe "[$1]"+  js_buildArrayI1 :: J -> A+++buildArrayI2 :: J -> J -> A+buildArrayI2 x1 x2 =+  js_buildArrayI2 x1 x2+{-# INLINE buildArrayI2 #-}++foreign import javascript unsafe "[$1,$2]"+  js_buildArrayI2 :: J -> J -> A+++buildArrayI3 :: J -> J -> J -> A+buildArrayI3 x1 x2 x3 =+  js_buildArrayI3 x1 x2 x3+{-# INLINE buildArrayI3 #-}++foreign import javascript unsafe "[$1,$2,$3]"+  js_buildArrayI3 :: J -> J -> J -> A+++buildArrayI4 :: J -> J -> J -> J -> A+buildArrayI4 x1 x2 x3 x4 =+  js_buildArrayI4 x1 x2 x3 x4+{-# INLINE buildArrayI4 #-}++foreign import javascript unsafe "[$1,$2,$3,$4]"+  js_buildArrayI4 :: J -> J -> J -> J -> A+++buildArrayI5 :: J -> J -> J -> J -> J -> A+buildArrayI5 x1 x2 x3 x4 x5 =+  js_buildArrayI5 x1 x2 x3 x4 x5+{-# INLINE buildArrayI5 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5]"+  js_buildArrayI5 :: J -> J -> J -> J -> J -> A+++buildArrayI6 :: J -> J -> J -> J -> J -> J -> A+buildArrayI6 x1 x2 x3 x4 x5 x6 =+  js_buildArrayI6 x1 x2 x3 x4 x5 x6+{-# INLINE buildArrayI6 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6]"+  js_buildArrayI6 :: J -> J -> J -> J -> J -> J -> A+++buildArrayI7 :: J -> J -> J -> J -> J -> J -> J -> A+buildArrayI7 x1 x2 x3 x4 x5 x6 x7 =+  js_buildArrayI7 x1 x2 x3 x4 x5 x6 x7+{-# INLINE buildArrayI7 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7]"+  js_buildArrayI7 :: J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI8 :: J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI8 x1 x2 x3 x4 x5 x6 x7 x8 =+  js_buildArrayI8 x1 x2 x3 x4 x5 x6 x7 x8+{-# INLINE buildArrayI8 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8]"+  js_buildArrayI8 :: J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI9 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI9 x1 x2 x3 x4 x5 x6 x7 x8 x9 =+  js_buildArrayI9 x1 x2 x3 x4 x5 x6 x7 x8 x9+{-# INLINE buildArrayI9 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9]"+  js_buildArrayI9 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI10 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =+  js_buildArrayI10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10+{-# INLINE buildArrayI10 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10]"+  js_buildArrayI10 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI11 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =+  js_buildArrayI11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11+{-# INLINE buildArrayI11 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11]"+  js_buildArrayI11 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI12 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =+  js_buildArrayI12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12+{-# INLINE buildArrayI12 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12]"+  js_buildArrayI12 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI13 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =+  js_buildArrayI13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13+{-# INLINE buildArrayI13 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13]"+  js_buildArrayI13 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI14 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =+  js_buildArrayI14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14+{-# INLINE buildArrayI14 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14]"+  js_buildArrayI14 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI15 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =+  js_buildArrayI15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15+{-# INLINE buildArrayI15 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15]"+  js_buildArrayI15 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI16 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =+  js_buildArrayI16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16+{-# INLINE buildArrayI16 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16]"+  js_buildArrayI16 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI17 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =+  js_buildArrayI17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17+{-# INLINE buildArrayI17 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17]"+  js_buildArrayI17 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI18 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =+  js_buildArrayI18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18+{-# INLINE buildArrayI18 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18]"+  js_buildArrayI18 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI19 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =+  js_buildArrayI19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19+{-# INLINE buildArrayI19 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19]"+  js_buildArrayI19 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI20 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =+  js_buildArrayI20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20+{-# INLINE buildArrayI20 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20]"+  js_buildArrayI20 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI21 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =+  js_buildArrayI21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21+{-# INLINE buildArrayI21 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21]"+  js_buildArrayI21 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI22 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =+  js_buildArrayI22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22+{-# INLINE buildArrayI22 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22]"+  js_buildArrayI22 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI23 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =+  js_buildArrayI23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23+{-# INLINE buildArrayI23 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23]"+  js_buildArrayI23 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI24 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 =+  js_buildArrayI24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24+{-# INLINE buildArrayI24 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24]"+  js_buildArrayI24 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI25 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 =+  js_buildArrayI25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25+{-# INLINE buildArrayI25 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25]"+  js_buildArrayI25 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI26 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 =+  js_buildArrayI26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26+{-# INLINE buildArrayI26 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26]"+  js_buildArrayI26 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI27 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 =+  js_buildArrayI27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27+{-# INLINE buildArrayI27 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27]"+  js_buildArrayI27 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI28 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 =+  js_buildArrayI28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28+{-# INLINE buildArrayI28 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28]"+  js_buildArrayI28 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI29 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 =+  js_buildArrayI29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29+{-# INLINE buildArrayI29 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29]"+  js_buildArrayI29 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI30 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 =+  js_buildArrayI30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30+{-# INLINE buildArrayI30 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30]"+  js_buildArrayI30 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI31 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 =+  js_buildArrayI31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31+{-# INLINE buildArrayI31 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31]"+  js_buildArrayI31 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++buildArrayI32 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+buildArrayI32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 =+  js_buildArrayI32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32+{-# INLINE buildArrayI32 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32]"+  js_buildArrayI32 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> A+++foreign import javascript unsafe "$r = [];" js_emptyArrayM :: IO A++buildArrayM :: [J] -> IO A+buildArrayM xs = toJSArray xs+{-# INLINE [1] buildArrayM #-}+{-# RULES "buildArrayM/empty" buildArrayM [] = js_emptyArrayM #-}+{-# RULES "buildArrayM/buildArrayM1" forall x1. buildArrayM [x1] = buildArrayM1 x1 #-}+{-# RULES "buildArrayM/buildArrayM2" forall x1 x2. buildArrayM [x1,x2] = buildArrayM2 x1 x2 #-}+{-# RULES "buildArrayM/buildArrayM3" forall x1 x2 x3. buildArrayM [x1,x2,x3] = buildArrayM3 x1 x2 x3 #-}+{-# RULES "buildArrayM/buildArrayM4" forall x1 x2 x3 x4. buildArrayM [x1,x2,x3,x4] = buildArrayM4 x1 x2 x3 x4 #-}+{-# RULES "buildArrayM/buildArrayM5" forall x1 x2 x3 x4 x5. buildArrayM [x1,x2,x3,x4,x5] = buildArrayM5 x1 x2 x3 x4 x5 #-}+{-# RULES "buildArrayM/buildArrayM6" forall x1 x2 x3 x4 x5 x6. buildArrayM [x1,x2,x3,x4,x5,x6] = buildArrayM6 x1 x2 x3 x4 x5 x6 #-}+{-# RULES "buildArrayM/buildArrayM7" forall x1 x2 x3 x4 x5 x6 x7. buildArrayM [x1,x2,x3,x4,x5,x6,x7] = buildArrayM7 x1 x2 x3 x4 x5 x6 x7 #-}+{-# RULES "buildArrayM/buildArrayM8" forall x1 x2 x3 x4 x5 x6 x7 x8. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8] = buildArrayM8 x1 x2 x3 x4 x5 x6 x7 x8 #-}+{-# RULES "buildArrayM/buildArrayM9" forall x1 x2 x3 x4 x5 x6 x7 x8 x9. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9] = buildArrayM9 x1 x2 x3 x4 x5 x6 x7 x8 x9 #-}+{-# RULES "buildArrayM/buildArrayM10" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10] = buildArrayM10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 #-}+{-# RULES "buildArrayM/buildArrayM11" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11] = buildArrayM11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 #-}+{-# RULES "buildArrayM/buildArrayM12" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12] = buildArrayM12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 #-}+{-# RULES "buildArrayM/buildArrayM13" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13] = buildArrayM13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 #-}+{-# RULES "buildArrayM/buildArrayM14" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14] = buildArrayM14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 #-}+{-# RULES "buildArrayM/buildArrayM15" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15] = buildArrayM15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 #-}+{-# RULES "buildArrayM/buildArrayM16" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16] = buildArrayM16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 #-}+{-# RULES "buildArrayM/buildArrayM17" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17] = buildArrayM17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 #-}+{-# RULES "buildArrayM/buildArrayM18" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18] = buildArrayM18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 #-}+{-# RULES "buildArrayM/buildArrayM19" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19] = buildArrayM19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 #-}+{-# RULES "buildArrayM/buildArrayM20" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20] = buildArrayM20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 #-}+{-# RULES "buildArrayM/buildArrayM21" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21] = buildArrayM21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 #-}+{-# RULES "buildArrayM/buildArrayM22" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22] = buildArrayM22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 #-}+{-# RULES "buildArrayM/buildArrayM23" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23] = buildArrayM23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 #-}+{-# RULES "buildArrayM/buildArrayM24" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24] = buildArrayM24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 #-}+{-# RULES "buildArrayM/buildArrayM25" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25] = buildArrayM25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 #-}+{-# RULES "buildArrayM/buildArrayM26" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26] = buildArrayM26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 #-}+{-# RULES "buildArrayM/buildArrayM27" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27] = buildArrayM27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 #-}+{-# RULES "buildArrayM/buildArrayM28" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28] = buildArrayM28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 #-}+{-# RULES "buildArrayM/buildArrayM29" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29] = buildArrayM29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 #-}+{-# RULES "buildArrayM/buildArrayM30" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30] = buildArrayM30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 #-}+{-# RULES "buildArrayM/buildArrayM31" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31] = buildArrayM31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 #-}+{-# RULES "buildArrayM/buildArrayM32" forall x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32. buildArrayM [x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32] = buildArrayM32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 #-}++buildArrayM1 :: J -> IO A+buildArrayM1 x1 =+  js_buildArrayM1 x1+{-# INLINE buildArrayM1 #-}++foreign import javascript unsafe "[$1]"+  js_buildArrayM1 :: J -> IO A+++buildArrayM2 :: J -> J -> IO A+buildArrayM2 x1 x2 =+  js_buildArrayM2 x1 x2+{-# INLINE buildArrayM2 #-}++foreign import javascript unsafe "[$1,$2]"+  js_buildArrayM2 :: J -> J -> IO A+++buildArrayM3 :: J -> J -> J -> IO A+buildArrayM3 x1 x2 x3 =+  js_buildArrayM3 x1 x2 x3+{-# INLINE buildArrayM3 #-}++foreign import javascript unsafe "[$1,$2,$3]"+  js_buildArrayM3 :: J -> J -> J -> IO A+++buildArrayM4 :: J -> J -> J -> J -> IO A+buildArrayM4 x1 x2 x3 x4 =+  js_buildArrayM4 x1 x2 x3 x4+{-# INLINE buildArrayM4 #-}++foreign import javascript unsafe "[$1,$2,$3,$4]"+  js_buildArrayM4 :: J -> J -> J -> J -> IO A+++buildArrayM5 :: J -> J -> J -> J -> J -> IO A+buildArrayM5 x1 x2 x3 x4 x5 =+  js_buildArrayM5 x1 x2 x3 x4 x5+{-# INLINE buildArrayM5 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5]"+  js_buildArrayM5 :: J -> J -> J -> J -> J -> IO A+++buildArrayM6 :: J -> J -> J -> J -> J -> J -> IO A+buildArrayM6 x1 x2 x3 x4 x5 x6 =+  js_buildArrayM6 x1 x2 x3 x4 x5 x6+{-# INLINE buildArrayM6 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6]"+  js_buildArrayM6 :: J -> J -> J -> J -> J -> J -> IO A+++buildArrayM7 :: J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM7 x1 x2 x3 x4 x5 x6 x7 =+  js_buildArrayM7 x1 x2 x3 x4 x5 x6 x7+{-# INLINE buildArrayM7 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7]"+  js_buildArrayM7 :: J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM8 :: J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM8 x1 x2 x3 x4 x5 x6 x7 x8 =+  js_buildArrayM8 x1 x2 x3 x4 x5 x6 x7 x8+{-# INLINE buildArrayM8 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8]"+  js_buildArrayM8 :: J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM9 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM9 x1 x2 x3 x4 x5 x6 x7 x8 x9 =+  js_buildArrayM9 x1 x2 x3 x4 x5 x6 x7 x8 x9+{-# INLINE buildArrayM9 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9]"+  js_buildArrayM9 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM10 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 =+  js_buildArrayM10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10+{-# INLINE buildArrayM10 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10]"+  js_buildArrayM10 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM11 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 =+  js_buildArrayM11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11+{-# INLINE buildArrayM11 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11]"+  js_buildArrayM11 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM12 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 =+  js_buildArrayM12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12+{-# INLINE buildArrayM12 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12]"+  js_buildArrayM12 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM13 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 =+  js_buildArrayM13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13+{-# INLINE buildArrayM13 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13]"+  js_buildArrayM13 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM14 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 =+  js_buildArrayM14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14+{-# INLINE buildArrayM14 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14]"+  js_buildArrayM14 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM15 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 =+  js_buildArrayM15 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15+{-# INLINE buildArrayM15 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15]"+  js_buildArrayM15 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM16 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 =+  js_buildArrayM16 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16+{-# INLINE buildArrayM16 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16]"+  js_buildArrayM16 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM17 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 =+  js_buildArrayM17 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17+{-# INLINE buildArrayM17 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17]"+  js_buildArrayM17 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM18 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 =+  js_buildArrayM18 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18+{-# INLINE buildArrayM18 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18]"+  js_buildArrayM18 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM19 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 =+  js_buildArrayM19 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19+{-# INLINE buildArrayM19 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19]"+  js_buildArrayM19 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM20 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 =+  js_buildArrayM20 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20+{-# INLINE buildArrayM20 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20]"+  js_buildArrayM20 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM21 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 =+  js_buildArrayM21 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21+{-# INLINE buildArrayM21 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21]"+  js_buildArrayM21 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM22 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 =+  js_buildArrayM22 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22+{-# INLINE buildArrayM22 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22]"+  js_buildArrayM22 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM23 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 =+  js_buildArrayM23 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23+{-# INLINE buildArrayM23 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23]"+  js_buildArrayM23 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM24 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 =+  js_buildArrayM24 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24+{-# INLINE buildArrayM24 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24]"+  js_buildArrayM24 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM25 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 =+  js_buildArrayM25 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25+{-# INLINE buildArrayM25 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25]"+  js_buildArrayM25 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM26 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 =+  js_buildArrayM26 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26+{-# INLINE buildArrayM26 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26]"+  js_buildArrayM26 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM27 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 =+  js_buildArrayM27 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27+{-# INLINE buildArrayM27 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27]"+  js_buildArrayM27 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM28 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 =+  js_buildArrayM28 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28+{-# INLINE buildArrayM28 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28]"+  js_buildArrayM28 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM29 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 =+  js_buildArrayM29 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29+{-# INLINE buildArrayM29 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29]"+  js_buildArrayM29 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM30 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 =+  js_buildArrayM30 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30+{-# INLINE buildArrayM30 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30]"+  js_buildArrayM30 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM31 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 =+  js_buildArrayM31 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31+{-# INLINE buildArrayM31 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31]"+  js_buildArrayM31 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++buildArrayM32 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+buildArrayM32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32 =+  js_buildArrayM32 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 x31 x32+{-# INLINE buildArrayM32 #-}++foreign import javascript unsafe "[$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32]"+  js_buildArrayM32 :: J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> J -> IO A+++foreign import javascript unsafe "h$buildObjectFromTupList($1)"+  js_buildObjectFromTupListI :: Any -> O+foreign import javascript unsafe "$r = {};" js_emptyObjectI :: O+buildObjectI :: [(K,V)] -> O+buildObjectI xs = js_buildObjectFromTupListI . unsafeCoerce . seqTupList $ xs+{-# INLINE [1] buildObjectI #-}+{-# RULES "buildObjectI/empty" buildObjectI [] = js_emptyObjectI #-}+{-# RULES "buildObjectI/buildObjectI1" forall k1 v1. buildObjectI [(k1,v1)] = buildObjectI1 k1 v1 #-}+{-# RULES "buildObjectI/buildObjectI2" forall k1 v1 k2 v2. buildObjectI [(k1,v1),(k2,v2)] = buildObjectI2 k1 v1 k2 v2 #-}+{-# RULES "buildObjectI/buildObjectI3" forall k1 v1 k2 v2 k3 v3. buildObjectI [(k1,v1),(k2,v2),(k3,v3)] = buildObjectI3 k1 v1 k2 v2 k3 v3 #-}+{-# RULES "buildObjectI/buildObjectI4" forall k1 v1 k2 v2 k3 v3 k4 v4. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4)] = buildObjectI4 k1 v1 k2 v2 k3 v3 k4 v4 #-}+{-# RULES "buildObjectI/buildObjectI5" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5)] = buildObjectI5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 #-}+{-# RULES "buildObjectI/buildObjectI6" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6)] = buildObjectI6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 #-}+{-# RULES "buildObjectI/buildObjectI7" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7)] = buildObjectI7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 #-}+{-# RULES "buildObjectI/buildObjectI8" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8)] = buildObjectI8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 #-}+{-# RULES "buildObjectI/buildObjectI9" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9)] = buildObjectI9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 #-}+{-# RULES "buildObjectI/buildObjectI10" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10)] = buildObjectI10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 #-}+{-# RULES "buildObjectI/buildObjectI11" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11)] = buildObjectI11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 #-}+{-# RULES "buildObjectI/buildObjectI12" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12)] = buildObjectI12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 #-}+{-# RULES "buildObjectI/buildObjectI13" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13)] = buildObjectI13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 #-}+{-# RULES "buildObjectI/buildObjectI14" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14)] = buildObjectI14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 #-}+{-# RULES "buildObjectI/buildObjectI15" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15)] = buildObjectI15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 #-}+{-# RULES "buildObjectI/buildObjectI16" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16)] = buildObjectI16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 #-}+{-# RULES "buildObjectI/buildObjectI17" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17)] = buildObjectI17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 #-}+{-# RULES "buildObjectI/buildObjectI18" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18)] = buildObjectI18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 #-}+{-# RULES "buildObjectI/buildObjectI19" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19)] = buildObjectI19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 #-}+{-# RULES "buildObjectI/buildObjectI20" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20)] = buildObjectI20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 #-}+{-# RULES "buildObjectI/buildObjectI21" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21)] = buildObjectI21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 #-}+{-# RULES "buildObjectI/buildObjectI22" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22)] = buildObjectI22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 #-}+{-# RULES "buildObjectI/buildObjectI23" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23)] = buildObjectI23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 #-}+{-# RULES "buildObjectI/buildObjectI24" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24)] = buildObjectI24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 #-}+{-# RULES "buildObjectI/buildObjectI25" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25)] = buildObjectI25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 #-}+{-# RULES "buildObjectI/buildObjectI26" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26)] = buildObjectI26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 #-}+{-# RULES "buildObjectI/buildObjectI27" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27)] = buildObjectI27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 #-}+{-# RULES "buildObjectI/buildObjectI28" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28)] = buildObjectI28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 #-}+{-# RULES "buildObjectI/buildObjectI29" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29)] = buildObjectI29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 #-}+{-# RULES "buildObjectI/buildObjectI30" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30)] = buildObjectI30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 #-}+{-# RULES "buildObjectI/buildObjectI31" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30),(k31,v31)] = buildObjectI31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 #-}+{-# RULES "buildObjectI/buildObjectI32" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32. buildObjectI [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30),(k31,v31),(k32,v32)] = buildObjectI32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32 #-}++buildObjectI1 :: K -> V -> O+buildObjectI1 k1 v1 =+  js_buildObjectI1 k1 v1+{-# INLINE buildObjectI1 #-}++foreign import javascript unsafe "h$buildObject($1,$2)"+  js_buildObjectI1 :: K -> V -> O+++buildObjectI2 :: K -> V -> K -> V -> O+buildObjectI2 k1 v1 k2 v2 =+  js_buildObjectI2 k1 v1 k2 v2+{-# INLINE buildObjectI2 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4)"+  js_buildObjectI2 :: K -> V -> K -> V -> O+++buildObjectI3 :: K -> V -> K -> V -> K -> V -> O+buildObjectI3 k1 v1 k2 v2 k3 v3 =+  js_buildObjectI3 k1 v1 k2 v2 k3 v3+{-# INLINE buildObjectI3 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6)"+  js_buildObjectI3 :: K -> V -> K -> V -> K -> V -> O+++buildObjectI4 :: K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI4 k1 v1 k2 v2 k3 v3 k4 v4 =+  js_buildObjectI4 k1 v1 k2 v2 k3 v3 k4 v4+{-# INLINE buildObjectI4 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8)"+  js_buildObjectI4 :: K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI5 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 =+  js_buildObjectI5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5+{-# INLINE buildObjectI5 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)"+  js_buildObjectI5 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI6 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 =+  js_buildObjectI6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6+{-# INLINE buildObjectI6 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)"+  js_buildObjectI6 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI7 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 =+  js_buildObjectI7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7+{-# INLINE buildObjectI7 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)"+  js_buildObjectI7 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI8 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 =+  js_buildObjectI8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8+{-# INLINE buildObjectI8 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)"+  js_buildObjectI8 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI9 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 =+  js_buildObjectI9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9+{-# INLINE buildObjectI9 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18)"+  js_buildObjectI9 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI10 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 =+  js_buildObjectI10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10+{-# INLINE buildObjectI10 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)"+  js_buildObjectI10 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI11 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 =+  js_buildObjectI11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11+{-# INLINE buildObjectI11 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22)"+  js_buildObjectI11 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI12 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 =+  js_buildObjectI12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12+{-# INLINE buildObjectI12 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24)"+  js_buildObjectI12 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI13 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 =+  js_buildObjectI13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13+{-# INLINE buildObjectI13 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26)"+  js_buildObjectI13 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI14 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 =+  js_buildObjectI14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14+{-# INLINE buildObjectI14 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28)"+  js_buildObjectI14 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI15 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 =+  js_buildObjectI15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15+{-# INLINE buildObjectI15 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30)"+  js_buildObjectI15 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI16 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 =+  js_buildObjectI16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16+{-# INLINE buildObjectI16 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32)"+  js_buildObjectI16 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI17 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 =+  js_buildObjectI17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17+{-# INLINE buildObjectI17 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34)"+  js_buildObjectI17 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI18 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 =+  js_buildObjectI18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18+{-# INLINE buildObjectI18 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36)"+  js_buildObjectI18 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI19 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 =+  js_buildObjectI19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19+{-# INLINE buildObjectI19 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38)"+  js_buildObjectI19 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI20 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 =+  js_buildObjectI20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20+{-# INLINE buildObjectI20 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40)"+  js_buildObjectI20 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI21 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 =+  js_buildObjectI21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21+{-# INLINE buildObjectI21 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42)"+  js_buildObjectI21 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI22 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 =+  js_buildObjectI22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22+{-# INLINE buildObjectI22 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44)"+  js_buildObjectI22 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI23 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 =+  js_buildObjectI23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23+{-# INLINE buildObjectI23 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46)"+  js_buildObjectI23 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI24 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 =+  js_buildObjectI24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24+{-# INLINE buildObjectI24 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48)"+  js_buildObjectI24 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI25 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 =+  js_buildObjectI25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25+{-# INLINE buildObjectI25 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50)"+  js_buildObjectI25 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI26 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 =+  js_buildObjectI26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26+{-# INLINE buildObjectI26 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52)"+  js_buildObjectI26 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI27 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 =+  js_buildObjectI27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27+{-# INLINE buildObjectI27 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54)"+  js_buildObjectI27 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI28 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 =+  js_buildObjectI28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28+{-# INLINE buildObjectI28 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56)"+  js_buildObjectI28 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI29 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 =+  js_buildObjectI29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29+{-# INLINE buildObjectI29 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58)"+  js_buildObjectI29 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI30 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 =+  js_buildObjectI30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30+{-# INLINE buildObjectI30 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60)"+  js_buildObjectI30 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI31 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 =+  js_buildObjectI31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31+{-# INLINE buildObjectI31 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60,$61,$62)"+  js_buildObjectI31 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++buildObjectI32 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+buildObjectI32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32 =+  js_buildObjectI32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32+{-# INLINE buildObjectI32 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60,$61,$62,$63,$64)"+  js_buildObjectI32 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> O+++foreign import javascript unsafe "h$buildObjectFromTupList($1)"+  js_buildObjectFromTupListM :: Any -> IO O+foreign import javascript unsafe "$r = {};" js_emptyObjectM :: IO O+buildObjectM :: [(K,V)] -> IO O+buildObjectM xs = js_buildObjectFromTupListM . unsafeCoerce . seqTupList $ xs+{-# INLINE [1] buildObjectM #-}+{-# RULES "buildObjectM/empty" buildObjectM [] = js_emptyObjectM #-}+{-# RULES "buildObjectM/buildObjectM1" forall k1 v1. buildObjectM [(k1,v1)] = buildObjectM1 k1 v1 #-}+{-# RULES "buildObjectM/buildObjectM2" forall k1 v1 k2 v2. buildObjectM [(k1,v1),(k2,v2)] = buildObjectM2 k1 v1 k2 v2 #-}+{-# RULES "buildObjectM/buildObjectM3" forall k1 v1 k2 v2 k3 v3. buildObjectM [(k1,v1),(k2,v2),(k3,v3)] = buildObjectM3 k1 v1 k2 v2 k3 v3 #-}+{-# RULES "buildObjectM/buildObjectM4" forall k1 v1 k2 v2 k3 v3 k4 v4. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4)] = buildObjectM4 k1 v1 k2 v2 k3 v3 k4 v4 #-}+{-# RULES "buildObjectM/buildObjectM5" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5)] = buildObjectM5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 #-}+{-# RULES "buildObjectM/buildObjectM6" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6)] = buildObjectM6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 #-}+{-# RULES "buildObjectM/buildObjectM7" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7)] = buildObjectM7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 #-}+{-# RULES "buildObjectM/buildObjectM8" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8)] = buildObjectM8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 #-}+{-# RULES "buildObjectM/buildObjectM9" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9)] = buildObjectM9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 #-}+{-# RULES "buildObjectM/buildObjectM10" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10)] = buildObjectM10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 #-}+{-# RULES "buildObjectM/buildObjectM11" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11)] = buildObjectM11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 #-}+{-# RULES "buildObjectM/buildObjectM12" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12)] = buildObjectM12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 #-}+{-# RULES "buildObjectM/buildObjectM13" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13)] = buildObjectM13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 #-}+{-# RULES "buildObjectM/buildObjectM14" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14)] = buildObjectM14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 #-}+{-# RULES "buildObjectM/buildObjectM15" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15)] = buildObjectM15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 #-}+{-# RULES "buildObjectM/buildObjectM16" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16)] = buildObjectM16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 #-}+{-# RULES "buildObjectM/buildObjectM17" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17)] = buildObjectM17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 #-}+{-# RULES "buildObjectM/buildObjectM18" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18)] = buildObjectM18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 #-}+{-# RULES "buildObjectM/buildObjectM19" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19)] = buildObjectM19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 #-}+{-# RULES "buildObjectM/buildObjectM20" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20)] = buildObjectM20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 #-}+{-# RULES "buildObjectM/buildObjectM21" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21)] = buildObjectM21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 #-}+{-# RULES "buildObjectM/buildObjectM22" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22)] = buildObjectM22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 #-}+{-# RULES "buildObjectM/buildObjectM23" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23)] = buildObjectM23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 #-}+{-# RULES "buildObjectM/buildObjectM24" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24)] = buildObjectM24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 #-}+{-# RULES "buildObjectM/buildObjectM25" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25)] = buildObjectM25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 #-}+{-# RULES "buildObjectM/buildObjectM26" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26)] = buildObjectM26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 #-}+{-# RULES "buildObjectM/buildObjectM27" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27)] = buildObjectM27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 #-}+{-# RULES "buildObjectM/buildObjectM28" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28)] = buildObjectM28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 #-}+{-# RULES "buildObjectM/buildObjectM29" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29)] = buildObjectM29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 #-}+{-# RULES "buildObjectM/buildObjectM30" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30)] = buildObjectM30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 #-}+{-# RULES "buildObjectM/buildObjectM31" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30),(k31,v31)] = buildObjectM31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 #-}+{-# RULES "buildObjectM/buildObjectM32" forall k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32. buildObjectM [(k1,v1),(k2,v2),(k3,v3),(k4,v4),(k5,v5),(k6,v6),(k7,v7),(k8,v8),(k9,v9),(k10,v10),(k11,v11),(k12,v12),(k13,v13),(k14,v14),(k15,v15),(k16,v16),(k17,v17),(k18,v18),(k19,v19),(k20,v20),(k21,v21),(k22,v22),(k23,v23),(k24,v24),(k25,v25),(k26,v26),(k27,v27),(k28,v28),(k29,v29),(k30,v30),(k31,v31),(k32,v32)] = buildObjectM32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32 #-}++buildObjectM1 :: K -> V -> IO O+buildObjectM1 k1 v1 =+  js_buildObjectM1 k1 v1+{-# INLINE buildObjectM1 #-}++foreign import javascript unsafe "h$buildObject($1,$2)"+  js_buildObjectM1 :: K -> V -> IO O+++buildObjectM2 :: K -> V -> K -> V -> IO O+buildObjectM2 k1 v1 k2 v2 =+  js_buildObjectM2 k1 v1 k2 v2+{-# INLINE buildObjectM2 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4)"+  js_buildObjectM2 :: K -> V -> K -> V -> IO O+++buildObjectM3 :: K -> V -> K -> V -> K -> V -> IO O+buildObjectM3 k1 v1 k2 v2 k3 v3 =+  js_buildObjectM3 k1 v1 k2 v2 k3 v3+{-# INLINE buildObjectM3 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6)"+  js_buildObjectM3 :: K -> V -> K -> V -> K -> V -> IO O+++buildObjectM4 :: K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM4 k1 v1 k2 v2 k3 v3 k4 v4 =+  js_buildObjectM4 k1 v1 k2 v2 k3 v3 k4 v4+{-# INLINE buildObjectM4 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8)"+  js_buildObjectM4 :: K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM5 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 =+  js_buildObjectM5 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5+{-# INLINE buildObjectM5 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)"+  js_buildObjectM5 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM6 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 =+  js_buildObjectM6 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6+{-# INLINE buildObjectM6 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)"+  js_buildObjectM6 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM7 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 =+  js_buildObjectM7 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7+{-# INLINE buildObjectM7 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)"+  js_buildObjectM7 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM8 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 =+  js_buildObjectM8 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8+{-# INLINE buildObjectM8 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16)"+  js_buildObjectM8 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM9 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 =+  js_buildObjectM9 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9+{-# INLINE buildObjectM9 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18)"+  js_buildObjectM9 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM10 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 =+  js_buildObjectM10 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10+{-# INLINE buildObjectM10 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)"+  js_buildObjectM10 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM11 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 =+  js_buildObjectM11 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11+{-# INLINE buildObjectM11 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22)"+  js_buildObjectM11 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM12 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 =+  js_buildObjectM12 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12+{-# INLINE buildObjectM12 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24)"+  js_buildObjectM12 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM13 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 =+  js_buildObjectM13 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13+{-# INLINE buildObjectM13 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26)"+  js_buildObjectM13 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM14 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 =+  js_buildObjectM14 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14+{-# INLINE buildObjectM14 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28)"+  js_buildObjectM14 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM15 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 =+  js_buildObjectM15 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15+{-# INLINE buildObjectM15 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30)"+  js_buildObjectM15 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM16 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 =+  js_buildObjectM16 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16+{-# INLINE buildObjectM16 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32)"+  js_buildObjectM16 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM17 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 =+  js_buildObjectM17 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17+{-# INLINE buildObjectM17 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34)"+  js_buildObjectM17 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM18 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 =+  js_buildObjectM18 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18+{-# INLINE buildObjectM18 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36)"+  js_buildObjectM18 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM19 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 =+  js_buildObjectM19 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19+{-# INLINE buildObjectM19 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38)"+  js_buildObjectM19 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM20 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 =+  js_buildObjectM20 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20+{-# INLINE buildObjectM20 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40)"+  js_buildObjectM20 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM21 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 =+  js_buildObjectM21 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21+{-# INLINE buildObjectM21 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42)"+  js_buildObjectM21 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM22 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 =+  js_buildObjectM22 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22+{-# INLINE buildObjectM22 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44)"+  js_buildObjectM22 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM23 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 =+  js_buildObjectM23 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23+{-# INLINE buildObjectM23 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46)"+  js_buildObjectM23 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM24 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 =+  js_buildObjectM24 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24+{-# INLINE buildObjectM24 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48)"+  js_buildObjectM24 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM25 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 =+  js_buildObjectM25 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25+{-# INLINE buildObjectM25 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50)"+  js_buildObjectM25 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM26 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 =+  js_buildObjectM26 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26+{-# INLINE buildObjectM26 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52)"+  js_buildObjectM26 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM27 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 =+  js_buildObjectM27 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27+{-# INLINE buildObjectM27 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54)"+  js_buildObjectM27 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM28 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 =+  js_buildObjectM28 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28+{-# INLINE buildObjectM28 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56)"+  js_buildObjectM28 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM29 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 =+  js_buildObjectM29 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29+{-# INLINE buildObjectM29 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58)"+  js_buildObjectM29 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM30 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 =+  js_buildObjectM30 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30+{-# INLINE buildObjectM30 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60)"+  js_buildObjectM30 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM31 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 =+  js_buildObjectM31 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31+{-# INLINE buildObjectM31 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60,$61,$62)"+  js_buildObjectM31 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+++buildObjectM32 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O+buildObjectM32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32 =+  js_buildObjectM32 k1 v1 k2 v2 k3 v3 k4 v4 k5 v5 k6 v6 k7 v7 k8 v8 k9 v9 k10 v10 k11 v11 k12 v12 k13 v13 k14 v14 k15 v15 k16 v16 k17 v17 k18 v18 k19 v19 k20 v20 k21 v21 k22 v22 k23 v23 k24 v24 k25 v25 k26 v26 k27 v27 k28 v28 k29 v29 k30 v30 k31 v31 k32 v32+{-# INLINE buildObjectM32 #-}++foreign import javascript unsafe "h$buildObject($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41,$42,$43,$44,$45,$46,$47,$48,$49,$50,$51,$52,$53,$54,$55,$56,$57,$58,$59,$60,$61,$62,$63,$64)"+  js_buildObjectM32 :: K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> K -> V -> IO O++++#endif