containers.hs

{-# OPTIONS_GHC -Wall #-}

import Control.Lens
import Data.IntMap(IntMap)
import Data.Map(Map)
import Data.Set(Set)
import Prelude hiding (lookup)

{-#
  SPECIALIZE
  delete :: Ord a => a -> Set a -> Set a
  #-}
{-#
  SPECIALIZE
  delete :: Ord k => k -> Map k v -> Map k v
  #-}
{-#
  SPECIALIZE
  delete :: Int -> IntMap v -> IntMap v
  #-}
delete :: At m => Index m -> m -> m
delete = sans

{-#
  SPECIALIZE
  lookup :: Ord a => a -> Set a -> Maybe ()
  #-}
{-#
  SPECIALIZE
  lookup :: Ord k => k -> Map k v -> Maybe v
  #-}
{-#
  SPECIALIZE
  lookup :: Int -> IntMap v -> Maybe v
  #-}
{-#
  SPECIALIZE
  lookup :: Int -> [a] -> Maybe a
  #-}
lookup :: Ixed m => Index m -> m -> Maybe (IxValue m)
lookup n = preview (ix n)

{-#
  SPECIALIZE
  member :: Ord a => a -> Set a -> Bool
  #-}
{-#
  SPECIALIZE
  member :: Ord k => k -> Map k v -> Bool
  #-}
{-#
  SPECIALIZE
  member :: Int -> IntMap v -> Bool
  #-}
{-#
  SPECIALIZE
  member :: Int -> [a] -> Bool
  #-}
member :: Ixed m => Index m -> m -> Bool
member k = has (ix k)

{-#
  SPECIALIZE
  insert :: Ord a => a -> () -> Set a -> Set a
  #-}
{-#
  SPECIALIZE
  insert :: Ord k => k -> v -> Map k v -> Map k v
  #-}
{-#
  SPECIALIZE
  insert :: Int -> v -> IntMap v -> IntMap v
  #-}
insert :: At m => Index m -> IxValue m -> m -> m
insert k v = set (at k) (Just v)

{-#
  SPECIALIZE
  empty :: Set a
  #-}
{-#
  SPECIALIZE
  empty :: Map k v
  #-}
{-#
  SPECIALIZE
  empty :: IntMap k
  #-}
{-#
  SPECIALIZE
  empty :: [a]
  #-}
empty :: AsEmpty m => m
empty = review _Empty ()

{-#
  SPECIALIZE
  emptym :: Ord a => Set a
  #-}
{-#
  SPECIALIZE
  emptym :: Ord k => Map k v
  #-}
{-#
  SPECIALIZE
  emptym :: IntMap k
  #-}
{-#
  SPECIALIZE
  emptym :: [a]
  #-}
emptym :: Monoid m => m
emptym = mempty

{-#
  SPECIALIZE
  join :: Ord a => Set a -> Set a -> Set a
  #-}
{-#
  SPECIALIZE
  join :: Ord k => Map k v -> Map k v -> Map k v
  #-}
{-#
  SPECIALIZE
  join :: IntMap k -> IntMap k -> IntMap k
  #-}
{-#
  SPECIALIZE
  join :: [a] -> [a] -> [a]
  #-}
join :: Semigroup m => m -> m -> m
join = (<>)

{-#
  SPECIALIZE
  foreach :: Traversal (Map k v) (Map k v') v v'
  #-}
{-#
  SPECIALIZE
  foreach :: Traversal (IntMap v) (IntMap v') v v'
  #-}
{-#
  SPECIALIZE
  foreach :: Traversal [a] [b] a b
  #-}
foreach :: Each s t a b => Traversal s t a b
foreach = each

{-# 
  SPECIALIZE
  geteach :: Fold (Map k v) v
  #-}
{-# 
  SPECIALIZE
  geteach :: Fold (IntMap v) v
  #-}
{-# 
  SPECIALIZE
  geteach :: Fold (Set a) a
  #-}
{-# 
  SPECIALIZE
  geteach :: Fold [a] a
  #-}
geteach :: Foldable f => IndexedFold Int (f a) a
geteach = folded