{-# language MultiParamTypeClasses, FunctionalDependencies #-}
{-# language FlexibleInstances, UndecidableInstances, FlexibleContexts #-}

module Satchmo.Code 

( Decode (..)
-- , Decoder
)

where

import Satchmo.Data

import Data.Array

import Control.Monad.Reader
import qualified Data.Map as M

class Monad m => Decode m c a where 
    decode :: c -> m a

-- type Decoder a = Reader ( Map Variable Bool ) a
-- type Decoder a = Reader ( Array Variable Bool ) a

instance Monad m => Decode m () () where
    decode :: () -> m ()
decode () = forall (m :: * -> *) a. Monad m => a -> m a
return ()

instance (  Decode m c a, Decode m d b ) => Decode m ( c,d) (a,b) where
    decode :: (c, d) -> m (a, b)
decode (c
c,d
d) = do a
a <- forall (m :: * -> *) c a. Decode m c a => c -> m a
decode c
c; b
b <- forall (m :: * -> *) c a. Decode m c a => c -> m a
decode d
d; forall (m :: * -> *) a. Monad m => a -> m a
return ( a
a,b
b)

instance (  Decode m c a ) => Decode m [c] [a] where
    decode :: [c] -> m [a]
decode = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *) c a. Decode m c a => c -> m a
decode 

instance Decode m a b => Decode m ( Maybe a ) ( Maybe b ) where
    decode :: Maybe a -> m (Maybe b)
decode ( Just a
b ) = do b
a <- forall (m :: * -> *) c a. Decode m c a => c -> m a
decode a
b ; forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just b
a
    decode Maybe a
Nothing = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing

instance (Ix i, Decode m c a) => Decode m ( Array i c) ( Array i a ) where
    decode :: Array i c -> m (Array i a)
decode Array i c
x = do
        [(i, a)]
pairs <- forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall a b. (a -> b) -> a -> b
$ do
            (i
i,c
e) <- forall i e. Ix i => Array i e -> [(i, e)]
assocs Array i c
x
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ do
                a
f <- forall (m :: * -> *) c a. Decode m c a => c -> m a
decode c
e
                forall (m :: * -> *) a. Monad m => a -> m a
return (i
i,a
f)
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
array (forall i e. Array i e -> (i, i)
bounds Array i c
x) [(i, a)]
pairs

instance (Ord i, Decode m c a) => Decode m ( M.Map i c) ( M.Map i a ) where
    decode :: Map i c -> m (Map i a)
decode Map i c
x = do
        [(i, a)]
pairs <- forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall a b. (a -> b) -> a -> b
$ do
            (i
i,c
e) <- forall k a. Map k a -> [(k, a)]
M.assocs Map i c
x
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ do
                a
f <- forall (m :: * -> *) c a. Decode m c a => c -> m a
decode c
e
                forall (m :: * -> *) a. Monad m => a -> m a
return (i
i,a
f)
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(i, a)]
pairs