module Containers where

import BasePrelude (Applicative, Bool, Either, Foldable, Maybe (..), Monoid, Ord, Semigroup, maybe, pure, (.), (<*>), (<>))
import Data.Foldable (fold, toList)
import Data.Function (fix, id)
import Optics.Core (Prism', prism')

import Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq

import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map

import Data.Set (Set)
import qualified Data.Set as Set

import qualified Data.Text as Text

mapLookup :: Ord k => k -> Map k a -> Maybe a
mapLookup :: k -> Map k a -> Maybe a
mapLookup = k -> Map k a -> Maybe a
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup

mapDelete :: Ord k => k -> Map k a -> Map k a
mapDelete :: k -> Map k a -> Map k a
mapDelete = k -> Map k a -> Map k a
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete

mapInsert :: Ord k => k -> a -> Map k a -> Map k a
mapInsert :: k -> a -> Map k a -> Map k a
mapInsert = k -> a -> Map k a -> Map k a
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert

mapFromSet :: (k -> a) -> Set k -> Map k a
mapFromSet :: (k -> a) -> Set k -> Map k a
mapFromSet = (k -> a) -> Set k -> Map k a
forall k a. (k -> a) -> Set k -> Map k a
Map.fromSet

mapMapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
mapMapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
mapMapEither = (a -> Either b c) -> Map k a -> (Map k b, Map k c)
forall a b c k. (a -> Either b c) -> Map k a -> (Map k b, Map k c)
Map.mapEither

mapMapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
mapMapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
mapMapMaybe = (a -> Maybe b) -> Map k a -> Map k b
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe

mapKeysSet :: Map k a -> Set k
mapKeysSet :: Map k a -> Set k
mapKeysSet = Map k a -> Set k
forall k a. Map k a -> Set k
Map.keysSet

mapUnionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
mapUnionWith :: (a -> a -> a) -> Map k a -> Map k a -> Map k a
mapUnionWith = (a -> a -> a) -> Map k a -> Map k a -> Map k a
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith

mapFilter :: (a -> Bool) -> Map k a -> Map k a
mapFilter :: (a -> Bool) -> Map k a -> Map k a
mapFilter = (a -> Bool) -> Map k a -> Map k a
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter

mapToList :: Map k a -> [(k, a)]
mapToList :: Map k a -> [(k, a)]
mapToList = Map k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
Map.toAscList

mapFoldMapWithKey :: Monoid m => (k -> a -> m) -> Map k a -> m
mapFoldMapWithKey :: (k -> a -> m) -> Map k a -> m
mapFoldMapWithKey = (k -> a -> m) -> Map k a -> m
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey

setMember :: Ord a => a -> Set a -> Bool
setMember :: a -> Set a -> Bool
setMember = a -> Set a -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member

setInsert :: Ord a => a -> Set a -> Set a
setInsert :: a -> Set a -> Set a
setInsert = a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.insert

setDelete :: Ord a => a -> Set a -> Set a
setDelete :: a -> Set a -> Set a
setDelete = a -> Set a -> Set a
forall a. Ord a => a -> Set a -> Set a
Set.delete

seqWither :: Applicative f => (a -> f (Maybe b)) -> Seq a -> f (Seq b)
seqWither :: (a -> f (Maybe b)) -> Seq a -> f (Seq b)
seqWither a -> f (Maybe b)
f = ((Seq a -> f (Seq b)) -> Seq a -> f (Seq b)) -> Seq a -> f (Seq b)
forall a. (a -> a) -> a
fix \Seq a -> f (Seq b)
r -> f (Seq b) -> (a -> Seq a -> f (Seq b)) -> Seq a -> f (Seq b)
forall b a. b -> (a -> Seq a -> b) -> Seq a -> b
seqReduceR (Seq b -> f (Seq b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Seq b
forall a. Seq a
Seq.Empty) \a
x Seq a
xs -> (Maybe b -> Seq b -> Seq b) -> f (Maybe b -> Seq b -> Seq b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b -> Seq b -> Seq b
forall a. Maybe a -> Seq a -> Seq a
seqConsMaybe f (Maybe b -> Seq b -> Seq b) -> f (Maybe b) -> f (Seq b -> Seq b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a -> f (Maybe b)
f a
x f (Seq b -> Seq b) -> f (Seq b) -> f (Seq b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Seq a -> f (Seq b)
r Seq a
xs

seqReduceR :: b -> (a -> Seq a -> b) -> Seq a -> b
seqReduceR :: b -> (a -> Seq a -> b) -> Seq a -> b
seqReduceR b
z a -> Seq a -> b
f = \case{ Seq a
Seq.Empty -> b
z; (Seq.:<|) a
x Seq a
xs -> a -> Seq a -> b
f a
x Seq a
xs }

seqConsMaybe :: Maybe a -> Seq a -> Seq a
seqConsMaybe :: Maybe a -> Seq a -> Seq a
seqConsMaybe = (Seq a -> Seq a)
-> (a -> Seq a -> Seq a) -> Maybe a -> Seq a -> Seq a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Seq a -> Seq a
forall a. a -> a
id a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
(Seq.:<|)

seqFromMaybe :: Maybe a -> Seq a
seqFromMaybe :: Maybe a -> Seq a
seqFromMaybe = Seq a -> (a -> Seq a) -> Maybe a -> Seq a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Seq a
forall a. Seq a
Seq.empty a -> Seq a
forall a. a -> Seq a
Seq.singleton

seqSingleton :: Prism' (Seq a) a
seqSingleton :: Prism' (Seq a) a
seqSingleton = (a -> Seq a) -> (Seq a -> Maybe a) -> Prism' (Seq a) a
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' a -> Seq a
forall a. a -> Seq a
Seq.singleton Seq a -> Maybe a
forall a. Seq a -> Maybe a
f
  where
    f :: Seq a -> Maybe a
f = \case
        (a
x Seq.:<| Seq a
Seq.Empty) -> a -> Maybe a
forall a. a -> Maybe a
Just a
x
        Seq a
_ -> Maybe a
forall a. Maybe a
Nothing

seqAtMostOne :: Prism' (Seq a) (Maybe a)
seqAtMostOne :: Prism' (Seq a) (Maybe a)
seqAtMostOne = (Maybe a -> Seq a)
-> (Seq a -> Maybe (Maybe a)) -> Prism' (Seq a) (Maybe a)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' (Seq a -> (a -> Seq a) -> Maybe a -> Seq a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Seq a
forall a. Seq a
Seq.empty a -> Seq a
forall a. a -> Seq a
Seq.singleton) Seq a -> Maybe (Maybe a)
forall a. Seq a -> Maybe (Maybe a)
f
  where
    f :: Seq a -> Maybe (Maybe a)
f = \case
        Seq a
Seq.Empty -> Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just Maybe a
forall a. Maybe a
Nothing
        (a
x Seq.:<| Seq a
Seq.Empty) -> Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just (a -> Maybe a
forall a. a -> Maybe a
Just a
x)
        Seq a
_ -> Maybe (Maybe a)
forall a. Maybe a
Nothing

seqToList :: Seq a -> [a]
seqToList :: Seq a -> [a]
seqToList = Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList

seqConcat :: Seq (Seq a) -> Seq a
seqConcat :: Seq (Seq a) -> Seq a
seqConcat = Seq (Seq a) -> Seq a
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold

textEmpty :: Text.Text
textEmpty :: Text
textEmpty = Text
Text.empty

textConcat :: Foldable t => t Text.Text -> Text.Text
textConcat :: t Text -> Text
textConcat = [Text] -> Text
Text.concat ([Text] -> Text) -> (t Text -> [Text]) -> t Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t Text -> [Text]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList

seqAppendAndConcat :: Semigroup a => Seq a -> Seq a -> Seq a
seqAppendAndConcat :: Seq a -> Seq a -> Seq a
seqAppendAndConcat Seq a
x Seq a
Empty = Seq a
x
seqAppendAndConcat Seq a
Empty Seq a
x = Seq a
x
seqAppendAndConcat (Seq a
xs :|> a
x) (a
y :<| Seq a
ys) = Seq a
xs Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> a -> Seq a
forall a. a -> Seq a
Seq.singleton (a
x a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
y) Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> Seq a
ys

seqAppendAndConcatWith :: (a -> a -> Maybe a) -> Seq a -> Seq a -> Seq a
seqAppendAndConcatWith :: (a -> a -> Maybe a) -> Seq a -> Seq a -> Seq a
seqAppendAndConcatWith a -> a -> Maybe a
_ Seq a
x Seq a
Empty = Seq a
x
seqAppendAndConcatWith a -> a -> Maybe a
_ Seq a
Empty Seq a
x = Seq a
x
seqAppendAndConcatWith a -> a -> Maybe a
f a :: Seq a
a@(Seq a
xs :|> a
x) b :: Seq a
b@(a
y :<| Seq a
ys) =
    case a -> a -> Maybe a
f a
x a
y of
        Maybe a
Nothing -> Seq a
a Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> Seq a
b
        Just a
z -> Seq a
xs Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> a -> Seq a
forall a. a -> Seq a
Seq.singleton a
z Seq a -> Seq a -> Seq a
forall a. Semigroup a => a -> a -> a
<> Seq a
ys