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 (cluss-0.2-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 (cluss-0.2-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 (cluss-0.2-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 (cluss-0.2-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 (cluss-0.2-r0) |
2014-10-06T11:27:47Z |
Kinokkory |
d3d71cf315e2376148b1c45c447f4fd675c7d9277f39cf315a650c1e33de309c
|
|
|