Source: haskell-data-accessor
Priority: optional
Section: misc
Maintainer: Clifford Beshers <beshers@seereason.com>
Build-Depends: debhelper (>= 7.0),
               haskell-devscripts (>= 0.6.15+nmu7),
               hscolour,
               cdbs,
               ghc6 (>= 6.8),
               ghc6-prof,
               libghc6-transformers-prof (>= 0.0.1),
               libghc6-transformers-prof (<< 0.2)
Build-Depends-Indep: ghc6-doc,
                     haddock,
                     haskell-transformers-doc (>= 0.0.1),
                     haskell-transformers-doc (<< 0.2)
Standards-Version: 3.8.1
Homepage: http://www.haskell.org/haskellwiki/Record_access

Package: libghc6-data-accessor-dev
Architecture: any
Section: haskell
Depends: ${haskell:Depends},
         ${misc:Depends}
Description: Utilities for accessing and manipulating fields of records
 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.
 .
  Author: Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
  Upstream-Maintainer: Henning Thielemann <haskell@henning-thielemann.de>
  Url: http://code.haskell.org/data-accessor/
 .
 This package contains the normal library files.

Package: libghc6-data-accessor-prof
Architecture: any
Section: haskell
Depends: ${haskell:Depends},
         ${misc:Depends},
         libghc6-data-accessor-dev
Description: Utilities for accessing and manipulating fields of records
 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.
 .
  Author: Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
  Upstream-Maintainer: Henning Thielemann <haskell@henning-thielemann.de>
  Url: http://code.haskell.org/data-accessor/
 .
 This package contains the libraries compiled with profiling enabled.

Package: haskell-data-accessor-doc
Architecture: all
Section: doc
Depends: ${haskell:Depends},
         ${misc:Depends},
         ghc6-doc
Description: Utilities for accessing and manipulating fields of records
 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.
 .
  Author: Henning Thielemann <haskell@henning-thielemann.de>, Luke Palmer <lrpalmer@gmail.com>
  Upstream-Maintainer: Henning Thielemann <haskell@henning-thielemann.de>
  Url: http://code.haskell.org/data-accessor/
 .
 This package contains the documentation files.