{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}
module Data.Profunctor.Optic.Prelude (
re
, invert
, (&)
, (.)
, (%)
, (#)
, view
, (^.)
, iview
, (^%)
, review
, (#^)
, set
, (.~)
, iset
, (%~)
, kset
, (#~)
, over
, (..~)
, iover
, (%%~)
, kover
, (##~)
, (<>~)
, (><~)
, preview
, (^?)
, is
, isnt
, matches
, lists
, (^..)
, ilists
, ilistsFrom
, (^%%)
, folds
, foldsa
, foldsp
, foldsr
, ifoldsr
, ifoldsrFrom
, foldsl
, ifoldsl
, ifoldslFrom
, foldsr'
, ifoldsr'
, foldsl'
, ifoldsl'
, foldsrM
, ifoldsrM
, foldslM
, ifoldslM
, traverses_
, itraverses_
, asums
, concats
, iconcats
, endo
, endoM
, finds
, ifinds
, has
, hasnt
, elem
, pelem
, joins
, joins'
, meets
, meets'
, min
, max
) where
import Control.Monad (void)
import Control.Monad.Reader as Reader hiding (lift)
import Data.Bifunctor (Bifunctor(..))
import Data.Bool.Instance ()
import Data.Foldable (Foldable, foldMap, traverse_)
import Data.Function
import Data.Maybe
import Data.Monoid hiding (All(..), Any(..))
import Data.Profunctor.Optic.Carrier
import Data.Profunctor.Optic.Types
import Data.Profunctor.Optic.Iso
import Data.Profunctor.Optic.View
import Data.Profunctor.Optic.Import
import Data.Profunctor.Optic.Index
import Data.Profunctor.Optic.Setter
import Data.Profunctor.Optic.Fold
import Data.Profunctor.Optic.Option
import Data.Profunctor.Optic.Traversal
import Data.Profunctor.Optic.Affine
import Data.Prd (Prd, Minimal(..), Maximal(..))
import Data.Prd.Lattice (Lattice(..))
import Data.Semiring (Semiring(..), Prod(..))
import qualified Control.Applicative as A
import qualified Data.Prd as Prd
import qualified Data.Semiring as Rng
import qualified Prelude as Pre
asums :: Alternative f => AFold (Endo (Endo (f a))) s (f a) -> s -> f a
asums o = foldsl' o (<|>) A.empty
{-# INLINE asums #-}
concats :: AFold [r] s a -> (a -> [r]) -> s -> [r]
concats = withFold
{-# INLINE concats #-}
iconcats :: Monoid i => AIxfold [r] i s a -> (i -> a -> [r]) -> s -> [r]
iconcats o f = withIxfold o f mempty
{-# INLINE iconcats #-}
endo :: AFold (Endo (a -> a)) s (a -> a) -> s -> a -> a
endo o = foldsr o (.) id
endoM :: Monad m => AFold (Endo (a -> m a)) s (a -> m a) -> s -> a -> m a
endoM o = foldsr o (<=<) pure
finds :: AFold (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
finds o f = foldsr o (\a y -> if f a then Just a else y) Nothing
{-# INLINE finds #-}
ifinds :: Monoid i => AIxfold (Endo (Maybe (i, a))) i s a -> (i -> a -> Bool) -> s -> Maybe (i, a)
ifinds o f = ifoldsr o (\i a y -> if f i a then Just (i,a) else y) Nothing
{-# INLINE ifinds #-}
has :: AFold Any s a -> s -> Bool
has o = withFold o (const True)
{-# INLINE has #-}
hasnt :: AFold All s a -> s -> Bool
hasnt o = foldsp o (const False)
{-# INLINE hasnt #-}
elem :: Eq a => AFold Any s a -> a -> s -> Bool
elem o a = withFold o (== a)
pelem :: Prd a => AFold Any s a -> a -> s -> Bool
pelem o a = withFold o (Prd.=~ a)
{-# INLINE pelem #-}
min :: Ord a => AFold (Endo (Endo a)) s a -> a -> s -> a
min o = foldsl' o Pre.min
max :: Ord a => AFold (Endo (Endo a)) s a -> a -> s -> a
max o = foldsl' o Pre.max
joins :: Lattice a => AFold (Endo (Endo a)) s a -> a -> s -> a
joins o = foldsl' o (\/)
{-# INLINE joins #-}
joins' :: Lattice a => Minimal a => AFold (Endo (Endo a)) s a -> s -> a
joins' o = joins o minimal
{-# INLINE joins' #-}
meets :: Lattice a => AFold (Endo (Endo a)) s a -> a -> s -> a
meets o = foldsl' o (/\)
{-# INLINE meets #-}
meets' :: Lattice a => Maximal a => AFold (Endo (Endo a)) s a -> s -> a
meets' o = meets o maximal
{-# INLINE meets' #-}