module LLVM.Prelude (
module Prelude,
module Data.Data,
module GHC.Generics,
module Data.Int,
module Data.Word,
module Data.Functor,
module Data.Foldable,
module Data.Semigroup,
module Data.Traversable,
module Control.Applicative,
module Control.Monad,
ByteString,
ShortByteString,
fromMaybe,
leftBiasedZip,
findM,
ifM
) where
import Prelude hiding (
mapM, mapM_,
sequence, sequence_,
concat,
foldr, foldr1, foldl, foldl1,
minimum, maximum, sum, product, all, any, and, or,
concatMap,
elem, notElem,
)
import Data.Data (Data, Typeable)
import GHC.Generics (Generic)
import Data.Int
import Data.Maybe (fromMaybe)
import Data.Word
import Data.Functor
import Data.Foldable
import Data.Semigroup (Semigroup((<>)))
import Data.Traversable
import Control.Applicative
import Control.Monad hiding (
forM, forM_,
mapM, mapM_,
sequence, sequence_,
msum
)
import Data.ByteString (ByteString)
import Data.ByteString.Short (ShortByteString)
leftBiasedZip :: [a] -> [b] -> [(a, Maybe b)]
leftBiasedZip :: [a] -> [b] -> [(a, Maybe b)]
leftBiasedZip [] _ = []
leftBiasedZip xs :: [a]
xs [] = (a -> (a, Maybe b)) -> [a] -> [(a, Maybe b)]
forall a b. (a -> b) -> [a] -> [b]
map (, Maybe b
forall a. Maybe a
Nothing) [a]
xs
leftBiasedZip (x :: a
x:xs :: [a]
xs) (y :: b
y:ys :: [b]
ys) = (a
x, b -> Maybe b
forall a. a -> Maybe a
Just b
y) (a, Maybe b) -> [(a, Maybe b)] -> [(a, Maybe b)]
forall a. a -> [a] -> [a]
: [a] -> [b] -> [(a, Maybe b)]
forall a b. [a] -> [b] -> [(a, Maybe b)]
leftBiasedZip [a]
xs [b]
ys
ifM :: Monad m => m Bool -> m a -> m a -> m a
ifM :: m Bool -> m a -> m a -> m a
ifM cond :: m Bool
cond ifTrue :: m a
ifTrue ifFalse :: m a
ifFalse = do
Bool
cond' <- m Bool
cond
if Bool
cond'
then m a
ifTrue
else m a
ifFalse
findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
findM :: (a -> m Bool) -> [a] -> m (Maybe a)
findM _ [] = Maybe a -> m (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
findM p :: a -> m Bool
p (x :: a
x:xs :: [a]
xs) = m Bool -> m (Maybe a) -> m (Maybe a) -> m (Maybe a)
forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM (a -> m Bool
p a
x) (Maybe a -> m (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a)) -> Maybe a -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just a
x) ((a -> m Bool) -> [a] -> m (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> [a] -> m (Maybe a)
findM a -> m Bool
p [a]
xs)