mirror of
https://github.com/composewell/streamly.git
synced 2024-09-11 11:37:22 +03:00
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?
566 lines
22 KiB
Plaintext
566 lines
22 KiB
Plaintext
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
|