name:                lawless-concurrent-machines
version:             0.3.1
synopsis:            Concurrent networked stream transducers

description: A simple use-case for this library is to run the stages
             of a pipelined streaming computation concurrently. If
             data is streaming through multiple processing stages, you
             might build a machine like
             .
             @
             step1 >~> step2 >~> step3
             @
             .
             The @>~>@ operator connects the machines on
             either side with a one-element buffer. This means that
             data is pulled from upstream sources eagerly (perhaps
             pulling one more value than will be consumed by
             downstream), but it also means that each stage can be
             working simultaneously, increasing throughput of the
             entire pipeline.
             .
             A few small examples are available in the @examples@
             directory of the source repository.
             .
             NOTE: This is a temporary fork until concurrent-machines
             0.3.1 is released.

license:             BSD3
license-file:        LICENSE
author:              Anthony Cowley
maintainer:          acowley@gmail.com
copyright:           Copyright (C) 2014 Anthony Cowley
category:            Concurrency, Control
build-type:          Simple
extra-source-files:  README.md, CHANGELOG.md
cabal-version:       >=1.10
tested-with:         GHC == 7.10.3, GHC == 8.0.1, GHC == 8.2.1

source-repository head
  type:     git
  location: git@gitlab.com:theunixman/haskell/lawless-concurrent-machines.git


flag splot
  description: Build test with splot visual output
  default:     False
  manual:      True

library
  exposed-modules:     Data.Machine.Concurrent,
                       Data.Machine.Regulated,
                       Data.Machine.Concurrent.AsyncStep,
                       Data.Machine.Concurrent.Buffer,
                       Data.Machine.Concurrent.Fanout,
                       Data.Machine.Concurrent.Scatter,
                       Data.Machine.Concurrent.Tee,
                       Data.Machine.Concurrent.Wye
  -- other-modules:
  other-extensions:    GADTs, FlexibleContexts, RankNTypes, TupleSections,
                       ScopedTypeVariables
  build-depends:       base >= 4.8 && < 5,
                       monad-control >= 1.0 && < 1.1,
                       transformers >= 0.4 && < 0.6,
                       time >= 1.4 && < 1.9,
                       containers >= 0.5 && < 0.6,
                       transformers-base >= 0.4 && < 0.6,
                       machines >= 0.5 && < 0.7,
                       async >= 2.0.1 && < 2.2,
                       lifted-async >= 0.1 && < 0.10,
                       semigroups >= 0.8 && < 0.19
  hs-source-dirs:      src
  default-language:    Haskell2010
  ghc-options: -Wall

test-suite tests
  type: exitcode-stdio-1.0
  hs-source-dirs: tests
  main-is: AllTests.hs
  ghc-options: -Wall -O0
  default-language: Haskell2010
  build-depends: base >= 4.6 && < 5, lawless-concurrent-machines, machines,
                 tasty, tasty-hunit, transformers, time

-- This is a nice modification of the tests that generates plots for
-- visualizing the execution of parallel processes using the splot
-- tool. That program requires cairo, so the test is disabled by
-- default.
test-suite splotime
  type: exitcode-stdio-1.0
  if flag(splot)
    buildable: True
  else
    buildable: False
  hs-source-dirs: tests
  main-is: SPlotTests.hs
  ghc-options: -Wall -O0
  default-language: Haskell2010
  if flag(splot)
    build-depends: base >= 4.6 && < 5, lawless-concurrent-machines, machines,
                   process, tasty, tasty-hunit, transformers, time

benchmark fanout
  type: exitcode-stdio-1.0
  hs-source-dirs: examples
  main-is: ExampleFanout.hs
  build-depends: base >= 4.8 && < 5, time, machines, lawless-concurrent-machines
  default-language: Haskell2010
  ghc-options: -threaded "-with-rtsopts=-N2"