mirror of
https://github.com/github/semantic.git
synced 2024-12-22 22:31:36 +03:00
73 lines
2.5 KiB
Haskell
73 lines
2.5 KiB
Haskell
{-# LANGUAGE UndecidableInstances #-}
|
|
module Prologue
|
|
( module X
|
|
, foldMapA
|
|
, maybeM
|
|
, maybeLast
|
|
, fromMaybeLast
|
|
) where
|
|
|
|
|
|
import Data.Bifunctor.Join as X
|
|
import Data.Bits as X
|
|
import Data.ByteString as X (ByteString)
|
|
import Data.Functor.Both as X (Both, both, runBothWith)
|
|
import Data.IntMap as X (IntMap)
|
|
import Data.IntSet as X (IntSet)
|
|
import Data.Ix as X (Ix (..))
|
|
import Data.List.NonEmpty as X (NonEmpty (..), nonEmpty, some1)
|
|
import Data.Map as X (Map)
|
|
import Data.Maybe as X
|
|
import Data.Monoid (Alt (..))
|
|
import Data.Sequence as X (Seq)
|
|
import Data.Semilattice.Lower as X (Lower(..))
|
|
import Data.Set as X (Set)
|
|
import Data.Sum as X (Sum, Element, Elements, (:<), (:<:), Apply (..), inject)
|
|
import Data.Text as X (Text)
|
|
import Data.These as X
|
|
|
|
import Control.Exception as X hiding (Handler (..), assert, evaluate, throw, throwIO, throwTo)
|
|
|
|
-- Typeclasses
|
|
import Control.Applicative as X
|
|
import Control.Arrow as X ((&&&), (***))
|
|
import Control.Monad as X hiding (fail, return)
|
|
import Control.Monad.Except as X (MonadError (..))
|
|
import Control.Monad.Fail as X (MonadFail (..))
|
|
import Data.Algebra as X
|
|
import Data.Bifoldable as X
|
|
import Data.Bifunctor as X (Bifunctor (..))
|
|
import Data.Bitraversable as X
|
|
import Data.Foldable as X hiding (product, sum)
|
|
import Data.Function as X (fix, on, (&))
|
|
import Data.Functor as X (void, ($>))
|
|
import Data.Functor.Classes as X
|
|
import Data.Functor.Classes.Generic as X
|
|
import Data.Functor.Foldable as X (Base, Corecursive (..), Recursive (..))
|
|
import Data.Hashable as X (Hashable, hash, hashUsing, hashWithSalt)
|
|
import Data.Hashable.Lifted as X (Hashable1(..), hashWithSalt1)
|
|
import Data.Monoid as X (First (..), Last (..), Monoid (..))
|
|
import Data.Proxy as X (Proxy (..))
|
|
import Data.Semigroup as X (Semigroup (..))
|
|
import Data.Traversable as X
|
|
import Data.Typeable as X (Typeable)
|
|
|
|
-- Generics
|
|
import GHC.Generics as X (Generic, Generic1)
|
|
import GHC.Stack as X
|
|
|
|
-- | Fold a collection by mapping each element onto an 'Alternative' action.
|
|
foldMapA :: (Alternative m, Foldable t) => (b -> m a) -> t b -> m a
|
|
foldMapA f = getAlt . foldMap (Alt . f)
|
|
|
|
|
|
maybeLast :: Foldable t => b -> (a -> b) -> t a -> b
|
|
maybeLast b f = maybe b f . getLast . foldMap (Last . Just)
|
|
|
|
fromMaybeLast :: Foldable t => a -> t a -> a
|
|
fromMaybeLast b = fromMaybe b . getLast . foldMap (Last . Just)
|
|
|
|
-- | Extract the 'Just' of a 'Maybe' in an 'Applicative' context or, given 'Nothing', run the provided action.
|
|
maybeM :: Applicative f => f a -> Maybe a -> f a
|
|
maybeM f = maybe f pure
|