| Index | index by Group | index by Distribution | index by Vendor | index by creation date | index by Name | Mirrors | Help | Search |
| Name: ghc-semigroupoids | Distribution: openSUSE Tumbleweed |
| Version: 6.0.0.1 | Vendor: openSUSE |
| Release: 1.5 | Build date: Sat Sep 30 14:41:14 2023 |
| Group: Unspecified | Build host: reproducible |
| Size: 1362302 | Source RPM: ghc-semigroupoids-6.0.0.1-1.5.src.rpm |
| Packager: https://bugs.opensuse.org | |
| Url: https://hackage.haskell.org/package/semigroupoids | |
| Summary: Semigroupoids: Category sans id | |
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. <<https://raw.githubusercontent.com/ekmett/semigroupoids/master/img/classes.svg Relationships among type classes from this package and others>> 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.
BSD-2-Clause
* Sat Sep 30 2023 Peter Simons <psimons@suse.com>
- Update semigroupoids to version 6.0.0.1 revision 1.
6.0.0.1 [2023.03.16]
- -------------------
* When building with GHC 9.6, require `transformers >= 0.6.1` and
`containers >= 0.6.7`. This ensures that `semigroupoids` always provides
`Traversable1` instances for data types from `transformers` and `containers`
unconditionally.
6 [2023.03.12]
- -------------
* Drop support for GHC 7.10 and earlier.
* The `Foldable1` and `Bifoldable1` classes have been migrated:
* When building with `base-4.18` or later, `semigroupoids` re-exports
`Foldable1` and `Bifoldable1` from `base`. (These classes were added to
`base-4.18` as a result of
[this Core Libraries proposal](haskell/core-libraries-committee#9).)
* When building with older versions of `base`, `semigroupoids` re-exports
`Foldable1` and `Bifoldable1` from the
[`foldable1-classes-compat`](https://github.com/haskell-compat/foldable1-classes-compat)
compatibility package.
Note that the version of `Foldable1` that `semigroupoids` defined in previous
releases only had three class methods: `fold1`, `foldMap1`, and `toNonEmpty`.
Moreover, `foldMap1` had a default implementation in terms of a `Foldable`
constraint. `base`'s version of `Foldable1`, however, has some notable
differences:
1. It has many more methods than the three listed above, such as the
`foldrMap1` method.
2. `foldMap1` now has a default implementation in terms of `foldrMap1` instead
of in terms of a `Foldable` constraint.
To avoid (1) causing issues when upgrading to `semigroupoids-6`,
`Data.Semigroup.Foldable` only re-exports the `fold1`, `foldMap1`, and
`toNonEmpty` methods, which reflects the API in previous `semigroupoids`
releases. If you want to use the other, new class methods of `Foldable1`,
consider importing it from `Data.Foldable1` (its home in `base`) instead.
Difference (2) is trickier, because it is possible that existing code that
defines valid `Foldable1` instances will need to be migrated. If you have an
instance like this:
```hs
import Data.Semigroup.Foldable
data T a = MkT a
instance Foldable T where
foldMap f (MkT x) = f x
instance Foldable1 T -- Relying on Foldable-based defaults
```
Then calling `foldMap1` on `T` will throw an error with `semigroupoids-6`, as
`foldMap1`'s default implementation no longer uses `Foldable`. To migrate this
code, change the instance to explicitly define `foldMap1`:
```hs
instance Foldable1 T where
foldMap1 f (MkT x) = f x
```
This approach should be backwards-compatible with previous `semigroupoids`
releases.
Some other side effects of this migration include:
* The `Data.Semigroup.Foldable.Class` module has been deprecated. It no
longer serves a useful role, as it simply re-exports a limited subset of
the `Data.Foldable1` and `Data.Bifoldable1` API.
* All of the `Foldable1` and `Bifoldable1` instances that were previously
defined in `semigroupoids` have now been migrated to downstream libraries
(`base`, `bifunctors`, `containers`, `tagged`, and `transformers`), so it
is no longer strictly necessary to depend on `semigroupoids` to make use of
these instances.
* Add `Generic1`-based functions for many classes, useful for writing instances:
- `Data.Functor.Alt.(<!>)` -> `Data.Functor.Alt.galt`
- `Data.Functor.Apply.{liftF2,liftF3}` -> `Data.Functor.Apply.{gliftF2,gliftF3}`
- `Data.Functor.Bind.(>>-)` -> `Data.Functor.Bind.gbind`
- `Data.Functor.Contravariant.Conclude.{conclude,concluded}` -> `Data.Functor.Contravariant.Conclude.{gconclude,gconcluded}`
- `Data.Functor.Contravariant.Decide.{decide,decided}` -> `Data.Functor.Contravariant.Decide.{gdecide,gdecided}`
- `Data.Functor.Contravariant.Divise.{divise,divised}` -> `Data.Functor.Contravariant.Divise.{gdivise,gdivised}`
- `Data.Functor.Extend.{duplicated,extended}` -> `Data.Functor.Extend.{gduplicated,gextended}`
- `Data.Functor.Plus.zero` -> `Data.Functor.Plus.gzero`
- `Data.Semigroup.Foldable.{fold1,foldMap1,toNonEmpty}` -> `Data.Semigroup.Foldable.{gfold1,gfoldMap1,gtoNonEmpty}`
- `Data.Semigroup.Traversable.{traverse1,sequence1}` -> `Data.Semigroup.Traversable.{gtraverse1,gsequence1}`
* Thu Mar 30 2023 Peter Simons <psimons@suse.com>
- Updated spec file to conform with ghc-rpm-macros-2.5.2.
* Thu Feb 02 2023 Peter Simons <psimons@suse.com>
- Update semigroupoids to version 5.3.7 revision 1.
Upstream has revised the Cabal build instructions on Hackage.
* Mon Jan 10 2022 Peter Simons <psimons@suse.com>
- Update semigroupoids to version 5.3.7.
5.3.7 [2022.01.09]
- -----------------
* Relax the `Bind` constraints in the following instances to `Functor`:
```diff
- instance (Bind f, Monad f) => Alt (MaybeT f)
- instance (Bind f, Monad f) => Plus (MaybeT f)
+instance (Functor f, Monad f) => Alt (MaybeT f)
+instance (Functor f, Monad f) => Plus (MaybeT f)
- instance (Bind f, Monad f, Semigroup e) => Alt (ExceptT e f)
- instance (Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)
+instance (Functor f, Monad f, Semigroup e) => Alt (ExceptT e f)
+instance (Functor f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)
- - If building with transformers-0.5.* or older
- instance (Bind f, Monad f) => Alt (ErrorT e f)
- instance (Bind f, Monad f, Error e) => Plus (ErrorT e f
+instance (Functor f, Monad f) => Alt (ErrorT e f)
+instance (Functor f, Monad f, Error e) => Plus (ErrorT e f)
```
* Wed Nov 10 2021 psimons@suse.com
- Update semigroupoids to version 5.3.6 revision 2.
Upstream has revised the Cabal build instructions on Hackage.
* Sun Oct 10 2021 psimons@suse.com
- Update semigroupoids to version 5.3.6 revision 1.
Upstream has revised the Cabal build instructions on Hackage.
* Fri Oct 08 2021 psimons@suse.com
- Update semigroupoids to version 5.3.6.
5.3.6 [2021.10.07]
- -----------------
* Allow building with GHC 9.2.
* Allow building with `transformers-0.6.*`.
* Add `Alt` instance for `Identity`.
* Add `Conclude`, `Decide` and `Divise` type classes and instances.
* Add `(<.*>)`, `(<*.>)`, and `traverseMaybe` functions, which make it easier
to defined `Traversable1` instances for data types that have fields with a
combination of `Traversable` and `Traversable1` instances.
* Add `Semigroupoids.Do` module with overloads for use with `QualifiedDo`.
* Add `Apply`, `Alt`, `Plus`, `Bind` and `BindTrans` instances for the CPS
versions of `WriterT` and `RWST`.
* Add `psum` function to `Data.Functor.Plus`.
* Add `Categorical` data type.
* Tue Jul 27 2021 psimons@suse.com
- Update semigroupoids to version 5.3.5 revision 1.
Upstream has revised the Cabal build instructions on Hackage.
* Mon Jan 04 2021 psimons@suse.com
- Update semigroupoids to version 5.3.5.
5.3.5 [2020.12.31]
- -----------------
* The build-type has been changed from `Custom` to `Simple`.
To achieve this, the `doctests` test suite has been removed in favor of using
[`cabal-docspec`](https://github.com/phadej/cabal-extras/tree/master/cabal-docspec)
to run the doctests.
* Explicitly mark modules as `Safe`.
* Thu Dec 17 2020 Ondřej Súkup <mimi.vx@gmail.com>
- disable %{ix86} build
/usr/lib64/ghc-9.8.2/lib/libHSsemigroupoids-6.0.0.1-F2Polsi9zqJLg0MVf424YS-ghc9.8.2.so /usr/share/licenses/ghc-semigroupoids /usr/share/licenses/ghc-semigroupoids/LICENSE
Generated by rpm2html 1.8.1
Fabrice Bellet, Tue Apr 30 23:58:22 2024