data-accessor-0.2.1: data-accessor.cabal

Name:             data-accessor
Version:          0.2.1
License:          BSD3
License-File:     LICENSE
Author:           Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>
Homepage:         http://www.haskell.org/haskellwiki/Record_access
Package-URL:      http://code.haskell.org/data-accessor/
Category:         Data
Synopsis:         Utilities for accessing and manipulating fields of records
Description:
  In Haskell 98 the name of a record field
  is automatically also the name of a function which gets the value
  of the according field.
  E.g. if we have
  .
    data Pair a b = Pair {first :: a, second :: b}
  .
  then
  .
  > first  :: Pair a b -> a
  > second :: Pair a b -> b
  .
  However for setting or modifying a field value
  we need to use some syntactic sugar, which is often clumsy.
  .
    modifyFirst :: (a -> a) -> (Pair a b -> Pair a b)
    modifyFirst f r\@(Pair {first=a}) = r{first = f a}
  .
  With this package you can define record field accessors
  which allow setting, getting and modifying values easily.
  The package clearly demonstrates the power of the functional approach:
  You can combine accessors of a record and sub-records,
  to make the access look like the fields of the sub-record belong to the main record.
  .
  Example:
  .
  > *Data.Accessor.Example> (first^:second^=10) (('b',7),"hallo")
  > (('b',10),"hallo")
  .
  You can easily manipulate record fields in a 'Control.Monad.State.State' monad,
  you can easily code 'Show' instances that use the Accessor syntax
  and you can parse binary streams into records.
  See @Data.Accessor.Example@ for demonstration of all features.
  .
  It would be great if in revised Haskell versions the names of record fields
  are automatically 'Data.Accessor.Accessor's
  rather than plain @get@ functions.
  For now, the package @data-accessor-template@ provides Template Haskell functions
  for automated generation of 'Data.Acesssor.Accessor's.
  .
  For similar packages see @lenses@ and @fclabel@.
  A related concept are editors
  <http://conal.net/blog/posts/semantic-editor-combinators/>.
  Editors only consist of a modify method
  (and @modify@ applied to a 'const' function is a @set@ function).
  This way, they can modify all function values of a function at once,
  whereas an accessor can only change a single function value,
  say, it can change @f 0 = 1@ to @f 0 = 2@.
  This way, editors can even change the type of a record or a function.
  An Arrow instance can be define for editors,
  but for accessors only a Category instance is possible ('(.)' method).
  The reason is the @arr@ method of the @Arrow@ class,
  that conflicts with the two-way nature (set and get) of accessors.
-- Portability:      Haskell98
Cabal-Version:    >=1.2
Tested-With:      GHC==6.4.1 && ==6.8.2
Build-Type:       Simple

Extra-Source-Files:
  RegExp
  src-3/Data/Accessor/Private.hs
  src-4/Data/Accessor/Private.hs

Flag category
  description: Check whether Arrow class is split into Arrow and Category.

Library
  Build-Depends:
    array >=0.1 && <0.3,
    containers >=0.1 && <0.3,
    transformers >=0.0.1 && <0.2
  If flag(category)
    Hs-Source-Dirs: src-4
    Build-Depends: base >= 4 && <6
  Else
    Hs-Source-Dirs: src-3
    Build-Depends: base >= 1 && <4

  GHC-Options:      -Wall
  Hs-Source-Dirs:   src
  Exposed-Modules:
    Data.Accessor
    Data.Accessor.Basic
    Data.Accessor.Container
    Data.Accessor.Show
    Data.Accessor.Tuple
    Data.Accessor.BinaryRead
    Data.Accessor.MonadState
  Other-Modules:
    Data.Accessor.Example
    Data.Accessor.Private