streamly/asyncly.cabal

name:               asyncly
version:            0.1.0
synopsis:           Beautiful High Level Concurrent Composition
description:        Asyncly is best described as a superset of list transformer
                    (`ListT`) or logic programming monad (`LogicT`)
                    with additional support for concurrent operation. Monadic
                    streams of data can be composed using serial or parallel
                    compositions with or without fair interleaving, enabling a
                    high level composition of concurrent tasks without
                    requiring knowledge of low level concurrency
                    primitives. The programmer just expresses whether a task
                    can run in parallel with another. Threads, synchronization
                    and concurrency rate control is handled automatically.
                    .
                    This library was originally inspired by the `transient`
                    package authored by Alberto G. Corona.
homepage:            http://github.com/harendra-kumar/asyncly
bug-reports:         https://github.com/harendra-kumar/asyncly/issues
license:             BSD3
license-file:        LICENSE
author:              Harendra Kumar
maintainer:          harendra.kumar@gmail.com
copyright:           2017 Harendra Kumar
category:            Control, Concurrency, Streaming
stability:           Experimental
build-type:          Simple
cabal-version:       >= 1.10

library
    hs-source-dirs:    src
    exposed-modules:   Asyncly
                     , Asyncly.AsyncT

    default-language: Haskell2010
    ghc-options:      -Wall -fwarn-identities -fwarn-incomplete-record-updates
                      -fwarn-incomplete-uni-patterns -fwarn-tabs

    build-depends:     base              >= 4.8   &&  < 5
                     , atomic-primops    >= 0.8   && < 0.9
                     , containers        >= 0.5   && < 0.6
                     , exceptions        >= 0.8   && < 0.9
                     , lifted-base       >= 0.2   && < 0.3
                     , lockfree-queue    >= 0.2.3 && < 0.3
                     , monad-control     >= 1.0   && < 2
                     , mtl               >= 2.2   && < 3
                     , stm               >= 2.4.3 && < 2.5
                     , transformers      >= 0.5   && < 0.6
                     , transformers-base >= 0.4   && < 0.5

test-suite test
  type: exitcode-stdio-1.0
  main-is: Main.hs
  hs-source-dirs: test
  ghc-options: -O0 -Wall -fwarn-identities -fwarn-incomplete-record-updates
               -fwarn-incomplete-uni-patterns -fwarn-tabs
  build-depends:
      asyncly
    , base              >= 4.8   && < 5
    , hspec             >= 2.0   && < 3
    , containers        >= 0.5   && < 0.6
  default-language: Haskell2010

benchmark bench
  type: exitcode-stdio-1.0
  main-is: Main.hs
  hs-source-dirs: benchmark
  ghc-options: -Wall -fwarn-identities -fwarn-incomplete-record-updates
               -fwarn-incomplete-uni-patterns -fwarn-tabs
               -O2 -funbox-strict-fields
               -fno-ignore-asserts
  build-depends:
      asyncly
    , atomic-primops      >= 0.8   && < 0.9
    , base                >= 4.8   && < 5
    , criterion           >= 1     && < 2
    , list-t              >= 1     && < 2
    , logict              >= 0.6   && < 0.7
    , machines            >= 0.6   && < 0.7
    , mtl                 >= 2.2   && < 3
    , simple-conduit      >= 0.6   && < 0.7
    , transient           >= 0.5   && < 0.6
  default-language: Haskell2010

source-repository head
    type: git
    location: https://github.com/harendra-kumar/asyncly