box-tuples 0.1.1.0 → 0.2.0.0
raw patch · 3 files changed
+407/−103 lines, 3 filesdep ~base
Dependency ranges changed: base
Files
- box-tuples.cabal +3/−2
- src/Data/Tuple/Unboxed.hs +154/−101
- src/Data/Tuple/Unboxed/Rep.hs +250/−0
box-tuples.cabal view
@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: box-tuples-version: 0.1.1.0+version: 0.2.0.0 synopsis: A hack to use GHC.Prim primitives in GHCi description: As of now, the GHCi interactive runtime is incapable of working on unboxed tuples. In particular, it is unable to fully apply any function returning an@@ -21,7 +21,8 @@ cabal-version: >=1.10 library- exposed-modules: Data.Tuple.Unboxed+ exposed-modules: Data.Tuple.Unboxed,+ Data.Tuple.Unboxed.Rep build-depends: base == 4.*, ghc-prim hs-source-dirs: src default-language: Haskell2010
src/Data/Tuple/Unboxed.hs view
@@ -1,8 +1,10 @@-{-# LANGUAGE UnboxedTuples, MagicHash #-}+{-# LANGUAGE UnboxedTuples, MagicHash, CPP #-}+{-# OPTIONS_GHC -fobject-code #-}+#include "MachDeps.h" ------------------------------------------------------------------------------- -- | -- Module : Data.Tuple.Unboxed--- Copyright : (C) 2016 mniip+-- Copyright : (C) 2016,2020 mniip -- License : MIT -- Maintainer : mniip <mniip@mniip.com> -- Stability : experimental@@ -40,9 +42,14 @@ -- * Aa = 'ArrayArray#' -- * b = 'ByteArray#' -- * c = 'Char#'+-- * C = 'Compact#' -- * d = 'Double#' -- * f = 'Float#' -- * i = 'Int#'+-- * li = INT32 (@if WORD\_SIZE_IN_BITS >= 32 then 'Int#' else 'Int32#'@)+-- * lli = INT64 (@if WORD\_SIZE_IN_BITS >= 64 then 'Int#' else 'Int64#'@)+-- * hi = 'Int16#'+-- * hhi = 'Int8#' -- * Ma = 'MutableArray#' -- * MAa = 'MutableArrayArray#' -- * Mb = 'MutableByteArray#'@@ -58,138 +65,184 @@ -- * Tv = 'TVar#' -- * v = 'MutVar#' -- * w = 'Word#'+-- * lw = WORD32 (@if WORD\_SIZE_IN_BITS >= 32 then 'Word#' else 'Word32#'@)+-- * llw = WORD64 (@if WORD\_SIZE_IN_BITS >= 64 then 'Word#' else 'Word64#'@)+-- * hw = 'Word16#'+-- * hhw = 'Word8#' -- * Wp = 'Weak#' ----- This module contains functions for all combinations of types that come up in--- "GHC.Prim" but in principle other cases could be added too.+-- This module contains functions for all combinations of types that have ever+-- come up in "GHC.Prim" but in principle other cases could be added too. --------------------------------------------------------------------------------module Data.Tuple.Unboxed- (- composea1_,- composei1_,- composeo1_,- composed2ii,- composef2ii,- composei2i_,- composei2ii,- composes2s_,- composes2sa,- composes2sAa,- composes2sb,- composes2sc,- composes2sd,- composes2sf,- composes2si,- composes2sSa,- composes2sSMa,- composes2sSn,- composes2sSp,- composes2sMa,- composes2sMAa,- composes2sMb,- composes2sMv,- composes2so,- composes2sp,- composes2st,- composes2sTv,- composes2sv,- composes2sw,- composes2sWp,- composew2wi,- composew2ww,- compose_3pab,- compose_3pba,- composes3si_,- composes3spw,- composed4iwwi,- composes4siii,- decomposes2s_- )- where+module Data.Tuple.Unboxed where import GHC.Prim -composea1_ :: (Addr# -> (# a #)) -> Addr# -> (a -> r) -> r+#if WORD_SIZE_IN_BITS >= 32+#define INT32 Int#+#define WORD32 Word#+#else+#define INT32 Int32#+#define WORD32 Word32#+#endif+#if WORD_SIZE_IN_BITS >= 64+#define INT64 Int#+#define WORD64 Word#+#else+#define INT64 Int64#+#define WORD64 Word64#+#endif++compose_1_ :: (a -> (# b #)) -> a -> (b -> r) -> r composei1_ :: (Int# -> (# a #)) -> Int# -> (a -> r) -> r composeo1_ :: (BCO# -> (# a #)) -> BCO# -> (a -> r) -> r-composed2ii :: (Double# -> (# Int#, Int# #)) -> Double# -> (Int# -> Int# -> r) -> r+composep1_ :: (Addr# -> (# a #)) -> Addr# -> (a -> r) -> r+composew1_ :: (Word# -> (# a #)) -> Word# -> (a -> r) -> r+compose_2ab :: (a -> (# Array# e, ByteArray# #)) -> a -> (Array# e -> ByteArray# -> r) -> r+composeb2ib :: (ByteArray# -> (# Int#, ByteArray# #)) -> ByteArray# -> (Int# -> ByteArray# -> r) -> r+composed2ii :: (Double# -> (# INT64, Int# #)) -> Double# -> (Int# -> Int# -> r) -> r+composed2llii :: (Double# -> (# INT64, Int# #)) -> Double# -> (INT64 -> Int# -> r) -> r composef2ii :: (Float# -> (# Int#, Int# #)) -> Float# -> (Int# -> Int# -> r) -> r+composehhi2hhihhi :: (Int8# -> (# Int8#, Int8# #)) -> Int8# -> (Int8# -> Int8# -> r) -> r+composehhw2hhwhhw :: (Word8# -> (# Word8#, Word8# #)) -> Word8# -> (Word8# -> Word8# -> r) -> r+composehi2hihi :: (Int16# -> (# Int16#, Int16# #)) -> Int16# -> (Int16# -> Int16# -> r) -> r+composehw2hwhw :: (Word16# -> (# Word16#, Word16# #)) -> Word16# -> (Word16# -> Word16# -> r) -> r composei2i_ :: (Int# -> (# Int#, a #)) -> Int# -> (Int# -> a -> r) -> r+composei2ib :: (Int# -> (# Int#, ByteArray# #)) -> Int# -> (Int# -> ByteArray# -> r) -> r composei2ii :: (Int# -> (# Int#, Int# #)) -> Int# -> (Int# -> Int# -> r) -> r+composeli2ib :: (INT32 -> (# Int#, ByteArray# #)) -> INT32 -> (Int# -> ByteArray# -> r) -> r+composelli2ib :: (INT64 -> (# Int#, ByteArray# #)) -> INT64 -> (Int# -> ByteArray# -> r) -> r+composellw2ib :: (WORD64 -> (# Int#, ByteArray# #)) -> WORD64 -> (Int# -> ByteArray# -> r) -> r+composelw2ib :: (WORD32 -> (# Int#, ByteArray# #)) -> WORD32 -> (Int# -> ByteArray# -> r) -> r+composep2ib :: (Addr# -> (# Int#, ByteArray# #)) -> Addr# -> (Int# -> ByteArray# -> r) -> r composes2s_ :: (State# s -> (# State# t, a #)) -> State# s -> (State# t -> a -> r) -> r-composes2sa :: (State# s -> (# State# t, Array# a #)) -> State# s -> (State# t -> Array# a -> r) -> r-composes2sAa :: (State# s -> (# State# t, ArrayArray# #)) -> State# s -> (State# t -> ArrayArray# -> r) -> r+composes2sa :: (State# s -> (# State# t, Array# e #)) -> State# s -> (State# t -> Array# e -> r) -> r composes2sb :: (State# s -> (# State# t, ByteArray# #)) -> State# s -> (State# t -> ByteArray# -> r) -> r composes2sc :: (State# s -> (# State# t, Char# #)) -> State# s -> (State# t -> Char# -> r) -> r+composes2sC :: (State# s -> (# State# t, Compact# #)) -> State# s -> (State# t -> Compact# -> r) -> r composes2sd :: (State# s -> (# State# t, Double# #)) -> State# s -> (State# t -> Double# -> r) -> r composes2sf :: (State# s -> (# State# t, Float# #)) -> State# s -> (State# t -> Float# -> r) -> r composes2si :: (State# s -> (# State# t, Int# #)) -> State# s -> (State# t -> Int# -> r) -> r-composes2sSa :: (State# s -> (# State# t, SmallArray# a #)) -> State# s -> (State# t -> SmallArray# a -> r) -> r-composes2sSMa :: (State# s -> (# State# t, SmallMutableArray# u a #)) -> State# s -> (State# t -> SmallMutableArray# u a -> r) -> r-composes2sSn :: (State# s -> (# State# t, StableName# a #)) -> State# s -> (State# t -> StableName# a -> r) -> r-composes2sSp :: (State# s -> (# State# t, StablePtr# a #)) -> State# s -> (State# t -> StablePtr# a -> r) -> r-composes2sMa :: (State# s -> (# State# t, MutableArray# u a #)) -> State# s -> (State# t -> MutableArray# u a -> r) -> r-composes2sMAa :: (State# s -> (# State# t, MutableArrayArray# u #)) -> State# s -> (State# t -> MutableArrayArray# u -> r) -> r+composes2sli :: (State# s -> (# State# t, INT32 #)) -> State# s -> (State# t -> INT32 -> r) -> r+composes2slli :: (State# s -> (# State# t, INT64 #)) -> State# s -> (State# t -> INT64 -> r) -> r+composes2sllw :: (State# s -> (# State# t, WORD64 #)) -> State# s -> (State# t -> WORD64 -> r) -> r+composes2slw :: (State# s -> (# State# t, WORD32 #)) -> State# s -> (State# t -> WORD32 -> r) -> r+composes2sMa :: (State# s -> (# State# t, MutableArray# u e #)) -> State# s -> (State# t -> MutableArray# u e -> r) -> r composes2sMb :: (State# s -> (# State# t, MutableByteArray# u #)) -> State# s -> (State# t -> MutableByteArray# u -> r) -> r-composes2sMv :: (State# s -> (# State# t, MVar# u a #)) -> State# s -> (State# t -> MVar# u a -> r) -> r+composes2sMv :: (State# s -> (# State# t, MVar# u e #)) -> State# s -> (State# t -> MVar# u e -> r) -> r composes2so :: (State# s -> (# State# t, BCO# #)) -> State# s -> (State# t -> BCO# -> r) -> r composes2sp :: (State# s -> (# State# t, Addr# #)) -> State# s -> (State# t -> Addr# -> r) -> r+composes2sSn :: (State# s -> (# State# t, StableName# a #)) -> State# s -> (State# t -> StableName# a -> r) -> r+composes2sSp :: (State# s -> (# State# t, StablePtr# a #)) -> State# s -> (State# t -> StablePtr# a -> r) -> r composes2st :: (State# s -> (# State# t, ThreadId# #)) -> State# s -> (State# t -> ThreadId# -> r) -> r-composes2sTv :: (State# s -> (# State# t, TVar# u a #)) -> State# s -> (State# t -> TVar# u a -> r) -> r-composes2sv :: (State# s -> (# State# t, MutVar# u a #)) -> State# s -> (State# t -> MutVar# u a -> r) -> r+composes2sTv :: (State# s -> (# State# t, TVar# u e #)) -> State# s -> (State# t -> TVar# u e -> r) -> r+composes2sv :: (State# s -> (# State# t, MutVar# u e #)) -> State# s -> (State# t -> MutVar# u e -> r) -> r composes2sw :: (State# s -> (# State# t, Word# #)) -> State# s -> (State# t -> Word# -> r) -> r composes2sWp :: (State# s -> (# State# t, Weak# a #)) -> State# s -> (State# t -> Weak# a -> r) -> r+composew2ib :: (Word# -> (# Int#, ByteArray# #)) -> Word# -> (Int# -> ByteArray# -> r) -> r composew2wi :: (Word# -> (# Word#, Int# #)) -> Word# -> (Word# -> Int# -> r) -> r composew2ww :: (Word# -> (# Word#, Word# #)) -> Word# -> (Word# -> Word# -> r) -> r-compose_3pab :: (a -> (# Addr#, Array# b, ByteArray# #)) -> a -> (Addr# -> Array# b -> ByteArray# -> r) -> r-compose_3pba :: (a -> (# Addr#, ByteArray#, Array# b #)) -> a -> (Addr# -> ByteArray# -> Array# b -> r) -> r+compose_3pab :: (a -> (# Addr#, Array# e, ByteArray# #)) -> a -> (Addr# -> Array# e -> ByteArray# -> r) -> r+compose_3pba :: (a -> (# Addr#, ByteArray#, Array# e #)) -> a -> (Addr# -> ByteArray# -> Array# e -> r) -> r+composed3iib :: (Double# -> (# Int#, Int#, ByteArray# #)) -> Double# -> (Int# -> Int# -> ByteArray# -> r) -> r+composed3iii :: (Double# -> (# Int#, Int#, Int# #)) -> Double# -> (Int# -> Int# -> Int# -> r) -> r+composef3iib :: (Float# -> (# Int#, Int#, ByteArray# #)) -> Float# -> (Int# -> Int# -> ByteArray# -> r) -> r+composei3iii :: (Int# -> (# Int#, Int#, Int# #)) -> Int# -> (Int# -> Int# -> Int# -> r) -> r+composes3s__ :: (State# s -> (# State# t, a, b #)) -> State# s -> (State# t -> a -> b -> r) -> r+composes3s_2__ :: (State# s -> (# State# t, a, (# b, c #) #)) -> State# s -> (State# t -> a -> b -> c -> r) -> r+composes3sCp :: (State# s -> (# State# t, Compact#, Addr# #)) -> State# s -> (State# t -> Compact# -> Addr# -> r) -> r+composes3sii :: (State# s -> (# State# t, Int#, Int# #)) -> State# s -> (State# t -> Int# -> Int# -> r) -> r composes3si_ :: (State# s -> (# State# t, Int#, a #)) -> State# s -> (State# t -> Int# -> a -> r) -> r composes3spw :: (State# s -> (# State# t, Addr#, Word# #)) -> State# s -> (State# t -> Addr# -> Word# -> r) -> r+composeb4ibib :: (ByteArray# -> (# Int#, ByteArray#, Int#, ByteArray# #)) -> ByteArray# -> (Int# -> ByteArray# -> Int# -> ByteArray# -> r) -> r composed4iwwi :: (Double# -> (# Int#, Word#, Word#, Int# #)) -> Double# -> (Int# -> Word# -> Word# -> Int# -> r) -> r composes4siii :: (State# s -> (# State# t, Int#, Int#, Int# #)) -> State# s -> (State# t -> Int# -> Int# -> Int# -> r) -> r-composea1_ p x f = case p x of (# a #) -> f a-composei1_ p x f = case p x of (# a #) -> f a-composeo1_ p x f = case p x of (# a #) -> f a-composed2ii p x f = case p x of (# a, b #) -> f a b-composef2ii p x f = case p x of (# a, b #) -> f a b-composei2i_ p x f = case p x of (# a, b #) -> f a b-composei2ii p x f = case p x of (# a, b #) -> f a b-composes2s_ p x f = case p x of (# a, b #) -> f a b-composes2sa p x f = case p x of (# a, b #) -> f a b-composes2sAa p x f = case p x of (# a, b #) -> f a b-composes2sb p x f = case p x of (# a, b #) -> f a b-composes2sc p x f = case p x of (# a, b #) -> f a b-composes2sd p x f = case p x of (# a, b #) -> f a b-composes2sf p x f = case p x of (# a, b #) -> f a b-composes2si p x f = case p x of (# a, b #) -> f a b-composes2sSa p x f = case p x of (# a, b #) -> f a b-composes2sSMa p x f = case p x of (# a, b #) -> f a b-composes2sSn p x f = case p x of (# a, b #) -> f a b-composes2sSp p x f = case p x of (# a, b #) -> f a b-composes2sMa p x f = case p x of (# a, b #) -> f a b-composes2sMAa p x f = case p x of (# a, b #) -> f a b-composes2sMb p x f = case p x of (# a, b #) -> f a b-composes2sMv p x f = case p x of (# a, b #) -> f a b-composes2so p x f = case p x of (# a, b #) -> f a b-composes2sp p x f = case p x of (# a, b #) -> f a b-composes2st p x f = case p x of (# a, b #) -> f a b-composes2sTv p x f = case p x of (# a, b #) -> f a b-composes2sv p x f = case p x of (# a, b #) -> f a b-composes2sw p x f = case p x of (# a, b #) -> f a b-composes2sWp p x f = case p x of (# a, b #) -> f a b-composew2wi p x f = case p x of (# a, b #) -> f a b-composew2ww p x f = case p x of (# a, b #) -> f a b-compose_3pab p x f = case p x of (# a, b, c #) -> f a b c-compose_3pba p x f = case p x of (# a, b, c #) -> f a b c-composes3si_ p x f = case p x of (# a, b, c #) -> f a b c-composes3spw p x f = case p x of (# a, b, c #) -> f a b c-composed4iwwi p x f = case p x of (# a, b, c, d #) -> f a b c d-composes4siii p x f = case p x of (# a, b, c, d #) -> f a b c d +compose_1_ f x k = case f x of (# a #) -> k a+composei1_ f x k = case f x of (# a #) -> k a+composeo1_ f x k = case f x of (# a #) -> k a+composep1_ f x k = case f x of (# a #) -> k a+composew1_ f x k = case f x of (# a #) -> k a+compose_2ab f x k = case f x of (# a, b #) -> k a b+composeb2ib f x k = case f x of (# a, b #) -> k a b+composed2ii f x k = case f x of (# a, b #) -> k a b+composed2llii f x k = case f x of (# a, b #) -> k a b+composef2ii f x k = case f x of (# a, b #) -> k a b+composehhi2hhihhi f x k = case f x of (# a, b #) -> k a b+composehhw2hhwhhw f x k = case f x of (# a, b #) -> k a b+composehi2hihi f x k = case f x of (# a, b #) -> k a b+composehw2hwhw f x k = case f x of (# a, b #) -> k a b+composei2i_ f x k = case f x of (# a, b #) -> k a b+composei2ib f x k = case f x of (# a, b #) -> k a b+composei2ii f x k = case f x of (# a, b #) -> k a b+composeli2ib f x k = case f x of (# a, b #) -> k a b+composelli2ib f x k = case f x of (# a, b #) -> k a b+composellw2ib f x k = case f x of (# a, b #) -> k a b+composelw2ib f x k = case f x of (# a, b #) -> k a b+composep2ib f x k = case f x of (# a, b #) -> k a b+composes2s_ f x k = case f x of (# a, b #) -> k a b+composes2sa f x k = case f x of (# a, b #) -> k a b+composes2sb f x k = case f x of (# a, b #) -> k a b+composes2sC f x k = case f x of (# a, b #) -> k a b+composes2sc f x k = case f x of (# a, b #) -> k a b+composes2sd f x k = case f x of (# a, b #) -> k a b+composes2sf f x k = case f x of (# a, b #) -> k a b+composes2si f x k = case f x of (# a, b #) -> k a b+composes2sli f x k = case f x of (# a, b #) -> k a b+composes2slli f x k = case f x of (# a, b #) -> k a b+composes2sllw f x k = case f x of (# a, b #) -> k a b+composes2slw f x k = case f x of (# a, b #) -> k a b+composes2sMa f x k = case f x of (# a, b #) -> k a b+composes2sMb f x k = case f x of (# a, b #) -> k a b+composes2sMv f x k = case f x of (# a, b #) -> k a b+composes2so f x k = case f x of (# a, b #) -> k a b+composes2sp f x k = case f x of (# a, b #) -> k a b+composes2sSn f x k = case f x of (# a, b #) -> k a b+composes2sSp f x k = case f x of (# a, b #) -> k a b+composes2st f x k = case f x of (# a, b #) -> k a b+composes2sTv f x k = case f x of (# a, b #) -> k a b+composes2sv f x k = case f x of (# a, b #) -> k a b+composes2sw f x k = case f x of (# a, b #) -> k a b+composes2sWp f x k = case f x of (# a, b #) -> k a b+composew2ib f x k = case f x of (# a, b #) -> k a b+composew2wi f x k = case f x of (# a, b #) -> k a b+composew2ww f x k = case f x of (# a, b #) -> k a b+compose_3pab f x k = case f x of (# a, b, c #) -> k a b c+compose_3pba f x k = case f x of (# a, b, c #) -> k a b c+composed3iib f x k = case f x of (# a, b, c #) -> k a b c+composed3iii f x k = case f x of (# a, b, c #) -> k a b c+composef3iib f x k = case f x of (# a, b, c #) -> k a b c+composei3iii f x k = case f x of (# a, b, c #) -> k a b c+composes3s__ f x k = case f x of (# a, b, c #) -> k a b c+composes3s_2__ f x k = case f x of (# a, b, (# c, d #) #) -> k a b c d+composes3sCp f x k = case f x of (# a, b, c #) -> k a b c+composes3sii f x k = case f x of (# a, b, c #) -> k a b c+composes3si_ f x k = case f x of (# a, b, c #) -> k a b c+composes3spw f x k = case f x of (# a, b, c #) -> k a b c+composeb4ibib f x k = case f x of (# a, b, c, d #) -> k a b c d+composed4iwwi f x k = case f x of (# a, b, c, d #) -> k a b c d+composes4siii f x k = case f x of (# a, b, c, d #) -> k a b c d++#if __GLASGOW_HASKELL__ >= 710+composes2sSa :: (State# s -> (# State# t, SmallArray# e #)) -> State# s -> (State# t -> SmallArray# e -> r) -> r+composes2sSMa :: (State# s -> (# State# t, SmallMutableArray# u e #)) -> State# s -> (State# t -> SmallMutableArray# u e -> r) -> r+composes2sSa f x k = case f x of (# a, b #) -> k a b+composes2sSMa f x k = case f x of (# a, b #) -> k a b+#endif+#if __GLASGOW_HASKELL__ >= 704+composes2sAa :: (State# s -> (# State# t, ArrayArray# #)) -> State# s -> (State# t -> ArrayArray# -> r) -> r+composes2sMAa :: (State# s -> (# State# t, MutableArrayArray# u #)) -> State# s -> (State# t -> MutableArrayArray# u -> r) -> r+composes2sAa f x k = case f x of (# a, b #) -> k a b+composes2sMAa f x k = case f x of (# a, b #) -> k a b+#endif+ -- | This is an \"inverse\" of 'composes2s_' because sometimes it might be -- useful to produce a @'State#' s a -> (\# 'State#' s, a \#)@ of your own. -- Example: -- -- @returnIO x = 'IO' ('decomposes2s_' (\s r -> r s x))@-decomposes2s_ :: (State# s -> (State# s -> a -> (# State# s, a #)) -> (# State# s, a #)) -> State# s -> (# State# s, a #)+decomposes2s_ :: (State# s -> (State# t -> a -> (# State# t, a #)) -> (# State# t, a #)) -> State# s -> (# State# t, a #) decomposes2s_ f x = f x (\a b -> (# a, b #))++decompose_2__ :: (a -> (b -> c -> (# b, c #)) -> (# b, c #)) -> a -> (# b, c #)+decompose_2__ f x = f x (\a b -> (# a, b #))
+ src/Data/Tuple/Unboxed/Rep.hs view
@@ -0,0 +1,250 @@+{-# LANGUAGE UnboxedTuples, MagicHash, CPP #-}+#if __GLASGOW_HASKELL__ >= 800+{-# LANGUAGE TypeInType, RankNTypes, MultiParamTypeClasses, FlexibleInstances #-}+{-# OPTIONS_GHC -fobject-code #-}++-------------------------------------------------------------------------------+-- |+-- Module : Data.Tuple.Unboxed.Rep+-- Copyright : (C) 2020 mniip+-- License : MIT+-- Maintainer : mniip <mniip@mniip.com>+-- Stability : experimental+-- Portability : non-portable+--+-- This module provides an ad-hoc polymorphic alternative to the functions in +-- "Data.Tuple.Unboxed". The functions have the same basic signature, but using+-- GHC 8.0+ features they are made parametrically polymorphic within each fixed+-- representation/calling convention.+--+-- This module defines instances for all calling conventions that have ever come+-- up in "GHC.Prim" but in principle other cases could be added too.+-------------------------------------------------------------------------------+module Data.Tuple.Unboxed.Rep+ ( RepCompose1(..)+ , RepCompose2(..)+ , RepCompose3(..)+ , RepCompose4(..)+ ) where++import GHC.Prim+import GHC.Exts++#if __GLASGOW_HASKELL__ >= 802+type VoidRep = TupleRep '[]+#endif++#if __GLASGOW_HASKELL__ < 802+type LiftedRep = PtrRepLifted+type UnlfitedRep = PtrRepUnlifted+#endif++class RepCompose1 (r0 :: RuntimeRep) (r1 :: RuntimeRep) where+ repCompose1 :: forall (a :: TYPE r0) (b :: TYPE r1) (r :: *). (a -> (# b #)) -> a -> (b -> r) -> r+ repDecompose1 :: forall (a :: TYPE r0) (b :: TYPE r1) (r :: *). (a -> (b -> (# b #)) -> (# b #)) -> a -> (# b #)++class RepCompose2 (r0 :: RuntimeRep) (r1 :: RuntimeRep) (r2 :: RuntimeRep) where+ repCompose2 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (r :: *). (a -> (# b, c #)) -> a -> (b -> c -> r) -> r+ repDecompose2 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (r :: *). (a -> (b -> c -> (# b, c #)) -> (# b, c #)) -> a -> (# b, c #)++class RepCompose3 (r0 :: RuntimeRep) (r1 :: RuntimeRep) (r2 :: RuntimeRep) (r3 :: RuntimeRep) where+ repCompose3 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (d :: TYPE r3) (r :: *). (a -> (# b, c, d #)) -> a -> (b -> c -> d -> r) -> r+ repDecompose3 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (d :: TYPE r3) (r :: *). (a -> (b -> c -> d -> (# b, c, d #)) -> (# b, c, d #)) -> a -> (# b, c, d #)++class RepCompose4 (r0 :: RuntimeRep) (r1 :: RuntimeRep) (r2 :: RuntimeRep) (r3 :: RuntimeRep) (r4 :: RuntimeRep) where+ repCompose4 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (d :: TYPE r3) (e :: TYPE r4) (r :: *). (a -> (# b, c, d, e #)) -> a -> (b -> c -> d -> e -> r) -> r+ repDecompose4 :: forall (a :: TYPE r0) (b :: TYPE r1) (c :: TYPE r2) (d :: TYPE r3) (e :: TYPE r4) (r :: *). (a -> (b -> c -> d -> e -> (# b, c, d, e #)) -> (# b, c, d, e #)) -> a -> (# b, c, d, e #)++instance RepCompose1 LiftedRep LiftedRep where+ repCompose1 f x k = case f x of (# a #) -> k a+ repDecompose1 f x = f x (\a -> (# a #))++instance RepCompose1 UnliftedRep LiftedRep where+ repCompose1 f x k = case f x of (# a #) -> k a+ repDecompose1 f x = f x (\a -> (# a #))++instance RepCompose1 IntRep LiftedRep where+ repCompose1 f x k = case f x of (# a #) -> k a+ repDecompose1 f x = f x (\a -> (# a #))++instance RepCompose1 WordRep LiftedRep where+ repCompose1 f x k = case f x of (# a #) -> k a+ repDecompose1 f x = f x (\a -> (# a #))++instance RepCompose1 AddrRep LiftedRep where+ repCompose1 f x k = case f x of (# a #) -> k a+ repDecompose1 f x = f x (\a -> (# a #))++instance RepCompose2 VoidRep VoidRep LiftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep WordRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep AddrRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep FloatRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep DoubleRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 LiftedRep UnliftedRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 UnliftedRep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 IntRep IntRep LiftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 IntRep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 IntRep IntRep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 WordRep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 WordRep WordRep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 WordRep WordRep WordRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 AddrRep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 FloatRep IntRep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 DoubleRep IntRep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose3 VoidRep VoidRep LiftedRep LiftedRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 VoidRep VoidRep UnliftedRep AddrRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 VoidRep VoidRep IntRep LiftedRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 VoidRep VoidRep IntRep IntRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 VoidRep VoidRep AddrRep WordRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 LiftedRep AddrRep UnliftedRep UnliftedRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 IntRep IntRep IntRep IntRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 FloatRep IntRep IntRep UnliftedRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 DoubleRep IntRep IntRep UnliftedRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose3 DoubleRep IntRep IntRep IntRep where+ repCompose3 f x k = case f x of (# a, b, c #) -> k a b c+ repDecompose3 f x = f x (\a b c -> (# a, b, c #))++instance RepCompose4 VoidRep VoidRep IntRep IntRep IntRep where+ repCompose4 f x k = case f x of (# a, b, c, d #) -> k a b c d+ repDecompose4 f x = f x (\a b c d -> (# a, b, c, d #))++instance RepCompose4 UnliftedRep IntRep UnliftedRep IntRep UnliftedRep where+ repCompose4 f x k = case f x of (# a, b, c, d #) -> k a b c d+ repDecompose4 f x = f x (\a b c d -> (# a, b, c, d #))++instance RepCompose4 DoubleRep IntRep WordRep WordRep IntRep where+ repCompose4 f x k = case f x of (# a, b, c, d #) -> k a b c d+ repDecompose4 f x = f x (\a b c d -> (# a, b, c, d #))++#if __GLASGOW_HASKELL__ >= 808+instance RepCompose2 VoidRep VoidRep Int64Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 VoidRep VoidRep Word64Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Int8Rep Int8Rep Int8Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Int16Rep Int16Rep Int16Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Int64Rep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Int64Rep Int64Rep Int64Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Word8Rep Word8Rep Word8Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Word16Rep Word16Rep Word16Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Word64Rep IntRep UnliftedRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 Word64Rep Word64Rep Word64Rep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))++instance RepCompose2 DoubleRep Int64Rep IntRep where+ repCompose2 f x k = case f x of (# a, b #) -> k a b+ repDecompose2 f x = f x (\a b -> (# a, b #))+#endif++#else+module Data.Tuple.Unboxed.Rep () where+#endif