data-accessor 0.1.4 → 0.2

raw patch · 7 files changed

+85/−28 lines, 7 filesdep +transformersdep −mtldep ~arraydep ~containers

Dependencies added: transformers

Dependencies removed: mtl

Dependency ranges changed: array, containers

Files

• data-accessor.cabal +2/−2
• src/Data/Accessor.hs +7/−7
• src/Data/Accessor/Basic.hs +13/−2
• src/Data/Accessor/BinaryRead.hs +6/−4
• src/Data/Accessor/Container.hs +17/−3
• src/Data/Accessor/Example.hs +8/−1
• src/Data/Accessor/MonadState.hs +32/−9

@@ -1,5 +1,5 @@ Name:             data-accessor-Version:          0.1.4+Version:          0.2 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>@@ -9,7 +9,7 @@ Category:         Data -- Portability:      Haskell98, not quite because of MTL dependency Build-Type:       Simple-Build-Depends:    base>=1.0, array, containers, mtl+Build-Depends:    base>=1.0, array >=0.1 && <0.2, containers >=0.1 && <0.2, transformers >=0.0.1 && <0.1 Synopsis:         Utilities for accessing and manipulating fields of records Description:   In Haskell 98 the name of a record field

@@ -14,7 +14,7 @@  import qualified Data.Accessor.Basic as Accessor import qualified Data.Accessor.MonadState as State-import Control.Monad.State (MonadState, )+import Control.Monad.Trans.State (StateT, )  -- |An @Accessor r a@ is an object that encodes how to -- get and put a subject of type @a@ out of/into an object@@ -80,7 +80,7 @@  > (=:) = putA -}-(=:) :: MonadState r m => Accessor r a -> a -> m ()+(=:) :: Monad m => Accessor r a -> a -> StateT r m () (=:) = putA  @@ -92,24 +92,24 @@ that provides more consistency with the infix operators for records (without State monad). -}-(%=) :: MonadState r m => Accessor r a -> a -> m ()+(%=) :: Monad m => Accessor r a -> a -> StateT r m () (%=) = putA  {- | Infix variant of 'modA'. -}-(%:) :: MonadState r m => Accessor r a -> (a -> a) -> m ()+(%:) :: Monad m => Accessor r a -> (a -> a) -> StateT r m () (%:) = modA -}  -- |A structural dereference function for state monads.-getA :: MonadState r m => Accessor r a -> m a+getA :: Monad m => Accessor r a -> StateT r m a getA = State.get  -- |A structural assignment function for state monads.-putA :: MonadState r m => Accessor r a -> a -> m ()+putA :: Monad m => Accessor r a -> a -> StateT r m () putA = State.set  -- |A structural modification function for state monads.-modA :: MonadState r m => Accessor r a -> (a -> a) -> m ()+modA :: Monad m => Accessor r a -> (a -> a) -> StateT r m () modA = State.modify

@@ -34,17 +34,28 @@    Cons $ \ x r -> let (y,f) = lens r in (y, f x)  +-- Simple accessors+ {- |-Simple accessor: Access the record itself+Access the record itself -} self :: T r r self = fromSetGet const id  {- |-Simple accessor: Access a (non-existing) element of type @()@+Access a (non-existing) element of type @()@ -} null :: T r () null = fromSetGet (flip const) (const ())++{-+{- |+Access the result of a function.+Cf. "http://conal.net/blog/posts/semantic-editor-combinators/"+-}+result :: a -> T (a -> r) r+result = fromSetGet (flip const) (const ())+-}   -- * Apply accessors, similar to State methods

@@ -8,8 +8,10 @@  import qualified Data.Accessor.Basic as Accessor -import qualified Control.Monad.State as State-import Control.Monad.State (MonadState, StateT, )+import qualified Control.Monad.Trans.State as State+import Control.Monad.Trans.State (StateT, )+import Control.Monad.Trans (lift, )+import Control.Monad (liftM, ) import Data.Word (Word8, ) import Data.Char (chr, ) @@ -42,7 +44,7 @@ instance (ByteStream s, Monad m) => ByteSource (StateT s m) where    readWord8 =       do xs <- State.get-         (c,cs) <- State.lift (getWord8 xs)+         (c,cs) <- lift (getWord8 xs)          State.put cs          return c @@ -51,7 +53,7 @@  instance C Char where    any =-      State.liftM (chr . fromIntegral) readWord8+      liftM (chr . fromIntegral) readWord8  instance C Int where    any =

@@ -5,12 +5,16 @@ consisting of arrays, maps and records. -} module Data.Accessor.Container-   (array, mapDefault, mapMaybe, ) where+   (array,+    mapDefault, mapMaybe,+    intMapDefault, intMapMaybe,+   ) where  import qualified Data.Accessor.Basic as Accessor -import qualified Data.Array as Array-import qualified Data.Map   as Map+import qualified Data.Array  as Array+import qualified Data.Map    as Map+import qualified Data.IntMap as IntMap  import Prelude hiding (map) @@ -36,3 +40,13 @@    Accessor.fromSetGet       (\e m -> maybe (Map.delete key m) (flip (Map.insert key) m) e)       (Map.lookup key)++intMapDefault :: elem -> Int -> Accessor.T (IntMap.IntMap elem) elem+intMapDefault deflt key =+   Accessor.fromSetGet (IntMap.insert key) (IntMap.findWithDefault deflt key)++intMapMaybe :: Int -> Accessor.T (IntMap.IntMap elem) (Maybe elem)+intMapMaybe key =+   Accessor.fromSetGet+      (\e m -> maybe (IntMap.delete key m) (flip (IntMap.insert key) m) e)+      (IntMap.lookup key)

@@ -13,7 +13,7 @@  import Data.Accessor.MonadState ((%=), (%:), ) import qualified Data.Accessor.MonadState as AState-import Control.Monad.State (State)+import Control.Monad.Trans.State (State) import Data.Char (ord, toUpper, )  import Prelude hiding (init)@@ -43,6 +43,13 @@       first.>first %= 'b'       second %= '!' : str       AState.get (first.>second)++stateLift :: State (Int, (Bool, Char)) ()+stateLift = do+  first %= 42+  AState.lift second $ do+    first  %: not+    second %= 'q'  init :: (Char,Int) init =

@@ -2,22 +2,26 @@ module Data.Accessor.MonadState where  import qualified Data.Accessor.Basic as Accessor-import qualified Control.Monad.State as State-import Control.Monad.State (MonadState, )+import qualified Control.Monad.Trans.State as State+import qualified Control.Monad.Trans as Trans+import Control.Monad.Trans.State (State, runState, StateT(runStateT), )+import Control.Monad.Trans (MonadTrans) -set :: MonadState r m => Accessor.T r a -> a -> m ()+-- * accessors in the form of actions in the state monad++set :: Monad m => Accessor.T r a -> a -> StateT r m () set f x = State.modify (Accessor.set f x) -get :: MonadState r m => Accessor.T r a -> m a+get :: Monad m => Accessor.T r a -> StateT r m a get f = State.gets (Accessor.get f) -modify :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()+modify :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m () modify f g = State.modify (Accessor.modify f g)  {- | Modify a record element and return its old value. -}-getAndModify :: MonadState r m => Accessor.T r a -> (a -> a) -> m a+getAndModify :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m a getAndModify f g =    do x <- get f       modify f g@@ -26,7 +30,7 @@ {- | Modify a record element and return its new value. -}-modifyAndGet :: MonadState r m => Accessor.T r a -> (a -> a) -> m a+modifyAndGet :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m a modifyAndGet f g =    do modify f g       get f@@ -38,11 +42,30 @@ {- | Infix variant of 'set'. -}-(%=) :: MonadState r m => Accessor.T r a -> a -> m ()+(%=) :: Monad m => Accessor.T r a -> a -> StateT r m () (%=) = set  {- | Infix variant of 'modify'. -}-(%:) :: MonadState r m => Accessor.T r a -> (a -> a) -> m ()+(%:) :: Monad m => Accessor.T r a -> (a -> a) -> StateT r m () (%:) = modify++++-- * lift a state monadic accessor to an accessor of a parent record++lift :: Monad m => Accessor.T r s -> State s a -> StateT r m a+lift f m =+   do s0 <- get f+      let (a,s1) = runState m s0+      set f s1+      return a++liftT :: (Monad m) =>+   Accessor.T r s -> StateT s m a -> StateT r m a+liftT f m =+   do s0 <- get f+      (a,s1) <- Trans.lift $ runStateT m s0+      set f s1+      return a