module Unbound.Util where
import Data.Maybe (catMaybes)
import Data.Monoid
import qualified Data.Foldable as F
import qualified Data.Set as S
import qualified Data.Map as M
(<>) :: Monoid m => m -> m -> m
(<>) = mappend
class F.Foldable f => Collection f where
emptyC :: f a
singleton :: a -> f a
union :: Ord a => f a -> f a -> f a
cmap :: (Ord a, Ord b) => (a -> b) -> f a -> f b
unions :: (Ord a, Collection f) => [f a] -> f a
unions = foldr union emptyC
fromList :: (Ord a, Collection f) => [a] -> f a
fromList = unions . map singleton
filterC :: (Collection f, Ord a) => f (Maybe a) -> f a
filterC = fromList . catMaybes . F.toList
instance Collection [] where
emptyC = []
singleton = (:[])
union = (++)
cmap = map
newtype Multiset a = Multiset (M.Map a Int)
instance F.Foldable Multiset where
fold (Multiset m) = M.foldrWithKey (\a n x -> mconcat (x : replicate n a)) mempty m
instance Collection Multiset where
emptyC = Multiset M.empty
singleton = Multiset . flip M.singleton 1
(Multiset m1) `union` (Multiset m2) = Multiset $ M.unionWith (+) m1 m2
cmap f (Multiset m) = Multiset $ M.mapKeys f m
instance Collection S.Set where
emptyC = S.empty
singleton = S.singleton
union = S.union
cmap = S.map