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.1-r4) |
2014-10-05T12:05:45Z |
Kinokkory |
c60ed38d9c7fd593690792cbb3aa5ed62ac042e399c803bf1375af6cdfdc3403
|
|
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
The updated haddock is here: <http://hackage.haskell.org/package/cluss>.
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
The updated haddock is here: <http://kinokkory.github.io/cluss/>.
|
| -r3 (cluss-0.1-r3) |
2014-10-05T12:04:29Z |
Kinokkory |
0812e33825593b7585e11a4f171f66c22520c12b2e441bd97de2222039be8a81
|
|
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
The updated haddock is here: <http://hackage.haskell.org/package/cluss>.
|
| -r2 (cluss-0.1-r2) |
2014-10-04T15:35:33Z |
Kinokkory |
488cb16e95ef35975a612d3be524224ad94a13086a3adecb1294cf0c2c9618f7
|
|
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
|
| -r1 (cluss-0.1-r1) |
2014-10-04T04:39:40Z |
Kinokkory |
98bdd7fba90f6865e8fedb513ca95a206a7aade233fb1cdb46d11c78db11e9cc
|
|
Changed synopsis
from Simple Alternative to Type Classes
to simple alternative to type classes 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".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
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\".
Cluss instances are /closed/ and cluss methods are /open/,
unlike type classes, whose instances are open and whose methods are closed.
Clusses can easily be used in a nested way,
and can even be /recursive/, just like recursive type classes,
and therefore clusses are expressive enough to imitate Haskell-98-style type classes.
More information can be found in the Haddock or the comments in the source code.
|
| -r0 (cluss-0.1-r0) |
2014-10-03T14:01:20Z |
Kinokkory |
b8d7333f3ec457878559fff6367fdd013070c85df4f48d4fb95d86793d724fd8
|
|
|