rebase 1.10.0.1 → 1.11

raw patch · 4 files changed

+15/−19 lines, 4 filesdep −contravariant-extrasdep ~bytestringdep ~dlistdep ~profunctorsPVP ok

version bump matches the API change (PVP)

Dependencies removed: contravariant-extras

Dependency ranges changed: bytestring, dlist, profunctors, time, vector-instances

API changes (from Hackage documentation)

- Rebase.Prelude: (>*<) :: Divisible f => f a -> f b -> f (a, b)

- Rebase.Prelude: [Handler] :: forall a e. Exception e => (e -> IO a) -> Handler a

- Rebase.Prelude: [SomeAsyncException] :: forall e. Exception e => e -> SomeAsyncException

- Rebase.Prelude: [SomeException] :: forall e. Exception e => e -> SomeException

- Rebase.Prelude: [Supplied] :: forall (divisible :: Type -> Type) input. () => divisible input -> input -> Supplied divisible

- Rebase.Prelude: contramany :: Decidable f => f a -> f [a]

- Rebase.Prelude: contrazip10 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

- Rebase.Prelude: contrazip11 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

- Rebase.Prelude: contrazip12 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

- Rebase.Prelude: contrazip13 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)

- Rebase.Prelude: contrazip14 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)

- Rebase.Prelude: contrazip15 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)

- Rebase.Prelude: contrazip16 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16)

- Rebase.Prelude: contrazip17 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)

- Rebase.Prelude: contrazip18 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18)

- Rebase.Prelude: contrazip19 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)

- Rebase.Prelude: contrazip2 :: Divisible f => f a1 -> f a2 -> f (a1, a2)

- Rebase.Prelude: contrazip20 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)

- Rebase.Prelude: contrazip21 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21)

- Rebase.Prelude: contrazip22 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22)

- Rebase.Prelude: contrazip23 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23)

- Rebase.Prelude: contrazip24 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24)

- Rebase.Prelude: contrazip25 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)

- Rebase.Prelude: contrazip26 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)

- Rebase.Prelude: contrazip27 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)

- Rebase.Prelude: contrazip28 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)

- Rebase.Prelude: contrazip29 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)

- Rebase.Prelude: contrazip3 :: Divisible f => f a1 -> f a2 -> f a3 -> f (a1, a2, a3)

- Rebase.Prelude: contrazip30 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30)

- Rebase.Prelude: contrazip31 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31)

- Rebase.Prelude: contrazip32 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32)

- Rebase.Prelude: contrazip33 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33)

- Rebase.Prelude: contrazip34 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34)

- Rebase.Prelude: contrazip35 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35)

- Rebase.Prelude: contrazip36 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36)

- Rebase.Prelude: contrazip37 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37)

- Rebase.Prelude: contrazip38 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f a38 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38)

- Rebase.Prelude: contrazip39 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f a38 -> f a39 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39)

- Rebase.Prelude: contrazip4 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f (a1, a2, a3, a4)

- Rebase.Prelude: contrazip40 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f a38 -> f a39 -> f a40 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40)

- Rebase.Prelude: contrazip41 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f a38 -> f a39 -> f a40 -> f a41 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41)

- Rebase.Prelude: contrazip42 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f a10 -> f a11 -> f a12 -> f a13 -> f a14 -> f a15 -> f a16 -> f a17 -> f a18 -> f a19 -> f a20 -> f a21 -> f a22 -> f a23 -> f a24 -> f a25 -> f a26 -> f a27 -> f a28 -> f a29 -> f a30 -> f a31 -> f a32 -> f a33 -> f a34 -> f a35 -> f a36 -> f a37 -> f a38 -> f a39 -> f a40 -> f a41 -> f a42 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42)

- Rebase.Prelude: contrazip5 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f (a1, a2, a3, a4, a5)

- Rebase.Prelude: contrazip6 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f (a1, a2, a3, a4, a5, a6)

- Rebase.Prelude: contrazip7 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f (a1, a2, a3, a4, a5, a6, a7)

- Rebase.Prelude: contrazip8 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f (a1, a2, a3, a4, a5, a6, a7, a8)

- Rebase.Prelude: contrazip9 :: Divisible f => f a1 -> f a2 -> f a3 -> f a4 -> f a5 -> f a6 -> f a7 -> f a8 -> f a9 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9)

- Rebase.Prelude: contrazipLifting10 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> g a10 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

- Rebase.Prelude: contrazipLifting2 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> f (a1, a2)

- Rebase.Prelude: contrazipLifting3 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> f (a1, a2, a3)

- Rebase.Prelude: contrazipLifting4 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> f (a1, a2, a3, a4)

- Rebase.Prelude: contrazipLifting5 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> f (a1, a2, a3, a4, a5)

- Rebase.Prelude: contrazipLifting6 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> f (a1, a2, a3, a4, a5, a6)

- Rebase.Prelude: contrazipLifting7 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> f (a1, a2, a3, a4, a5, a6, a7)

- Rebase.Prelude: contrazipLifting8 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> f (a1, a2, a3, a4, a5, a6, a7, a8)

- Rebase.Prelude: contrazipLifting9 :: Divisible f => (forall x. () => g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9)

- Rebase.Prelude: data Supplied (divisible :: Type -> Type)

- Rebase.Prelude: data Prep (p :: Type -> k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type

- Rebase.Prelude: data Procompose (p :: k -> k2 -> Type) (q :: k1 -> k -> Type) (d :: k1) (c :: k2) :: forall k k1 k2. () => k -> k2 -> Type -> k1 -> k -> Type -> k1 -> k2 -> Type

- Rebase.Prelude: data (:~~:) (a :: k1) (b :: k2) :: forall k1 k2. () => k1 -> k2 -> Type

- Rebase.Prelude: newtype Semi m (a :: k) (b :: k1) :: forall k k1. () => Type -> k -> k1 -> Type

- Rebase.Prelude: newtype WrappedCategory (k2 :: k -> k1 -> Type) (a :: k) (b :: k1) :: forall k k1. () => k -> k1 -> Type -> k -> k1 -> Type

- Rebase.Prelude: newtype Rift (p :: k2 -> k -> Type) (q :: k1 -> k -> Type) (a :: k1) (b :: k2) :: forall k k1 k2. () => k2 -> k -> Type -> k1 -> k -> Type -> k1 -> k2 -> Type

- Rebase.Prelude: pattern ErrorCall :: () => () => String -> ErrorCall

+ Rebase.Prelude: Handler :: (e -> IO a) -> Handler a

+ Rebase.Prelude: MkSystemTime :: {-# UNPACK #-} !Int64 -> {-# UNPACK #-} !Word32 -> SystemTime

+ Rebase.Prelude: SomeAsyncException :: e -> SomeAsyncException

+ Rebase.Prelude: SomeException :: e -> SomeException

+ Rebase.Prelude: [getDown] :: Down a -> a

+ Rebase.Prelude: [systemNanoseconds] :: SystemTime -> {-# UNPACK #-} !Word32

+ Rebase.Prelude: [systemSeconds] :: SystemTime -> {-# UNPACK #-} !Int64

+ Rebase.Prelude: bitReverse16 :: Word16 -> Word16

+ Rebase.Prelude: bitReverse32 :: Word32 -> Word32

+ Rebase.Prelude: bitReverse64 :: Word64 -> Word64

+ Rebase.Prelude: bitReverse8 :: Word8 -> Word8

+ Rebase.Prelude: data (a :: k1) :~~: (b :: k2)

+ Rebase.Prelude: data Prep (p :: Type -> k -> Type) (a :: k)

+ Rebase.Prelude: data Procompose (p :: k -> k1 -> Type) (q :: k2 -> k -> Type) (d :: k2) (c :: k1)

+ Rebase.Prelude: data Proxy (t :: k)

+ Rebase.Prelude: data SystemTime

+ Rebase.Prelude: data Timeout

+ Rebase.Prelude: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

+ Rebase.Prelude: getSystemTime :: IO SystemTime

+ Rebase.Prelude: isResourceVanishedError :: IOError -> Bool

+ Rebase.Prelude: isResourceVanishedErrorType :: IOErrorType -> Bool

+ Rebase.Prelude: newtype Ap (f :: k -> Type) (a :: k)

+ Rebase.Prelude: newtype Cayley (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2)

+ Rebase.Prelude: newtype Codensity (p :: k -> k1 -> Type) (a :: k1) (b :: k1)

+ Rebase.Prelude: newtype Cokleisli (w :: k -> Type) (a :: k) b

+ Rebase.Prelude: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)

+ Rebase.Prelude: newtype Const a (b :: k)

+ Rebase.Prelude: newtype ContT (r :: k) (m :: k -> Type) a

+ Rebase.Prelude: newtype Coprep (p :: k -> Type -> Type) (a :: k)

+ Rebase.Prelude: newtype Costar (f :: k -> Type) (d :: k) c

+ Rebase.Prelude: newtype Forget r a (b :: k)

+ Rebase.Prelude: newtype Ran (p :: k -> k1 -> Type) (q :: k -> k2 -> Type) (a :: k1) (b :: k2)

+ Rebase.Prelude: newtype ReaderT r (m :: Type -> Type) a

+ Rebase.Prelude: newtype Rift (p :: k -> k1 -> Type) (q :: k2 -> k1 -> Type) (a :: k2) (b :: k)

+ Rebase.Prelude: newtype Semi m (a :: k) (b :: k1)

+ Rebase.Prelude: newtype Star (f :: k -> Type) d (c :: k)

+ Rebase.Prelude: newtype WrappedCategory (k2 :: k -> k1 -> Type) (a :: k) (b :: k1)

+ Rebase.Prelude: pattern ErrorCall :: String -> ErrorCall

+ Rebase.Prelude: resourceVanishedErrorType :: IOErrorType

+ Rebase.Prelude: systemEpochDay :: Day

+ Rebase.Prelude: systemToTAITime :: SystemTime -> AbsoluteTime

+ Rebase.Prelude: systemToUTCTime :: SystemTime -> UTCTime

+ Rebase.Prelude: truncateSystemTimeLeapSecond :: SystemTime -> SystemTime

+ Rebase.Prelude: utcToSystemTime :: UTCTime -> SystemTime

- Rebase.Prelude: (!!) :: () => [a] -> Int -> a

+ Rebase.Prelude: (!!) :: [a] -> Int -> a

- Rebase.Prelude: (#.) :: (Profunctor p, Coercible c b) => q b c -> p a b -> p a c

+ Rebase.Prelude: (#.) :: forall a b c q. (Profunctor p, Coercible c b) => q b c -> p a b -> p a c

- Rebase.Prelude: ($!) :: () => (a -> b) -> a -> b

+ Rebase.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Rebase.Prelude: ($) :: () => (a -> b) -> a -> b

+ Rebase.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Rebase.Prelude: (&) :: () => a -> (a -> b) -> b

+ Rebase.Prelude: (&) :: a -> (a -> b) -> b

- Rebase.Prelude: (++) :: () => [a] -> [a] -> [a]

+ Rebase.Prelude: (++) :: [a] -> [a] -> [a]

- Rebase.Prelude: (.#) :: (Profunctor p, Coercible b a) => p b c -> q a b -> p a c

+ Rebase.Prelude: (.#) :: forall a b c q. (Profunctor p, Coercible b a) => p b c -> q a b -> p a c

- Rebase.Prelude: (.) :: Category cat => cat b c -> cat a b -> cat a c

+ Rebase.Prelude: (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c

- Rebase.Prelude: (<<$>>) :: () => (a -> b) -> a -> b

+ Rebase.Prelude: (<<$>>) :: (a -> b) -> a -> b

- Rebase.Prelude: (<<<) :: Category cat => cat b c -> cat a b -> cat a c

+ Rebase.Prelude: (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c

- Rebase.Prelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c

+ Rebase.Prelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c

- Rebase.Prelude: Ap :: f a -> Ap

+ Rebase.Prelude: Ap :: f a -> Ap (f :: k -> Type) (a :: k)

- Rebase.Prelude: ArrowMonad :: a () b -> ArrowMonad b

+ Rebase.Prelude: ArrowMonad :: a () b -> ArrowMonad (a :: Type -> Type -> Type) b

- Rebase.Prelude: Cayley :: f (p a b) -> Cayley

+ Rebase.Prelude: Cayley :: f (p a b) -> Cayley (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2)

- Rebase.Prelude: Closure :: (forall x. () => p (x -> a) (x -> b)) -> Closure a b

+ Rebase.Prelude: Closure :: (forall x. () => p (x -> a) (x -> b)) -> Closure (p :: Type -> Type -> Type) a b

- Rebase.Prelude: Codensity :: (forall (x :: k). () => p x a -> p x b) -> Codensity

+ Rebase.Prelude: Codensity :: (forall (x :: k). () => p x a -> p x b) -> Codensity (p :: k -> k1 -> Type) (a :: k1) (b :: k1)

- Rebase.Prelude: CofreeMapping :: (forall (f :: Type -> Type). Functor f => p (f a) (f b)) -> CofreeMapping a b

+ Rebase.Prelude: CofreeMapping :: (forall (f :: Type -> Type). Functor f => p (f a) (f b)) -> CofreeMapping (p :: Type -> Type -> Type) a b

- Rebase.Prelude: CofreeTraversing :: (forall (f :: Type -> Type). Traversable f => p (f a) (f b)) -> CofreeTraversing a b

+ Rebase.Prelude: CofreeTraversing :: (forall (f :: Type -> Type). Traversable f => p (f a) (f b)) -> CofreeTraversing (p :: Type -> Type -> Type) a b

- Rebase.Prelude: Cokleisli :: (w a -> b) -> Cokleisli b

+ Rebase.Prelude: Cokleisli :: (w a -> b) -> Cokleisli (w :: k -> Type) (a :: k) b

- Rebase.Prelude: Compose :: f (g a) -> Compose

+ Rebase.Prelude: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)

- Rebase.Prelude: ComposeEither :: f (Either e a) -> ComposeEither e a

+ Rebase.Prelude: ComposeEither :: f (Either e a) -> ComposeEither (f :: Type -> Type) e a

- Rebase.Prelude: Const :: a -> Const a

+ Rebase.Prelude: Const :: a -> Const a (b :: k)

- Rebase.Prelude: ContT :: ((a -> m r) -> m r) -> ContT a

+ Rebase.Prelude: ContT :: ((a -> m r) -> m r) -> ContT (r :: k) (m :: k -> Type) a

- Rebase.Prelude: Copastro :: (forall (r :: Type -> Type -> Type). Costrong r => (forall x y. () => p x y -> r x y) -> r a b) -> Copastro a b

+ Rebase.Prelude: Copastro :: (forall (r :: Type -> Type -> Type). Costrong r => (forall x y. () => p x y -> r x y) -> r a b) -> Copastro (p :: Type -> Type -> Type) a b

- Rebase.Prelude: CopastroSum :: (forall (r :: Type -> Type -> Type). Cochoice r => (forall x y. () => p x y -> r x y) -> r a b) -> CopastroSum a b

+ Rebase.Prelude: CopastroSum :: (forall (r :: Type -> Type -> Type). Cochoice r => (forall x y. () => p x y -> r x y) -> r a b) -> CopastroSum (p :: Type -> Type -> Type) a b

- Rebase.Prelude: Coprep :: (forall r. () => p a r -> r) -> Coprep

+ Rebase.Prelude: Coprep :: (forall r. () => p a r -> r) -> Coprep (p :: k -> Type -> Type) (a :: k)

- Rebase.Prelude: Costar :: (f d -> c) -> Costar c

+ Rebase.Prelude: Costar :: (f d -> c) -> Costar (f :: k -> Type) (d :: k) c

- Rebase.Prelude: ExceptT :: m (Either e a) -> ExceptT e a

+ Rebase.Prelude: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a

- Rebase.Prelude: Forget :: (a -> r) -> Forget r a

+ Rebase.Prelude: Forget :: (a -> r) -> Forget r a (b :: k)

- Rebase.Prelude: Kleisli :: (a -> m b) -> Kleisli a b

+ Rebase.Prelude: Kleisli :: (a -> m b) -> Kleisli (m :: Type -> Type) a b

- Rebase.Prelude: MaybeApply :: Either (f a) a -> MaybeApply a

+ Rebase.Prelude: MaybeApply :: Either (f a) a -> MaybeApply (f :: Type -> Type) a

- Rebase.Prelude: MaybeT :: m (Maybe a) -> MaybeT a

+ Rebase.Prelude: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a

- Rebase.Prelude: MkFixed :: Integer -> Fixed a

+ Rebase.Prelude: MkFixed :: Integer -> Fixed (a :: k)

- Rebase.Prelude: Proxy :: Proxy

+ Rebase.Prelude: Proxy :: Proxy (t :: k)

- Rebase.Prelude: Ran :: (forall (x :: k). () => p x a -> q x b) -> Ran

+ Rebase.Prelude: Ran :: (forall (x :: k). () => p x a -> q x b) -> Ran (p :: k -> k1 -> Type) (q :: k -> k2 -> Type) (a :: k1) (b :: k2)

- Rebase.Prelude: ReaderT :: (r -> m a) -> ReaderT r

+ Rebase.Prelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a

- Rebase.Prelude: Rift :: (forall (x :: k). () => p b x -> q a x) -> Rift

+ Rebase.Prelude: Rift :: (forall (x :: k1). () => p b x -> q a x) -> Rift (p :: k -> k1 -> Type) (q :: k2 -> k1 -> Type) (a :: k2) (b :: k)

- Rebase.Prelude: SelectA :: f a -> SelectA a

+ Rebase.Prelude: SelectA :: f a -> SelectA (f :: Type -> Type) a

- Rebase.Prelude: SelectM :: f a -> SelectM a

+ Rebase.Prelude: SelectM :: f a -> SelectM (f :: Type -> Type) a

- Rebase.Prelude: Semi :: m -> Semi m

+ Rebase.Prelude: Semi :: m -> Semi m (a :: k) (b :: k1)

- Rebase.Prelude: Star :: (d -> f c) -> Star d

+ Rebase.Prelude: Star :: (d -> f c) -> Star (f :: k -> Type) d (c :: k)

- Rebase.Prelude: StateT :: (s -> m (a, s)) -> StateT s a

+ Rebase.Prelude: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a

- Rebase.Prelude: Tambara :: (forall c. () => p (a, c) (b, c)) -> Tambara a b

+ Rebase.Prelude: Tambara :: (forall c. () => p (a, c) (b, c)) -> Tambara (p :: Type -> Type -> Type) a b

- Rebase.Prelude: TambaraSum :: (forall c. () => p (Either a c) (Either b c)) -> TambaraSum a b

+ Rebase.Prelude: TambaraSum :: (forall c. () => p (Either a c) (Either b c)) -> TambaraSum (p :: Type -> Type -> Type) a b

- Rebase.Prelude: WrapApplicative :: f a -> WrappedApplicative a

+ Rebase.Prelude: WrapApplicative :: f a -> WrappedApplicative (f :: Type -> Type) a

- Rebase.Prelude: WrapArrow :: a b c -> WrappedArrow b c

+ Rebase.Prelude: WrapArrow :: a b c -> WrappedArrow (a :: Type -> Type -> Type) b c

- Rebase.Prelude: WrapCategory :: k2 a b -> WrappedCategory

+ Rebase.Prelude: WrapCategory :: k2 a b -> WrappedCategory (k2 :: k -> k1 -> Type) (a :: k) (b :: k1)

- Rebase.Prelude: WrapMonad :: m a -> WrappedMonad a

+ Rebase.Prelude: WrapMonad :: m a -> WrappedMonad (m :: Type -> Type) a

- Rebase.Prelude: WriterT :: m (a, w) -> WriterT w a

+ Rebase.Prelude: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a

- Rebase.Prelude: Yoneda :: (forall x y. () => (x -> a) -> (b -> y) -> p x y) -> Yoneda a b

+ Rebase.Prelude: Yoneda :: (forall x y. () => (x -> a) -> (b -> y) -> p x y) -> Yoneda (p :: Type -> Type -> Type) a b

- Rebase.Prelude: [CotambaraSum] :: forall (q :: Type -> Type -> Type) a b (r :: Type -> Type -> Type). Cochoice r => (r :-> q) -> r a b -> CotambaraSum q a b

+ Rebase.Prelude: [CotambaraSum] :: forall (r :: Type -> Type -> Type) (q :: Type -> Type -> Type) a b. Cochoice r => (r :-> q) -> r a b -> CotambaraSum q a b

- Rebase.Prelude: [Cotambara] :: forall (q :: Type -> Type -> Type) a b (r :: Type -> Type -> Type). Costrong r => (r :-> q) -> r a b -> Cotambara q a b

+ Rebase.Prelude: [Cotambara] :: forall (r :: Type -> Type -> Type) (q :: Type -> Type -> Type) a b. Costrong r => (r :-> q) -> r a b -> Cotambara q a b

- Rebase.Prelude: [Coyoneda] :: forall (p :: Type -> Type -> Type) a b x y. () => (a -> x) -> (y -> b) -> p x y -> Coyoneda p a b

+ Rebase.Prelude: [Coyoneda] :: forall a x y b (p :: Type -> Type -> Type). (a -> x) -> (y -> b) -> p x y -> Coyoneda p a b

- Rebase.Prelude: [Dynamic] :: forall a. () => TypeRep a -> a -> Dynamic

+ Rebase.Prelude: [Dynamic] :: forall a. TypeRep a -> a -> Dynamic

- Rebase.Prelude: [Environment] :: forall (p :: Type -> Type -> Type) a b z y x. () => ((z -> y) -> b) -> p x y -> (a -> z -> x) -> Environment p a b

+ Rebase.Prelude: [Environment] :: forall z y b (p :: Type -> Type -> Type) x a. ((z -> y) -> b) -> p x y -> (a -> z -> x) -> Environment p a b

- Rebase.Prelude: [FreeMapping] :: forall (p :: Type -> Type -> Type) a b (f :: Type -> Type) y x. Functor f => (f y -> b) -> p x y -> (a -> f x) -> FreeMapping p a b

+ Rebase.Prelude: [FreeMapping] :: forall (f :: Type -> Type) y b (p :: Type -> Type -> Type) x a. Functor f => (f y -> b) -> p x y -> (a -> f x) -> FreeMapping p a b

- Rebase.Prelude: [FreeTraversing] :: forall (p :: Type -> Type -> Type) a b (f :: Type -> Type) y x. Traversable f => (f y -> b) -> p x y -> (a -> f x) -> FreeTraversing p a b

+ Rebase.Prelude: [FreeTraversing] :: forall (f :: Type -> Type) y b (p :: Type -> Type -> Type) x a. Traversable f => (f y -> b) -> p x y -> (a -> f x) -> FreeTraversing p a b

- Rebase.Prelude: [HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a

+ Rebase.Prelude: [HRefl] :: forall k1 (a :: k1). a :~~: a

- Rebase.Prelude: [PastroSum] :: forall (p :: Type -> Type -> Type) a b y z x. () => (Either y z -> b) -> p x y -> (a -> Either x z) -> PastroSum p a b

+ Rebase.Prelude: [PastroSum] :: forall y z b (p :: Type -> Type -> Type) x a. (Either y z -> b) -> p x y -> (a -> Either x z) -> PastroSum p a b

- Rebase.Prelude: [Pastro] :: forall (p :: Type -> Type -> Type) a b y z x. () => ((y, z) -> b) -> p x y -> (a -> (x, z)) -> Pastro p a b

+ Rebase.Prelude: [Pastro] :: forall y z b (p :: Type -> Type -> Type) x a. ((y, z) -> b) -> p x y -> (a -> (x, z)) -> Pastro p a b

- Rebase.Prelude: [Prep] :: forall k (p :: Type -> k -> Type) (a :: k) x. () => x -> p x a -> Prep p a

+ Rebase.Prelude: [Prep] :: forall k x (p :: Type -> k -> Type) (a :: k). x -> p x a -> Prep p a

- Rebase.Prelude: [Procompose] :: forall k k1 k2 (p :: k -> k2 -> Type) (q :: k1 -> k -> Type) (d :: k1) (c :: k2) (x :: k). () => p x c -> q d x -> Procompose p q d c

+ Rebase.Prelude: [Procompose] :: forall k k1 k2 (p :: k -> k1 -> Type) (x :: k) (c :: k1) (q :: k2 -> k -> Type) (d :: k2). p x c -> q d x -> Procompose p q d c

- Rebase.Prelude: [Refl] :: forall k (a :: k) (b :: k). () => a :~: a

+ Rebase.Prelude: [Refl] :: forall k (a :: k). a :~: a

- Rebase.Prelude: [getAp] :: Ap -> f a

+ Rebase.Prelude: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a

- Rebase.Prelude: [getCompose] :: Compose -> f (g a)

+ Rebase.Prelude: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)

- Rebase.Prelude: [getConst] :: Const a -> a

+ Rebase.Prelude: [getConst] :: Const a (b :: k) -> a

- Rebase.Prelude: [getSelectA] :: SelectA a -> f a

+ Rebase.Prelude: [getSelectA] :: SelectA (f :: Type -> Type) a -> f a

- Rebase.Prelude: [getSelectM] :: SelectM a -> f a

+ Rebase.Prelude: [getSelectM] :: SelectM (f :: Type -> Type) a -> f a

- Rebase.Prelude: [getSemi] :: Semi m -> m

+ Rebase.Prelude: [getSemi] :: Semi m (a :: k) (b :: k1) -> m

- Rebase.Prelude: [runCayley] :: Cayley -> f (p a b)

+ Rebase.Prelude: [runCayley] :: Cayley (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2) -> f (p a b)

- Rebase.Prelude: [runClosure] :: Closure a b -> forall x. () => p (x -> a) (x -> b)

+ Rebase.Prelude: [runClosure] :: Closure (p :: Type -> Type -> Type) a b -> forall x. () => p (x -> a) (x -> b)

- Rebase.Prelude: [runCodensity] :: Codensity -> forall (x :: k). () => p x a -> p x b

+ Rebase.Prelude: [runCodensity] :: Codensity (p :: k -> k1 -> Type) (a :: k1) (b :: k1) -> forall (x :: k). () => p x a -> p x b

- Rebase.Prelude: [runCofreeMapping] :: CofreeMapping a b -> forall (f :: Type -> Type). Functor f => p (f a) (f b)

+ Rebase.Prelude: [runCofreeMapping] :: CofreeMapping (p :: Type -> Type -> Type) a b -> forall (f :: Type -> Type). Functor f => p (f a) (f b)

- Rebase.Prelude: [runCofreeTraversing] :: CofreeTraversing a b -> forall (f :: Type -> Type). Traversable f => p (f a) (f b)

+ Rebase.Prelude: [runCofreeTraversing] :: CofreeTraversing (p :: Type -> Type -> Type) a b -> forall (f :: Type -> Type). Traversable f => p (f a) (f b)

- Rebase.Prelude: [runCokleisli] :: Cokleisli b -> w a -> b

+ Rebase.Prelude: [runCokleisli] :: Cokleisli (w :: k -> Type) (a :: k) b -> w a -> b

- Rebase.Prelude: [runContT] :: ContT a -> (a -> m r) -> m r

+ Rebase.Prelude: [runContT] :: ContT (r :: k) (m :: k -> Type) a -> (a -> m r) -> m r

- Rebase.Prelude: [runCopastroSum] :: CopastroSum a b -> forall (r :: Type -> Type -> Type). Cochoice r => (forall x y. () => p x y -> r x y) -> r a b

+ Rebase.Prelude: [runCopastroSum] :: CopastroSum (p :: Type -> Type -> Type) a b -> forall (r :: Type -> Type -> Type). Cochoice r => (forall x y. () => p x y -> r x y) -> r a b

- Rebase.Prelude: [runCopastro] :: Copastro a b -> forall (r :: Type -> Type -> Type). Costrong r => (forall x y. () => p x y -> r x y) -> r a b

+ Rebase.Prelude: [runCopastro] :: Copastro (p :: Type -> Type -> Type) a b -> forall (r :: Type -> Type -> Type). Costrong r => (forall x y. () => p x y -> r x y) -> r a b

- Rebase.Prelude: [runCoprep] :: Coprep -> forall r. () => p a r -> r

+ Rebase.Prelude: [runCoprep] :: Coprep (p :: k -> Type -> Type) (a :: k) -> forall r. () => p a r -> r

- Rebase.Prelude: [runCostar] :: Costar c -> f d -> c

+ Rebase.Prelude: [runCostar] :: Costar (f :: k -> Type) (d :: k) c -> f d -> c

- Rebase.Prelude: [runForget] :: Forget r a -> a -> r

+ Rebase.Prelude: [runForget] :: Forget r a (b :: k) -> a -> r

- Rebase.Prelude: [runKleisli] :: Kleisli a b -> a -> m b

+ Rebase.Prelude: [runKleisli] :: Kleisli (m :: Type -> Type) a b -> a -> m b

- Rebase.Prelude: [runMaybeApply] :: MaybeApply a -> Either (f a) a

+ Rebase.Prelude: [runMaybeApply] :: MaybeApply (f :: Type -> Type) a -> Either (f a) a

- Rebase.Prelude: [runMaybeT] :: MaybeT a -> m (Maybe a)

+ Rebase.Prelude: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)

- Rebase.Prelude: [runRan] :: Ran -> forall (x :: k). () => p x a -> q x b

+ Rebase.Prelude: [runRan] :: Ran (p :: k -> k1 -> Type) (q :: k -> k2 -> Type) (a :: k1) (b :: k2) -> forall (x :: k). () => p x a -> q x b

- Rebase.Prelude: [runReaderT] :: ReaderT r -> r -> m a

+ Rebase.Prelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a

- Rebase.Prelude: [runRift] :: Rift -> forall (x :: k). () => p b x -> q a x

+ Rebase.Prelude: [runRift] :: Rift (p :: k -> k1 -> Type) (q :: k2 -> k1 -> Type) (a :: k2) (b :: k) -> forall (x :: k1). () => p b x -> q a x

- Rebase.Prelude: [runStar] :: Star d -> d -> f c

+ Rebase.Prelude: [runStar] :: Star (f :: k -> Type) d (c :: k) -> d -> f c

- Rebase.Prelude: [runStateT] :: StateT s a -> s -> m (a, s)

+ Rebase.Prelude: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)

- Rebase.Prelude: [runTambaraSum] :: TambaraSum a b -> forall c. () => p (Either a c) (Either b c)

+ Rebase.Prelude: [runTambaraSum] :: TambaraSum (p :: Type -> Type -> Type) a b -> forall c. () => p (Either a c) (Either b c)

- Rebase.Prelude: [runTambara] :: Tambara a b -> forall c. () => p (a, c) (b, c)

+ Rebase.Prelude: [runTambara] :: Tambara (p :: Type -> Type -> Type) a b -> forall c. () => p (a, c) (b, c)

- Rebase.Prelude: [runWriterT] :: WriterT w a -> m (a, w)

+ Rebase.Prelude: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)

- Rebase.Prelude: [runYoneda] :: Yoneda a b -> forall x y. () => (x -> a) -> (b -> y) -> p x y

+ Rebase.Prelude: [runYoneda] :: Yoneda (p :: Type -> Type -> Type) a b -> forall x y. () => (x -> a) -> (b -> y) -> p x y

- Rebase.Prelude: [unwrapApplicative] :: WrappedApplicative a -> f a

+ Rebase.Prelude: [unwrapApplicative] :: WrappedApplicative (f :: Type -> Type) a -> f a

- Rebase.Prelude: [unwrapArrow] :: WrappedArrow b c -> a b c

+ Rebase.Prelude: [unwrapArrow] :: WrappedArrow (a :: Type -> Type -> Type) b c -> a b c

- Rebase.Prelude: [unwrapCategory] :: WrappedCategory -> k2 a b

+ Rebase.Prelude: [unwrapCategory] :: WrappedCategory (k2 :: k -> k1 -> Type) (a :: k) (b :: k1) -> k2 a b

- Rebase.Prelude: [unwrapMonad] :: WrappedMonad a -> m a

+ Rebase.Prelude: [unwrapMonad] :: WrappedMonad (m :: Type -> Type) a -> m a

- Rebase.Prelude: absurd :: () => Void -> a

+ Rebase.Prelude: absurd :: Void -> a

- Rebase.Prelude: addForeignPtrFinalizer :: () => FinalizerPtr a -> ForeignPtr a -> IO ()

+ Rebase.Prelude: addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()

- Rebase.Prelude: addForeignPtrFinalizerEnv :: () => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()

+ Rebase.Prelude: addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()

- Rebase.Prelude: addMVarFinalizer :: () => MVar a -> IO () -> IO ()

+ Rebase.Prelude: addMVarFinalizer :: MVar a -> IO () -> IO ()

- Rebase.Prelude: alignPtr :: () => Ptr a -> Int -> Ptr a

+ Rebase.Prelude: alignPtr :: Ptr a -> Int -> Ptr a

- Rebase.Prelude: asProxyTypeOf :: () => a -> proxy a -> a

+ Rebase.Prelude: asProxyTypeOf :: a -> proxy a -> a

- Rebase.Prelude: asTypeOf :: () => a -> a -> a

+ Rebase.Prelude: asTypeOf :: a -> a -> a

- Rebase.Prelude: assert :: () => Bool -> a -> a

+ Rebase.Prelude: assert :: Bool -> a -> a

- Rebase.Prelude: assertError :: ?callStack :: CallStack => Bool -> a -> a

+ Rebase.Prelude: assertError :: (?callStack :: CallStack) => Bool -> a -> a

- Rebase.Prelude: assoc :: () => Iso (Procompose p (Procompose q r) a b) (Procompose x (Procompose y z) a b) (Procompose (Procompose p q) r a b) (Procompose (Procompose x y) z a b)

+ Rebase.Prelude: assoc :: forall k1 k2 k3 k4 k5 k6 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k4 -> k3 -> Type) (a :: k4) (b :: k2) (x :: k5 -> k2 -> Type) (y :: k6 -> k5 -> Type) (z :: k4 -> k6 -> Type). Iso (Procompose p (Procompose q r) a b) (Procompose x (Procompose y z) a b) (Procompose (Procompose p q) r a b) (Procompose (Procompose x y) z a b)

- Rebase.Prelude: atomicModifyIORef :: () => IORef a -> (a -> (a, b)) -> IO b

+ Rebase.Prelude: atomicModifyIORef :: IORef a -> (a -> (a, b)) -> IO b

- Rebase.Prelude: atomicModifyIORef' :: () => IORef a -> (a -> (a, b)) -> IO b

+ Rebase.Prelude: atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b

- Rebase.Prelude: atomicWriteIORef :: () => IORef a -> a -> IO ()

+ Rebase.Prelude: atomicWriteIORef :: IORef a -> a -> IO ()

- Rebase.Prelude: atomically :: () => STM a -> IO a

+ Rebase.Prelude: atomically :: STM a -> IO a

- Rebase.Prelude: bool :: () => a -> a -> Bool -> a

+ Rebase.Prelude: bool :: a -> a -> Bool -> a

- Rebase.Prelude: bracket :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c

+ Rebase.Prelude: bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

- Rebase.Prelude: bracketOnError :: () => IO a -> (a -> IO b) -> (a -> IO c) -> IO c

+ Rebase.Prelude: bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

- Rebase.Prelude: bracket_ :: () => IO a -> IO b -> IO c -> IO c

+ Rebase.Prelude: bracket_ :: IO a -> IO b -> IO c -> IO c

- Rebase.Prelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Rebase.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])

- Rebase.Prelude: castForeignPtr :: () => ForeignPtr a -> ForeignPtr b

+ Rebase.Prelude: castForeignPtr :: ForeignPtr a -> ForeignPtr b

- Rebase.Prelude: castFunPtr :: () => FunPtr a -> FunPtr b

+ Rebase.Prelude: castFunPtr :: FunPtr a -> FunPtr b

- Rebase.Prelude: castFunPtrToPtr :: () => FunPtr a -> Ptr b

+ Rebase.Prelude: castFunPtrToPtr :: FunPtr a -> Ptr b

- Rebase.Prelude: castPtr :: () => Ptr a -> Ptr b

+ Rebase.Prelude: castPtr :: Ptr a -> Ptr b

- Rebase.Prelude: castPtrToFunPtr :: () => Ptr a -> FunPtr b

+ Rebase.Prelude: castPtrToFunPtr :: Ptr a -> FunPtr b

- Rebase.Prelude: castPtrToStablePtr :: () => Ptr () -> StablePtr a

+ Rebase.Prelude: castPtrToStablePtr :: Ptr () -> StablePtr a

- Rebase.Prelude: castStablePtrToPtr :: () => StablePtr a -> Ptr ()

+ Rebase.Prelude: castStablePtrToPtr :: StablePtr a -> Ptr ()

- Rebase.Prelude: catMaybes :: () => [Maybe a] -> [a]

+ Rebase.Prelude: catMaybes :: [Maybe a] -> [a]

- Rebase.Prelude: catchIOError :: () => IO a -> (IOError -> IO a) -> IO a

+ Rebase.Prelude: catchIOError :: IO a -> (IOError -> IO a) -> IO a

- Rebase.Prelude: catches :: () => IO a -> [Handler a] -> IO a

+ Rebase.Prelude: catches :: IO a -> [Handler a] -> IO a

- Rebase.Prelude: class a ~R# b => Coercible (a :: k0) (b :: k0)

+ Rebase.Prelude: class a ~R# b => Coercible (a :: k) (b :: k)

- Rebase.Prelude: class HasResolution a

+ Rebase.Prelude: class HasResolution (a :: k)

- Rebase.Prelude: cloneTChan :: () => TChan a -> STM (TChan a)

+ Rebase.Prelude: cloneTChan :: TChan a -> STM (TChan a)

- Rebase.Prelude: close :: Closed p => (p :-> q) -> p :-> Closure q

+ Rebase.Prelude: close :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Closed p => (p :-> q) -> p :-> Closure q

- Rebase.Prelude: coerce :: Coercible a b => a -> b

+ Rebase.Prelude: coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

- Rebase.Prelude: cokleislis :: Functor f => Iso (Procompose (Cokleisli f) (Cokleisli g) d c) (Procompose (Cokleisli f') (Cokleisli g') d' c') (Cokleisli (Compose f g) d c) (Cokleisli (Compose f' g') d' c')

+ Rebase.Prelude: cokleislis :: forall k1 k2 (f :: Type -> Type) (g :: k1 -> Type) (d :: k1) c (f' :: Type -> Type) (g' :: k2 -> Type) (d' :: k2) c'. Functor f => Iso (Procompose (Cokleisli f) (Cokleisli g) d c) (Procompose (Cokleisli f') (Cokleisli g') d' c') (Cokleisli (Compose f g) d c) (Cokleisli (Compose f' g') d' c')

- Rebase.Prelude: comparisonEquivalence :: () => Comparison a -> Equivalence a

+ Rebase.Prelude: comparisonEquivalence :: Comparison a -> Equivalence a

- Rebase.Prelude: const :: () => a -> b -> a

+ Rebase.Prelude: const :: a -> b -> a

- Rebase.Prelude: cont :: () => ((a -> r) -> r) -> Cont r a

+ Rebase.Prelude: cont :: ((a -> r) -> r) -> Cont r a

- Rebase.Prelude: coprepAdj :: () => (forall (a :: k). () => f a -> Coprep p a) -> p :-> Costar f

+ Rebase.Prelude: coprepAdj :: forall k f (p :: k -> Type -> Type). (forall (a :: k). () => f a -> Coprep p a) -> p :-> Costar f

- Rebase.Prelude: coprepCounit :: () => f a -> Coprep (Costar f) a

+ Rebase.Prelude: coprepCounit :: forall k f (a :: k). f a -> Coprep (Costar f) a

- Rebase.Prelude: coprepUnit :: () => p :-> Costar (Coprep p)

+ Rebase.Prelude: coprepUnit :: forall k (p :: k -> Type -> Type). p :-> Costar (Coprep p)

- Rebase.Prelude: costars :: Functor f => Iso (Procompose (Costar f) (Costar g) d c) (Procompose (Costar f') (Costar g') d' c') (Costar (Compose f g) d c) (Costar (Compose f' g') d' c')

+ Rebase.Prelude: costars :: forall k1 k2 (f :: Type -> Type) (g :: k1 -> Type) (d :: k1) c (f' :: Type -> Type) (g' :: k2 -> Type) (d' :: k2) c'. Functor f => Iso (Procompose (Costar f) (Costar g) d c) (Procompose (Costar f') (Costar g') d' c') (Costar (Compose f g) d c) (Costar (Compose f' g') d' c')

- Rebase.Prelude: cotabulated :: (Corepresentable p, Corepresentable q) => Iso (Corep p d -> c) (Corep q d' -> c') (p d c) (q d' c')

+ Rebase.Prelude: cotabulated :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) d c d' c'. (Corepresentable p, Corepresentable q) => Iso (Corep p d -> c) (Corep q d' -> c') (p d c) (q d' c')

- Rebase.Prelude: cotambara :: Costrong p => (p :-> q) -> p :-> Cotambara q

+ Rebase.Prelude: cotambara :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Costrong p => (p :-> q) -> p :-> Cotambara q

- Rebase.Prelude: cotambaraSum :: Cochoice p => (p :-> q) -> p :-> CotambaraSum q

+ Rebase.Prelude: cotambaraSum :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Cochoice p => (p :-> q) -> p :-> CotambaraSum q

- Rebase.Prelude: counit :: (ProfunctorAdjunction f u, Profunctor p) => f (u p) :-> p

+ Rebase.Prelude: counit :: forall (p :: Type -> Type -> Type). (ProfunctorAdjunction f u, Profunctor p) => f (u p) :-> p

- Rebase.Prelude: curry :: () => ((a, b) -> c) -> a -> b -> c

+ Rebase.Prelude: curry :: ((a, b) -> c) -> a -> b -> c

- Rebase.Prelude: curryRan :: () => (Procompose p q :-> r) -> p :-> Ran q r

+ Rebase.Prelude: curryRan :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k3 -> k2 -> Type). (Procompose p q :-> r) -> p :-> Ran q r

- Rebase.Prelude: cycle :: () => [a] -> [a]

+ Rebase.Prelude: cycle :: [a] -> [a]

- Rebase.Prelude: data RealWorld :: Type

+ Rebase.Prelude: data RealWorld

- Rebase.Prelude: deRefStablePtr :: () => StablePtr a -> IO a

+ Rebase.Prelude: deRefStablePtr :: StablePtr a -> IO a

- Rebase.Prelude: decomposeCodensity :: () => Procompose (Codensity p) p a b -> p a b

+ Rebase.Prelude: decomposeCodensity :: forall k1 k2 p (a :: k1) (b :: k2). Procompose (Codensity p) p a b -> p a b

- Rebase.Prelude: decomposeRan :: () => Procompose (Ran q p) q :-> p

+ Rebase.Prelude: decomposeRan :: forall k1 k2 k3 (q :: k1 -> k2 -> Type) (p :: k1 -> k3 -> Type). Procompose (Ran q p) q :-> p

- Rebase.Prelude: decomposeRift :: () => Procompose p (Rift p q) :-> q

+ Rebase.Prelude: decomposeRift :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k2 -> Type). Procompose p (Rift p q) :-> q

- Rebase.Prelude: deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]

+ Rebase.Prelude: deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]

- Rebase.Prelude: deleteFirstsBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

+ Rebase.Prelude: deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

- Rebase.Prelude: denominator :: () => Ratio a -> a

+ Rebase.Prelude: denominator :: Ratio a -> a

- Rebase.Prelude: die :: () => String -> IO a

+ Rebase.Prelude: die :: String -> IO a

- Rebase.Prelude: drop :: () => Int -> [a] -> [a]

+ Rebase.Prelude: drop :: Int -> [a] -> [a]

- Rebase.Prelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]

+ Rebase.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]

- Rebase.Prelude: dropWhileEnd :: () => (a -> Bool) -> [a] -> [a]

+ Rebase.Prelude: dropWhileEnd :: (a -> Bool) -> [a] -> [a]

- Rebase.Prelude: dupChan :: () => Chan a -> IO (Chan a)

+ Rebase.Prelude: dupChan :: Chan a -> IO (Chan a)

- Rebase.Prelude: dupTChan :: () => TChan a -> STM (TChan a)

+ Rebase.Prelude: dupTChan :: TChan a -> STM (TChan a)

- Rebase.Prelude: duplicateYoneda :: () => Yoneda p a b -> Yoneda (Yoneda p) a b

+ Rebase.Prelude: duplicateYoneda :: forall (p :: Type -> Type -> Type) a b. Yoneda p a b -> Yoneda (Yoneda p) a b

- Rebase.Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c

+ Rebase.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c

- Rebase.Prelude: eqStableName :: () => StableName a -> StableName b -> Bool

+ Rebase.Prelude: eqStableName :: StableName a -> StableName b -> Bool

- Rebase.Prelude: eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)

+ Rebase.Prelude: eqT :: forall k (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)

- Rebase.Prelude: error :: HasCallStack => [Char] -> a

+ Rebase.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

- Rebase.Prelude: errorWithoutStackTrace :: () => [Char] -> a

+ Rebase.Prelude: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a

- Rebase.Prelude: eta :: (Profunctor p, Category p) => ((->) :: Type -> Type -> Type) :-> p

+ Rebase.Prelude: eta :: forall (p :: Type -> Type -> Type). (Profunctor p, Category p) => ((->) :: Type -> Type -> Type) :-> p

- Rebase.Prelude: evalCont :: () => Cont r r -> r

+ Rebase.Prelude: evalCont :: Cont r r -> r

- Rebase.Prelude: evalState :: () => State s a -> s -> a

+ Rebase.Prelude: evalState :: State s a -> s -> a

- Rebase.Prelude: evaluate :: () => a -> IO a

+ Rebase.Prelude: evaluate :: a -> IO a

- Rebase.Prelude: except :: () => Either e a -> Except e a

+ Rebase.Prelude: except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a

- Rebase.Prelude: exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a

+ Rebase.Prelude: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a

- Rebase.Prelude: execState :: () => State s a -> s -> s

+ Rebase.Prelude: execState :: State s a -> s -> s

- Rebase.Prelude: execWriter :: () => Writer w a -> w

+ Rebase.Prelude: execWriter :: Writer w a -> w

- Rebase.Prelude: exitFailure :: () => IO a

+ Rebase.Prelude: exitFailure :: IO a

- Rebase.Prelude: exitSuccess :: () => IO a

+ Rebase.Prelude: exitSuccess :: IO a

- Rebase.Prelude: exitWith :: () => ExitCode -> IO a

+ Rebase.Prelude: exitWith :: ExitCode -> IO a

- Rebase.Prelude: extractYoneda :: () => Yoneda p a b -> p a b

+ Rebase.Prelude: extractYoneda :: Yoneda p a b -> p a b

- Rebase.Prelude: filter :: () => (a -> Bool) -> [a] -> [a]

+ Rebase.Prelude: filter :: (a -> Bool) -> [a] -> [a]

- Rebase.Prelude: finalizeForeignPtr :: () => ForeignPtr a -> IO ()

+ Rebase.Prelude: finalizeForeignPtr :: ForeignPtr a -> IO ()

- Rebase.Prelude: finally :: () => IO a -> IO b -> IO a

+ Rebase.Prelude: finally :: IO a -> IO b -> IO a

- Rebase.Prelude: findIndex :: () => (a -> Bool) -> [a] -> Maybe Int

+ Rebase.Prelude: findIndex :: (a -> Bool) -> [a] -> Maybe Int

- Rebase.Prelude: findIndices :: () => (a -> Bool) -> [a] -> [Int]

+ Rebase.Prelude: findIndices :: (a -> Bool) -> [a] -> [Int]

- Rebase.Prelude: fix :: () => (a -> a) -> a

+ Rebase.Prelude: fix :: (a -> a) -> a

- Rebase.Prelude: fixST :: () => (a -> ST s a) -> ST s a

+ Rebase.Prelude: fixST :: (a -> ST s a) -> ST s a

- Rebase.Prelude: flip :: () => (a -> b -> c) -> b -> a -> c

+ Rebase.Prelude: flip :: (a -> b -> c) -> b -> a -> c

- Rebase.Prelude: flushTBQueue :: () => TBQueue a -> STM [a]

+ Rebase.Prelude: flushTBQueue :: TBQueue a -> STM [a]

- Rebase.Prelude: flushTQueue :: () => TQueue a -> STM [a]

+ Rebase.Prelude: flushTQueue :: TQueue a -> STM [a]

- Rebase.Prelude: foldl1' :: () => (a -> a -> a) -> [a] -> a

+ Rebase.Prelude: foldl1' :: (a -> a -> a) -> [a] -> a

- Rebase.Prelude: forkFinally :: () => IO a -> (Either SomeException a -> IO ()) -> IO ThreadId

+ Rebase.Prelude: forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId

- Rebase.Prelude: freeHaskellFunPtr :: () => FunPtr a -> IO ()

+ Rebase.Prelude: freeHaskellFunPtr :: FunPtr a -> IO ()

- Rebase.Prelude: freeStablePtr :: () => StablePtr a -> IO ()

+ Rebase.Prelude: freeStablePtr :: StablePtr a -> IO ()

- Rebase.Prelude: fromJust :: () => Maybe a -> a

+ Rebase.Prelude: fromJust :: HasCallStack => Maybe a -> a

- Rebase.Prelude: fromLeft :: () => a -> Either a b -> a

+ Rebase.Prelude: fromLeft :: a -> Either a b -> a

- Rebase.Prelude: fromLeft' :: () => Either a b -> a

+ Rebase.Prelude: fromLeft' :: Either a b -> a

- Rebase.Prelude: fromMaybe :: () => a -> Maybe a -> a

+ Rebase.Prelude: fromMaybe :: a -> Maybe a -> a

- Rebase.Prelude: fromRight :: () => b -> Either a b -> b

+ Rebase.Prelude: fromRight :: b -> Either a b -> b

- Rebase.Prelude: fromRight' :: () => Either a b -> b

+ Rebase.Prelude: fromRight' :: Either a b -> b

- Rebase.Prelude: fst :: () => (a, b) -> a

+ Rebase.Prelude: fst :: (a, b) -> a

- Rebase.Prelude: gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)

+ Rebase.Prelude: gcast :: forall k (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)

- Rebase.Prelude: gcast1 :: (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))

+ Rebase.Prelude: gcast1 :: forall k1 k2 c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))

- Rebase.Prelude: gcast2 :: (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))

+ Rebase.Prelude: gcast2 :: forall k1 k2 k3 c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))

- Rebase.Prelude: getChanContents :: () => Chan a -> IO [a]

+ Rebase.Prelude: getChanContents :: Chan a -> IO [a]

- Rebase.Prelude: gmapQr :: Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r

+ Rebase.Prelude: gmapQr :: forall r r'. Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r

- Rebase.Prelude: groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]

+ Rebase.Prelude: groupBy :: (a -> a -> Bool) -> [a] -> [[a]]

- Rebase.Prelude: hashPtr :: () => Ptr a -> Int -> IO Int

+ Rebase.Prelude: hashPtr :: Ptr a -> Int -> IO Int

- Rebase.Prelude: hashPtrWithSalt :: () => Ptr a -> Int -> Int -> IO Int

+ Rebase.Prelude: hashPtrWithSalt :: Ptr a -> Int -> Int -> IO Int

- Rebase.Prelude: hashStableName :: () => StableName a -> Int

+ Rebase.Prelude: hashStableName :: StableName a -> Int

- Rebase.Prelude: head :: () => [a] -> a

+ Rebase.Prelude: head :: [a] -> a

- Rebase.Prelude: id :: Category cat => cat a a

+ Rebase.Prelude: id :: forall (a :: k). Category cat => cat a a

- Rebase.Prelude: idl :: Profunctor q => Iso (Procompose ((->) :: Type -> Type -> Type) q d c) (Procompose ((->) :: Type -> Type -> Type) r d' c') (q d c) (r d' c')

+ Rebase.Prelude: idl :: forall k (q :: Type -> Type -> Type) d c (r :: k -> Type -> Type) (d' :: k) c'. Profunctor q => Iso (Procompose ((->) :: Type -> Type -> Type) q d c) (Procompose ((->) :: Type -> Type -> Type) r d' c') (q d c) (r d' c')

- Rebase.Prelude: idr :: Profunctor q => Iso (Procompose q ((->) :: Type -> Type -> Type) d c) (Procompose r ((->) :: Type -> Type -> Type) d' c') (q d c) (r d' c')

+ Rebase.Prelude: idr :: forall k (q :: Type -> Type -> Type) d c (r :: Type -> k -> Type) d' (c' :: k). Profunctor q => Iso (Procompose q ((->) :: Type -> Type -> Type) d c) (Procompose r ((->) :: Type -> Type -> Type) d' c') (q d c) (r d' c')

- Rebase.Prelude: imagPart :: () => Complex a -> a

+ Rebase.Prelude: imagPart :: Complex a -> a

- Rebase.Prelude: infixl 4 <<.

+ Rebase.Prelude: infixl 4 .>>

- Rebase.Prelude: init :: () => [a] -> [a]

+ Rebase.Prelude: init :: [a] -> [a]

- Rebase.Prelude: inits :: () => [a] -> [[a]]

+ Rebase.Prelude: inits :: [a] -> [[a]]

- Rebase.Prelude: inline :: () => a -> a

+ Rebase.Prelude: inline :: a -> a

- Rebase.Prelude: insertBy :: () => (a -> a -> Ordering) -> a -> [a] -> [a]

+ Rebase.Prelude: insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]

- Rebase.Prelude: intPtrToPtr :: () => IntPtr -> Ptr a

+ Rebase.Prelude: intPtrToPtr :: IntPtr -> Ptr a

- Rebase.Prelude: intercalate :: () => [a] -> [[a]] -> [a]

+ Rebase.Prelude: intercalate :: [a] -> [[a]] -> [a]

- Rebase.Prelude: interruptible :: () => IO a -> IO a

+ Rebase.Prelude: interruptible :: IO a -> IO a

- Rebase.Prelude: intersectBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

+ Rebase.Prelude: intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

- Rebase.Prelude: intersperse :: () => a -> [a] -> [a]

+ Rebase.Prelude: intersperse :: a -> [a] -> [a]

- Rebase.Prelude: ioError :: () => IOError -> IO a

+ Rebase.Prelude: ioError :: IOError -> IO a

- Rebase.Prelude: ioException :: () => IOException -> IO a

+ Rebase.Prelude: ioException :: IOException -> IO a

- Rebase.Prelude: isEmptyMVar :: () => MVar a -> IO Bool

+ Rebase.Prelude: isEmptyMVar :: MVar a -> IO Bool

- Rebase.Prelude: isEmptyTBQueue :: () => TBQueue a -> STM Bool

+ Rebase.Prelude: isEmptyTBQueue :: TBQueue a -> STM Bool

- Rebase.Prelude: isEmptyTChan :: () => TChan a -> STM Bool

+ Rebase.Prelude: isEmptyTChan :: TChan a -> STM Bool

- Rebase.Prelude: isEmptyTMVar :: () => TMVar a -> STM Bool

+ Rebase.Prelude: isEmptyTMVar :: TMVar a -> STM Bool

- Rebase.Prelude: isEmptyTQueue :: () => TQueue a -> STM Bool

+ Rebase.Prelude: isEmptyTQueue :: TQueue a -> STM Bool

- Rebase.Prelude: isFullTBQueue :: () => TBQueue a -> STM Bool

+ Rebase.Prelude: isFullTBQueue :: TBQueue a -> STM Bool

- Rebase.Prelude: isJust :: () => Maybe a -> Bool

+ Rebase.Prelude: isJust :: Maybe a -> Bool

- Rebase.Prelude: isLeft :: () => Either a b -> Bool

+ Rebase.Prelude: isLeft :: Either a b -> Bool

- Rebase.Prelude: isNothing :: () => Maybe a -> Bool

+ Rebase.Prelude: isNothing :: Maybe a -> Bool

- Rebase.Prelude: isRight :: () => Either a b -> Bool

+ Rebase.Prelude: isRight :: Either a b -> Bool

- Rebase.Prelude: iterate :: () => (a -> a) -> a -> [a]

+ Rebase.Prelude: iterate :: (a -> a) -> a -> [a]

- Rebase.Prelude: iterate' :: () => (a -> a) -> a -> [a]

+ Rebase.Prelude: iterate' :: (a -> a) -> a -> [a]

- Rebase.Prelude: joinCoyoneda :: () => Coyoneda (Coyoneda p) a b -> Coyoneda p a b

+ Rebase.Prelude: joinCoyoneda :: forall (p :: Type -> Type -> Type) a b. Coyoneda (Coyoneda p) a b -> Coyoneda p a b

- Rebase.Prelude: kleislis :: Monad g => Iso (Procompose (Kleisli f) (Kleisli g) d c) (Procompose (Kleisli f') (Kleisli g') d' c') (Kleisli (Compose g f) d c) (Kleisli (Compose g' f') d' c')

+ Rebase.Prelude: kleislis :: forall (g :: Type -> Type) (f :: Type -> Type) d c (f' :: Type -> Type) (g' :: Type -> Type) d' c'. Monad g => Iso (Procompose (Kleisli f) (Kleisli g) d c) (Procompose (Kleisli f') (Kleisli g') d' c') (Kleisli (Compose g f) d c) (Kleisli (Compose g' f') d' c')

- Rebase.Prelude: last :: () => [a] -> a

+ Rebase.Prelude: last :: [a] -> a

- Rebase.Prelude: lazy :: () => a -> a

+ Rebase.Prelude: lazy :: a -> a

- Rebase.Prelude: leftToMaybe :: () => Either a b -> Maybe a

+ Rebase.Prelude: leftToMaybe :: Either a b -> Maybe a

- Rebase.Prelude: lefts :: () => [Either a b] -> [a]

+ Rebase.Prelude: lefts :: [Either a b] -> [a]

- Rebase.Prelude: lengthTBQueue :: () => TBQueue a -> STM Natural

+ Rebase.Prelude: lengthTBQueue :: TBQueue a -> STM Natural

- Rebase.Prelude: liftCallCC :: () => CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b

+ Rebase.Prelude: liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b

- Rebase.Prelude: liftCatch :: () => Catch e m (Maybe a) -> Catch e (MaybeT m) a

+ Rebase.Prelude: liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a

- Rebase.Prelude: listToMaybe :: () => [a] -> Maybe a

+ Rebase.Prelude: listToMaybe :: [a] -> Maybe a

- Rebase.Prelude: makeStableName :: () => a -> IO (StableName a)

+ Rebase.Prelude: makeStableName :: a -> IO (StableName a)

- Rebase.Prelude: mallocForeignPtrBytes :: () => Int -> IO (ForeignPtr a)

+ Rebase.Prelude: mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)

- Rebase.Prelude: map :: () => (a -> b) -> [a] -> [b]

+ Rebase.Prelude: map :: (a -> b) -> [a] -> [b]

- Rebase.Prelude: mapBoth :: () => (a -> c) -> (b -> d) -> Either a b -> Either c d

+ Rebase.Prelude: mapBoth :: (a -> c) -> (b -> d) -> Either a b -> Either c d

- Rebase.Prelude: mapCayley :: () => (forall (a :: k3). () => f a -> g a) -> Cayley f p x y -> Cayley g p x y

+ Rebase.Prelude: mapCayley :: forall k1 k2 k3 f g (p :: k2 -> k3 -> k1) (x :: k2) (y :: k3). (forall (a :: k1). () => f a -> g a) -> Cayley f p x y -> Cayley g p x y

- Rebase.Prelude: mapCont :: () => (r -> r) -> Cont r a -> Cont r a

+ Rebase.Prelude: mapCont :: (r -> r) -> Cont r a -> Cont r a

- Rebase.Prelude: mapContT :: () => (m r -> m r) -> ContT r m a -> ContT r m a

+ Rebase.Prelude: mapContT :: forall k m (r :: k) a. (m r -> m r) -> ContT r m a -> ContT r m a

- Rebase.Prelude: mapExcept :: () => (Either e a -> Either e' b) -> Except e a -> Except e' b

+ Rebase.Prelude: mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b

- Rebase.Prelude: mapExceptT :: () => (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

+ Rebase.Prelude: mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

- Rebase.Prelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]

+ Rebase.Prelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]

- Rebase.Prelude: mapMaybeT :: () => (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

+ Rebase.Prelude: mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

- Rebase.Prelude: mapReader :: () => (a -> b) -> Reader r a -> Reader r b

+ Rebase.Prelude: mapReader :: (a -> b) -> Reader r a -> Reader r b

- Rebase.Prelude: mapReaderT :: () => (m a -> n b) -> ReaderT r m a -> ReaderT r n b

+ Rebase.Prelude: mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

- Rebase.Prelude: mapState :: () => ((a, s) -> (b, s)) -> State s a -> State s b

+ Rebase.Prelude: mapState :: ((a, s) -> (b, s)) -> State s a -> State s b

- Rebase.Prelude: mapStateT :: () => (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

+ Rebase.Prelude: mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

- Rebase.Prelude: mapWriter :: () => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

+ Rebase.Prelude: mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

- Rebase.Prelude: mapWriterT :: () => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

+ Rebase.Prelude: mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

- Rebase.Prelude: mask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b

+ Rebase.Prelude: mask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b

- Rebase.Prelude: mask_ :: () => IO a -> IO a

+ Rebase.Prelude: mask_ :: IO a -> IO a

- Rebase.Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b

+ Rebase.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b

- Rebase.Prelude: maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a

+ Rebase.Prelude: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a

- Rebase.Prelude: maybeToLeft :: () => b -> Maybe a -> Either a b

+ Rebase.Prelude: maybeToLeft :: b -> Maybe a -> Either a b

- Rebase.Prelude: maybeToList :: () => Maybe a -> [a]

+ Rebase.Prelude: maybeToList :: Maybe a -> [a]

- Rebase.Prelude: maybeToRight :: () => b -> Maybe a -> Either b a

+ Rebase.Prelude: maybeToRight :: b -> Maybe a -> Either b a

- Rebase.Prelude: minusPtr :: () => Ptr a -> Ptr b -> Int

+ Rebase.Prelude: minusPtr :: Ptr a -> Ptr b -> Int

- Rebase.Prelude: mkWeakIORef :: () => IORef a -> IO () -> IO (Weak (IORef a))

+ Rebase.Prelude: mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))

- Rebase.Prelude: mkWeakMVar :: () => MVar a -> IO () -> IO (Weak (MVar a))

+ Rebase.Prelude: mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))

- Rebase.Prelude: mkWeakTMVar :: () => TMVar a -> IO () -> IO (Weak (TMVar a))

+ Rebase.Prelude: mkWeakTMVar :: TMVar a -> IO () -> IO (Weak (TMVar a))

- Rebase.Prelude: mkWeakTVar :: () => TVar a -> IO () -> IO (Weak (TVar a))

+ Rebase.Prelude: mkWeakTVar :: TVar a -> IO () -> IO (Weak (TVar a))

- Rebase.Prelude: modifyIOError :: () => (IOError -> IOError) -> IO a -> IO a

+ Rebase.Prelude: modifyIOError :: (IOError -> IOError) -> IO a -> IO a

- Rebase.Prelude: modifyIORef :: () => IORef a -> (a -> a) -> IO ()

+ Rebase.Prelude: modifyIORef :: IORef a -> (a -> a) -> IO ()

- Rebase.Prelude: modifyIORef' :: () => IORef a -> (a -> a) -> IO ()

+ Rebase.Prelude: modifyIORef' :: IORef a -> (a -> a) -> IO ()

- Rebase.Prelude: modifyMVar :: () => MVar a -> (a -> IO (a, b)) -> IO b

+ Rebase.Prelude: modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b

- Rebase.Prelude: modifyMVarMasked :: () => MVar a -> (a -> IO (a, b)) -> IO b

+ Rebase.Prelude: modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b

- Rebase.Prelude: modifyMVarMasked_ :: () => MVar a -> (a -> IO a) -> IO ()

+ Rebase.Prelude: modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()

- Rebase.Prelude: modifyMVar_ :: () => MVar a -> (a -> IO a) -> IO ()

+ Rebase.Prelude: modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()

- Rebase.Prelude: modifySTRef :: () => STRef s a -> (a -> a) -> ST s ()

+ Rebase.Prelude: modifySTRef :: STRef s a -> (a -> a) -> ST s ()

- Rebase.Prelude: modifySTRef' :: () => STRef s a -> (a -> a) -> ST s ()

+ Rebase.Prelude: modifySTRef' :: STRef s a -> (a -> a) -> ST s ()

- Rebase.Prelude: modifyTVar :: () => TVar a -> (a -> a) -> STM ()

+ Rebase.Prelude: modifyTVar :: TVar a -> (a -> a) -> STM ()

- Rebase.Prelude: modifyTVar' :: () => TVar a -> (a -> a) -> STM ()

+ Rebase.Prelude: modifyTVar' :: TVar a -> (a -> a) -> STM ()

- Rebase.Prelude: mu :: Category p => Procompose p p :-> p

+ Rebase.Prelude: mu :: forall k (p :: k -> k -> Type). Category p => Procompose p p :-> p

- Rebase.Prelude: newBroadcastTChan :: () => STM (TChan a)

+ Rebase.Prelude: newBroadcastTChan :: STM (TChan a)

- Rebase.Prelude: newBroadcastTChanIO :: () => IO (TChan a)

+ Rebase.Prelude: newBroadcastTChanIO :: IO (TChan a)

- Rebase.Prelude: newChan :: () => IO (Chan a)

+ Rebase.Prelude: newChan :: IO (Chan a)

- Rebase.Prelude: newEmptyMVar :: () => IO (MVar a)

+ Rebase.Prelude: newEmptyMVar :: IO (MVar a)

- Rebase.Prelude: newEmptyTMVar :: () => STM (TMVar a)

+ Rebase.Prelude: newEmptyTMVar :: STM (TMVar a)

- Rebase.Prelude: newEmptyTMVarIO :: () => IO (TMVar a)

+ Rebase.Prelude: newEmptyTMVarIO :: IO (TMVar a)

- Rebase.Prelude: newForeignPtr :: () => FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)

+ Rebase.Prelude: newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)

- Rebase.Prelude: newForeignPtrEnv :: () => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)

+ Rebase.Prelude: newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)

- Rebase.Prelude: newForeignPtr_ :: () => Ptr a -> IO (ForeignPtr a)

+ Rebase.Prelude: newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)

- Rebase.Prelude: newIORef :: () => a -> IO (IORef a)

+ Rebase.Prelude: newIORef :: a -> IO (IORef a)

- Rebase.Prelude: newMVar :: () => a -> IO (MVar a)

+ Rebase.Prelude: newMVar :: a -> IO (MVar a)

- Rebase.Prelude: newSTRef :: () => a -> ST s (STRef s a)

+ Rebase.Prelude: newSTRef :: a -> ST s (STRef s a)

- Rebase.Prelude: newStablePtr :: () => a -> IO (StablePtr a)

+ Rebase.Prelude: newStablePtr :: a -> IO (StablePtr a)

- Rebase.Prelude: newTBQueue :: () => Natural -> STM (TBQueue a)

+ Rebase.Prelude: newTBQueue :: Natural -> STM (TBQueue a)

- Rebase.Prelude: newTBQueueIO :: () => Natural -> IO (TBQueue a)

+ Rebase.Prelude: newTBQueueIO :: Natural -> IO (TBQueue a)

- Rebase.Prelude: newTChan :: () => STM (TChan a)

+ Rebase.Prelude: newTChan :: STM (TChan a)

- Rebase.Prelude: newTChanIO :: () => IO (TChan a)

+ Rebase.Prelude: newTChanIO :: IO (TChan a)

- Rebase.Prelude: newTMVar :: () => a -> STM (TMVar a)

+ Rebase.Prelude: newTMVar :: a -> STM (TMVar a)

- Rebase.Prelude: newTMVarIO :: () => a -> IO (TMVar a)

+ Rebase.Prelude: newTMVarIO :: a -> IO (TMVar a)

- Rebase.Prelude: newTQueue :: () => STM (TQueue a)

+ Rebase.Prelude: newTQueue :: STM (TQueue a)

- Rebase.Prelude: newTQueueIO :: () => IO (TQueue a)

+ Rebase.Prelude: newTQueueIO :: IO (TQueue a)

- Rebase.Prelude: newTVar :: () => a -> STM (TVar a)

+ Rebase.Prelude: newTVar :: a -> STM (TVar a)

- Rebase.Prelude: newTVarIO :: () => a -> IO (TVar a)

+ Rebase.Prelude: newTVarIO :: a -> IO (TVar a)

- Rebase.Prelude: newtype Fixed a

+ Rebase.Prelude: newtype Fixed (a :: k)

- Rebase.Prelude: nubBy :: () => (a -> a -> Bool) -> [a] -> [a]

+ Rebase.Prelude: nubBy :: (a -> a -> Bool) -> [a] -> [a]

- Rebase.Prelude: nullFunPtr :: () => FunPtr a

+ Rebase.Prelude: nullFunPtr :: FunPtr a

- Rebase.Prelude: nullPtr :: () => Ptr a

+ Rebase.Prelude: nullPtr :: Ptr a

- Rebase.Prelude: numerator :: () => Ratio a -> a

+ Rebase.Prelude: numerator :: Ratio a -> a

- Rebase.Prelude: o :: Semigroupoid c => c j k1 -> c i j -> c i k1

+ Rebase.Prelude: o :: forall (j :: k) (k1 :: k) (i :: k). Semigroupoid c => c j k1 -> c i j -> c i k1

- Rebase.Prelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c

+ Rebase.Prelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

- Rebase.Prelude: onException :: () => IO a -> IO b -> IO a

+ Rebase.Prelude: onException :: IO a -> IO b -> IO a

- Rebase.Prelude: option :: () => b -> (a -> b) -> Option a -> b

+ Rebase.Prelude: option :: b -> (a -> b) -> Option a -> b

- Rebase.Prelude: par :: () => a -> b -> b

+ Rebase.Prelude: par :: a -> b -> b

- Rebase.Prelude: partition :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Rebase.Prelude: partition :: (a -> Bool) -> [a] -> ([a], [a])

- Rebase.Prelude: partitionEithers :: () => [Either a b] -> ([a], [b])

+ Rebase.Prelude: partitionEithers :: [Either a b] -> ([a], [b])

- Rebase.Prelude: pastro :: Strong q => (p :-> q) -> Pastro p :-> q

+ Rebase.Prelude: pastro :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Strong q => (p :-> q) -> Pastro p :-> q

- Rebase.Prelude: peekTBQueue :: () => TBQueue a -> STM a

+ Rebase.Prelude: peekTBQueue :: TBQueue a -> STM a

- Rebase.Prelude: peekTChan :: () => TChan a -> STM a

+ Rebase.Prelude: peekTChan :: TChan a -> STM a

- Rebase.Prelude: peekTQueue :: () => TQueue a -> STM a

+ Rebase.Prelude: peekTQueue :: TQueue a -> STM a

- Rebase.Prelude: permutations :: () => [a] -> [[a]]

+ Rebase.Prelude: permutations :: [a] -> [[a]]

- Rebase.Prelude: plusForeignPtr :: () => ForeignPtr a -> Int -> ForeignPtr b

+ Rebase.Prelude: plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b

- Rebase.Prelude: plusPtr :: () => Ptr a -> Int -> Ptr b

+ Rebase.Prelude: plusPtr :: Ptr a -> Int -> Ptr b

- Rebase.Prelude: precomposeRan :: Profunctor q => Procompose q (Ran p ((->) :: Type -> Type -> Type)) :-> Ran p q

+ Rebase.Prelude: precomposeRan :: forall k (q :: Type -> Type -> Type) (p :: Type -> k -> Type). Profunctor q => Procompose q (Ran p ((->) :: Type -> Type -> Type)) :-> Ran p q

- Rebase.Prelude: prepAdj :: () => (forall (a :: k). () => Prep p a -> g a) -> p :-> Star g

+ Rebase.Prelude: prepAdj :: forall k (p :: Type -> k -> Type) g. (forall (a :: k). () => Prep p a -> g a) -> p :-> Star g

- Rebase.Prelude: prepCounit :: () => Prep (Star f) a -> f a

+ Rebase.Prelude: prepCounit :: forall k f (a :: k). Prep (Star f) a -> f a

- Rebase.Prelude: prepUnit :: () => p :-> Star (Prep p)

+ Rebase.Prelude: prepUnit :: forall k (p :: Type -> k -> Type). p :-> Star (Prep p)

- Rebase.Prelude: procomposed :: Category p => Procompose p p a b -> p a b

+ Rebase.Prelude: procomposed :: forall k p (a :: k) (b :: k). Category p => Procompose p p a b -> p a b

- Rebase.Prelude: produplicate :: (ProfunctorComonad t, Profunctor p) => t p :-> t (t p)

+ Rebase.Prelude: produplicate :: forall (p :: Type -> Type -> Type). (ProfunctorComonad t, Profunctor p) => t p :-> t (t p)

- Rebase.Prelude: proextract :: (ProfunctorComonad t, Profunctor p) => t p :-> p

+ Rebase.Prelude: proextract :: forall (p :: Type -> Type -> Type). (ProfunctorComonad t, Profunctor p) => t p :-> p

- Rebase.Prelude: projoin :: (ProfunctorMonad t, Profunctor p) => t (t p) :-> t p

+ Rebase.Prelude: projoin :: forall (p :: Type -> Type -> Type). (ProfunctorMonad t, Profunctor p) => t (t p) :-> t p

- Rebase.Prelude: promap :: (ProfunctorFunctor t, Profunctor p) => (p :-> q) -> t p :-> t q

+ Rebase.Prelude: promap :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). (ProfunctorFunctor t, Profunctor p) => (p :-> q) -> t p :-> t q

- Rebase.Prelude: proreturn :: (ProfunctorMonad t, Profunctor p) => p :-> t p

+ Rebase.Prelude: proreturn :: forall (p :: Type -> Type -> Type). (ProfunctorMonad t, Profunctor p) => p :-> t p

- Rebase.Prelude: pseq :: () => a -> b -> b

+ Rebase.Prelude: pseq :: a -> b -> b

- Rebase.Prelude: ptrToIntPtr :: () => Ptr a -> IntPtr

+ Rebase.Prelude: ptrToIntPtr :: Ptr a -> IntPtr

- Rebase.Prelude: ptrToWordPtr :: () => Ptr a -> WordPtr

+ Rebase.Prelude: ptrToWordPtr :: Ptr a -> WordPtr

- Rebase.Prelude: putMVar :: () => MVar a -> a -> IO ()

+ Rebase.Prelude: putMVar :: MVar a -> a -> IO ()

- Rebase.Prelude: putTMVar :: () => TMVar a -> a -> STM ()

+ Rebase.Prelude: putTMVar :: TMVar a -> a -> STM ()

- Rebase.Prelude: readBinaryWith :: () => ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t

+ Rebase.Prelude: readBinaryWith :: ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t

- Rebase.Prelude: readChan :: () => Chan a -> IO a

+ Rebase.Prelude: readChan :: Chan a -> IO a

- Rebase.Prelude: readData :: () => ReadPrec a -> ReadPrec a

+ Rebase.Prelude: readData :: ReadPrec a -> ReadPrec a

- Rebase.Prelude: readIORef :: () => IORef a -> IO a

+ Rebase.Prelude: readIORef :: IORef a -> IO a

- Rebase.Prelude: readMVar :: () => MVar a -> IO a

+ Rebase.Prelude: readMVar :: MVar a -> IO a

- Rebase.Prelude: readP_to_Prec :: () => (Int -> ReadP a) -> ReadPrec a

+ Rebase.Prelude: readP_to_Prec :: (Int -> ReadP a) -> ReadPrec a

- Rebase.Prelude: readP_to_S :: () => ReadP a -> ReadS a

+ Rebase.Prelude: readP_to_S :: ReadP a -> ReadS a

- Rebase.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a

+ Rebase.Prelude: readParen :: Bool -> ReadS a -> ReadS a

- Rebase.Prelude: readPrec_to_P :: () => ReadPrec a -> Int -> ReadP a

+ Rebase.Prelude: readPrec_to_P :: ReadPrec a -> Int -> ReadP a

- Rebase.Prelude: readPrec_to_S :: () => ReadPrec a -> Int -> ReadS a

+ Rebase.Prelude: readPrec_to_S :: ReadPrec a -> Int -> ReadS a

- Rebase.Prelude: readSTRef :: () => STRef s a -> ST s a

+ Rebase.Prelude: readSTRef :: STRef s a -> ST s a

- Rebase.Prelude: readS_to_P :: () => ReadS a -> ReadP a

+ Rebase.Prelude: readS_to_P :: ReadS a -> ReadP a

- Rebase.Prelude: readS_to_Prec :: () => (Int -> ReadS a) -> ReadPrec a

+ Rebase.Prelude: readS_to_Prec :: (Int -> ReadS a) -> ReadPrec a

- Rebase.Prelude: readTBQueue :: () => TBQueue a -> STM a

+ Rebase.Prelude: readTBQueue :: TBQueue a -> STM a

- Rebase.Prelude: readTChan :: () => TChan a -> STM a

+ Rebase.Prelude: readTChan :: TChan a -> STM a

- Rebase.Prelude: readTMVar :: () => TMVar a -> STM a

+ Rebase.Prelude: readTMVar :: TMVar a -> STM a

- Rebase.Prelude: readTQueue :: () => TQueue a -> STM a

+ Rebase.Prelude: readTQueue :: TQueue a -> STM a

- Rebase.Prelude: readTVar :: () => TVar a -> STM a

+ Rebase.Prelude: readTVar :: TVar a -> STM a

- Rebase.Prelude: readTVarIO :: () => TVar a -> IO a

+ Rebase.Prelude: readTVarIO :: TVar a -> IO a

- Rebase.Prelude: readUnaryWith :: () => ReadPrec a -> String -> (a -> t) -> ReadPrec t

+ Rebase.Prelude: readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t

- Rebase.Prelude: readsBinaryWith :: () => (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t

+ Rebase.Prelude: readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t

- Rebase.Prelude: readsData :: () => (String -> ReadS a) -> Int -> ReadS a

+ Rebase.Prelude: readsData :: (String -> ReadS a) -> Int -> ReadS a

- Rebase.Prelude: readsUnaryWith :: () => (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t

+ Rebase.Prelude: readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t

- Rebase.Prelude: realPart :: () => Complex a -> a

+ Rebase.Prelude: realPart :: Complex a -> a

- Rebase.Prelude: repeat :: () => a -> [a]

+ Rebase.Prelude: repeat :: a -> [a]

- Rebase.Prelude: replicate :: () => Int -> a -> [a]

+ Rebase.Prelude: replicate :: Int -> a -> [a]

- Rebase.Prelude: reset :: () => Cont r r -> Cont r' r

+ Rebase.Prelude: reset :: Cont r r -> Cont r' r

- Rebase.Prelude: resetT :: Monad m => ContT r m r -> ContT r' m r

+ Rebase.Prelude: resetT :: forall (m :: Type -> Type) r r'. Monad m => ContT r m r -> ContT r' m r

- Rebase.Prelude: retry :: () => STM a

+ Rebase.Prelude: retry :: STM a

- Rebase.Prelude: returnCoyoneda :: () => p a b -> Coyoneda p a b

+ Rebase.Prelude: returnCoyoneda :: p a b -> Coyoneda p a b

- Rebase.Prelude: reverse :: () => [a] -> [a]

+ Rebase.Prelude: reverse :: [a] -> [a]

- Rebase.Prelude: rightToMaybe :: () => Either a b -> Maybe b

+ Rebase.Prelude: rightToMaybe :: Either a b -> Maybe b

- Rebase.Prelude: rights :: () => [Either a b] -> [b]

+ Rebase.Prelude: rights :: [Either a b] -> [b]

- Rebase.Prelude: runCont :: () => Cont r a -> (a -> r) -> r

+ Rebase.Prelude: runCont :: Cont r a -> (a -> r) -> r

- Rebase.Prelude: runExcept :: () => Except e a -> Either e a

+ Rebase.Prelude: runExcept :: Except e a -> Either e a

- Rebase.Prelude: runExceptT :: () => ExceptT e m a -> m (Either e a)

+ Rebase.Prelude: runExceptT :: ExceptT e m a -> m (Either e a)

- Rebase.Prelude: runInBoundThread :: () => IO a -> IO a

+ Rebase.Prelude: runInBoundThread :: IO a -> IO a

- Rebase.Prelude: runInUnboundThread :: () => IO a -> IO a

+ Rebase.Prelude: runInUnboundThread :: IO a -> IO a

- Rebase.Prelude: runReader :: () => Reader r a -> r -> a

+ Rebase.Prelude: runReader :: Reader r a -> r -> a

- Rebase.Prelude: runST :: () => (forall s. () => ST s a) -> a

+ Rebase.Prelude: runST :: (forall s. () => ST s a) -> a

- Rebase.Prelude: runState :: () => State s a -> s -> (a, s)

+ Rebase.Prelude: runState :: State s a -> s -> (a, s)

- Rebase.Prelude: runWriter :: () => Writer w a -> (a, w)

+ Rebase.Prelude: runWriter :: Writer w a -> (a, w)

- Rebase.Prelude: rwhnf :: () => a -> ()

+ Rebase.Prelude: rwhnf :: a -> ()

- Rebase.Prelude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]

+ Rebase.Prelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]

- Rebase.Prelude: scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]

+ Rebase.Prelude: scanl' :: (b -> a -> b) -> b -> [a] -> [b]

- Rebase.Prelude: scanl1 :: () => (a -> a -> a) -> [a] -> [a]

+ Rebase.Prelude: scanl1 :: (a -> a -> a) -> [a] -> [a]

- Rebase.Prelude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]

+ Rebase.Prelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]

- Rebase.Prelude: scanr1 :: () => (a -> a -> a) -> [a] -> [a]

+ Rebase.Prelude: scanr1 :: (a -> a -> a) -> [a] -> [a]

- Rebase.Prelude: seq :: () => a -> b -> b

+ Rebase.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b

- Rebase.Prelude: showFixed :: HasResolution a => Bool -> Fixed a -> String

+ Rebase.Prelude: showFixed :: forall k (a :: k). HasResolution a => Bool -> Fixed a -> String

- Rebase.Prelude: showsBinaryWith :: () => (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS

+ Rebase.Prelude: showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS

- Rebase.Prelude: showsUnaryWith :: () => (Int -> a -> ShowS) -> String -> Int -> a -> ShowS

+ Rebase.Prelude: showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS

- Rebase.Prelude: snd :: () => (a, b) -> b

+ Rebase.Prelude: snd :: (a, b) -> b

- Rebase.Prelude: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]

+ Rebase.Prelude: sortBy :: (a -> a -> Ordering) -> [a] -> [a]

- Rebase.Prelude: span :: () => (a -> Bool) -> [a] -> ([a], [a])

+ Rebase.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])

- Rebase.Prelude: splitAt :: () => Int -> [a] -> ([a], [a])

+ Rebase.Prelude: splitAt :: Int -> [a] -> ([a], [a])

- Rebase.Prelude: stToIO :: () => ST RealWorld a -> IO a

+ Rebase.Prelude: stToIO :: ST RealWorld a -> IO a

- Rebase.Prelude: stars :: Functor g => Iso (Procompose (Star f) (Star g) d c) (Procompose (Star f') (Star g') d' c') (Star (Compose g f) d c) (Star (Compose g' f') d' c')

+ Rebase.Prelude: stars :: forall k1 k2 (g :: Type -> Type) (f :: k1 -> Type) d (c :: k1) (f' :: k2 -> Type) (g' :: Type -> Type) d' (c' :: k2). Functor g => Iso (Procompose (Star f) (Star g) d c) (Procompose (Star f') (Star g') d' c') (Star (Compose g f) d c) (Star (Compose g' f') d' c')

- Rebase.Prelude: stateTVar :: () => TVar s -> (s -> (a, s)) -> STM a

+ Rebase.Prelude: stateTVar :: TVar s -> (s -> (a, s)) -> STM a

- Rebase.Prelude: subsequences :: () => [a] -> [[a]]

+ Rebase.Prelude: subsequences :: [a] -> [[a]]

- Rebase.Prelude: swap :: () => (a, b) -> (b, a)

+ Rebase.Prelude: swap :: (a, b) -> (b, a)

- Rebase.Prelude: swapEither :: () => Either e a -> Either a e

+ Rebase.Prelude: swapEither :: Either e a -> Either a e

- Rebase.Prelude: swapMVar :: () => MVar a -> a -> IO a

+ Rebase.Prelude: swapMVar :: MVar a -> a -> IO a

- Rebase.Prelude: swapTMVar :: () => TMVar a -> a -> STM a

+ Rebase.Prelude: swapTMVar :: TMVar a -> a -> STM a

- Rebase.Prelude: swapTVar :: () => TVar a -> a -> STM a

+ Rebase.Prelude: swapTVar :: TVar a -> a -> STM a

- Rebase.Prelude: tabulated :: (Representable p, Representable q) => Iso (d -> Rep p c) (d' -> Rep q c') (p d c) (q d' c')

+ Rebase.Prelude: tabulated :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) d c d' c'. (Representable p, Representable q) => Iso (d -> Rep p c) (d' -> Rep q c') (p d c) (q d' c')

- Rebase.Prelude: tail :: () => [a] -> [a]

+ Rebase.Prelude: tail :: [a] -> [a]

- Rebase.Prelude: tails :: () => [a] -> [[a]]

+ Rebase.Prelude: tails :: [a] -> [[a]]

- Rebase.Prelude: take :: () => Int -> [a] -> [a]

+ Rebase.Prelude: take :: Int -> [a] -> [a]

- Rebase.Prelude: takeMVar :: () => MVar a -> IO a

+ Rebase.Prelude: takeMVar :: MVar a -> IO a

- Rebase.Prelude: takeTMVar :: () => TMVar a -> STM a

+ Rebase.Prelude: takeTMVar :: TMVar a -> STM a

- Rebase.Prelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]

+ Rebase.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]

- Rebase.Prelude: tambara :: Strong p => (p :-> q) -> p :-> Tambara q

+ Rebase.Prelude: tambara :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Strong p => (p :-> q) -> p :-> Tambara q

- Rebase.Prelude: tambaraSum :: Choice p => (p :-> q) -> p :-> TambaraSum q

+ Rebase.Prelude: tambaraSum :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Choice p => (p :-> q) -> p :-> TambaraSum q

- Rebase.Prelude: throw :: Exception e => e -> a

+ Rebase.Prelude: throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a

- Rebase.Prelude: timeout :: () => Int -> IO a -> IO (Maybe a)

+ Rebase.Prelude: timeout :: Int -> IO a -> IO (Maybe a)

- Rebase.Prelude: touchForeignPtr :: () => ForeignPtr a -> IO ()

+ Rebase.Prelude: touchForeignPtr :: ForeignPtr a -> IO ()

- Rebase.Prelude: trace :: () => String -> a -> a

+ Rebase.Prelude: trace :: String -> a -> a

- Rebase.Prelude: traceEvent :: () => String -> a -> a

+ Rebase.Prelude: traceEvent :: String -> a -> a

- Rebase.Prelude: traceMarker :: () => String -> a -> a

+ Rebase.Prelude: traceMarker :: String -> a -> a

- Rebase.Prelude: traceStack :: () => String -> a -> a

+ Rebase.Prelude: traceStack :: String -> a -> a

- Rebase.Prelude: transpose :: () => [[a]] -> [[a]]

+ Rebase.Prelude: transpose :: [[a]] -> [[a]]

- Rebase.Prelude: tryIOError :: () => IO a -> IO (Either IOError a)

+ Rebase.Prelude: tryIOError :: IO a -> IO (Either IOError a)

- Rebase.Prelude: tryPeekTBQueue :: () => TBQueue a -> STM (Maybe a)

+ Rebase.Prelude: tryPeekTBQueue :: TBQueue a -> STM (Maybe a)

- Rebase.Prelude: tryPeekTChan :: () => TChan a -> STM (Maybe a)

+ Rebase.Prelude: tryPeekTChan :: TChan a -> STM (Maybe a)

- Rebase.Prelude: tryPeekTQueue :: () => TQueue a -> STM (Maybe a)

+ Rebase.Prelude: tryPeekTQueue :: TQueue a -> STM (Maybe a)

- Rebase.Prelude: tryPutMVar :: () => MVar a -> a -> IO Bool

+ Rebase.Prelude: tryPutMVar :: MVar a -> a -> IO Bool

- Rebase.Prelude: tryPutTMVar :: () => TMVar a -> a -> STM Bool

+ Rebase.Prelude: tryPutTMVar :: TMVar a -> a -> STM Bool

- Rebase.Prelude: tryReadMVar :: () => MVar a -> IO (Maybe a)

+ Rebase.Prelude: tryReadMVar :: MVar a -> IO (Maybe a)

- Rebase.Prelude: tryReadTBQueue :: () => TBQueue a -> STM (Maybe a)

+ Rebase.Prelude: tryReadTBQueue :: TBQueue a -> STM (Maybe a)

- Rebase.Prelude: tryReadTChan :: () => TChan a -> STM (Maybe a)

+ Rebase.Prelude: tryReadTChan :: TChan a -> STM (Maybe a)

- Rebase.Prelude: tryReadTMVar :: () => TMVar a -> STM (Maybe a)

+ Rebase.Prelude: tryReadTMVar :: TMVar a -> STM (Maybe a)

- Rebase.Prelude: tryReadTQueue :: () => TQueue a -> STM (Maybe a)

+ Rebase.Prelude: tryReadTQueue :: TQueue a -> STM (Maybe a)

- Rebase.Prelude: tryTakeMVar :: () => MVar a -> IO (Maybe a)

+ Rebase.Prelude: tryTakeMVar :: MVar a -> IO (Maybe a)

- Rebase.Prelude: tryTakeTMVar :: () => TMVar a -> STM (Maybe a)

+ Rebase.Prelude: tryTakeTMVar :: TMVar a -> STM (Maybe a)

- Rebase.Prelude: type (:->) (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). () => p a b -> q a b

+ Rebase.Prelude: type (p :: k -> k1 -> Type) :-> (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). () => p a b -> q a b

- Rebase.Prelude: typeRep :: Typeable a => proxy a -> TypeRep

+ Rebase.Prelude: typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep

- Rebase.Prelude: unGetTBQueue :: () => TBQueue a -> a -> STM ()

+ Rebase.Prelude: unGetTBQueue :: TBQueue a -> a -> STM ()

- Rebase.Prelude: unGetTChan :: () => TChan a -> a -> STM ()

+ Rebase.Prelude: unGetTChan :: TChan a -> a -> STM ()

- Rebase.Prelude: unGetTQueue :: () => TQueue a -> a -> STM ()

+ Rebase.Prelude: unGetTQueue :: TQueue a -> a -> STM ()

- Rebase.Prelude: unclose :: Profunctor q => (p :-> Closure q) -> p :-> q

+ Rebase.Prelude: unclose :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Closure q) -> p :-> q

- Rebase.Prelude: uncons :: () => [a] -> Maybe (a, [a])

+ Rebase.Prelude: uncons :: [a] -> Maybe (a, [a])

- Rebase.Prelude: uncoprepAdj :: () => (p :-> Costar f) -> f a -> Coprep p a

+ Rebase.Prelude: uncoprepAdj :: forall k (p :: k -> Type -> Type) f (a :: k). (p :-> Costar f) -> f a -> Coprep p a

- Rebase.Prelude: uncotambara :: Profunctor q => (p :-> Cotambara q) -> p :-> q

+ Rebase.Prelude: uncotambara :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Cotambara q) -> p :-> q

- Rebase.Prelude: uncotambaraSum :: Profunctor q => (p :-> CotambaraSum q) -> p :-> q

+ Rebase.Prelude: uncotambaraSum :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> CotambaraSum q) -> p :-> q

- Rebase.Prelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c

+ Rebase.Prelude: uncurry :: (a -> b -> c) -> (a, b) -> c

- Rebase.Prelude: uncurryRan :: () => (p :-> Ran q r) -> Procompose p q :-> r

+ Rebase.Prelude: uncurryRan :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k3 -> k2 -> Type). (p :-> Ran q r) -> Procompose p q :-> r

- Rebase.Prelude: undefined :: HasCallStack => a

+ Rebase.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

- Rebase.Prelude: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]

+ Rebase.Prelude: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

- Rebase.Prelude: unhashed :: () => Hashed a -> a

+ Rebase.Prelude: unhashed :: Hashed a -> a

- Rebase.Prelude: uninterruptibleMask :: () => ((forall a. () => IO a -> IO a) -> IO b) -> IO b

+ Rebase.Prelude: uninterruptibleMask :: ((forall a. () => IO a -> IO a) -> IO b) -> IO b

- Rebase.Prelude: uninterruptibleMask_ :: () => IO a -> IO a

+ Rebase.Prelude: uninterruptibleMask_ :: IO a -> IO a

- Rebase.Prelude: unionBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]

+ Rebase.Prelude: unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

- Rebase.Prelude: unit :: (ProfunctorAdjunction f u, Profunctor p) => p :-> u (f p)

+ Rebase.Prelude: unit :: forall (p :: Type -> Type -> Type). (ProfunctorAdjunction f u, Profunctor p) => p :-> u (f p)

- Rebase.Prelude: unpastro :: () => (Pastro p :-> q) -> p :-> q

+ Rebase.Prelude: unpastro :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). (Pastro p :-> q) -> p :-> q

- Rebase.Prelude: unprepAdj :: () => (p :-> Star g) -> Prep p a -> g a

+ Rebase.Prelude: unprepAdj :: forall k (p :: Type -> k -> Type) g (a :: k). (p :-> Star g) -> Prep p a -> g a

- Rebase.Prelude: unsafeCoerce :: () => a -> b

+ Rebase.Prelude: unsafeCoerce :: a -> b

- Rebase.Prelude: unsafeDupablePerformIO :: () => IO a -> a

+ Rebase.Prelude: unsafeDupablePerformIO :: IO a -> a

- Rebase.Prelude: unsafeFixIO :: () => (a -> IO a) -> IO a

+ Rebase.Prelude: unsafeFixIO :: (a -> IO a) -> IO a

- Rebase.Prelude: unsafeIOToSTM :: () => IO a -> STM a

+ Rebase.Prelude: unsafeIOToSTM :: IO a -> STM a

- Rebase.Prelude: unsafeInterleaveIO :: () => IO a -> IO a

+ Rebase.Prelude: unsafeInterleaveIO :: IO a -> IO a

- Rebase.Prelude: unsafePerformIO :: () => IO a -> a

+ Rebase.Prelude: unsafePerformIO :: IO a -> a

- Rebase.Prelude: untambara :: Profunctor q => (p :-> Tambara q) -> p :-> q

+ Rebase.Prelude: untambara :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Tambara q) -> p :-> q

- Rebase.Prelude: untambaraSum :: Profunctor q => (p :-> TambaraSum q) -> p :-> q

+ Rebase.Prelude: untambaraSum :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> TambaraSum q) -> p :-> q

- Rebase.Prelude: until :: () => (a -> Bool) -> (a -> a) -> a -> a

+ Rebase.Prelude: until :: (a -> Bool) -> (a -> a) -> a -> a

- Rebase.Prelude: unzip :: () => [(a, b)] -> ([a], [b])

+ Rebase.Prelude: unzip :: [(a, b)] -> ([a], [b])

- Rebase.Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])

+ Rebase.Prelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])

- Rebase.Prelude: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])

+ Rebase.Prelude: unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])

- Rebase.Prelude: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])

+ Rebase.Prelude: unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])

- Rebase.Prelude: unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])

+ Rebase.Prelude: unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])

- Rebase.Prelude: unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])

+ Rebase.Prelude: unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])

- Rebase.Prelude: withArgs :: () => [String] -> IO a -> IO a

+ Rebase.Prelude: withArgs :: [String] -> IO a -> IO a

- Rebase.Prelude: withCont :: () => ((b -> r) -> a -> r) -> Cont r a -> Cont r b

+ Rebase.Prelude: withCont :: ((b -> r) -> a -> r) -> Cont r a -> Cont r b

- Rebase.Prelude: withContT :: () => ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b

+ Rebase.Prelude: withContT :: forall k b m (r :: k) a. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b

- Rebase.Prelude: withExcept :: () => (e -> e') -> Except e a -> Except e' a

+ Rebase.Prelude: withExcept :: (e -> e') -> Except e a -> Except e' a

- Rebase.Prelude: withExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

+ Rebase.Prelude: withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

- Rebase.Prelude: withForeignPtr :: () => ForeignPtr a -> (Ptr a -> IO b) -> IO b

+ Rebase.Prelude: withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b

- Rebase.Prelude: withMVar :: () => MVar a -> (a -> IO b) -> IO b

+ Rebase.Prelude: withMVar :: MVar a -> (a -> IO b) -> IO b

- Rebase.Prelude: withMVarMasked :: () => MVar a -> (a -> IO b) -> IO b

+ Rebase.Prelude: withMVarMasked :: MVar a -> (a -> IO b) -> IO b

- Rebase.Prelude: withProgName :: () => String -> IO a -> IO a

+ Rebase.Prelude: withProgName :: String -> IO a -> IO a

- Rebase.Prelude: withReader :: () => (r' -> r) -> Reader r a -> Reader r' a

+ Rebase.Prelude: withReader :: (r' -> r) -> Reader r a -> Reader r' a

- Rebase.Prelude: withReaderT :: () => (r' -> r) -> ReaderT r m a -> ReaderT r' m a

+ Rebase.Prelude: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a

- Rebase.Prelude: withState :: () => (s -> s) -> State s a -> State s a

+ Rebase.Prelude: withState :: (s -> s) -> State s a -> State s a

- Rebase.Prelude: withStateT :: () => (s -> s) -> StateT s m a -> StateT s m a

+ Rebase.Prelude: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a

- Rebase.Prelude: wordPtrToPtr :: () => WordPtr -> Ptr a

+ Rebase.Prelude: wordPtrToPtr :: WordPtr -> Ptr a

- Rebase.Prelude: writeChan :: () => Chan a -> a -> IO ()

+ Rebase.Prelude: writeChan :: Chan a -> a -> IO ()

- Rebase.Prelude: writeIORef :: () => IORef a -> a -> IO ()

+ Rebase.Prelude: writeIORef :: IORef a -> a -> IO ()

- Rebase.Prelude: writeList2Chan :: () => Chan a -> [a] -> IO ()

+ Rebase.Prelude: writeList2Chan :: Chan a -> [a] -> IO ()

- Rebase.Prelude: writeSTRef :: () => STRef s a -> a -> ST s ()

+ Rebase.Prelude: writeSTRef :: STRef s a -> a -> ST s ()

- Rebase.Prelude: writeTBQueue :: () => TBQueue a -> a -> STM ()

+ Rebase.Prelude: writeTBQueue :: TBQueue a -> a -> STM ()

- Rebase.Prelude: writeTChan :: () => TChan a -> a -> STM ()

+ Rebase.Prelude: writeTChan :: TChan a -> a -> STM ()

- Rebase.Prelude: writeTQueue :: () => TQueue a -> a -> STM ()

+ Rebase.Prelude: writeTQueue :: TQueue a -> a -> STM ()

- Rebase.Prelude: writeTVar :: () => TVar a -> a -> STM ()

+ Rebase.Prelude: writeTVar :: TVar a -> a -> STM ()

- Rebase.Prelude: zip :: () => [a] -> [b] -> [(a, b)]

+ Rebase.Prelude: zip :: [a] -> [b] -> [(a, b)]

- Rebase.Prelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

+ Rebase.Prelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

- Rebase.Prelude: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]

+ Rebase.Prelude: zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]

- Rebase.Prelude: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

+ Rebase.Prelude: zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

- Rebase.Prelude: zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

+ Rebase.Prelude: zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

- Rebase.Prelude: zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]

+ Rebase.Prelude: zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]

- Rebase.Prelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]

+ Rebase.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

- Rebase.Prelude: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

+ Rebase.Prelude: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

- Rebase.Prelude: zipWith4 :: () => (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]

+ Rebase.Prelude: zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]

- Rebase.Prelude: zipWith5 :: () => (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]

+ Rebase.Prelude: zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]

- Rebase.Prelude: zipWith6 :: () => (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]

+ Rebase.Prelude: zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]

- Rebase.Prelude: zipWith7 :: () => (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

+ Rebase.Prelude: zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

Files

library/Rebase/Contravariant/Extras.hs +0/−7
library/Rebase/Data/Time/Clock/System.hs +7/−0
library/Rebase/Prelude.hs +1/−4
rebase.cabal +7/−8

− library/Rebase/Contravariant/Extras.hs

@@ -1,7 +0,0 @@-module Rebase.Contravariant.Extras-(-  module Contravariant.Extras-)-where--import Contravariant.Extras

+ library/Rebase/Data/Time/Clock/System.hs view

@@ -0,0 +1,7 @@+module Rebase.Data.Time.Clock.System+(+  module Data.Time.Clock.System+)+where++import Data.Time.Clock.System

library/Rebase/Prelude.hs view

@@ -111,10 +111,6 @@ import Rebase.Data.Functor.Contravariant as Exports import Rebase.Data.Functor.Contravariant.Divisible as Exports --- contravariant-extras---------------------------import Rebase.Contravariant.Extras as Exports- -- semigroups ------------------------- import Rebase.Data.List.NonEmpty as Exports (NonEmpty)@@ -227,6 +223,7 @@ ------------------------- import Rebase.Data.Time as Exports import Rebase.Data.Time.Clock.POSIX as Exports+import Rebase.Data.Time.Clock.System as Exports  -- hashable-time -------------------------

rebase.cabal view

@@ -1,5 +1,5 @@ name: rebase-version: 1.10.0.1+version: 1.11 synopsis: A more progressive alternative to the "base" package description:   This package is intended for those who are tired of keeping@@ -38,7 +38,6 @@   default-extensions: NoImplicitPrelude, NoMonomorphismRestriction   default-language: Haskell2010   exposed-modules:-    Rebase.Contravariant.Extras     Rebase.Control.Applicative     Rebase.Control.Applicative.Backwards     Rebase.Control.Applicative.Lift@@ -268,6 +267,7 @@     Rebase.Data.Time.Calendar.WeekDate     Rebase.Data.Time.Clock     Rebase.Data.Time.Clock.POSIX+    Rebase.Data.Time.Clock.System     Rebase.Data.Time.Clock.TAI     Rebase.Data.Time.Format     Rebase.Data.Time.LocalTime@@ -424,27 +424,26 @@   build-depends:     base >=4.10 && <5,     bifunctors >=5.5 && <5.6,-    bytestring >=0.10 && <0.11,+    bytestring >=0.10 && <0.12,     containers >=0.6 && <0.7,     contravariant >=1.5 && <1.6,-    contravariant-extras >=0.3 && <0.4,     comonad >=5 && <5.1,     deepseq >=1.4 && <1.5,-    dlist >=1 && <2,+    dlist >=0.8 && <1.1,     either >=5 && <5.1,     hashable >=1.3 && <1.4,     hashable-time >=0.2.0.2 && <0.3,     mtl >=2.2 && <2.3,-    profunctors >=5.5.2 && <5.7,+    profunctors >=5.6 && <5.7,     scientific >=0.3 && <0.4,     selective >=0.4 && <0.5,     semigroupoids >=5.3 && <5.4,     stm >=2.5 && <2.6,     text >=1.2 && <1.3,-    time >=1.9 && <1.10,+    time >=1.9 && <1.12,     transformers >=0.5 && <0.6,     unordered-containers >=0.2.13 && <0.3,     uuid >=1.3 && <1.4,     vector >=0.12 && <0.13,-    vector-instances >=3.4 && <4,+    vector-instances >=3.4 && <3.5,     void >=0.7 && <0.8