Data.Tuple.Unboxed

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 unboxed tuple, create a function that takes a non-nullary unboxed tuple as argument, or pass a non-nullary tuple to some other function. The usual solution is to enable object code generation with -fobject-code. This module serves as a workaround for the cases where -fobject-code is undesiable.

Due to the aforementioned restrictions on operations on unboxed tuples, we can't simply expose operations of type (# a, b #) -> (a, b). We have to provide operations for working on functions of type a -> (# b, c #).

More often than not, the types in unboxed tuples are themselves unboxed. There are two major issues with this: 1) we cannot use (,) and 2) we have to provide different functions for different combinations of types. It is also worth mentioning that the a above can also be unboxed and therefore cannot be quantified either.

This module provides a class of compose functions of type

composeA#BC :: (a -> (# b, c, ... #)) -> a -> (b -> c -> ... -> r) -> r

Where A is the function argument type a, # is number of fields in the tuple, and BC are the tupled types b, c, ...

The key for type names is as follows:

• _ = forall (a :: *). a (regular lifted type)
• a = Array#
• 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#
• Mv = MVar#
• o = BCO#
• p = Addr#
• s = State#
• Sa = SmallArray#
• SMa = SmallMutableArray#
• Sn = StableName#
• Sp = StablePtr#
• t = ThreadId#
• 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 have ever come up in GHC.Prim but in principle other cases could be added too.

Documentation

compose_1_ :: (a -> (#b#)) -> a -> (b -> r) -> r

composei1_ :: (Int# -> (#a#)) -> Int# -> (a -> r) -> r

composeo1_ :: (BCO# -> (#a#)) -> BCO# -> (a -> 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# -> (#Int#, Int##)) -> Double# -> (Int# -> Int# -> r) -> r

composed2llii :: (Double# -> (#Int#, Int##)) -> Double# -> (Int# -> Int# -> r) -> r

composef2ii :: (Float# -> (#Int#, Int##)) -> Float# -> (Int# -> Int# -> 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 :: (Int# -> (#Int#, ByteArray##)) -> Int# -> (Int# -> ByteArray# -> r) -> r

composelli2ib :: (Int# -> (#Int#, ByteArray##)) -> Int# -> (Int# -> ByteArray# -> r) -> r

composellw2ib :: (Word# -> (#Int#, ByteArray##)) -> Word# -> (Int# -> ByteArray# -> r) -> r

composelw2ib :: (Word# -> (#Int#, ByteArray##)) -> Word# -> (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# 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

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

composes2sli :: (State# s -> (#State# t, Int##)) -> State# s -> (State# t -> Int# -> r) -> r

composes2slli :: (State# s -> (#State# t, Int##)) -> State# s -> (State# t -> Int# -> r) -> r

composes2sllw :: (State# s -> (#State# t, Word##)) -> State# s -> (State# t -> Word# -> r) -> r

composes2slw :: (State# s -> (#State# t, Word##)) -> State# s -> (State# t -> Word# -> 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 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 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# 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

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

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

composes3s_2__ :: (State# s -> (#State# t, a, (#b, c#)#)) -> State# s -> (State# t -> a -> b -> c -> r) -> r

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

decomposes2s_ :: (State# s -> (State# t -> a -> (#State# t, a#)) -> (#State# t, a#)) -> State# s -> (#State# t, a#)

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))

decompose_2__ :: (a -> (b -> c -> (#b, c#)) -> (#b, c#)) -> a -> (#b, c#)