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 |
| -r2 (auto-0.2.0.5-r2) |
2015-03-24T21:05:48Z |
jle |
21de0f6b3309a084876f2e6a3ef4a87a2953511d9d564528071c0a81bcf22dd0
|
|
Changed description
from (Up to date documentation is maintained at
<https://mstksg.github.com/auto>)
/auto/ is a Haskell DSL and platform providing
declarative, compositional, denotative semantics for
discrete-step, locally stateful, interactive programs,
games, and automations, with implicitly derived
serialization. It is suited for any domain where either
the input or the output can be described as a stream: a
stream of input events, output views, etc.
/auto/ works by providing a type that encapsulates
"stream transformers", or locally stateful functions; by
specifying your program as a (potentially cyclic) graph
of relationships between streams, you create a way of
"declaring" a system based simply on static relationships
between quantities.
Instead of a "state monad" type solution, where all
functions have access to a global state, /auto/ works by
specifying relationships which each exist independently
and on their own, without any global state.
A more fuller exposition is in the `README.md`, in this
project directory and also online at
<https://github.com/mstksg/auto/blob/master/README.md>;
you can get started by reading the tutorial, which is
also in this project directory in the `tutorial`
directory, and also incidentally online at
<https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md>.
Also, check out the
<https://github.com/mstksg/auto-examples auto-examples>
repository on github for plenty of real-world and toy
examples to learn from!
Support available on freenode's #haskell-auto,
#haskell-game, and also on the github issue
tracker for the source repository.
Import "Control.Auto" to begin!
to (Up to date documentation is maintained at
<https://mstksg.github.com/auto>)
Read the README first!
<https://github.com/mstksg/auto/blob/master/README.md>
for motivating, short examples and concrete explanations of
the things described here.
/auto/ is a Haskell DSL and platform providing
declarative, compositional, denotative semantics for
discrete-step, locally stateful, interactive programs,
games, and automations, with implicitly derived
serialization. It is suited for any domain where either
the input or the output can be described as a stream: a
stream of input events, output views, etc.
/auto/ works by providing a type that encapsulates
"stream transformers", or locally stateful functions; by
specifying your program as a (potentially cyclic) graph
of relationships between streams, you create a way of
"declaring" a system based simply on static relationships
between quantities.
Instead of a "state monad" type solution, where all
functions have access to a global state, /auto/ works by
specifying relationships which each exist independently
and on their own, without any global state.
A more fuller exposition is in the `README.md`, in this
project directory and also online at
<https://github.com/mstksg/auto/blob/master/README.md>;
you can get started by reading the tutorial, which is
also in this project directory in the `tutorial`
directory, and also incidentally online at
<https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md>.
Also, check out the
<https://github.com/mstksg/auto-examples auto-examples>
repository on github for plenty of real-world and toy
examples to learn from!
Support available on freenode's #haskell-auto,
#haskell-game, and also on the github issue
tracker for the source repository.
Import "Control.Auto" to begin!
|
| -r1 (auto-0.2.0.5-r1) |
2015-03-24T11:21:33Z |
jle |
d157149714040ab304b3cc808a27ac914576f0c7cbf73e399f2fb9eb0cd7f7cb
|
|
Changed description
from (Up to date documentation is maintained at
<https://mstksg.github.com/auto>)
/auto/ is a Haskell DSL and platform providing
declarative, compositional, denotative semantics for
discrete-step, locally stateful, interactive programs,
games, and automations, with implicitly derived
serialization.
/auto/ works by providing a type that encapsulates
"stream transformers", or locally stateful functions; by
specifying your program as a (potentially cyclic) graph
of relationships between streams, you create a way of
"declaring" a system based simply on static relationships
between quantities.
Instead of a "state monad" type solution, where all
functions have access to a global state, /auto/ works by
specifying relationships which each exist independently
and on their own, without any global state.
A more fuller exposition is in the `README.md`, in this
project directory and also online at
<https://github.com/mstksg/auto/blob/master/README.md>;
you can get started by reading the tutorial, which is
also in this project directory in the `tutorial`
directory, and also incidentally online at
<https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md>.
Also, check out the
<https://github.com/mstksg/auto-examples auto-examples>
repository on github for plenty of real-world and toy
examples to learn from!
Support available on freenode's #haskell-auto,
#haskell-game, and also on the github issue
tracker for the source repository.
Import "Control.Auto" to begin!
to (Up to date documentation is maintained at
<https://mstksg.github.com/auto>)
/auto/ is a Haskell DSL and platform providing
declarative, compositional, denotative semantics for
discrete-step, locally stateful, interactive programs,
games, and automations, with implicitly derived
serialization. It is suited for any domain where either
the input or the output can be described as a stream: a
stream of input events, output views, etc.
/auto/ works by providing a type that encapsulates
"stream transformers", or locally stateful functions; by
specifying your program as a (potentially cyclic) graph
of relationships between streams, you create a way of
"declaring" a system based simply on static relationships
between quantities.
Instead of a "state monad" type solution, where all
functions have access to a global state, /auto/ works by
specifying relationships which each exist independently
and on their own, without any global state.
A more fuller exposition is in the `README.md`, in this
project directory and also online at
<https://github.com/mstksg/auto/blob/master/README.md>;
you can get started by reading the tutorial, which is
also in this project directory in the `tutorial`
directory, and also incidentally online at
<https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md>.
Also, check out the
<https://github.com/mstksg/auto-examples auto-examples>
repository on github for plenty of real-world and toy
examples to learn from!
Support available on freenode's #haskell-auto,
#haskell-game, and also on the github issue
tracker for the source repository.
Import "Control.Auto" to begin!
|
| -r0 (auto-0.2.0.5-r0) |
2015-03-22T10:40:53Z |
jle |
c9232e7b7b7118631fdb728875b25e4a9b098daef971c500d9dcb416576aa2ea
|
|
|