{-# language FlexibleInstances, MultiParamTypeClasses, FlexibleContexts #-}
{-# language TupleSections #-}

module Satchmo.Map.Data

( Map
, unknown, constant
, (!), elems, keys, toList, fromList
, map, mapWithKey
) 

where

import qualified Prelude; import Prelude hiding ( map ) 
import Satchmo.Code
import qualified Satchmo.Boolean as B

import Satchmo.SAT

import qualified Data.Set as S
import qualified Data.Map.Strict as M

import Control.Monad ( guard, forM )
import Control.Applicative ( (<$>), (<*>) )

newtype Map a b = Map (M.Map a b)

Map Map k a
m ! :: Map k a -> k -> a
! k
i = Map k a
m forall k a. Ord k => Map k a -> k -> a
M.! k
i
elems :: Map k a -> [a]
elems (Map Map k a
m) = forall k a. Map k a -> [a]
M.elems Map k a
m
keys :: Map k a -> [k]
keys (Map Map k a
m) = forall k a. Map k a -> [k]
M.keys Map k a
m
toList :: Map k a -> [(k, a)]
toList (Map Map k a
m) = forall k a. Map k a -> [(k, a)]
M.toList Map k a
m
fromList :: [(a, b)] -> Map a b
fromList [(a, b)]
kvs = forall a b. Map a b -> Map a b
Map forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(a, b)]
kvs
map :: (a -> b) -> Map a a -> Map a b
map a -> b
f (Map Map a a
m) = forall a b. Map a b -> Map a b
Map (forall a b k. (a -> b) -> Map k a -> Map k b
M.map a -> b
f Map a a
m)
mapWithKey :: (a -> a -> b) -> Map a a -> Map a b
mapWithKey a -> a -> b
f (Map Map a a
m) = forall a b. Map a b -> Map a b
Map (forall k a b. (k -> a -> b) -> Map k a -> Map k b
M.mapWithKey a -> a -> b
f Map a a
m)

instance ( Functor m, Decode m b c, Ord a )
         => Decode m (Map a b) ( M.Map a c) where
    decode :: Map a b -> m (Map a c)
decode (Map Map a b
m) = forall (m :: * -> *) c a. Decode m c a => c -> m a
decode Map a b
m

-- | allocate an unknown map with this domain
unknown :: ( B.MonadSAT m , Ord a )
         => [a] -> m b -> m (Map a b)
unknown :: forall (m :: * -> *) a b.
(MonadSAT m, Ord a) =>
[a] -> m b -> m (Map a b)
unknown [a]
xs m b
build = forall a b. Map a b -> Map a b
Map forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall k a. Ord k => [(k, a)] -> Map k a
M.fromList 
     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [a]
xs forall a b. (a -> b) -> a -> b
$ \ a
x -> (a
x,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m b
build )

constant :: ( B.MonadSAT m , Ord a )
         => [(a,c)] -> (c -> m b) -> m (Map a b)
constant :: forall (m :: * -> *) a c b.
(MonadSAT m, Ord a) =>
[(a, c)] -> (c -> m b) -> m (Map a b)
constant [(a, c)]
xys c -> m b
encode = forall a b. Map a b -> Map a b
Map forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall k a. Ord k => [(k, a)] -> Map k a
M.fromList 
     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(a, c)]
xys forall a b. (a -> b) -> a -> b
$ \ (a
x,c
y) -> (a
x,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> m b
encode c
y )