streamly/streamly.cabal

cabal-version:      2.2
name:               streamly
version:            0.7.0
synopsis:           Beautiful Streaming, Concurrent and Reactive Composition
description:
  Streamly is a framework for writing programs in a high level, declarative
  data flow programming paradigm. It provides a simple API, very close to
  standard Haskell lists.  A program is expressed as a composition of data
  processing pipes, generally known as streams.  Streams can be generated,
  merged, chained, mapped, zipped, and consumed concurrently – enabling a high
  level, declarative yet concurrent composition of programs.  Programs can be
  concurrent or non-concurrent without any significant change.  Concurrency is
  auto scaled based on consumption rate.  Programmers do not have to be aware
  of threads, locking or synchronization to write scalable concurrent programs.
  Streamly provides C like performance, orders of magnitude better compared to
  existing streaming libraries.
  .
  Streamly is designed to express the full spectrum of programs with highest
  performance. Do not think that if you are writing a small and simple program
  it may not be for you. It expresses a small "hello world" program with the
  same efficiency, simplicity and elegance as a large scale concurrent
  application. It unifies many different aspects of special purpose libraries
  into a single yet simple framework.
  .
  Streamly covers the functionality provided by Haskell lists as well as the
  functionality provided by streaming libraries like
  <https://hackage.haskell.org/package/streaming streaming>,
  <https://hackage.haskell.org/package/pipes pipes>, and
  <https://hackage.haskell.org/package/conduit conduit> with a simpler API and
  better performance. Streamly provides
  advanced stream composition including various ways of appending, merging,
  zipping, splitting, grouping, distributing, partitioning and unzipping of
  streams with true streaming and with concurrency. Streamly subsumes the
  functionality of list transformer libraries like @pipes@ or
  <https://hackage.haskell.org/package/list-t list-t> and also the logic
  programming library <https://hackage.haskell.org/package/logict logict>.
  The grouping, splitting and windowing combinators in streamly can be compared
  to the window operators in <https://flink.apache.org/ Apache Flink>.
  However, compared to Flink streamly has a pure functional, succinct and
  expressive API.
  .
  The concurrency capabilities of streamly are much more advanced and powerful
  compared to the basic concurrency functionality provided by the
  <https://hackage.haskell.org/package/async async> package.  Streamly is a
  first class reactive programming library.  If you are familiar with
  <http://reactivex.io/ Reactive Extensions> you will find that it is very
  similar.  For most RxJs combinators you can find or write corresponding ones
  in streamly. Streamly can be used as an alternative to
  <https://hackage.haskell.org/package/Yampa Yampa> or
  <https://hackage.haskell.org/package/reflex reflex> as well.
  .
  Streamly focuses on practical engineering with high performance. From well
  written streamly programs one can expect performance competitive to C.  High
  performance streaming eliminates the need for string and text libraries like
  <https://hackage.haskell.org/package/bytestring bytestring>,
  <https://hackage.haskell.org/package/text text> and their lazy and strict
  flavors. The confusion and cognitive overhead arising from different
  string types is eliminated. The two fundamental types in streamly are arrays
  for storage and streams for processing. Strings and text are simply streams
  or arrays of 'Char' as they should be. Arrays in streamly have performance
  at par with the vector library.
  .
  Where to find more information:
  .
  * /Quick Overview/: <#readme README file> in the package
  * /Building/: <src/docs/Build.md Build guide> for optimal performance
  * /Detailed Tutorial/: "Streamly.Tutorial" module in the haddock documentation
  * /Interoperation/: "Streamly.Tutorial" module for interop with other
    streaming libraries
  * /Reference Documentation/: Haddock documentation for the respective modules
  * /Examples/: <src/examples examples directory> in the package
  * /Guides/: <src/docs docs directory> in the package, for documentation on
    advanced topics, limitations, semantics of the library or on specific use
    cases.
  * <https://github.com/composewell/streaming-benchmarks Streaming Benchmarks>
  * <https://github.com/composewell/concurrency-benchmarks Concurrency Benchmarks>
  .


homepage:            https://github.com/composewell/streamly
bug-reports:         https://github.com/composewell/streamly/issues
license:             BSD-3-Clause
license-file:        LICENSE
tested-with:         GHC==7.10.3
                   , GHC==8.0.2
                   , GHC==8.4.4
                   , GHC==8.6.5
                   , GHC==8.8.1
author:              Harendra Kumar
maintainer:          streamly@composewell.com
copyright:           2017 Harendra Kumar
category:            Control, Concurrency, Streaming, Reactivity
stability:           Experimental
build-type:          Configure

extra-source-files:
    Changelog.md
    credits/*.md
    credits/base-4.12.0.0.txt
    credits/bjoern-2008-2009.txt
    credits/clock-0.7.2.txt
    credits/foldl-1.4.5.txt
    credits/pipes-concurrency-2.0.8.txt
    credits/pipes-concurrency.txt
    credits/transient-0.5.5.txt
    credits/vector-0.12.0.2.txt
    credits/Yampa-0.10.6.2.txt
    README.md
    docs/streamly-vs-async.md
    docs/streamly-vs-lists.md
    docs/transformers.md
    docs/Build.md
    design/*.md
    design/*.png
    bench.sh
    stack.yaml
    src/Streamly/Internal/Data/Stream/Instances.hs
    src/inline.hs
    configure.ac
    configure
    src/Streamly/Internal/Data/Time/config.h.in

extra-tmp-files:
    config.log
    config.status
    autom4te.cache
    src/Streamly/Internal/Data/Time/config.h

source-repository head
    type: git
    location: https://github.com/composewell/streamly

flag inspection
  description: Enable inspection testing
  manual: True
  default: False

flag debug
  description: Debug build with asserts enabled
  manual: True
  default: False

flag dev
  description: Development build
  manual: True
  default: False

flag has-llvm
  description: Use llvm backend for better performance
  manual: True
  default: False

flag no-charts
  description: Disable chart generation
  manual: True
  default: False

flag no-fusion
  description: Disable rewrite rules
  manual: True
  default: False

flag streamk
  description: Use CPS style streams when possible
  manual: True
  default: False

flag examples
  description: Build including examples
  manual: True
  default: False

flag examples-sdl
  description: Build including SDL examples
  manual: True
  default: False

-------------------------------------------------------------------------------
-- Common stanzas
-------------------------------------------------------------------------------

common compile-options
    default-language: Haskell2010
    if flag(streamk)
      cpp-options:    -DUSE_STREAMK_ONLY

    if flag(no-fusion)
      cpp-options:    -DDISABLE_FUSION

    if flag(dev)
      cpp-options:    -DDEVBUILD

    if flag(inspection)
      cpp-options:    -DINSPECTION

    ghc-options:      -Wall

    if flag(has-llvm)
      ghc-options: -fllvm

    if flag(dev)
      ghc-options:    -Wmissed-specialisations
                      -Wall-missed-specialisations

    if flag(dev) || flag(debug)
      ghc-options:    -fno-ignore-asserts

    if impl(ghc >= 8.0)
      ghc-options:    -Wcompat
                      -Wunrecognised-warning-flags
                      -Widentities
                      -Wincomplete-record-updates
                      -Wincomplete-uni-patterns
                      -Wredundant-constraints
                      -Wnoncanonical-monad-instances

common optimization-options
  ghc-options: -O2
               -fspec-constr-recursive=16
               -fmax-worker-args=16

common threading-options
  ghc-options:  -threaded
                -with-rtsopts=-N

-- We need optimization options here to optimize internal (non-inlined)
-- versions of functions. Also, we have some benchmarking inspection tests
-- part of the library when built with --benchmarks flag. Thos tests fail
-- if we do not use optimization options here. It was observed that due to
-- -O2 here some concurrent/nested benchmarks improved and others regressed.
-- We can investigate a bit more here why the regression occurred.
common lib-options
  import: compile-options, optimization-options

-- Compilation for coverage builds on CI machines takes too long without -O0
-- XXX we should use coverage flag for that, -O0 may take too long to run tests
-- in general.
common test-options
  import: compile-options, threading-options
  ghc-options:  -O0
                -fno-ignore-asserts

-- Used by maxrate test, benchmarks and executables
common exe-options
  import: compile-options, optimization-options, threading-options

-- Some benchmarks are threaded some are not
-- XXX dependencies should be separated under bench-depends
common bench-options
  import: compile-options, optimization-options
  ghc-options: -with-rtsopts "-T -M256M"
  build-depends: mtl >= 2.2 && < 3

common bench-options-threaded
  import: compile-options, optimization-options
  -- -threaded and -N2 is important because some GC and space leak issues
  -- trigger only with these options.
  ghc-options: -threaded -with-rtsopts "-T -N2 -M256M"
  build-depends: mtl >= 2.2 && < 3

-------------------------------------------------------------------------------
-- Library
-------------------------------------------------------------------------------

library
    import: lib-options
    js-sources: jsbits/clock.js
    include-dirs:     src/Streamly/Internal/Data/Time
                    , src
    if os(windows)
      c-sources:     src/Streamly/Internal/Data/Time/Windows.c
    if os(darwin)
      c-sources:     src/Streamly/Internal/Data/Time/Darwin.c
    hs-source-dirs:    src
    other-modules:
                       Streamly.Data.Array
                     , Streamly.Data.SmallArray

                    -- Memory storage
                       Streamly.Memory.Malloc
                     , Streamly.Memory.Ring

                     , Streamly.FileSystem.IOVec
                     , Streamly.FileSystem.FDIO
                     , Streamly.FileSystem.FD

                     , Streamly.Data.Prim.Array

    exposed-modules:
                       Streamly.Prelude
                     , Streamly
                     , Streamly.Data.Array
                     , Streamly.Data.SmallArray
                     , Streamly.Data.Fold
                     , Streamly.Data.Unfold
                     , Streamly.Data.Unicode.Stream

                    -- IO devices
                     , Streamly.Memory.Array
                     , Streamly.FileSystem.Handle

                     , Streamly.Tutorial

                     -- Internal modules
                     , Streamly.Internal.Control.Monad
                     , Streamly.Internal.Data.Strict
                     , Streamly.Internal.Data.Atomics
                     , Streamly.Internal.Data.Time
                     , Streamly.Internal.Data.Time.Units
                     , Streamly.Internal.Data.Time.Clock
                     , Streamly.Internal.Data.SVar
                     , Streamly.Internal.Data.Array
                     , Streamly.Internal.Data.Prim.Array
                     , Streamly.Internal.Data.SmallArray
                     , Streamly.Internal.Memory.Array.Types
                     , Streamly.Internal.Memory.Array
                     , Streamly.Internal.Memory.ArrayStream
                     , Streamly.Internal.Data.Fold.Types
                     , Streamly.Internal.Data.Fold
                     , Streamly.Internal.Data.Sink.Types
                     , Streamly.Internal.Data.Sink

                     -- Base streams
                     , Streamly.Internal.Data.Stream.StreamK.Type
                     , Streamly.Internal.Data.Stream.StreamK
                     , Streamly.Internal.Data.Stream.StreamD.Type
                     , Streamly.Internal.Data.Stream.StreamD
                     , Streamly.Internal.Data.Stream.StreamDK.Type
                     , Streamly.Internal.Data.Stream.StreamDK
                     , Streamly.Internal.Data.Stream.Enumeration
                     , Streamly.Internal.Data.Stream.Prelude

                     -- Higher level streams
                     , Streamly.Internal.Data.Stream.SVar
                     , Streamly.Internal.Data.Stream.Serial
                     , Streamly.Internal.Data.Stream.Async
                     , Streamly.Internal.Data.Stream.Parallel
                     , Streamly.Internal.Data.Stream.Ahead
                     , Streamly.Internal.Data.Stream.Zip
                     , Streamly.Internal.Data.Stream.Combinators
                     , Streamly.Internal.Data.Unfold.Types
                     , Streamly.Internal.Data.Unfold
                     , Streamly.Internal.Data.Pipe.Types
                     , Streamly.Internal.Data.Pipe
                     , Streamly.Internal.Data.List
                     , Streamly.Internal.FileSystem.Handle
                     , Streamly.Internal.FileSystem.Dir
                     , Streamly.Internal.FileSystem.File
                     , Streamly.Internal.Data.Unicode.Stream
                     , Streamly.Internal.Data.Unicode.Char
                     , Streamly.Internal.Memory.Unicode.Array
                     , Streamly.Internal.Prelude

                     -- Mutable data
                     , Streamly.Internal.Mutable.Prim.Var

    if !impl(ghcjs)
       exposed-modules:
                       Streamly.Network.Socket
                     , Streamly.Network.Inet.TCP

                     , Streamly.Internal.Network.Socket
                     , Streamly.Internal.Network.Inet.TCP

    build-depends:
                    -- Core libraries shipped with ghc, the min and max
                    -- constraints of these libraries should match with
                    -- the GHC versions we support
                       base              >= 4.8   &&  < 5
                     , containers        >= 0.5   && < 0.7
                     , deepseq           >= 1.4.1 && < 1.5
                     , directory         >= 1.3   && < 1.4
                     , ghc-prim          >= 0.2   && < 0.6
                     , transformers      >= 0.4   && < 0.6

                     , heaps             >= 0.3   && < 0.4
                     , primitive         >= 0.6.4.0   && < 0.8

                    -- concurrency
                     , atomic-primops    >= 0.8   && < 0.9
                     , lockfree-queue    >= 0.2.3 && < 0.3

                    -- transfomers
                     , exceptions        >= 0.8   && < 0.11
                     , monad-control     >= 1.0   && < 2
                     , mtl               >= 2.2   && < 3
                     , transformers-base >= 0.4   && < 0.5

  if !impl(ghcjs)
    build-depends:
                     network           >= 2.6   && < 4
  if impl(ghc < 8.0)
    build-depends:
        semigroups    >= 0.18   && < 0.19

  -- Array uses a Storable constraint in dev build making several inspection
  -- tests fail
  if flag(dev) && flag(inspection)
    build-depends: inspection-and-dev-flags-cannot-be-used-together

-------------------------------------------------------------------------------
-- Test suites
-------------------------------------------------------------------------------

test-suite test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Main.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , hspec             >= 2.0   && < 3
    , containers        >= 0.5   && < 0.7
    , transformers      >= 0.4   && < 0.6
    , mtl               >= 2.2   && < 3
    , exceptions        >= 0.8   && < 0.11
  default-language: Haskell2010

test-suite internal-prelude-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Internal/Prelude.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  default-language: Haskell2010

test-suite pure-streams-base
  import: test-options
  type: exitcode-stdio-1.0
  main-is: PureStreams.hs
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , hspec             >= 2.0   && < 3
  default-language: Haskell2010

test-suite pure-streams-streamly
  import: test-options
  type: exitcode-stdio-1.0
  main-is: PureStreams.hs
  hs-source-dirs: test
  cpp-options:  -DUSE_STREAMLY_LIST
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , hspec             >= 2.0   && < 3
  default-language: Haskell2010

test-suite properties
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Prop.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite array-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Array.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  cpp-options: -DTEST_ARRAY
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite internal-data-fold-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Internal/Data/Fold.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , hspec             >= 2.0   && < 3
    , QuickCheck        >= 2.10  && < 2.14
  default-language: Haskell2010

test-suite data-array-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Array.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite smallarray-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Array.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  cpp-options: -DTEST_SMALL_ARRAY
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite primarray-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Array.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  cpp-options: -DTEST_PRIM_ARRAY
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite string-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: String.hs
  js-sources: jsbits/clock.js
  hs-source-dirs: test
  build-depends:
      streamly
    , base              >= 4.8   && < 5
    , QuickCheck        >= 2.10  && < 2.14
    , hspec             >= 2.0   && < 3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite maxrate
  import: exe-options
  type: exitcode-stdio-1.0
  default-language: Haskell2010
  main-is: MaxRate.hs
  js-sources: jsbits/clock.js
  hs-source-dirs:  test
  if flag(dev)
    buildable: True
    build-Depends:
          streamly
        , base   >= 4.8   && < 5
        , clock  >= 0.7.1 && < 0.9
        , hspec  >= 2.0   && < 3
        , random >= 1.0.0 && < 2
  else
    buildable: False

test-suite loops
  import: test-options
  type: exitcode-stdio-1.0
  default-language: Haskell2010
  main-is: loops.hs
  hs-source-dirs:  test
  build-Depends:
      streamly
    , base >= 4.8   && < 5

test-suite nested-loops
  import: test-options
  type: exitcode-stdio-1.0
  default-language: Haskell2010
  main-is: nested-loops.hs
  hs-source-dirs:  test
  build-Depends:
      streamly
    , base   >= 4.8   && < 5
    , random >= 1.0.0 && < 2

test-suite parallel-loops
  import: test-options
  type: exitcode-stdio-1.0
  default-language: Haskell2010
  main-is: parallel-loops.hs
  hs-source-dirs:  test
  build-Depends:
      streamly
    , base   >= 4.8   && < 5
    , random >= 1.0.0 && < 2

-------------------------------------------------------------------------------
-- Benchmarks
-------------------------------------------------------------------------------

-- For linear, linear-async, linear-rate, nested and nested-concurrent
-- you can pass the number of elements in the stream using the
-- --stream-size option:
-- $ cabal run linear -- --stream-size 1000000

benchmark linear
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Linear.hs
  other-modules: Streamly.Benchmark.Prelude, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.16
                     , inspection-testing >= 0.4   && < 0.5

benchmark nested
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Nested.hs
  other-modules: NestedOps, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark nested-unfold
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: NestedUnfold.hs
  other-modules: NestedUnfoldOps, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark unpinned-array
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Streamly/Benchmark/Data/Array.hs
  other-modules: Streamly.Benchmark.Data.ArrayOps
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark prim-array
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Streamly/Benchmark/Data/Prim/Array.hs
  other-modules: Streamly.Benchmark.Data.Prim.ArrayOps
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
        
benchmark small-array
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Streamly/Benchmark/Data/SmallArray.hs
  other-modules: Streamly.Benchmark.Data.SmallArrayOps
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark array
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Array.hs
  other-modules: ArrayOps
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark fileio
  import: bench-options
  type: exitcode-stdio-1.0
  -- A value of 400 works better for some benchmarks, however, it takes
  -- extraordinary amount of time to compile with that.
  -- ghc-options: -funfolding-use-threshold=150
  hs-source-dirs: benchmark
  main-is: FileIO.hs
  other-modules: Streamly.Benchmark.FileIO.Array
               , Streamly.Benchmark.FileIO.Stream
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , gauge               >= 0.2.4 && < 0.3
    , typed-process       >= 0.2.3 && < 0.3
    , deepseq             >= 1.4.1 && < 1.5
  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.16
                     , inspection-testing >= 0.4   && < 0.5

-------------------------------------------------------------------------------
-- Threaded Benchmarks
-------------------------------------------------------------------------------

benchmark linear-async
  import: bench-options-threaded
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: LinearAsync.hs
  other-modules: Streamly.Benchmark.Prelude, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.16
                     , inspection-testing >= 0.4   && < 0.5

benchmark nested-concurrent
  import: bench-options-threaded
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: NestedConcurrent.hs
  other-modules: NestedOps, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6

benchmark parallel
  import: bench-options-threaded
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Parallel.hs
  other-modules: Streamly.Benchmark.Prelude, NestedOps, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.16
                     , inspection-testing >= 0.4   && < 0.5

benchmark linear-rate
  import: bench-options-threaded
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: LinearRate.hs
  other-modules: Streamly.Benchmark.Prelude, Common
  build-depends:
      streamly
    , base                >= 4.8   && < 5
    , deepseq             >= 1.4.1 && < 1.5
    , random              >= 1.0   && < 2.0
    , gauge               >= 0.2.4 && < 0.3
  if impl(ghc < 8.0)
    build-depends:
        transformers  >= 0.4 && < 0.6
  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.16
                     , inspection-testing >= 0.4   && < 0.5

benchmark concurrent
  import: bench-options-threaded
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Concurrent.hs
  if flag(dev)
    buildable: True
    build-depends:
        streamly
      , base                >= 4.8   && < 5
      , gauge               >= 0.2.4 && < 0.3
  else
    buildable: False

-------------------------------------------------------------------------------
-- Internal benchmarks
-------------------------------------------------------------------------------

benchmark base
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: BaseStreams.hs
  other-modules:     StreamDOps
                   , StreamKOps
                   , StreamDKOps

  if flag(dev)
    buildable: True
    build-depends:
        streamly
      , base              >= 4.8   && < 5
      , deepseq           >= 1.4.1 && < 1.5
      , random            >= 1.0   && < 2.0
      , gauge             >= 0.2.4 && < 0.3
  else
    buildable: False

executable nano-bench
  import: bench-options
  hs-source-dirs: benchmark
  main-is: NanoBenchmarks.hs
  if flag(dev)
    buildable: True
    build-depends:
        streamly
      , base              >= 4.8   && < 5
      , gauge             >= 0.2.4 && < 0.3
      , random            >= 1.0   && < 2.0
  else
    buildable: False

benchmark adaptive
  import: bench-options
  type: exitcode-stdio-1.0
  hs-source-dirs: benchmark
  main-is: Adaptive.hs
  default-language: Haskell2010
  if flag(dev)
    buildable: True
    build-depends:
        streamly
      , base              >= 4.8   && < 5
      , gauge             >= 0.2.4 && < 0.3
      , random            >= 1.0   && < 2.0
  else
    buildable: False

executable chart
  default-language: Haskell2010
  ghc-options: -Wall
  hs-source-dirs: benchmark
  main-is: Chart.hs
  if flag(dev) && !flag(no-charts) && !impl(ghcjs)
    buildable: True
    build-Depends:
        base >= 4.8 && < 5
      , bench-show >= 0.3 && < 0.4
      , split
      , transformers >= 0.4   && < 0.6
  else
    buildable: False

-------------------------------------------------------------------------------
-- Examples
-------------------------------------------------------------------------------

executable SearchQuery
  import: exe-options
  main-is: SearchQuery.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base         >= 4.8   && < 5
      , http-conduit >= 2.2.2 && < 2.4
  else
    buildable: False

executable ListDir
  import: exe-options
  main-is: ListDir.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base    >= 4.8   && < 5
      , directory >= 1.3 && < 1.4
    if impl(ghc < 8.0)
      build-depends:
          transformers  >= 0.4    && < 0.6
  else
    buildable: False

executable MergeSort
  import: exe-options
  main-is: MergeSort.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base   >= 4.8   && < 5
      , random >= 1.0.0 && < 2
  else
    buildable: False

executable AcidRain
  import: exe-options
  main-is: AcidRain.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base         >= 4.8   && < 5
      , mtl          >= 2.2   && < 3
    if impl(ghc < 8.0)
      build-depends:
          semigroups    >= 0.18   && < 0.19
        , transformers  >= 0.4    && < 0.6
  else
    buildable: False

executable CirclingSquare
  import: exe-options
  main-is: CirclingSquare.hs
  hs-source-dirs:  examples
  if flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base >= 4.8   && < 5
      , SDL  >= 0.6.5 && < 0.7
  else
    buildable: False

executable ControlFlow
  import: exe-options
  main-is: ControlFlow.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
      , exceptions        >= 0.8   && < 0.11
      , transformers      >= 0.4   && < 0.6
      , transformers-base >= 0.4   && < 0.5
    if impl(ghc < 8.0)
      build-depends:
          semigroups    >= 0.18   && < 0.19
  else
    buildable: False

executable HandleIO
  import: exe-options
  main-is: HandleIO.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
  else
    buildable: False

executable FileIOExamples
  import: exe-options
  main-is: FileIOExamples.hs
  hs-source-dirs:  examples
  if flag(examples) || flag(examples-sdl)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
  else
    buildable: False

executable EchoServer
  import: exe-options
  main-is: EchoServer.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
      , network           >= 2.6   && < 4
    if impl(ghc < 8.0)
      build-depends:
          transformers  >= 0.4 && < 0.6
  else
    buildable: False

executable FileSinkServer
  import: exe-options
  main-is: FileSinkServer.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
      , network           >= 2.6   && < 4
    if impl(ghc < 8.0)
      build-depends:
          transformers  >= 0.4 && < 0.6
  else
    buildable: False

executable FromFileClient
  import: exe-options
  main-is: FromFileClient.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base              >= 4.8   && < 5
  else
    buildable: False

executable WordClassifier
  import: exe-options
  main-is: WordClassifier.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base                 >= 4.8   && < 5
      , hashable             >= 1.2   && < 1.4
      , unordered-containers >= 0.2   && < 0.3
  else
    buildable: False

executable WordCount
  import: exe-options
  main-is: WordCount.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base                 >= 4.8   && < 5
      , vector               >= 0.12  && < 0.13
  else
    buildable: False

executable CamelCase
  import: exe-options
  main-is: CamelCase.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base                 >= 4.8   && < 5
  else
    buildable: False