name:                auto
version:             0.4.1.0
x-revision: 1
synopsis:            Denotative, locally stateful programming DSL & platform
description:         (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 examples, and concrete explanations of
                     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 of
                     values: a stream of input events, output views, etc.
                     .
                     /auto/ works by providing a type that encapsulates
                     "value stream transformers", or locally stateful
                     functions; by specifying your program as a (potentially
                     cyclic) graph of relationships between value 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 rigid 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; I've also done a
                     <blog.jle.im/entries/series/+all-about-auto blog series>
                     on this library, with examples and full tutorials!
                     .
                     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!

license:             MIT
license-file:        LICENSE
author:              Justin Le
maintainer:          justin@jle.im
copyright:           (c) Justin Le 2015
category:            Control
homepage:            https://github.com/mstksg/auto
bug-reports:         https://github.com/mstksg/issues
build-type:          Simple
extra-source-files:  README.md
                     CHANGELOG.md
                     tutorial/tutorial.md
                     .gitignore
cabal-version:       >=1.10

source-repository head
  type:              git
  location:          git://github.com/mstksg/auto.git

library
  exposed-modules:     Control.Auto
                     , Control.Auto.Blip
                     , Control.Auto.Blip.Internal
                     , Control.Auto.Collection
                     , Control.Auto.Core
                     , Control.Auto.Effects
                     , Control.Auto.Generate
                     , Control.Auto.Interval
                     , Control.Auto.Process
                     , Control.Auto.Process.Random
                     , Control.Auto.Run
                     , Control.Auto.Serialize
                     , Control.Auto.Switch
                     , Control.Auto.Time
  -- other-modules:
  -- other-extensions:
  build-depends:       base         >= 4.6      && < 4.9
                     , MonadRandom  >= 0.3.0.1  && < 0.4
                     , bytestring   >= 0.10.4.0 && < 0.11
                     , cereal       >= 0.4.1.1  && < 0.5
                     , containers   >= 0.5.5.1  && < 0.6
                     , deepseq      >= 1.3.0.2  && < 2.0
                     , profunctors  >= 4.3      && < 5.0
                     , random       >= 1.1      && < 2.0
                     , semigroups   >= 0.16     && < 0.17
                     , transformers >= 0.4.2.0  && < 0.5
  hs-source-dirs:      src
  default-language:    Haskell2010
  ghc-options:         -Wall