Metadata revisions for cluss-0.2

Package maintainers and Hackage trustees are allowed to edit certain bits of package metadata after a release, without uploading a new tarball. Note that the tarball itself is never changed, just the metadata that is stored separately. For more information about metadata revisions, please refer to the Hackage Metadata Revisions FAQ.

No. Time User SHA256
-r4 2014-10-06T11:41:28Z Kinokkory 252b014a2c2499e6704c850c01c1e3fd7ee97bd71756e13c96003fb99e8bc5e6
  • Changed description from

    A /cluss/ enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be /recursive/;
    therefore, they are expressive enough to imitate Haskell-98-style type classes.
    
    Clusses, however, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.
    to
    A /cluss/ enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be /recursive/;
    therefore, they are expressive enough to imitate Haskell-98-style type classes.
    
    Clusses, however, go beyond a mere alternative to type classes.
    They have /closed/ and /prioritized/ instances and /open/ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can judge whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more flexibly,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can create new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.

-r3 2014-10-06T11:39:33Z Kinokkory 889029cf5fe1193a0f7970b05bb40608bf17b6f54cd24e098188babcb97af117
  • Changed description from

    A <b>cluss</b> enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be __recursive__;
    therefore, they are /expressive/ enough to imitate Haskell-98-style type classes.
    
    Clusses, /however/, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.
    to
    A /cluss/ enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be /recursive/;
    therefore, they are expressive enough to imitate Haskell-98-style type classes.
    
    Clusses, however, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.

-r2 2014-10-06T11:34:17Z Kinokkory 3551c178e92fde2611bf30429e8ca9766e098dbf55875d0222018ea04fd8e3de
  • Changed description from

    A *cluss* enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be __recursive__;
    therefore, they are /expressive/ enough to imitate Haskell-98-style type classes.
    
    Clusses, /however/, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.
    to
    A <b>cluss</b> enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be __recursive__;
    therefore, they are /expressive/ enough to imitate Haskell-98-style type classes.
    
    Clusses, /however/, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.

-r1 2014-10-06T11:32:40Z Kinokkory c5b478329fdcf2587d868e005380cf792eb010bfafab33ba85104e116494dadd
  • Changed description from

    A __cluss__ enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be __recursive__;
    therefore, they are /expressive/ enough to imitate Haskell-98-style type classes.
    
    Clusses, /however/, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage\'s haddock> or the <https://github.com/Kinokkory/cluss updated haddock>.
    to
    A *cluss* enables you to achieve function overloading, or ad-hoc polymorphism,
    without creating a new type class.
    
    In order to give ad-hoc polymorphism to a type variable @a@,
    you simply use @'In'@ with a list of \"type patterns\" like @In [Type T, ...] a@,
    which indicates that the type matches some of the patterns;
    which is analogous to a type class indicating that a type matches some of its \"instances\".
    The constraint @In [Type T, ...] a@ is what we call a \"cluss\".
    
    Clusses can easily be used in a nested way
    and even be __recursive__;
    therefore, they are /expressive/ enough to imitate Haskell-98-style type classes.
    
    Clusses, /however/, go beyond a mere alternative to type classes.
    They have __closed__ and __prioritized__ instances and __open__ methods,
    while type classes have open and unprioritized instances and closed methods.
    Those properties give clusses the advantages different from type classes:
    
    * You can /judge/ whether a type @a@ belongs to a cluss @'In' as@,
    on some level, writing @Has as a@,
    since cluss instances are closed.
    
    * You can make cluss instances more /flexibly/,
    without causing overlapping instances or incoherent instances,
    since cluss instances are prioritized.
    
    * You can /create/ new methods for clusses anywhere in any module,
    since cluss methods are open.
    
    More information can be found in the <http://hackage.haskell.org/package/cluss hackage's haddock> or the <http://kinokkory.github.io/cluss/ updated haddock>.

-r0 2014-10-06T11:27:47Z Kinokkory d3d71cf315e2376148b1c45c447f4fd675c7d9277f39cf315a650c1e33de309c