{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-}
module PreludePlus (module Import, concat, concatMap, catMaybes, filter, fromList, mapMaybe, map, mapM, mapM_, sequence, sequence_) where
import PreludePlus.Unicode as Import
import Prelude as Import hiding ((!!), (++), concat, concatMap, filter, head, last, map, mapM, mapM_, sequence, sequence_, tail, init)
import Data.Foldable as Import hiding (concat, concatMap, mapM, mapM_, sequence, sequence_)
import Data.List as Import hiding ((!!), (++), concat, concatMap, filter, group, groupBy, head, last, map, tail, init, insert)
import Data.List.NonEmpty as Import (NonEmpty(..), (!!), group, groupBy, head, last, tail, init)
import Data.Maybe as Import hiding (catMaybes, mapMaybe)
import Control.Applicative (Alternative)
import Control.Monad (MonadPlus, mfilter, mzero)
import Data.Monoid ((<>))
(++) ∷ Semigroup a ⇒ a → a → a
(++) = (<>)
concat ∷ (Foldable t, Alternative f) ⇒ t (f a) → f a
concat = asum
concatMap ∷ (Alternative f, Foldable t, Functor t) ⇒ (a → f b) → t a → f b
concatMap f = asum ∘ fmap f
catMaybes ∷ MonadPlus m ⇒ m (Maybe a) → m a
catMaybes xs = do
x ← xs
case x of
Just a → return a
Nothing → mzero
filter ∷ MonadPlus m ⇒ (a → Bool) → m a → m a
filter = mfilter
fromList ∷ MonadPlus m ⇒ [a] → m a
fromList = asum ∘ fmap return
map ∷ Functor f ⇒ (a → b) → f a → f b
map = fmap
mapM ∷ (Applicative f, Traversable t) ⇒ (a → f b) → t a → f (t b)
mapM = traverse
mapM_ ∷ (Foldable t, Applicative f) ⇒ (a → f b) → t a → f ()
mapM_ = traverse_
mapMaybe ∷ MonadPlus m ⇒ (a → Maybe b) → m a → m b
mapMaybe f = catMaybes ∘ fmap f
sequence ∷ (Traversable t, Applicative f) ⇒ t (f a) → f (t a)
sequence = sequenceA
sequence_ ∷ (Foldable t, Applicative f) ⇒ t (f a) → f ()
sequence_ = sequenceA_