mirror of
https://github.com/composewell/streamly.git
synced 2024-09-19 07:29:02 +03:00
f448fb5643
There is no functional change in this commit, only refactoring. * Update module documentation for arrays * Rearrange and re-group related functions together * Ability to use fold/unfold/foldMany/chunksOf in low level array modules so that we are able to express some of the functions more idiomatically. We have not done that in this change but with this change we should be able to do it later. * Separate out the array stream code from lower level modules to the higher level array stream module.
564 lines
21 KiB
Plaintext
564 lines
21 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/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.Data.Unfold
|
||
, Streamly.Data.Fold
|
||
, Streamly.Data.Array.Storable.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.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
|
||
|
||
-- 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.Storable.Foreign.Mut.Types
|
||
, Streamly.Internal.Data.Array.Storable.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.Storable.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.Memory.ArrayStream
|
||
|
||
-- 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-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
|