Documentation

Methods

fold :: Monoid m => Mass m -> m #

foldMap :: Monoid m => (a -> m) -> Mass a -> m #

foldMap' :: Monoid m => (a -> m) -> Mass a -> m #

foldr :: (a -> b -> b) -> b -> Mass a -> b #

foldr' :: (a -> b -> b) -> b -> Mass a -> b #

foldl :: (b -> a -> b) -> b -> Mass a -> b #

foldl' :: (b -> a -> b) -> b -> Mass a -> b #

foldr1 :: (a -> a -> a) -> Mass a -> a #

foldl1 :: (a -> a -> a) -> Mass a -> a #

toList :: Mass a -> [a] #

null :: Mass a -> Bool #

length :: Mass a -> Int #

elem :: Eq a => a -> Mass a -> Bool #

maximum :: Ord a => Mass a -> a #

minimum :: Ord a => Mass a -> a #

sum :: Num a => Mass a -> a #

product :: Num a => Mass a -> a #

Methods

liftEq :: (a -> b -> Bool) -> Mass a -> Mass b -> Bool #

Methods

traverse :: Applicative f => (a -> f b) -> Mass a -> f (Mass b) #

sequenceA :: Applicative f => Mass (f a) -> f (Mass a) #

mapM :: Monad m => (a -> m b) -> Mass a -> m (Mass b) #

sequence :: Monad m => Mass (m a) -> m (Mass a) #

Methods

pure :: a -> Mass a #

(<*>) :: Mass (a -> b) -> Mass a -> Mass b #

liftA2 :: (a -> b -> c) -> Mass a -> Mass b -> Mass c #

(*>) :: Mass a -> Mass b -> Mass b #

(<*) :: Mass a -> Mass b -> Mass a #

Methods

fmap :: (a -> b) -> Mass a -> Mass b #

(<$) :: a -> Mass b -> Mass a #

Methods

(>>=) :: Mass a -> (a -> Mass b) -> Mass b #

(>>) :: Mass a -> Mass b -> Mass b #

return :: a -> Mass a #

Methods

serializeWith :: MonadPut m => (a -> m ()) -> Mass a -> m () #

deserializeWith :: MonadGet m => m a -> m (Mass a) #

Methods

extract :: Mass a -> a #

duplicate :: Mass a -> Mass (Mass a) #

extend :: (Mass a -> b) -> Mass a -> Mass b #

Methods

(<@>) :: Mass (a -> b) -> Mass a -> Mass b #

(@>) :: Mass a -> Mass b -> Mass b #

(<@) :: Mass a -> Mass b -> Mass a #

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Mass a -> Int #

Methods

copoint :: Mass a -> a #

Methods

point :: a -> Mass a #

Methods

(<.>) :: Mass (a -> b) -> Mass a -> Mass b #

(.>) :: Mass a -> Mass b -> Mass b #

(<.) :: Mass a -> Mass b -> Mass a #

liftF2 :: (a -> b -> c) -> Mass a -> Mass b -> Mass c #

Methods

(>>-) :: Mass a -> (a -> Mass b) -> Mass b #

join :: Mass (Mass a) -> Mass a #

Methods

duplicated :: Mass a -> Mass (Mass a) #

extended :: (Mass a -> b) -> Mass a -> Mass b #

Methods

basicUnsafeFreeze :: Mutable Vector s (Mass a) -> ST s (Vector (Mass a))

basicUnsafeThaw :: Vector (Mass a) -> ST s (Mutable Vector s (Mass a))

basicLength :: Vector (Mass a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Mass a) -> Vector (Mass a)

basicUnsafeIndexM :: Vector (Mass a) -> Int -> Box (Mass a)

basicUnsafeCopy :: Mutable Vector s (Mass a) -> Vector (Mass a) -> ST s ()

elemseq :: Vector (Mass a) -> Mass a -> b -> b

Methods

basicLength :: MVector s (Mass a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Mass a) -> MVector s (Mass a)

basicOverlaps :: MVector s (Mass a) -> MVector s (Mass a) -> Bool

basicUnsafeNew :: Int -> ST s (MVector s (Mass a))

basicInitialize :: MVector s (Mass a) -> ST s ()

basicUnsafeReplicate :: Int -> Mass a -> ST s (MVector s (Mass a))

basicUnsafeRead :: MVector s (Mass a) -> Int -> ST s (Mass a)

basicUnsafeWrite :: MVector s (Mass a) -> Int -> Mass a -> ST s ()

basicClear :: MVector s (Mass a) -> ST s ()

basicSet :: MVector s (Mass a) -> Mass a -> ST s ()

basicUnsafeCopy :: MVector s (Mass a) -> MVector s (Mass a) -> ST s ()

basicUnsafeMove :: MVector s (Mass a) -> MVector s (Mass a) -> ST s ()

basicUnsafeGrow :: MVector s (Mass a) -> Int -> ST s (MVector s (Mass a))

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Mass a -> c (Mass a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Mass a) #

toConstr :: Mass a -> Constr #

dataTypeOf :: Mass a -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Mass a -> Mass a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mass a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Mass a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Mass a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Mass a -> m (Mass a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Mass a -> m (Mass a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Mass a -> m (Mass a) #

Methods

mempty :: Mass a #

mappend :: Mass a -> Mass a -> Mass a #

mconcat :: [Mass a] -> Mass a #

Methods

(<>) :: Mass a -> Mass a -> Mass a #

sconcat :: NonEmpty (Mass a) -> Mass a #

stimes :: Integral b => b -> Mass a -> Mass a #

Methods

from :: Mass a -> Rep (Mass a) x #

to :: Rep (Mass a) x -> Mass a #

Methods

readsPrec :: Int -> ReadS (Mass a) #

readList :: ReadS [Mass a] #

readPrec :: ReadPrec (Mass a) #

readListPrec :: ReadPrec [Mass a] #

Methods

showsPrec :: Int -> Mass a -> ShowS #

show :: Mass a -> String #

showList :: [Mass a] -> ShowS #

Methods

put :: Mass a -> Put #

get :: Get (Mass a) #

putList :: [Mass a] -> Put #

Methods

serialize :: MonadPut m => Mass a -> m () #

deserialize :: MonadGet m => m (Mass a) #

Methods

put :: Putter (Mass a) #

get :: Get (Mass a) #

Methods

rnf :: Mass a -> () #

Methods

(==) :: Mass a -> Mass a -> Bool #

(/=) :: Mass a -> Mass a -> Bool #

Methods

compare :: Mass a -> Mass a -> Ordering #

(<) :: Mass a -> Mass a -> Bool #

(<=) :: Mass a -> Mass a -> Bool #

(>) :: Mass a -> Mass a -> Bool #

(>=) :: Mass a -> Mass a -> Bool #

max :: Mass a -> Mass a -> Mass a #

min :: Mass a -> Mass a -> Mass a #

Methods

hashWithSalt :: Int -> Mass a -> Int #

hash :: Mass a -> Int #

Methods

version :: Version (Mass a) #

kind :: Kind (Mass a) #

getCopy :: Contained (Get (Mass a)) #

putCopy :: Mass a -> Contained Put #

internalConsistency :: Consistency (Mass a) #

objectProfile :: Profile (Mass a) #

errorTypeName :: Proxy (Mass a) -> String #