Methods

from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source

to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source

toConstr :: Ptr a -> Constr Source

dataTypeOf :: Ptr a -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source

gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source

Methods

fold :: Monoid m => UAddr m -> m Source

foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source

foldr :: (a -> b -> b) -> b -> UAddr a -> b Source

foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source

foldl :: (b -> a -> b) -> b -> UAddr a -> b Source

foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source

foldr1 :: (a -> a -> a) -> UAddr a -> a Source

foldl1 :: (a -> a -> a) -> UAddr a -> a Source

toList :: UAddr a -> [a] Source

null :: UAddr a -> Bool Source

length :: UAddr a -> Int Source

elem :: Eq a => a -> UAddr a -> Bool Source

maximum :: Ord a => UAddr a -> a Source

minimum :: Ord a => UAddr a -> a Source

sum :: Num a => UAddr a -> a Source

product :: Num a => UAddr a -> a Source

Methods

traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) Source

sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) Source

mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) Source

sequence :: Monad m => UAddr (m a) -> m (UAddr a) Source

Methods

sizeOf :: Ptr a -> Int Source

alignment :: Ptr a -> Int Source

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) Source

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () Source

peekByteOff :: Ptr b -> Int -> IO (Ptr a) Source

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source

peek :: Ptr (Ptr a) -> IO (Ptr a) Source

poke :: Ptr (Ptr a) -> Ptr a -> IO () Source

Methods

showsPrec :: Int -> Ptr a -> ShowS Source

show :: Ptr a -> String Source

showList :: [Ptr a] -> ShowS Source

Methods

(==) :: Ptr a -> Ptr a -> Bool Source

(/=) :: Ptr a -> Ptr a -> Bool Source

Methods

compare :: Ptr a -> Ptr a -> Ordering Source

(<) :: Ptr a -> Ptr a -> Bool Source

(<=) :: Ptr a -> Ptr a -> Bool Source

(>) :: Ptr a -> Ptr a -> Bool Source

(>=) :: Ptr a -> Ptr a -> Bool Source

max :: Ptr a -> Ptr a -> Ptr a Source

min :: Ptr a -> Ptr a -> Ptr a Source

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source

Methods

sizeOf :: FunPtr a -> Int Source

alignment :: FunPtr a -> Int Source

peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) Source

pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () Source

peekByteOff :: Ptr b -> Int -> IO (FunPtr a) Source

pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source

peek :: Ptr (FunPtr a) -> IO (FunPtr a) Source

poke :: Ptr (FunPtr a) -> FunPtr a -> IO () Source

Methods

showsPrec :: Int -> FunPtr a -> ShowS Source

show :: FunPtr a -> String Source

showList :: [FunPtr a] -> ShowS Source

Methods

(==) :: FunPtr a -> FunPtr a -> Bool Source

(/=) :: FunPtr a -> FunPtr a -> Bool Source

Methods

compare :: FunPtr a -> FunPtr a -> Ordering Source

(<) :: FunPtr a -> FunPtr a -> Bool Source

(<=) :: FunPtr a -> FunPtr a -> Bool Source

(>) :: FunPtr a -> FunPtr a -> Bool Source

(>=) :: FunPtr a -> FunPtr a -> Bool Source

max :: FunPtr a -> FunPtr a -> FunPtr a Source

min :: FunPtr a -> FunPtr a -> FunPtr a Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source

toConstr :: Word -> Constr Source

dataTypeOf :: Word -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source

gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source

Methods

sizeOf :: Word -> Int Source

alignment :: Word -> Int Source

peekElemOff :: Ptr Word -> Int -> IO Word Source

pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source

peekByteOff :: Ptr b -> Int -> IO Word Source

pokeByteOff :: Ptr b -> Int -> Word -> IO () Source

peek :: Ptr Word -> IO Word Source

poke :: Ptr Word -> Word -> IO () Source

Methods

(.&.) :: Word -> Word -> Word Source

(.|.) :: Word -> Word -> Word Source

xor :: Word -> Word -> Word Source

complement :: Word -> Word Source

shift :: Word -> Int -> Word Source

rotate :: Word -> Int -> Word Source

zeroBits :: Word Source

bit :: Int -> Word Source

setBit :: Word -> Int -> Word Source

clearBit :: Word -> Int -> Word Source

complementBit :: Word -> Int -> Word Source

testBit :: Word -> Int -> Bool Source

bitSizeMaybe :: Word -> Maybe Int Source

bitSize :: Word -> Int Source

isSigned :: Word -> Bool Source

shiftL :: Word -> Int -> Word Source

unsafeShiftL :: Word -> Int -> Word Source

shiftR :: Word -> Int -> Word Source

unsafeShiftR :: Word -> Int -> Word Source

rotateL :: Word -> Int -> Word Source

rotateR :: Word -> Int -> Word Source

popCount :: Word -> Int Source

Methods

finiteBitSize :: Word -> Int Source

countLeadingZeros :: Word -> Int Source

countTrailingZeros :: Word -> Int Source

Methods

minBound :: Word Source

maxBound :: Word Source

Methods

succ :: Word -> Word Source

pred :: Word -> Word Source

toEnum :: Int -> Word Source

fromEnum :: Word -> Int Source

enumFrom :: Word -> [Word] Source

enumFromThen :: Word -> Word -> [Word] Source

enumFromTo :: Word -> Word -> [Word] Source

enumFromThenTo :: Word -> Word -> Word -> [Word] Source

Methods

range :: (Word, Word) -> [Word] Source

index :: (Word, Word) -> Word -> Int Source

unsafeIndex :: (Word, Word) -> Word -> Int Source

inRange :: (Word, Word) -> Word -> Bool Source

rangeSize :: (Word, Word) -> Int Source

unsafeRangeSize :: (Word, Word) -> Int Source

Methods

(+) :: Word -> Word -> Word Source

(-) :: Word -> Word -> Word Source

(*) :: Word -> Word -> Word Source

negate :: Word -> Word Source

abs :: Word -> Word Source

signum :: Word -> Word Source

fromInteger :: Integer -> Word Source

Methods

readsPrec :: Int -> ReadS Word Source

readList :: ReadS [Word] Source

readPrec :: ReadPrec Word Source

readListPrec :: ReadPrec [Word] Source

Methods

quot :: Word -> Word -> Word Source

rem :: Word -> Word -> Word Source

div :: Word -> Word -> Word Source

mod :: Word -> Word -> Word Source

quotRem :: Word -> Word -> (Word, Word) Source

divMod :: Word -> Word -> (Word, Word) Source

toInteger :: Word -> Integer Source

Methods

toRational :: Word -> Rational Source

Methods

showsPrec :: Int -> Word -> ShowS Source

show :: Word -> String Source

showList :: [Word] -> ShowS Source

Methods

formatArg :: Word -> FieldFormatter Source

parseFormat :: Word -> ModifierParser Source

Methods

(==) :: Word -> Word -> Bool Source

(/=) :: Word -> Word -> Bool Source

Methods

compare :: Word -> Word -> Ordering Source

(<) :: Word -> Word -> Bool Source

(<=) :: Word -> Word -> Bool Source

(>) :: Word -> Word -> Bool Source

(>=) :: Word -> Word -> Bool Source

max :: Word -> Word -> Word Source

min :: Word -> Word -> Word Source

Methods

from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a Source

to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a Source

Methods

fold :: Monoid m => UWord m -> m Source

foldMap :: Monoid m => (a -> m) -> UWord a -> m Source

foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source

foldr :: (a -> b -> b) -> b -> UWord a -> b Source

foldr' :: (a -> b -> b) -> b -> UWord a -> b Source

foldl :: (b -> a -> b) -> b -> UWord a -> b Source

foldl' :: (b -> a -> b) -> b -> UWord a -> b Source

foldr1 :: (a -> a -> a) -> UWord a -> a Source

foldl1 :: (a -> a -> a) -> UWord a -> a Source

toList :: UWord a -> [a] Source

null :: UWord a -> Bool Source

length :: UWord a -> Int Source

elem :: Eq a => a -> UWord a -> Bool Source

maximum :: Ord a => UWord a -> a Source

minimum :: Ord a => UWord a -> a Source

sum :: Num a => UWord a -> a Source

product :: Num a => UWord a -> a Source

Methods

traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) Source

sequenceA :: Applicative f => UWord (f a) -> f (UWord a) Source

mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) Source

sequence :: Monad m => UWord (m a) -> m (UWord a) Source

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b Source

(<$) :: a -> URec Word b -> URec Word a Source

Methods

from :: URec Word p -> Rep (URec Word p) x Source

to :: Rep (URec Word p) x -> URec Word p Source

Methods

showsPrec :: Int -> URec Word p -> ShowS Source

show :: URec Word p -> String Source

showList :: [URec Word p] -> ShowS Source

Methods

(==) :: URec Word p -> URec Word p -> Bool Source

(/=) :: URec Word p -> URec Word p -> Bool Source

Methods

compare :: URec Word p -> URec Word p -> Ordering Source

(<) :: URec Word p -> URec Word p -> Bool Source

(<=) :: URec Word p -> URec Word p -> Bool Source

(>) :: URec Word p -> URec Word p -> Bool Source

(>=) :: URec Word p -> URec Word p -> Bool Source

max :: URec Word p -> URec Word p -> URec Word p Source

min :: URec Word p -> URec Word p -> URec Word p Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source

toConstr :: Float -> Constr Source

dataTypeOf :: Float -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source

gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source

Methods

sizeOf :: Float -> Int Source

alignment :: Float -> Int Source

peekElemOff :: Ptr Float -> Int -> IO Float Source

pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source

peekByteOff :: Ptr b -> Int -> IO Float Source

pokeByteOff :: Ptr b -> Int -> Float -> IO () Source

peek :: Ptr Float -> IO Float Source

poke :: Ptr Float -> Float -> IO () Source

Methods

succ :: Float -> Float Source

pred :: Float -> Float Source

toEnum :: Int -> Float Source

fromEnum :: Float -> Int Source

enumFrom :: Float -> [Float] Source

enumFromThen :: Float -> Float -> [Float] Source

enumFromTo :: Float -> Float -> [Float] Source

enumFromThenTo :: Float -> Float -> Float -> [Float] Source

Methods

pi :: Float Source

exp :: Float -> Float Source

log :: Float -> Float Source

sqrt :: Float -> Float Source

(**) :: Float -> Float -> Float Source

logBase :: Float -> Float -> Float Source

sin :: Float -> Float Source

cos :: Float -> Float Source

tan :: Float -> Float Source

asin :: Float -> Float Source

acos :: Float -> Float Source

atan :: Float -> Float Source

sinh :: Float -> Float Source

cosh :: Float -> Float Source

tanh :: Float -> Float Source

asinh :: Float -> Float Source

acosh :: Float -> Float Source

atanh :: Float -> Float Source

log1p :: Float -> Float Source

expm1 :: Float -> Float Source

log1pexp :: Float -> Float Source

log1mexp :: Float -> Float Source

Methods

floatRadix :: Float -> Integer Source

floatDigits :: Float -> Int Source

floatRange :: Float -> (Int, Int) Source

decodeFloat :: Float -> (Integer, Int) Source

encodeFloat :: Integer -> Int -> Float Source

exponent :: Float -> Int Source

significand :: Float -> Float Source

scaleFloat :: Int -> Float -> Float Source

isNaN :: Float -> Bool Source

isInfinite :: Float -> Bool Source

isDenormalized :: Float -> Bool Source

isNegativeZero :: Float -> Bool Source

isIEEE :: Float -> Bool Source

atan2 :: Float -> Float -> Float Source

Methods

(+) :: Float -> Float -> Float Source

(-) :: Float -> Float -> Float Source

(*) :: Float -> Float -> Float Source

negate :: Float -> Float Source

abs :: Float -> Float Source

signum :: Float -> Float Source

fromInteger :: Integer -> Float Source

Methods

readsPrec :: Int -> ReadS Float Source

readList :: ReadS [Float] Source

readPrec :: ReadPrec Float Source

readListPrec :: ReadPrec [Float] Source

Methods

(/) :: Float -> Float -> Float Source

recip :: Float -> Float Source

fromRational :: Rational -> Float Source

Methods

toRational :: Float -> Rational Source

Methods

properFraction :: Integral b => Float -> (b, Float) Source

truncate :: Integral b => Float -> b Source

round :: Integral b => Float -> b Source

ceiling :: Integral b => Float -> b Source

floor :: Integral b => Float -> b Source

Methods

showsPrec :: Int -> Float -> ShowS Source

show :: Float -> String Source

showList :: [Float] -> ShowS Source

Methods

formatArg :: Float -> FieldFormatter Source

parseFormat :: Float -> ModifierParser Source

Methods

(==) :: Float -> Float -> Bool Source

(/=) :: Float -> Float -> Bool Source

Methods

compare :: Float -> Float -> Ordering Source

(<) :: Float -> Float -> Bool Source

(<=) :: Float -> Float -> Bool Source

(>) :: Float -> Float -> Bool Source

(>=) :: Float -> Float -> Bool Source

max :: Float -> Float -> Float Source

min :: Float -> Float -> Float Source

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a Source

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a Source

Methods

fold :: Monoid m => UFloat m -> m Source

foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source

foldr :: (a -> b -> b) -> b -> UFloat a -> b Source

foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source

foldl :: (b -> a -> b) -> b -> UFloat a -> b Source

foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source

foldr1 :: (a -> a -> a) -> UFloat a -> a Source

foldl1 :: (a -> a -> a) -> UFloat a -> a Source

toList :: UFloat a -> [a] Source

null :: UFloat a -> Bool Source

length :: UFloat a -> Int Source

elem :: Eq a => a -> UFloat a -> Bool Source

maximum :: Ord a => UFloat a -> a Source

minimum :: Ord a => UFloat a -> a Source

sum :: Num a => UFloat a -> a Source

product :: Num a => UFloat a -> a Source

Methods

traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) Source

sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) Source

mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) Source

sequence :: Monad m => UFloat (m a) -> m (UFloat a) Source

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b Source

(<$) :: a -> URec Float b -> URec Float a Source

Methods

from :: URec Float p -> Rep (URec Float p) x Source

to :: Rep (URec Float p) x -> URec Float p Source

Methods

showsPrec :: Int -> URec Float p -> ShowS Source

show :: URec Float p -> String Source

showList :: [URec Float p] -> ShowS Source

Methods

(==) :: URec Float p -> URec Float p -> Bool Source

(/=) :: URec Float p -> URec Float p -> Bool Source

Methods

compare :: URec Float p -> URec Float p -> Ordering Source

(<) :: URec Float p -> URec Float p -> Bool Source

(<=) :: URec Float p -> URec Float p -> Bool Source

(>) :: URec Float p -> URec Float p -> Bool Source

(>=) :: URec Float p -> URec Float p -> Bool Source

max :: URec Float p -> URec Float p -> URec Float p Source

min :: URec Float p -> URec Float p -> URec Float p Source

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int Source

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int Source

toConstr :: Int -> Constr Source

dataTypeOf :: Int -> DataType Source

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) Source

gmapT :: (forall b. Data b => b -> b) -> Int -> Int Source

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] Source

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u Source

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int Source

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source

Methods

sizeOf :: Int -> Int Source

alignment :: Int -> Int Source

peekElemOff :: Ptr Int -> Int -> IO Int Source

pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source

peekByteOff :: Ptr b -> Int -> IO Int Source

pokeByteOff :: Ptr b -> Int -> Int -> IO () Source

peek :: Ptr Int -> IO Int Source

poke :: Ptr Int -> Int -> IO () Source

Methods

(.&.) :: Int -> Int -> Int Source

(.|.) :: Int -> Int -> Int Source

xor :: Int -> Int -> Int Source

complement :: Int -> Int Source

shift :: Int -> Int -> Int Source

rotate :: Int -> Int -> Int Source

zeroBits :: Int Source

bit :: Int -> Int Source

setBit :: Int -> Int -> Int Source

clearBit :: Int -> Int -> Int Source

complementBit :: Int -> Int -> Int Source

testBit :: Int -> Int -> Bool Source

bitSizeMaybe :: Int -> Maybe Int Source

bitSize :: Int -> Int Source

isSigned :: Int -> Bool Source

shiftL :: Int -> Int -> Int Source

unsafeShiftL :: Int -> Int -> Int Source

shiftR :: Int -> Int -> Int Source

unsafeShiftR :: Int -> Int -> Int Source

rotateL :: Int -> Int -> Int Source

rotateR :: Int -> Int -> Int Source

popCount :: Int -> Int Source

Methods

finiteBitSize :: Int -> Int Source

countLeadingZeros :: Int -> Int Source

countTrailingZeros :: Int -> Int Source

Methods

minBound :: Int Source

maxBound :: Int Source

Methods

succ :: Int -> Int Source

pred :: Int -> Int Source

toEnum :: Int -> Int Source

fromEnum :: Int -> Int Source

enumFrom :: Int -> [Int] Source

enumFromThen :: Int -> Int -> [Int] Source

enumFromTo :: Int -> Int -> [Int] Source

enumFromThenTo :: Int -> Int -> Int -> [Int] Source

Methods

range :: (Int, Int) -> [Int] Source

index :: (Int, Int) -> Int -> Int Source

unsafeIndex :: (Int, Int) -> Int -> Int Source

inRange :: (Int, Int) -> Int -> Bool Source

rangeSize :: (Int, Int) -> Int Source

unsafeRangeSize :: (Int, Int) -> Int Source

Methods

(+) :: Int -> Int -> Int Source

(-) :: Int -> Int -> Int Source

(*) :: Int -> Int -> Int Source

negate :: Int -> Int Source

abs :: Int -> Int Source

signum :: Int -> Int Source

fromInteger :: Integer -> Int Source

Methods

readsPrec :: Int -> ReadS Int Source

readList :: ReadS [Int] Source

readPrec :: ReadPrec Int Source

readListPrec :: ReadPrec [Int] Source

Methods

quot :: Int -> Int -> Int Source

rem :: Int -> Int -> Int Source

div :: Int -> Int -> Int Source

mod :: Int -> Int -> Int Source

quotRem :: Int -> Int -> (Int, Int) Source

divMod :: Int -> Int -> (Int, Int) Source

toInteger :: Int -> Integer Source

Methods

toRational :: Int -> Rational Source

Methods

showsPrec :: Int -> Int -> ShowS Source

show :: Int -> String Source

showList :: [Int] -> ShowS Source

Methods

formatArg :: Int -> FieldFormatter Source

parseFormat :: Int -> ModifierParser Source

Methods

(==) :: Int -> Int -> Bool Source

(/=) :: Int -> Int -> Bool Source

Methods

compare :: Int -> Int -> Ordering Source

(<) :: Int -> Int -> Bool Source

(<=) :: Int -> Int -> Bool Source

(>) :: Int -> Int -> Bool Source

(>=) :: Int -> Int -> Bool Source

max :: Int -> Int -> Int Source

min :: Int -> Int -> Int Source

Methods

from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a Source

to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a Source

Methods

fold :: Monoid m => UInt m -> m Source

foldMap :: Monoid m => (a -> m) -> UInt a -> m Source

foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source

foldr :: (a -> b -> b) -> b -> UInt a -> b Source

foldr' :: (a -> b -> b) -> b -> UInt a -> b Source

foldl :: (b -> a -> b) -> b -> UInt a -> b Source

foldl' :: (b -> a -> b) -> b -> UInt a -> b Source

foldr1 :: (a -> a -> a) -> UInt a -> a Source

foldl1 :: (a -> a -> a) -> UInt a -> a Source

toList :: UInt a -> [a] Source

null :: UInt a -> Bool Source

length :: UInt a -> Int Source

elem :: Eq a => a -> UInt a -> Bool Source

maximum :: Ord a => UInt a -> a Source

minimum :: Ord a => UInt a -> a Source

sum :: Num a => UInt a -> a Source

product :: Num a => UInt a -> a Source

Methods

traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) Source

sequenceA :: Applicative f => UInt (f a) -> f (UInt a) Source

mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) Source

sequence :: Monad m => UInt (m a) -> m (UInt a) Source

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b Source

(<$) :: a -> URec Int b -> URec Int a Source

Methods

from :: URec Int p -> Rep (URec Int p) x Source

to :: Rep (URec Int p) x -> URec Int p Source

Methods

showsPrec :: Int -> URec Int p -> ShowS Source

show :: URec Int p -> String Source

showList :: [URec Int p] -> ShowS Source

Methods

(==) :: URec Int p -> URec Int p -> Bool Source

(/=) :: URec Int p -> URec Int p -> Bool Source

Methods

compare :: URec Int p -> URec Int p -> Ordering Source

(<) :: URec Int p -> URec Int p -> Bool Source

(<=) :: URec Int p -> URec Int p -> Bool Source

(>) :: URec Int p -> URec Int p -> Bool Source

(>=) :: URec Int p -> URec Int p -> Bool Source

max :: URec Int p -> URec Int p -> URec Int p Source

min :: URec Int p -> URec Int p -> URec Int p Source

Methods

id :: forall (a :: k). Op a a Source

(.) :: forall (b :: k) (c :: k) (a :: k). Op b c -> Op a b -> Op a c Source

Methods

resolution :: p E0 -> Integer Source

Methods

resolution :: p E1 -> Integer Source

Methods

resolution :: p E12 -> Integer Source

Methods

resolution :: p E2 -> Integer Source

Methods

resolution :: p E3 -> Integer Source

Methods

resolution :: p E6 -> Integer Source

Methods

resolution :: p E9 -> Integer Source

Methods

from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a Source

to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a Source

Methods

from1 :: forall (a :: k). Complex a -> Rep1 Complex a Source

to1 :: forall (a :: k). Rep1 Complex a -> Complex a Source

Methods

from1 :: forall (a :: k). Identity a -> Rep1 Identity a Source

to1 :: forall (a :: k). Rep1 Identity a -> Identity a Source

Methods

from1 :: forall (a :: k). First a -> Rep1 First a Source

to1 :: forall (a :: k). Rep1 First a -> First a Source

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a Source

to1 :: forall (a :: k). Rep1 Last a -> Last a Source

Methods

from1 :: forall (a :: k). Down a -> Rep1 Down a Source

to1 :: forall (a :: k). Rep1 Down a -> Down a Source

Methods

from1 :: forall (a :: k). First a -> Rep1 First a Source

to1 :: forall (a :: k). Rep1 First a -> First a Source

Methods

from1 :: forall (a :: k). Last a -> Rep1 Last a Source

to1 :: forall (a :: k). Rep1 Last a -> Last a Source

Methods

from1 :: forall (a :: k). Max a -> Rep1 Max a Source

to1 :: forall (a :: k). Rep1 Max a -> Max a Source

Methods

from1 :: forall (a :: k). Min a -> Rep1 Min a Source

to1 :: forall (a :: k). Rep1 Min a -> Min a Source

Methods

from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a Source

to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a Source

Methods

from1 :: forall (a :: k). Dual a -> Rep1 Dual a Source

to1 :: forall (a :: k). Rep1 Dual a -> Dual a Source

Methods

from1 :: forall (a :: k). Product a -> Rep1 Product a Source

to1 :: forall (a :: k). Rep1 Product a -> Product a Source

Methods

from1 :: forall (a :: k). Sum a -> Rep1 Sum a Source

to1 :: forall (a :: k). Rep1 Sum a -> Sum a Source

Methods

from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a Source

to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a Source

Methods

from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a Source

to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a Source

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a Source

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a Source

Methods

from1 :: forall (a :: k). Solo a -> Rep1 Solo a Source

to1 :: forall (a :: k). Rep1 Solo a -> Solo a Source

Methods

from1 :: forall (a :: k). [a] -> Rep1 [] a Source

to1 :: forall (a :: k). Rep1 [] a -> [a] Source

Methods

id :: forall (a :: k). Kleisli m a a Source

(.) :: forall (b :: k) (c :: k) (a :: k). Kleisli m b c -> Kleisli m a b -> Kleisli m a c Source

Methods

from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a Source

to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a Source

Methods

from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0 Source

to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0 Source

Methods

from1 :: forall (a0 :: k). Arg a a0 -> Rep1 (Arg a) a0 Source

to1 :: forall (a0 :: k). Rep1 (Arg a) a0 -> Arg a a0 Source

Methods

from1 :: forall (a0 :: k). (a, a0) -> Rep1 ((,) a) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,) a) a0 -> (a, a0) Source

Methods

id :: forall (a :: k). a -> a Source

(.) :: forall (b :: k) (c :: k) (a :: k). (b -> c) -> (a -> b) -> a -> c Source

Methods

from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 Source

to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 Source

Methods

from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0 Source

to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0 Source

Methods

from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ((,,) a b) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,) a b) a0 -> (a, b, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ((,,,) a b c) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,) a b c) a0 -> (a, b, c, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ((,,,,) a b c d) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,) a b c d) a0 -> (a, b, c, d, a0) Source

Methods

from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a Source

to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a Source

Methods

from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a Source

to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ((,,,,,) a b c d e) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ((,,,,,,) a b c d e f) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, a0) -> Rep1 ((,,,,,,,) a b c d e f g) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,) a b c d e f g) a0 -> (a, b, c, d, e, f, g, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, a0) -> Rep1 ((,,,,,,,,) a b c d e f g h) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,) a b c d e f g h) a0 -> (a, b, c, d, e, f, g, h, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, a0) -> Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 -> (a, b, c, d, e, f, g, h, i, a0) Source

Methods

from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, j, a0) -> Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 Source

to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 -> (a, b, c, d, e, f, g, h, i, j, a0) Source

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, a0) -> Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 Source

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 -> (a, b, c, d, e, f, g, h, i, j, k, a0) Source

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 Source

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) Source

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 Source

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) Source

Methods

from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 Source

to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) Source

Methods

mzip :: Proxy a -> Proxy b -> Proxy (a, b) Source

mzipWith :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source

munzip :: Proxy (a, b) -> (Proxy a, Proxy b) Source

Methods

mzip :: U1 a -> U1 b -> U1 (a, b) Source

mzipWith :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source

munzip :: U1 (a, b) -> (U1 a, U1 b) Source

Methods

bifold :: Monoid m => Const m m -> m Source

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m Source

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c Source

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c Source

Methods

bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d Source

first :: (a -> b) -> Const a c -> Const b c Source

second :: (b -> c) -> Const a b -> Const a c Source

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) Source

Methods

fold :: Monoid m => Proxy m -> m Source

foldMap :: Monoid m => (a -> m) -> Proxy a -> m Source

foldMap' :: Monoid m => (a -> m) -> Proxy a -> m Source

foldr :: (a -> b -> b) -> b -> Proxy a -> b Source

foldr' :: (a -> b -> b) -> b -> Proxy a -> b Source

foldl :: (b -> a -> b) -> b -> Proxy a -> b Source

foldl' :: (b -> a -> b) -> b -> Proxy a -> b Source

foldr1 :: (a -> a -> a) -> Proxy a -> a Source

foldl1 :: (a -> a -> a) -> Proxy a -> a Source

toList :: Proxy a -> [a] Source

null :: Proxy a -> Bool Source

length :: Proxy a -> Int Source

elem :: Eq a => a -> Proxy a -> Bool Source

maximum :: Ord a => Proxy a -> a Source

minimum :: Ord a => Proxy a -> a Source

sum :: Num a => Proxy a -> a Source

product :: Num a => Proxy a -> a Source

Methods

fold :: Monoid m => U1 m -> m Source

foldMap :: Monoid m => (a -> m) -> U1 a -> m Source

foldMap' :: Monoid m => (a -> m) -> U1 a -> m Source

foldr :: (a -> b -> b) -> b -> U1 a -> b Source

foldr' :: (a -> b -> b) -> b -> U1 a -> b Source

foldl :: (b -> a -> b) -> b -> U1 a -> b Source

foldl' :: (b -> a -> b) -> b -> U1 a -> b Source

foldr1 :: (a -> a -> a) -> U1 a -> a Source

foldl1 :: (a -> a -> a) -> U1 a -> a Source

toList :: U1 a -> [a] Source

null :: U1 a -> Bool Source

length :: U1 a -> Int Source

elem :: Eq a => a -> U1 a -> Bool Source

maximum :: Ord a => U1 a -> a Source

minimum :: Ord a => U1 a -> a Source

sum :: Num a => U1 a -> a Source

product :: Num a => U1 a -> a Source

Methods

fold :: Monoid m => UAddr m -> m Source

foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source

foldr :: (a -> b -> b) -> b -> UAddr a -> b Source

foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source

foldl :: (b -> a -> b) -> b -> UAddr a -> b Source

foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source

foldr1 :: (a -> a -> a) -> UAddr a -> a Source

foldl1 :: (a -> a -> a) -> UAddr a -> a Source

toList :: UAddr a -> [a] Source

null :: UAddr a -> Bool Source

length :: UAddr a -> Int Source

elem :: Eq a => a -> UAddr a -> Bool Source

maximum :: Ord a => UAddr a -> a Source

minimum :: Ord a => UAddr a -> a Source

sum :: Num a => UAddr a -> a Source

product :: Num a => UAddr a -> a Source

Methods

fold :: Monoid m => UChar m -> m Source

foldMap :: Monoid m => (a -> m) -> UChar a -> m Source

foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source

foldr :: (a -> b -> b) -> b -> UChar a -> b Source

foldr' :: (a -> b -> b) -> b -> UChar a -> b Source

foldl :: (b -> a -> b) -> b -> UChar a -> b Source

foldl' :: (b -> a -> b) -> b -> UChar a -> b Source

foldr1 :: (a -> a -> a) -> UChar a -> a Source

foldl1 :: (a -> a -> a) -> UChar a -> a Source

toList :: UChar a -> [a] Source

null :: UChar a -> Bool Source

length :: UChar a -> Int Source

elem :: Eq a => a -> UChar a -> Bool Source

maximum :: Ord a => UChar a -> a Source

minimum :: Ord a => UChar a -> a Source

sum :: Num a => UChar a -> a Source

product :: Num a => UChar a -> a Source

Methods

fold :: Monoid m => UDouble m -> m Source

foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source

foldr :: (a -> b -> b) -> b -> UDouble a -> b Source

foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source

foldl :: (b -> a -> b) -> b -> UDouble a -> b Source

foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source

foldr1 :: (a -> a -> a) -> UDouble a -> a Source

foldl1 :: (a -> a -> a) -> UDouble a -> a Source

toList :: UDouble a -> [a] Source

null :: UDouble a -> Bool Source

length :: UDouble a -> Int Source

elem :: Eq a => a -> UDouble a -> Bool Source

maximum :: Ord a => UDouble a -> a Source

minimum :: Ord a => UDouble a -> a Source

sum :: Num a => UDouble a -> a Source

product :: Num a => UDouble a -> a Source

Methods

fold :: Monoid m => UFloat m -> m Source

foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source

foldr :: (a -> b -> b) -> b -> UFloat a -> b Source

foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source

foldl :: (b -> a -> b) -> b -> UFloat a -> b Source

foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source

foldr1 :: (a -> a -> a) -> UFloat a -> a Source

foldl1 :: (a -> a -> a) -> UFloat a -> a Source

toList :: UFloat a -> [a] Source

null :: UFloat a -> Bool Source

length :: UFloat a -> Int Source

elem :: Eq a => a -> UFloat a -> Bool Source

maximum :: Ord a => UFloat a -> a Source

minimum :: Ord a => UFloat a -> a Source

sum :: Num a => UFloat a -> a Source

product :: Num a => UFloat a -> a Source

Methods

fold :: Monoid m => UInt m -> m Source

foldMap :: Monoid m => (a -> m) -> UInt a -> m Source

foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source

foldr :: (a -> b -> b) -> b -> UInt a -> b Source

foldr' :: (a -> b -> b) -> b -> UInt a -> b Source

foldl :: (b -> a -> b) -> b -> UInt a -> b Source

foldl' :: (b -> a -> b) -> b -> UInt a -> b Source

foldr1 :: (a -> a -> a) -> UInt a -> a Source

foldl1 :: (a -> a -> a) -> UInt a -> a Source

toList :: UInt a -> [a] Source

null :: UInt a -> Bool Source

length :: UInt a -> Int Source

elem :: Eq a => a -> UInt a -> Bool Source

maximum :: Ord a => UInt a -> a Source

minimum :: Ord a => UInt a -> a Source

sum :: Num a => UInt a -> a Source

product :: Num a => UInt a -> a Source

Methods

fold :: Monoid m => UWord m -> m Source

foldMap :: Monoid m => (a -> m) -> UWord a -> m Source

foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source

foldr :: (a -> b -> b) -> b -> UWord a -> b Source

foldr' :: (a -> b -> b) -> b -> UWord a -> b Source

foldl :: (b -> a -> b) -> b -> UWord a -> b Source

foldl' :: (b -> a -> b) -> b -> UWord a -> b Source

foldr1 :: (a -> a -> a) -> UWord a -> a Source

foldl1 :: (a -> a -> a) -> UWord a -> a Source

toList :: UWord a -> [a] Source

null :: UWord a -> Bool Source

length :: UWord a -> Int Source

elem :: Eq a => a -> UWord a -> Bool Source

maximum :: Ord a => UWord a -> a Source

minimum :: Ord a => UWord a -> a Source

sum :: Num a => UWord a -> a Source

product :: Num a => UWord a -> a Source

Methods

fold :: Monoid m => V1 m -> m Source

foldMap :: Monoid m => (a -> m) -> V1 a -> m Source

foldMap' :: Monoid m => (a -> m) -> V1 a -> m Source

foldr :: (a -> b -> b) -> b -> V1 a -> b Source

foldr' :: (a -> b -> b) -> b -> V1 a -> b Source

foldl :: (b -> a -> b) -> b -> V1 a -> b Source

foldl' :: (b -> a -> b) -> b -> V1 a -> b Source

foldr1 :: (a -> a -> a) -> V1 a -> a Source

foldl1 :: (a -> a -> a) -> V1 a -> a Source

toList :: V1 a -> [a] Source

null :: V1 a -> Bool Source

length :: V1 a -> Int Source

elem :: Eq a => a -> V1 a -> Bool Source

maximum :: Ord a => V1 a -> a Source

minimum :: Ord a => V1 a -> a Source

sum :: Num a => V1 a -> a Source

product :: Num a => V1 a -> a Source

Methods

liftEq :: (a -> b -> Bool) -> Proxy a -> Proxy b -> Bool Source

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const a c -> Const b d -> Bool Source

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering Source

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering Source

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a) Source

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a] Source

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a) Source

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a] Source

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) Source

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] Source

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) Source

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] Source

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS Source

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS Source

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS Source

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS Source