composewell/streamly
1
1
Fork 0
mirror of https://github.com/composewell/streamly.git synced 2024-09-11 11:37:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
d2d0e16d53
streamly/streamly.cabal
Harendra Kumar d2d0e16d53 Add a ghc wrapper to invoke ghc on individual files 
With all the extensions used in streamly, optimization options and
ddump-simpl options.

This is useful for compiling standalone files, when inspecting core for
perf issues.  I wish cabal could invoke ghc with environment from the
cabal file. Can it?
2021-02-15 15:41:05 +05:30

566 lines
22 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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
.ghci
.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/ghc.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/Clock/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/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/Clock/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/Clock/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
exposed-modules:
Streamly.Prelude
, Streamly.Data.Unfold
, Streamly.Data.Fold
, Streamly.Data.Array.Foreign
-- Text Processing
, Streamly.Unicode.Stream
-- Filesystem/IO
, Streamly.FileSystem.Handle
-- Network/IO
, Streamly.Network.Socket
, Streamly.Network.Inet.TCP
-- documentation
, Streamly.Tutorial
-- Deprecated
, Streamly
, Streamly.Data.Unicode.Stream
, Streamly.Memory.Array
-- Internal modules, listed roughly in dependency order
-- streamly-base
, Streamly.Internal.BaseCompat
, Streamly.Internal.Control.Exception
, Streamly.Internal.Control.Monad
, Streamly.Internal.Control.Concurrent
, Streamly.Internal.Data.Cont
, Streamly.Internal.Data.Tuple.Strict
, Streamly.Internal.Data.Maybe.Strict
, Streamly.Internal.Data.Either.Strict
, Streamly.Internal.Foreign.Malloc
, Streamly.Internal.Data.Atomics
, Streamly.Internal.Data.IOFinalizer
, Streamly.Internal.Data.Time
, Streamly.Internal.Data.Time.TimeSpec
, Streamly.Internal.Data.Time.Units
, Streamly.Internal.Data.Time.Clock.Type
, Streamly.Internal.Data.Time.Clock
-- streamly-core-stream
, Streamly.Internal.Data.SVar
, Streamly.Internal.Data.Stream.StreamK.Type
, Streamly.Internal.Data.Fold.Types
, Streamly.Internal.Data.Stream.StreamD.Step
, Streamly.Internal.Data.Stream.StreamD.Type
, Streamly.Internal.Data.Stream.StreamDK.Type
, Streamly.Internal.Data.Unfold.Types
, Streamly.Internal.Data.Sink.Types
, Streamly.Internal.Data.Parser.ParserK.Types
, Streamly.Internal.Data.Parser.ParserD.Types
, Streamly.Internal.Data.Pipe.Types
-- Unboxed IORef
, Streamly.Internal.Data.IORef.Prim
-- streamly-core-array
-- May depend on streamly-core-stream
, Streamly.Internal.Data.Array.Foreign.Mut.Types
, Streamly.Internal.Data.Array.Foreign.Types
, Streamly.Internal.Data.Array.Prim.Mut.Types
, Streamly.Internal.Data.Array.Prim.Types
, Streamly.Internal.Data.Array.Prim.Pinned.Mut.Types
, Streamly.Internal.Data.Array.Prim.Pinned.Types
, Streamly.Internal.Data.SmallArray.Types
-- streamly-base-streams
, Streamly.Internal.Data.Stream.StreamK
-- StreamD depends on streamly-core-array
, Streamly.Internal.Data.Stream.StreamD.Generate
, Streamly.Internal.Data.Stream.StreamD.Eliminate
, Streamly.Internal.Data.Stream.StreamD.Nesting
, Streamly.Internal.Data.Stream.StreamD.Transform
, Streamly.Internal.Data.Stream.StreamD.Exception
, Streamly.Internal.Data.Stream.StreamD.Lift
, Streamly.Internal.Data.Stream.StreamD
, Streamly.Internal.Data.Stream.StreamDK
, Streamly.Internal.Data.Stream.Prelude
, Streamly.Internal.Data.Parser.ParserD.Tee
, Streamly.Internal.Data.Parser.ParserD
-- streamly-core
, Streamly.Internal.Data.Unfold
, Streamly.Internal.Data.Fold.Tee
, Streamly.Internal.Data.Fold
, Streamly.Internal.Data.Sink
, Streamly.Internal.Data.Parser
, Streamly.Internal.Data.Pipe
, 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.IsStream.Combinators
, Streamly.Internal.Data.Stream.IsStream.Common
, Streamly.Internal.Data.Stream.IsStream.Types
, Streamly.Internal.Data.Stream.IsStream.Enumeration
, Streamly.Internal.Data.Stream.IsStream.Generate
, Streamly.Internal.Data.Stream.IsStream.Eliminate
, Streamly.Internal.Data.Stream.IsStream.Transform
, Streamly.Internal.Data.Stream.IsStream.Nesting
, Streamly.Internal.Data.Stream.IsStream.Exception
, Streamly.Internal.Data.Stream.IsStream.Lift
, Streamly.Internal.Data.Stream.IsStream
, Streamly.Internal.Data.List
-- streamly-arrays
-- May depend on streamly-core
, Streamly.Internal.Data.Array
, Streamly.Internal.Data.Array.Foreign
, Streamly.Internal.Data.Array.Prim
, Streamly.Internal.Data.Array.Prim.Pinned
, Streamly.Internal.Data.SmallArray
, Streamly.Internal.Data.Array.Stream.Mut.Foreign
, Streamly.Internal.Data.Array.Stream.Foreign
-- Memory storage
, Streamly.Internal.Ring.Foreign
-- streamly-unicode
, Streamly.Internal.Unicode.Stream
, Streamly.Internal.Unicode.Char
, Streamly.Internal.Unicode.Array.Char
, Streamly.Internal.Unicode.Array.Prim.Pinned
-- streamly-serde
, Streamly.Internal.Data.Binary.Decode
-- streamly-filesystem
, Streamly.Internal.FileSystem.Handle
, Streamly.Internal.FileSystem.Dir
, Streamly.Internal.FileSystem.File
, Streamly.Internal.FileSystem.IOVec
, Streamly.Internal.FileSystem.FDIO
, Streamly.Internal.FileSystem.FD
-- streamly-network
, 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
-- Network
, 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
Reference in New Issue View Git Blame Copy Permalink