generics-sop 0.4.0.0 → 0.4.0.1

raw patch · 3 files changed

+7/−5 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Generics.SOP: data Shape (a :: [k]) :: forall k. () => [k] -> Type

- Generics.SOP: data Proxy (t :: k) :: forall k. () => k -> *

- Generics.SOP: newtype K a (b :: k) :: forall k. () => Type -> k -> *

- Generics.SOP: newtype (-.->) (f :: k -> *) (g :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> * -> k -> *

- Generics.SOP: newtype (:.:) (f :: l -> Type) (g :: k -> l) (p :: k) :: forall l k. () => l -> Type -> k -> l -> k -> *

- Generics.SOP.Instances: instance Generics.SOP.Universe.Generic (GHC.Base.Maybe a)

- Generics.SOP.Instances: instance Generics.SOP.Universe.Generic GHC.Event.Internal.Lifetime

- Generics.SOP.Instances: instance Generics.SOP.Universe.Generic GHC.Exception.ArithException

- Generics.SOP.Instances: instance Generics.SOP.Universe.HasDatatypeInfo (GHC.Base.Maybe a)

- Generics.SOP.Instances: instance Generics.SOP.Universe.HasDatatypeInfo GHC.Event.Internal.Lifetime

- Generics.SOP.Instances: instance Generics.SOP.Universe.HasDatatypeInfo GHC.Exception.ArithException

- Generics.SOP.Type.Metadata: instance (GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol d, Generics.SOP.Type.Metadata.DemoteConstructorInfo c '[x]) => Generics.SOP.Type.Metadata.DemoteDatatypeInfo ('Generics.SOP.Type.Metadata.Newtype m d c) '['[x]]

+ Generics.SOP: --

+ Generics.SOP: -- '[ '[ Int ]

+ Generics.SOP: -- , '[ Tree, Tree ]

+ Generics.SOP: -- </pre>

+ Generics.SOP: -- <i>Example:</i> The datatype

+ Generics.SOP: -- <pre>

+ Generics.SOP: -- This is a list of lists of its components. The outer list contains one

+ Generics.SOP: -- ]

+ Generics.SOP: -- constructor argument (field).

+ Generics.SOP: -- data Tree = Leaf Int | Node Tree Tree

+ Generics.SOP: -- element per constructor. The inner list contains one element per

+ Generics.SOP: -- is supposed to have the following code:

+ Generics.SOP: -- type instance Code (Tree a) =

+ Generics.SOP: -- | Type-level datatype info

+ Generics.SOP: data NP (a :: k -> Type) (b :: [k])

+ Generics.SOP: data NS (a :: k -> Type) (b :: [k])

+ Generics.SOP: data Proxy (t :: k)

+ Generics.SOP: data SList (a :: [k])

+ Generics.SOP: data Shape (a :: [k])

+ Generics.SOP: infixl 7 `And`

+ Generics.SOP: infixr 1 -.->

+ Generics.SOP: infixr 5 :*

+ Generics.SOP: infixr 7 :.:

+ Generics.SOP: infixr 9 `Compose`

+ Generics.SOP: newtype (:.:) (f :: l -> Type) (g :: k -> l) (p :: k)

+ Generics.SOP: newtype K a (b :: k)

+ Generics.SOP: newtype POP (f :: k -> Type) (xss :: [[k]])

+ Generics.SOP: newtype SOP (f :: k -> Type) (xss :: [[k]])

+ Generics.SOP.Instances: instance Generics.SOP.Universe.Generic (GHC.Maybe.Maybe a)

+ Generics.SOP.Instances: instance Generics.SOP.Universe.Generic GHC.Exception.Type.ArithException

+ Generics.SOP.Instances: instance Generics.SOP.Universe.HasDatatypeInfo (GHC.Maybe.Maybe a)

+ Generics.SOP.Instances: instance Generics.SOP.Universe.HasDatatypeInfo GHC.Exception.Type.ArithException

+ Generics.SOP.Type.Metadata: instance (GHC.TypeLits.KnownSymbol m, GHC.TypeLits.KnownSymbol d, Generics.SOP.Type.Metadata.DemoteConstructorInfo c '[x]) => Generics.SOP.Type.Metadata.DemoteDatatypeInfo ('Generics.SOP.Type.Metadata.Newtype m d c) '[ '[x]]

+ Generics.SOP.Universe: --

+ Generics.SOP.Universe: -- '[ '[ Int ]

+ Generics.SOP.Universe: -- , '[ Tree, Tree ]

+ Generics.SOP.Universe: -- </pre>

+ Generics.SOP.Universe: -- <i>Example:</i> The datatype

+ Generics.SOP.Universe: -- <pre>

+ Generics.SOP.Universe: -- This is a list of lists of its components. The outer list contains one

+ Generics.SOP.Universe: -- ]

+ Generics.SOP.Universe: -- constructor argument (field).

+ Generics.SOP.Universe: -- data Tree = Leaf Int | Node Tree Tree

+ Generics.SOP.Universe: -- element per constructor. The inner list contains one element per

+ Generics.SOP.Universe: -- is supposed to have the following code:

+ Generics.SOP.Universe: -- type instance Code (Tree a) =

+ Generics.SOP.Universe: -- | Type-level datatype info

- Generics.SOP: Comp :: f g p -> (:.:)

+ Generics.SOP: Comp :: f (g p) -> (:.:) (f :: l -> Type) (g :: k -> l) (p :: k)

- Generics.SOP: Fn :: f a -> g a -> (-.->)

+ Generics.SOP: Fn :: (f a -> g a) -> (-.->) (f :: k -> Type) (g :: k -> Type) (a :: k)

- Generics.SOP: K :: a -> K a

+ Generics.SOP: K :: a -> K a (b :: k)

- Generics.SOP: POP :: NP NP f xss -> POP

+ Generics.SOP: POP :: NP (NP f) xss -> POP (f :: k -> Type) (xss :: [[k]])

- Generics.SOP: Proxy :: Proxy

+ Generics.SOP: Proxy :: Proxy (t :: k)

- Generics.SOP: SOP :: NS NP f xss -> SOP

+ Generics.SOP: SOP :: NS (NP f) xss -> SOP (f :: k -> Type) (xss :: [[k]])

- Generics.SOP: [:*] :: NP a x : xs

+ Generics.SOP: [:*] :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). () => a x -> NP a xs -> NP a (x : xs)

- Generics.SOP: [Nil] :: NP a ([] :: [k])

+ Generics.SOP: [Nil] :: forall k (a :: k -> Type) (b :: [k]). () => NP a ([] :: [k])

- Generics.SOP: [SCons] :: SList x : xs

+ Generics.SOP: [SCons] :: forall k (a :: [k]) (xs :: [k]) (x :: k). SListI xs => SList (x : xs)

- Generics.SOP: [SNil] :: SList ([] :: [k])

+ Generics.SOP: [SNil] :: forall k (a :: [k]). () => SList ([] :: [k])

- Generics.SOP: [S] :: NS a x : xs

+ Generics.SOP: [S] :: forall k (a :: k -> Type) (b :: [k]) (xs :: [k]) (x :: k). () => NS a xs -> NS a (x : xs)

- Generics.SOP: [ShapeCons] :: Shape x : xs

+ Generics.SOP: [ShapeCons] :: forall k (a :: [k]) (xs :: [k]) (x :: k). SListI xs => Shape xs -> Shape (x : xs)

- Generics.SOP: [ShapeNil] :: Shape ([] :: [k])

+ Generics.SOP: [ShapeNil] :: forall k (a :: [k]). () => Shape ([] :: [k])

- Generics.SOP: [Z] :: NS a x : xs

+ Generics.SOP: [Z] :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). () => a x -> NS a (x : xs)

- Generics.SOP: [apFn] :: (-.->) -> f a -> g a

+ Generics.SOP: [apFn] :: (-.->) (f :: k -> Type) (g :: k -> Type) (a :: k) -> f a -> g a

- Generics.SOP: case_SList :: SListI xs => r ([] :: [k]) -> forall (y :: k) (ys :: [k]). SListI ys => r y : ys -> r xs

+ Generics.SOP: case_SList :: SListI xs => r ([] :: [k]) -> (forall (y :: k) (ys :: [k]). SListI ys => r (y : ys)) -> r xs

- Generics.SOP: ccase_SList :: All c xs => proxy c -> r ([] :: [k]) -> forall (y :: k) (ys :: [k]). (c y, All c ys) => r y : ys -> r xs

+ Generics.SOP: ccase_SList :: All c xs => proxy c -> r ([] :: [k]) -> (forall (y :: k) (ys :: [k]). (c y, All c ys) => r (y : ys)) -> r xs

- Generics.SOP: ccompare_NS :: All c xs => proxy c -> r -> forall (x :: k). c x => f x -> g x -> r -> r -> NS f xs -> NS g xs -> r

+ Generics.SOP: ccompare_NS :: All c xs => proxy c -> r -> (forall (x :: k). c x => f x -> g x -> r) -> r -> NS f xs -> NS g xs -> r

- Generics.SOP: ccompare_SOP :: All2 c xss => proxy c -> r -> forall (xs :: [k]). All c xs => NP f xs -> NP g xs -> r -> r -> SOP f xss -> SOP g xss -> r

+ Generics.SOP: ccompare_SOP :: All2 c xss => proxy c -> r -> (forall (xs :: [k]). All c xs => NP f xs -> NP g xs -> r) -> r -> SOP f xss -> SOP g xss -> r

- Generics.SOP: compare_NS :: () => r -> forall (x :: k). () => f x -> g x -> r -> r -> NS f xs -> NS g xs -> r

+ Generics.SOP: compare_NS :: () => r -> (forall (x :: k). () => f x -> g x -> r) -> r -> NS f xs -> NS g xs -> r

- Generics.SOP: compare_SOP :: () => r -> forall (xs :: [k]). () => NP f xs -> NP g xs -> r -> r -> SOP f xss -> SOP g xss -> r

+ Generics.SOP: compare_SOP :: () => r -> (forall (xs :: [k]). () => NP f xs -> NP g xs -> r) -> r -> SOP f xss -> SOP g xss -> r

- Generics.SOP: cpara_SList :: All c xs => proxy c -> r ([] :: [k]) -> forall (y :: k) (ys :: [k]). (c y, All c ys) => r ys -> r y : ys -> r xs

+ Generics.SOP: cpara_SList :: All c xs => proxy c -> r ([] :: [k]) -> (forall (y :: k) (ys :: [k]). (c y, All c ys) => r ys -> r (y : ys)) -> r xs

- Generics.SOP: fn :: () => f a -> f' a -> f -.-> f' a

+ Generics.SOP: fn :: () => (f a -> f' a) -> (f -.-> f') a

- Generics.SOP: fn_2 :: () => f a -> f' a -> f'' a -> f -.-> f' -.-> f'' a

+ Generics.SOP: fn_2 :: () => (f a -> f' a -> f'' a) -> (f -.-> (f' -.-> f'')) a

- Generics.SOP: fn_3 :: () => f a -> f' a -> f'' a -> f''' a -> f -.-> f' -.-> f'' -.-> f''' a

+ Generics.SOP: fn_3 :: () => (f a -> f' a -> f'' a -> f''' a) -> (f -.-> (f' -.-> (f'' -.-> f'''))) a

- Generics.SOP: fn_4 :: () => f a -> f' a -> f'' a -> f''' a -> f'''' a -> f -.-> f' -.-> f'' -.-> f''' -.-> f'''' a

+ Generics.SOP: fn_4 :: () => (f a -> f' a -> f'' a -> f''' a -> f'''' a) -> (f -.-> (f' -.-> (f'' -.-> (f''' -.-> f'''')))) a

- Generics.SOP: fromList :: SListI xs => [a] -> Maybe NP (K a :: k -> *) xs

+ Generics.SOP: fromList :: SListI xs => [a] -> Maybe (NP (K a :: k -> Type) xs)

- Generics.SOP: hap :: HAp h => Prod h f -.-> g xs -> h f xs -> h g xs

+ Generics.SOP: hap :: HAp h => Prod h (f -.-> g) xs -> h f xs -> h g xs

- Generics.SOP: hcexpand :: (HExpand h, AllN Prod h c xs) => proxy c -> forall (x :: k). c x => f x -> h f xs -> Prod h f xs

+ Generics.SOP: hcexpand :: (HExpand h, AllN (Prod h) c xs) => proxy c -> (forall (x :: k). c x => f x) -> h f xs -> Prod h f xs

- Generics.SOP: hcfoldMap :: (HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> forall (a :: k). c a => f a -> m -> h f xs -> m

+ Generics.SOP: hcfoldMap :: (HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> (forall (a :: k). c a => f a -> m) -> h f xs -> m

- Generics.SOP: hcfor :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> h f xs -> forall a. c a => f a -> g a -> g h I xs

+ Generics.SOP: hcfor :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall a. c a => f a -> g a) -> g (h I xs)

- Generics.SOP: hcfor_ :: (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> forall (a :: k). c a => f a -> g () -> g ()

+ Generics.SOP: hcfor_ :: (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall (a :: k). c a => f a -> g ()) -> g ()

- Generics.SOP: hcliftA :: (AllN Prod h c xs, HAp h) => proxy c -> forall (a :: k). c a => f a -> f' a -> h f xs -> h f' xs

+ Generics.SOP: hcliftA :: (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs

- Generics.SOP: hcliftA' :: (All2 c xss, Prod h ~ (NP :: [k] -> Type -> [[k]] -> Type), HAp h) => proxy c -> forall (xs :: [k]). All c xs => f xs -> f' xs -> h f xss -> h f' xss

+ Generics.SOP: hcliftA' :: (All2 c xss, Prod h ~ (NP :: ([k] -> Type) -> [[k]] -> Type), HAp h) => proxy c -> (forall (xs :: [k]). All c xs => f xs -> f' xs) -> h f xss -> h f' xss

- Generics.SOP: hcliftA2 :: (AllN Prod h c xs, HAp h, HAp Prod h) => proxy c -> forall (a :: k). c a => f a -> f' a -> f'' a -> Prod h f xs -> h f' xs -> h f'' xs

+ Generics.SOP: hcliftA2 :: (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs

- Generics.SOP: hcliftA2' :: (All2 c xss, Prod h ~ (NP :: [k] -> Type -> [[k]] -> Type), HAp h) => proxy c -> forall (xs :: [k]). All c xs => f xs -> f' xs -> f'' xs -> Prod h f xss -> h f' xss -> h f'' xss

+ Generics.SOP: hcliftA2' :: (All2 c xss, Prod h ~ (NP :: ([k] -> Type) -> [[k]] -> Type), HAp h) => proxy c -> (forall (xs :: [k]). All c xs => f xs -> f' xs -> f'' xs) -> Prod h f xss -> h f' xss -> h f'' xss

- Generics.SOP: hcliftA3 :: (AllN Prod h c xs, HAp h, HAp Prod h) => proxy c -> forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

+ Generics.SOP: hcliftA3 :: (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

- Generics.SOP: hcliftA3' :: (All2 c xss, Prod h ~ (NP :: [k] -> Type -> [[k]] -> Type), HAp h) => proxy c -> forall (xs :: [k]). All c xs => f xs -> f' xs -> f'' xs -> f''' xs -> Prod h f xss -> Prod h f' xss -> h f'' xss -> h f''' xss

+ Generics.SOP: hcliftA3' :: (All2 c xss, Prod h ~ (NP :: ([k] -> Type) -> [[k]] -> Type), HAp h) => proxy c -> (forall (xs :: [k]). All c xs => f xs -> f' xs -> f'' xs -> f''' xs) -> Prod h f xss -> Prod h f' xss -> h f'' xss -> h f''' xss

- Generics.SOP: hcmap :: (AllN Prod h c xs, HAp h) => proxy c -> forall (a :: k). c a => f a -> f' a -> h f xs -> h f' xs

+ Generics.SOP: hcmap :: (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs

- Generics.SOP: hcoerce :: (HTrans h1 h2, AllZipN Prod h1 LiftedCoercible f g xs ys, HTrans h1 h2) => h1 f xs -> h2 g ys

+ Generics.SOP: hcoerce :: (HTrans h1 h2, AllZipN (Prod h1) (LiftedCoercible f g) xs ys, HTrans h1 h2) => h1 f xs -> h2 g ys

- Generics.SOP: hcollapse :: (HCollapse h, SListIN h xs) => h (K a :: k -> *) xs -> CollapseTo h a

+ Generics.SOP: hcollapse :: (HCollapse h, SListIN h xs) => h (K a :: k -> Type) xs -> CollapseTo h a

- Generics.SOP: hcpure :: (HPure h, AllN h c xs) => proxy c -> forall (a :: k). c a => f a -> h f xs

+ Generics.SOP: hcpure :: (HPure h, AllN h c xs) => proxy c -> (forall (a :: k). c a => f a) -> h f xs

- Generics.SOP: hctraverse :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> forall a. c a => f a -> g a -> h f xs -> g h I xs

+ Generics.SOP: hctraverse :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> (forall a. c a => f a -> g a) -> h f xs -> g (h I xs)

- Generics.SOP: hctraverse' :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> forall (a :: k). c a => f a -> g f' a -> h f xs -> g h f' xs

+ Generics.SOP: hctraverse' :: (HSequence h, AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> h f xs -> g (h f' xs)

- Generics.SOP: hctraverse_ :: (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> forall (a :: k). c a => f a -> g () -> h f xs -> g ()

+ Generics.SOP: hctraverse_ :: (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> h f xs -> g ()

- Generics.SOP: hczipWith :: (AllN Prod h c xs, HAp h, HAp Prod h) => proxy c -> forall (a :: k). c a => f a -> f' a -> f'' a -> Prod h f xs -> h f' xs -> h f'' xs

+ Generics.SOP: hczipWith :: (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs

- Generics.SOP: hczipWith3 :: (AllN Prod h c xs, HAp h, HAp Prod h) => proxy c -> forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

+ Generics.SOP: hczipWith3 :: (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

- Generics.SOP: hd :: () => NP f x : xs -> f x

+ Generics.SOP: hd :: () => NP f (x : xs) -> f x

- Generics.SOP: hexpand :: (HExpand h, SListIN Prod h xs) => forall (x :: k). () => f x -> h f xs -> Prod h f xs

+ Generics.SOP: hexpand :: (HExpand h, SListIN (Prod h) xs) => (forall (x :: k). () => f x) -> h f xs -> Prod h f xs

- Generics.SOP: hfromI :: (AllZipN Prod h1 LiftedCoercible I f xs ys, HTrans h1 h2) => h1 I xs -> h2 f ys

+ Generics.SOP: hfromI :: (AllZipN (Prod h1) (LiftedCoercible I f) xs ys, HTrans h1 h2) => h1 I xs -> h2 f ys

- Generics.SOP: hliftA :: (SListIN Prod h xs, HAp h) => forall (a :: k). () => f a -> f' a -> h f xs -> h f' xs

+ Generics.SOP: hliftA :: (SListIN (Prod h) xs, HAp h) => (forall (a :: k). () => f a -> f' a) -> h f xs -> h f' xs

- Generics.SOP: hliftA2 :: (SListIN Prod h xs, HAp h, HAp Prod h) => forall (a :: k). () => f a -> f' a -> f'' a -> Prod h f xs -> h f' xs -> h f'' xs

+ Generics.SOP: hliftA2 :: (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). () => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs

- Generics.SOP: hliftA3 :: (SListIN Prod h xs, HAp h, HAp Prod h) => forall (a :: k). () => f a -> f' a -> f'' a -> f''' a -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

+ Generics.SOP: hliftA3 :: (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). () => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

- Generics.SOP: hmap :: (SListIN Prod h xs, HAp h) => forall (a :: k). () => f a -> f' a -> h f xs -> h f' xs

+ Generics.SOP: hmap :: (SListIN (Prod h) xs, HAp h) => (forall (a :: k). () => f a -> f' a) -> h f xs -> h f' xs

- Generics.SOP: hpure :: (HPure h, SListIN h xs) => forall (a :: k). () => f a -> h f xs

+ Generics.SOP: hpure :: (HPure h, SListIN h xs) => (forall (a :: k). () => f a) -> h f xs

- Generics.SOP: hsequence :: (SListIN h xs, SListIN Prod h xs, HSequence h, Applicative f) => h f xs -> f h I xs

+ Generics.SOP: hsequence :: (SListIN h xs, SListIN (Prod h) xs, HSequence h, Applicative f) => h f xs -> f (h I xs)

- Generics.SOP: hsequence' :: (HSequence h, SListIN h xs, Applicative f) => h f :.: g xs -> f h g xs

+ Generics.SOP: hsequence' :: (HSequence h, SListIN h xs, Applicative f) => h (f :.: g) xs -> f (h g xs)

- Generics.SOP: hsequenceK :: (SListIN h xs, SListIN Prod h xs, Applicative f, HSequence h) => h (K f a :: k -> *) xs -> f h (K a :: k -> *) xs

+ Generics.SOP: hsequenceK :: (SListIN h xs, SListIN (Prod h) xs, Applicative f, HSequence h) => h (K (f a) :: k -> Type) xs -> f (h (K a :: k -> Type) xs)

- Generics.SOP: htoI :: (AllZipN Prod h1 LiftedCoercible f I xs ys, HTrans h1 h2) => h1 f xs -> h2 I ys

+ Generics.SOP: htoI :: (AllZipN (Prod h1) (LiftedCoercible f I) xs ys, HTrans h1 h2) => h1 f xs -> h2 I ys

- Generics.SOP: htrans :: (HTrans h1 h2, AllZipN Prod h1 c xs ys) => proxy c -> forall (x :: k1) (y :: k2). c x y => f x -> g y -> h1 f xs -> h2 g ys

+ Generics.SOP: htrans :: (HTrans h1 h2, AllZipN (Prod h1) c xs ys) => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> h1 f xs -> h2 g ys

- Generics.SOP: htraverse' :: (HSequence h, SListIN h xs, Applicative g) => forall (a :: k). () => f a -> g f' a -> h f xs -> g h f' xs

+ Generics.SOP: htraverse' :: (HSequence h, SListIN h xs, Applicative g) => (forall (a :: k). () => f a -> g (f' a)) -> h f xs -> g (h f' xs)

- Generics.SOP: htraverse_ :: (HTraverse_ h, SListIN h xs, Applicative g) => forall (a :: k). () => f a -> g () -> h f xs -> g ()

+ Generics.SOP: htraverse_ :: (HTraverse_ h, SListIN h xs, Applicative g) => (forall (a :: k). () => f a -> g ()) -> h f xs -> g ()

- Generics.SOP: hzipWith :: (SListIN Prod h xs, HAp h, HAp Prod h) => forall (a :: k). () => f a -> f' a -> f'' a -> Prod h f xs -> h f' xs -> h f'' xs

+ Generics.SOP: hzipWith :: (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). () => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs

- Generics.SOP: hzipWith3 :: (SListIN Prod h xs, HAp h, HAp Prod h) => forall (a :: k). () => f a -> f' a -> f'' a -> f''' a -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

+ Generics.SOP: hzipWith3 :: (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). () => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs

- Generics.SOP: injections :: SListI xs => NP Injection f xs xs

+ Generics.SOP: injections :: SListI xs => NP (Injection f xs) xs

- Generics.SOP: mapII :: () => a -> b -> I a -> I b

+ Generics.SOP: mapII :: () => (a -> b) -> I a -> I b

- Generics.SOP: mapIII :: () => a -> b -> c -> I a -> I b -> I c

+ Generics.SOP: mapIII :: () => (a -> b -> c) -> I a -> I b -> I c

- Generics.SOP: mapIIK :: () => a -> b -> c -> I a -> I b -> K c d

+ Generics.SOP: mapIIK :: () => (a -> b -> c) -> I a -> I b -> K c d

- Generics.SOP: mapIK :: () => a -> b -> I a -> K b c

+ Generics.SOP: mapIK :: () => (a -> b) -> I a -> K b c

- Generics.SOP: mapIKI :: () => a -> b -> c -> I a -> K b d -> I c

+ Generics.SOP: mapIKI :: () => (a -> b -> c) -> I a -> K b d -> I c

- Generics.SOP: mapIKK :: () => a -> b -> c -> I a -> K b d -> K c e

+ Generics.SOP: mapIKK :: () => (a -> b -> c) -> I a -> K b d -> K c e

- Generics.SOP: mapKI :: () => a -> b -> K a c -> I b

+ Generics.SOP: mapKI :: () => (a -> b) -> K a c -> I b

- Generics.SOP: mapKII :: () => a -> b -> c -> K a d -> I b -> I c

+ Generics.SOP: mapKII :: () => (a -> b -> c) -> K a d -> I b -> I c

- Generics.SOP: mapKIK :: () => a -> b -> c -> K a d -> I b -> K c e

+ Generics.SOP: mapKIK :: () => (a -> b -> c) -> K a d -> I b -> K c e

- Generics.SOP: mapKK :: () => a -> b -> K a c -> K b d

+ Generics.SOP: mapKK :: () => (a -> b) -> K a c -> K b d

- Generics.SOP: mapKKI :: () => a -> b -> c -> K a d -> K b e -> I c

+ Generics.SOP: mapKKI :: () => (a -> b -> c) -> K a d -> K b e -> I c

- Generics.SOP: mapKKK :: () => a -> b -> c -> K a d -> K b e -> K c f

+ Generics.SOP: mapKKK :: () => (a -> b -> c) -> K a d -> K b e -> K c f

- Generics.SOP: para_SList :: SListI xs => r ([] :: [a]) -> forall (y :: a) (ys :: [a]). SListI ys => r ys -> r y : ys -> r xs

+ Generics.SOP: para_SList :: SListI xs => r ([] :: [k]) -> (forall (y :: k) (ys :: [k]). SListI ys => r ys -> r (y : ys)) -> r xs

- Generics.SOP: projections :: SListI xs => NP Projection f xs xs

+ Generics.SOP: projections :: SListI xs => NP (Projection f xs) xs

- Generics.SOP: shift :: () => Injection f xs a2 -> Injection f x : xs a2

+ Generics.SOP: shift :: () => Injection f xs a2 -> Injection f (x : xs) a2

- Generics.SOP: shiftInjection :: () => Injection f xs a2 -> Injection f x : xs a2

+ Generics.SOP: shiftInjection :: () => Injection f xs a2 -> Injection f (x : xs) a2

- Generics.SOP: shiftProjection :: () => Projection f xs a2 -> Projection f x : xs a2

+ Generics.SOP: shiftProjection :: () => Projection f xs a2 -> Projection f (x : xs) a2

- Generics.SOP: tl :: () => NP f x : xs -> NP f xs

+ Generics.SOP: tl :: () => NP f (x : xs) -> NP f xs

- Generics.SOP: type Injection (f :: k -> Type) (xs :: [k]) = f -.-> (K NS f xs :: k -> *)

+ Generics.SOP: type Injection (f :: k -> Type) (xs :: [k]) = f -.-> (K NS f xs :: k -> Type)

- Generics.SOP: type Projection (f :: k -> Type) (xs :: [k]) = (K NP f xs :: k -> *) -.-> f

+ Generics.SOP: type Projection (f :: k -> Type) (xs :: [k]) = (K NP f xs :: k -> Type) -.-> f

- Generics.SOP: type family DatatypeInfoOf a :: DatatypeInfo;

+ Generics.SOP: type family SameShapeAs (xs :: [a]) (ys :: [b]) :: Constraint

- Generics.SOP: unComp :: () => f :.: g p -> f g p

+ Generics.SOP: unComp :: () => (f :.: g) p -> f (g p)

- Generics.SOP: unPOP :: () => POP f xss -> NP NP f xss

+ Generics.SOP: unPOP :: () => POP f xss -> NP (NP f) xss

- Generics.SOP: unSOP :: () => SOP f xss -> NS NP f xss

+ Generics.SOP: unSOP :: () => SOP f xss -> NS (NP f) xss

- Generics.SOP: unZ :: () => NS f x : ([] :: [k]) -> f x

+ Generics.SOP: unZ :: () => NS f (x : ([] :: [k])) -> f x

- Generics.SOP.GGP: gdatatypeInfo :: forall proxy a. (GDatatypeInfo a) => proxy a -> DatatypeInfo (GCode a)

+ Generics.SOP.GGP: gdatatypeInfo :: forall proxy a. GDatatypeInfo a => proxy a -> DatatypeInfo (GCode a)

Files

CHANGELOG.md +5/−0
generics-sop.cabal +1/−1
src/Generics/SOP/Instances.hs +1/−4

CHANGELOG.md view

@@ -1,3 +1,8 @@+# 0.4.0.1 (2018-10-23)++* Remove `GHC.Event` import in `Generics.SOP.Instances`+  to fix build on Windows.+ # 0.4.0.0 (2018-10-20)  * Split into `sop-core` and `generics-sop` packages.

generics-sop.cabal view

@@ -1,5 +1,5 @@ name:                generics-sop-version:             0.4.0.0+version:             0.4.0.1 synopsis:            Generic Programming using True Sums of Products description:   A library to support the definition of generic functions.

src/Generics/SOP/Instances.hs view

@@ -48,7 +48,7 @@ import GHC.Conc -- new import GHC.ExecutionStack -- new import GHC.Exts -- new-import GHC.Event -- new+-- import GHC.Events -- platform-specific, omitted import GHC.Fingerprint -- new import GHC.Float -- new import qualified GHC.Generics -- new@@ -253,9 +253,6 @@ -- From GHC.Conc: deriveGeneric ''ThreadStatus -- new deriveGeneric ''BlockReason -- new---- From GHC.Event(.Inernal):-deriveGeneric ''Lifetime -- new  -- From GHC.ExecutionStack: deriveGeneric ''Location -- new