úÎGºF»     None6DOT Where  is a "lifted Apply", this is a "lifted  ".laws:  naturalityt .  f =  (t . f)) for every applicative transformation tidentity Identity = Identity composition (Compose .  g . f) = Compose .  ( g) .  fand cZipWithM f k l must behave like <cTraverse getCompose (cZipWith (x y -> Compose (f x y)) k l)laws:  (\x _ -> x) g _ = g  (\_ y -> y) _ h = h8This class seems to be some kind of "lifted" version of  (or rather: of Apply?), but it also seems to share an important property with the  ahttps://hackage.haskell.org/package/distributive-0.5.2/docs/Data-Distributive.html#t:Distributive Distributive class from the  0https://hackage.haskell.org/package/distributive distributive package, even when  Distributive and E methods don't appear all that similar. From the corresponding docs: ÿJTo be distributable a container will need to have a way to consistently zip a potentially infinite number of copies of itself. This effectively means that the holes in all values of that type, must have the same cardinality, fixed sized vectors, infinite streams, functions, etc. and no extra information to try to merge together.®Especially "all values of that type must have the same cardinality" is true for instances of CZipWith, the only difference being that the "holes" are instantiations of the  f :: * -> *& to some type, where they are simply a :: * for  Distributive. For many  DistributiveD instances there are corresponding datatypes that are instances of A (although they do not seem particularly useful..), for example: 9newtype CUnit a f = CUnit (f a) -- corresponding to Identityÿ data CPair a b f = CPair (f a) (f b) -- corresponding to 'data MonoPair a = MonoPair a a' -- (Pair being a trivial fixed-size vector example) data CStream a f = CStream (f a) (CStream a f) -- corresponding to an infinite stream *zipWith on constructors instead of values.The "lifted Functor" classThe "lifted Apply" class The equivalent of  's /  Derives a cPointed! instance for a datatype of kind  (* -> *) -> *.<Requires that for this datatype (we shall call its argument  f :: * -> * here)!there is exactly one constructor;9all fields in the one constructor are either of the form f x for some x or of the form X f for some type X where there is an instance cPointed X.0For example, the following would be valid usage: µdata A f = A { a_str :: f String , a_bool :: f Bool } data B f = B { b_int :: f Int , b_float :: f Float , b_a :: A f } derivecPointed ''A derivecPointed ''B &This produces the following instances: hinstance cPointed A where cPoint f = A f f instance cPointed B where cPoint f = B f f (cPoint f f)  Derives a ! instance for a datatype of kind  (* -> *) -> *.<Requires that for this datatype (we shall call its argument  f :: * -> * here)!there is exactly one constructor;9all fields in the one constructor are either of the form f x for some x or of the form X f for some type X where there is an instance CZipWith X.0For example, the following would be valid usage: µdata A f = A { a_str :: f String , a_bool :: f Bool } data B f = B { b_int :: f Int , b_float :: f Float , b_a :: A f } deriveCZipWith ''A deriveCZipWith ''B &This produces the following instances: Äinstance CZipWith A where cZipWith f (A x1 x2) (A y1 y2) = A (f x1 y1) (f x2 y2) instance CZipWith B where cZipWith f (B x1 x2 x3) (B y1 y2 y3) = B (f x1 y1) (f x2 y2) (cZipWith f x3 y3)  Derives a ! instance for a datatype of kind  (* -> *) -> *.<Requires that for this datatype (we shall call its argument  f :: * -> * here)!there is exactly one constructor;9all fields in the one constructor are either of the form f x for some x or of the form X f for some type X where there is an instance CZipWithM X.0For example, the following would be valid usage: ·data A f = A { a_str :: f String , a_bool :: f Bool } data B f = B { b_int :: f Int , b_float :: f Float , b_a :: A f } deriveCZipWithM ''A deriveCZipWithM ''B &This produces the following instances: Òinstance CZipWithM A where cZipWithM f (A x1 x2) (A y1 y2) = A <$> f x1 y1 <*> f x2 y2 instance CZipWith B where cZipWithM f (B x1 x2 x3) (B y1 y2 y3) = B <$> f x1 y1 <*> f x2 y2 <*> cZipWithM f x3 y3           'czipwith-1.0.1.1-3xUfbR2WefIBGkcow6C8ft Data.CZipWith CZipWithM cTraverse cZipWithMCZipWithcZipWithCFunctorcMapCPointedcPoint cSequencederiveCPointedderiveCZipWithderiveCZipWithMbaseData.Traversable TraversableGHC.Basefmap Applicativesequence sequenceA<&>