From e80cdd7caa63c8b9f59b527563bbe38965cf29ef Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Mon, 30 Oct 2023 08:48:54 +0000 Subject: automatic import of ghc-semigroupoids --- semigroupoids.cabal | 216 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100755 semigroupoids.cabal (limited to 'semigroupoids.cabal') diff --git a/semigroupoids.cabal b/semigroupoids.cabal new file mode 100755 index 0000000..35c29c6 --- /dev/null +++ b/semigroupoids.cabal @@ -0,0 +1,216 @@ +name: semigroupoids +category: Control, Comonads +version: 5.3.7 +x-revision: 1 +license: BSD2 +cabal-version: 1.18 +license-file: LICENSE +author: Edward A. Kmett +maintainer: Edward A. Kmett +stability: provisional +homepage: http://github.com/ekmett/semigroupoids +bug-reports: http://github.com/ekmett/semigroupoids/issues +copyright: Copyright (C) 2011-2015 Edward A. Kmett +tested-with: GHC == 7.0.4 + , GHC == 7.2.2 + , GHC == 7.4.2 + , GHC == 7.6.3 + , GHC == 7.8.4 + , GHC == 7.10.3 + , GHC == 8.0.2 + , GHC == 8.2.2 + , GHC == 8.4.4 + , GHC == 8.6.5 + , GHC == 8.8.4 + , GHC == 8.10.4 + , GHC == 9.0.1 +build-type: Simple +synopsis: Semigroupoids: Category sans id +extra-source-files: + .gitignore + .vim.custom + README.markdown + CHANGELOG.markdown + img/classes.dot +extra-doc-files: + img/classes.svg + +description: + Provides a wide array of (semi)groupoids and operations for working with them. + . + A 'Semigroupoid' is a 'Category' without the requirement of identity arrows for every object in the category. + . + A 'Category' is any 'Semigroupoid' for which the Yoneda lemma holds. + . + When working with comonads you often have the @\<*\>@ portion of an @Applicative@, but + not the @pure@. This was captured in Uustalu and Vene's \"Essence of Dataflow Programming\" + in the form of the @ComonadZip@ class in the days before @Applicative@. Apply provides a weaker invariant, but for the comonads used for data flow programming (found in the streams package), this invariant is preserved. Applicative function composition forms a semigroupoid. + . + Similarly many structures are nearly a comonad, but not quite, for instance lists provide a reasonable 'extend' operation in the form of 'tails', but do not always contain a value. + . + We describe the relationships between the type classes defined in this package + and those from `base` (and some from `contravariant`) in the diagram below. + Thick-bordered nodes correspond to type classes defined in this package; + thin-bordered ones correspond to type classes from elsewhere. Solid edges + indicate a subclass relationship that actually exists; dashed edges indicate a + subclass relationship that /should/ exist, but currently doesn't. + . + <> + . + Apply, Bind, and Extend (not shown) give rise the Static, Kleisli and Cokleisli semigroupoids respectively. + . + This lets us remove many of the restrictions from various monad transformers + as in many cases the binding operation or @\<*\>@ operation does not require them. + . + Finally, to work with these weaker structures it is beneficial to have containers + that can provide stronger guarantees about their contents, so versions of 'Traversable' + and 'Foldable' that can be folded with just a 'Semigroup' are added. + +source-repository head + type: git + location: git://github.com/ekmett/semigroupoids.git + +flag containers + description: + You can disable the use of the `containers` package using `-f-containers`. + . + Disabing this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + default: True + manual: True + +flag contravariant + description: + You can disable the use of the `contravariant` package using `-f-contravariant`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + . + If disabled we will not supply instances of `Contravariant` + . + default: True + manual: True + +flag distributive + description: + You can disable the use of the `distributive` package using `-f-distributive`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + . + If disabled we will not supply instances of `Distributive` + . + default: True + manual: True + +flag comonad + description: + You can disable the use of the `comonad` package using `-f-comonad`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + . + If disabled we will not supply instances of `Comonad` + . + default: True + manual: True + +flag tagged + description: + You can disable the use of the `tagged` package using `-f-tagged`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + default: True + manual: True + +flag unordered-containers + description: + You can disable the use of the `unordered-containers` package (and also its dependency `hashable`) using `-f-unordered-containers`. + . + Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users. + default: True + manual: True + +library + build-depends: + base >= 4.3 && < 4.18, + base-orphans >= 0.8.4 && < 1, + bifunctors >= 5.5.9 && < 6, + template-haskell >= 0.2.5.0, + transformers >= 0.3 && < 0.7, + transformers-compat >= 0.5 && < 0.8 + + if impl(ghc >= 7.0 && < 7.2) + build-depends: generic-deriving >= 1.14 && < 1.15 + + if impl(ghc >= 7.2 && < 7.6) + build-depends: ghc-prim + + if !impl(ghc >= 7.10) + build-depends: void >= 0.4 && < 1 + + if !impl(ghc >= 8.0) + build-depends: semigroups >= 0.18.5 && < 1 + + if flag(containers) + build-depends: containers >= 0.3 && < 0.7 + + if flag(contravariant) + build-depends: contravariant >= 1.5.3 && < 2 + + if flag(distributive) + build-depends: distributive >= 0.5.2 && < 1 + + if flag(comonad) + build-depends: comonad >= 5.0.8 && < 6 + + if flag(tagged) + build-depends: tagged >= 0.8.6.1 && < 1 + + if flag(unordered-containers) + if impl(ghc >= 7.4) + build-depends: hashable >= 1.2.7.0 && < 1.5, + unordered-containers >= 0.2.8.0 && < 0.3 + else + build-depends: hashable >= 1.2.5.0 && < 1.5, + unordered-containers >= 0.2.8.0 && < 0.3 + + hs-source-dirs: src + + exposed-modules: + Data.Bifunctor.Apply + Data.Functor.Alt + Data.Functor.Apply + Data.Functor.Bind + Data.Functor.Bind.Class + Data.Functor.Bind.Trans + Data.Functor.Contravariant.Conclude + Data.Functor.Contravariant.Decide + Data.Functor.Contravariant.Divise + Data.Functor.Extend + Data.Functor.Plus + Data.Groupoid + Data.Isomorphism + Data.Semigroup.Bifoldable + Data.Semigroup.Bitraversable + Data.Semigroup.Foldable + Data.Semigroup.Foldable.Class + Data.Semigroup.Traversable + Data.Semigroup.Traversable.Class + Data.Semigroupoid + Data.Semigroupoid.Categorical + Data.Semigroupoid.Dual + Data.Semigroupoid.Ob + Data.Semigroupoid.Static + Data.Traversable.Instances + Semigroupoids.Do + other-modules: + Semigroupoids.Internal + + ghc-options: -Wall -fno-warn-warnings-deprecations + + if impl(ghc >= 7.10) + ghc-options: -fno-warn-trustworthy-safe + + if impl(ghc >= 9.0) + -- these flags may abort compilation with GHC-8.10 + -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295 + ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode + + default-language: Haskell2010 -- cgit v1.2.3