streamly/streamly.cabal

cabal-version:      2.2
name:               streamly
version:            0.7.2
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
                   , GHC==8.10.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:
    .circleci/config.yml
    .github/workflows/haskell.yml
    .gitignore
    .hlint.ignore
    .hlint.yaml
    .travis.yml
    CONTRIBUTING.md
    Changelog.md
    INSTALL.md
    MAINTAINING.md
    README.md
    appveyor.yml
    bench.sh
    benchmark/*.hs
    benchmark/README.md
    benchmark/Streamly/Benchmark/Data/*.hs
    benchmark/Streamly/Benchmark/Data/Parser/*.hs
    benchmark/Streamly/Benchmark/Data/Stream/*.hs
    benchmark/Streamly/Benchmark/FileSystem/*.hs
    benchmark/Streamly/Benchmark/FileSystem/Handle/*.hs
    benchmark/Streamly/Benchmark/Prelude/*.hs
    benchmark/lib/Streamly/Benchmark/*.hs
    benchmark/streamly-benchmarks.cabal
    bin/bench-exec-one.sh
    cabal.project.ci
    charts-0/streamly-vs-list-time.svg
    configure
    configure.ac
    credits/*.md
    credits/Yampa-0.10.6.2.txt
    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/primitive-0.7.0.0.txt
    credits/transient-0.5.5.txt
    credits/vector-0.12.0.2.txt
    design/*.md
    design/*.png
    design/*.rst
    docs/Build.md
    docs/streamly-vs-async.md
    docs/streamly-vs-lists.md
    docs/transformers.md
    examples/README.md
    src/Streamly/Internal/Data/Stream/Instances.hs
    src/Streamly/Internal/Data/Time/config-clock.h
    src/Streamly/Internal/Data/Time/config.h.in
    src/inline.hs
    stack.yaml

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 fusion-plugin
  description: Use fusion plugin for benchmarks and executables
  manual: True
  default: False

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 code generation
  manual: True
  default: False

flag no-fusion
  description: Disable rewrite rules for stream fusion
  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 default-extensions
    default-extensions:
        BangPatterns
        CApiFFI
        CPP
        ConstraintKinds
        DeriveDataTypeable
        DeriveGeneric
        DeriveTraversable
        ExistentialQuantification
        FlexibleContexts
        FlexibleInstances
        GeneralizedNewtypeDeriving
        InstanceSigs
        KindSignatures
        LambdaCase
        MagicHash
        MultiParamTypeClasses
        PatternSynonyms
        RankNTypes
        RecordWildCards
        ScopedTypeVariables
        TupleSections
        TypeFamilies
        ViewPatterns

        -- MonoLocalBinds, enabled by TypeFamilies, causes performance
        -- regressions. Disable it. This must come after TypeFamilies,
        -- otherwise TypeFamilies will enable it again.
        NoMonoLocalBinds

        -- UndecidableInstances -- Does not show any perf impact
        -- UnboxedTuples        -- interferes with (#.)

common optimization-options
  ghc-options: -O2
               -fdicts-strict
               -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, default-extensions

-- 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, default-extensions

  ghc-options:  -O0
                -fno-ignore-asserts
  -- XXX we need -O for plugin to work
  -- if flag(fusion-plugin) && !impl(ghcjs) && !impl(ghc < 8.6)
  --   ghc-options: -fplugin Fusion.Plugin
  --   build-depends:
  --       fusion-plugin     >= 0.2   && < 0.3

-- Used by maxrate test, benchmarks and executables
common exe-options
  import: compile-options, optimization-options, threading-options
  if flag(fusion-plugin) && !impl(ghcjs) && !impl(ghc < 8.6)
    ghc-options: -fplugin Fusion.Plugin
    build-depends:
        fusion-plugin     >= 0.2   && < 0.3

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

library
    import: lib-options

    if impl(ghc >= 8.1)
      default-extensions: TypeApplications
    if impl(ghc >= 8.6)
      default-extensions: QuantifiedConstraints

    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
                     , Streamly.Data.Prim.Array

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

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

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

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

                     , Streamly.Tutorial

                     -- Internal modules
                     , Streamly.Internal.BaseCompat
                     , Streamly.Internal.Control.Monad
                     , Streamly.Internal.Data.Strict
                     , Streamly.Internal.Data.Atomics
                     , Streamly.Internal.Data.Time
                     , Streamly.Internal.Data.Time.TimeSpec
                     , Streamly.Internal.Data.Time.Units
                     , Streamly.Internal.Data.Time.Clock
                     , Streamly.Internal.Data.SVar

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

                     -- Arrays
                     , Streamly.Internal.Data.Array
                     , Streamly.Internal.Data.Prim.Array.Types
                     , Streamly.Internal.Data.Prim.Array
                     , Streamly.Internal.Data.SmallArray.Types
                     , Streamly.Internal.Data.SmallArray
                     , Streamly.Internal.Memory.Mutable.Array.Types
                     , Streamly.Internal.Memory.Array.Types
                     , Streamly.Internal.Memory.Array
                     , Streamly.Internal.Memory.ArrayStream

                     -- Folds
                     , Streamly.Internal.Data.Fold.Types
                     , Streamly.Internal.Data.Fold
                     , Streamly.Internal.Data.Sink.Types
                     , Streamly.Internal.Data.Sink

                     -- Parsers
                     , Streamly.Internal.Data.Zipper
                     , Streamly.Internal.Data.Parser.ParserK.Types
                     , Streamly.Internal.Data.Parser.ParserD.Types
                     , Streamly.Internal.Data.Parser.ParserD.Tee
                     , Streamly.Internal.Data.Parser.ParserD
                     , Streamly.Internal.Data.Parser

                     -- 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.List
                     , Streamly.Internal.Prelude

                     -- Unfolds
                     , Streamly.Internal.Data.Unfold.Types
                     , Streamly.Internal.Data.Unfold

                     -- Pipes
                     , Streamly.Internal.Data.Pipe.Types
                     , Streamly.Internal.Data.Pipe

                     -- Filesystem
                     , Streamly.Internal.FileSystem.Handle
                     , Streamly.Internal.FileSystem.Dir
                     , Streamly.Internal.FileSystem.File

                     -- Text Processing
                     , Streamly.Internal.Data.Unicode.Stream
                     , Streamly.Internal.Data.Unicode.Char
                     , Streamly.Internal.Memory.Unicode.Array

    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.2.2 && < 1.4
                     , exceptions        >= 0.8   && < 0.11
                     , ghc-prim          >= 0.2   && < 0.7
                     , mtl               >= 2.2   && < 3
                     , primitive         >= 0.5.4 && < 0.8
                     , transformers      >= 0.4   && < 0.6

                     , heaps             >= 0.3     && < 0.4

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

                    -- transfomers
                     , monad-control     >= 1.0   && < 2
                     , transformers-base >= 0.4   && < 0.5

                     , fusion-plugin-types >= 0.1 && < 0.2

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

  if flag(inspection)
    build-depends:     template-haskell   >= 2.14  && < 2.17
                     , inspection-testing >= 0.4   && < 0.5

  -- 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.15
    , 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.15
    , 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.15
    , 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.15
  default-language: Haskell2010

test-suite internal-data-parser-test
  import: test-options
  ghc-options: -O2
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Internal/Data/Parser.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.15
    , transformers      >= 0.4 && < 0.6
  default-language: Haskell2010

test-suite internal-data-parser-parserd-test
  import: test-options
  type: exitcode-stdio-1.0
  main-is: Streamly/Test/Internal/Data/Parser/ParserD.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.15
    , transformers      >= 0.4 && < 0.6
  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.15
    , 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.15
    , 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.15
    , 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.15
    , 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
        , 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

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

-------------------------------------------------------------------------------
-- 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
    if impl(ghc < 8.0)
      build-depends:
        unliftio-core < 0.2
  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
    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

executable Rate
  import: exe-options
  main-is: Rate.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 Split
  import: exe-options
  main-is: Split.hs
  hs-source-dirs:  examples
  if (flag(examples) || flag(examples-sdl)) && !impl(ghcjs)
    buildable: True
    build-Depends:
        streamly
      , base         >= 4.8   && < 5
      , mtl          >= 2.2   && < 3
    if impl(ghc < 8.0)
      build-depends:
          transformers  >= 0.4 && < 0.6
  else
    buildable: False