Monad.hs

{-# LANGUAGE CPP #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -Wall #-}

module Papa.Base.Control.Monad (
  Functor (fmap),
  Monad ((>>=), return, (>>)),
  MonadFail (fail),
  MonadFix (mfix),
  MonadPlus (mzero, mplus),
  MonadZip (mzip, mzipWith, munzip),
  forever,
  msum,
  mfilter,
  filterM,
  foldM,
  foldM_,
  replicateM,
  replicateM_,
  guard,
  when,
  unless,
  (<$!>),
  anyM,
  allM,
  findM,
) where

import Control.Monad (
  Functor (fmap),
  Monad (return, (>>), (>>=)),
  MonadFail (fail),
  MonadPlus (mplus, mzero),
  filterM,
  foldM,
  foldM_,
  forever,
  guard,
  mfilter,
  msum,
  replicateM,
  replicateM_,
  unless,
  when,
  (<$!>),
 )
import Control.Monad.Fix as P (
  MonadFix (mfix),
 )
import Control.Monad.Zip as P (
  MonadZip (mzip, mzipWith, munzip),
 )

import Data.Bool (Bool (False, True))
import Data.Maybe (Maybe (Just, Nothing))

{-# INLINE anyM #-}
anyM ::
  (Monad m) =>
  (a -> m Bool) ->
  [a] ->
  m Bool
anyM _ [] =
  return False
anyM f (a : as) =
  do
    z <- f a
    if z
      then return True
      else anyM f as

{-# INLINE allM #-}
allM ::
  (Monad m) =>
  (a -> m Bool) ->
  [a] ->
  m Bool
allM _ [] =
  return True
allM f (a : as) =
  do
    z <- f a
    if z
      then allM f as
      else return False

{-# INLINE findM #-}
-- | Find an element satisfying a predicate
findM ::
  (Monad m) =>
  (a -> m Bool) ->
  [a] ->
  m (Maybe a)
findM _ [] =
  return Nothing
findM f (x : xs) =
  do
    b <- f x
    if b
      then
        return (Just x)
      else
        findM f xs