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/: <https://github.com/composewell/streamly-examples Streamly Examples>
  * /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==8.0.2
                   , GHC==8.4.4
                   , GHC==8.6.5
                   , GHC==8.8.1
                   , GHC==8.10.1
author:              Composewell Technologies
maintainer:          streamly@composewell.com
copyright:           2017 Composewell Technologies
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
    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/Streamly/Benchmark/Prelude/Serial/*.hs
    benchmark/Streamly/Benchmark/Unicode/*.hs
    benchmark/lib/Streamly/Benchmark/*.hs
    benchmark/lib/Streamly/Benchmark/Common/*.hs
    benchmark/streamly-benchmarks.cabal
    bin/bench.sh
    bin/bench-exec-one.sh
    bin/build-lib.sh
    bin/mk-hscope.sh
    bin/mk-tags.sh
    bin/targets.sh
    bin/test.sh
    cabal.project
    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/fsnotify-0.3.0.1.txt
    credits/hfsevents-0.1.6.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
    default.nix
    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/Array/PrimInclude.hs
    src/Streamly/Internal/Data/Array/Prim/TypesInclude.hs
    src/Streamly/Internal/Data/Array/Prim/MutTypesInclude.hs
    src/Streamly/Internal/FileSystem/Event/Darwin.h
    src/config.h.in
    src/inline.hs
    test/README.md
    test/Streamly/Test/Common/Array.hs
    test/Streamly/Test/Data/*.hs
    test/Streamly/Test/Data/Array/Prim.hs
    test/Streamly/Test/Data/Array/Prim/Pinned.hs
    test/Streamly/Test/Data/Array/Storable/Foreign.hs
    test/Streamly/Test/Data/Parser/ParserD.hs
    test/Streamly/Test/FileSystem/Event.hs
    test/Streamly/Test/FileSystem/Handle.hs
    test/Streamly/Test/Network/Socket.hs
    test/Streamly/Test/Network/Inet/TCP.hs
    test/Streamly/Test/Prelude.hs
    test/Streamly/Test/Prelude/*.hs
    test/Streamly/Test/Unicode/Stream.hs
    test/lib/Streamly/Test/Common.hs
    test/lib/Streamly/Test/Prelude/Common.hs
    test/streamly-tests.cabal
    test/version-bounds.hs
    stack.yaml

extra-tmp-files:
    config.log
    config.status
    autom4te.cache
    src/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 use-c-malloc
  description: Use C malloc instead of GHC malloc
  manual: True
  default: False

flag opt
  description: off=GHC default, on=-O2
  manual: True
  default: True

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

common compile-options
    default-language: Haskell2010

    if os(darwin)
      cpp-options:    -DCABAL_OS_DARWIN

    if os(linux)
      cpp-options:    -DCABAL_OS_LINUX

    if os(windows)
      cpp-options:    -DCABAL_OS_WINDOWS

    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

    if flag(use-c-malloc)
      cpp-options:    -DUSE_C_MALLOC

    ghc-options:      -Wall
                      -Wcompat
                      -Wunrecognised-warning-flags
                      -Widentities
                      -Wincomplete-record-updates
                      -Wincomplete-uni-patterns
                      -Wredundant-constraints
                      -Wnoncanonical-monad-instances
                      -Rghc-timing

    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

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
  if flag(opt)
    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

-------------------------------------------------------------------------------
-- 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
    if os(windows)
      c-sources:     src/Streamly/Internal/Data/Time/Windows.c
      exposed-modules: Streamly.Internal.FileSystem.Event.Windows
      build-depends: Win32 >= 2.6 && < 2.10

    if os(darwin)
      frameworks:    Cocoa
      include-dirs:  src/Streamly/Internal
      c-sources:     src/Streamly/Internal/Data/Time/Darwin.c
                   , src/Streamly/Internal/FileSystem/Event/Darwin.m
      exposed-modules:
                     Streamly.Internal.FileSystem.Event.Darwin

    if os(linux)
      exposed-modules: Streamly.Internal.FileSystem.Event.Linux

    hs-source-dirs:    src
    other-modules:
                       Streamly.Data.Array
                     , Streamly.Data.Prim.Array
                     , Streamly.Data.SmallArray

                    -- Memory storage
                     , Streamly.Memory.Ring

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

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

                     -- Text Processing
                     , Streamly.Unicode.Stream

                     -- IO devices
                     , Streamly.Data.Array.Storable.Foreign
                     , Streamly.FileSystem.Handle

                     , Streamly.Tutorial

                     -- Internal modules
                     , Streamly.Internal.BaseCompat
                     , Streamly.Internal.Control.Exception
                     , Streamly.Internal.Control.Monad
                     , Streamly.Internal.Data.Cont
                     , Streamly.Internal.Data.Tuple.Strict
                     , Streamly.Internal.Data.Maybe.Strict
                     , Streamly.Internal.Data.Either.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

                     -- Memory storage
                     ,  Streamly.Internal.Foreign.Malloc

                     -- Mutable data
                     , Streamly.Internal.Data.IORef.Prim

                     -- Arrays
                     , Streamly.Internal.Data.Array
                     , Streamly.Internal.Data.Array.Prim.Types
                     , Streamly.Internal.Data.Array.Prim
                     , Streamly.Internal.Data.Array.Prim.Mut.Types
                     , Streamly.Internal.Data.Array.Prim.Pinned.Types
                     , Streamly.Internal.Data.Array.Prim.Pinned
                     , Streamly.Internal.Data.Array.Prim.Pinned.Mut.Types
                     , Streamly.Internal.Data.SmallArray.Types
                     , Streamly.Internal.Data.SmallArray
                     , Streamly.Internal.Data.Array.Storable.Foreign.Mut.Types
                     , Streamly.Internal.Data.Array.Storable.Foreign.Types
                     , Streamly.Internal.Data.Array.Storable.Foreign
                     , 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.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.IsStream
                     , 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

                     -- 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.Unicode.Stream
                     , Streamly.Internal.Unicode.Char
                     , Streamly.Internal.Unicode.Array.Char
                     , Streamly.Internal.Unicode.Array.Prim.Pinned

                     -- Serialization/deserialization in binary format
                     , Streamly.Internal.Data.Binary.Decode

                     -- Deprecated
                     , Streamly.Data.Unicode.Stream
                     , Streamly.Memory.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.9   &&  < 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 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