Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. type ProductSurgery s a = GenericProduct Surgery' s a

    generic-data Generic.Data.Internal.Microsurgery

    Apply a microsurgery s to a type a for DerivingVia for the Monoid class.

  2. type ProductSurgeries (s :: [Type]) a = ProductSurgery Cat s a

    generic-data Generic.Data.Microsurgery

    Plural of ProductSurgery. Apply a list of microsurgeries.

  3. type ProductSurgery s a = GenericProduct Surgery' s a

    generic-data Generic.Data.Microsurgery

    Apply a microsurgery s to a type a for DerivingVia for the Monoid class.

  4. data ProductConst a b

    persistable-record Database.Record.Persistable

    Restricted in product isomorphism record type b

  5. data ProductUnitSupport

    relational-query Database.Relational.Arrow

    Unit of product is supported or not.

  6. data ProductUnitSupport

    relational-query Database.Relational.Config

    Unit of product is supported or not.

  7. data ProductTree rs

    relational-query Database.Relational.SqlSyntax

    Product tree type. Product tree is constructed by left node and right node.

  8. class Profunctor p => ProductProfunctor (p :: Type -> Type -> Type)

    product-profunctors Data.Profunctor.Product

    ProductProfunctor is a generalization of Applicative. It has the usual Applicative "output" (covariant) parameter on the right. Additionally it has an "input" (contravariant) type parameter on the left. The methods for ProductProfunctor correspond closely to those for Applicative as laid out in the following table. The only difference between them is that the ProductProfunctor has a contravariant type parameter on the left. We can use the contravariant to compose them in nice ways as described at Data.Profunctor.Product. 

    | Correspondence between Applicative and ProductProfunctor
|
|  Applicative f           ProductProfunctor p
|
|  pure                    purePP
|    :: b -> f b             :: b -> p a b
|
|  (<$>)                   (***$)
|    :: (b -> b')            :: (b -> b')
|    -> f b                  -> p a b
|    -> f b'                 -> p a b'
|
|  (<*>)                   (****)
|    :: f (b -> b')          :: p a (b -> b')
|    -> f b                  -> p a b
|    -> f b'                 -> p a b'
    If p is an instance of ProductProfunctor then p a a' represents a sort of process for turning as into a's that can be "laid out side-by-side" with other values of p to form "wider" processes. For example, if I have 
    p :: p a x -- a process for turning as into xs
q :: p b y -- a process for turning bs into ys
r :: p c z -- a process for turning cs into zs
    then I can combine them using p3 to get 
    p3 p q r :: p (a, b, c) (x, y, z)
-- a process for turning (a, b, c)s into (x, y, z)s
    You would typically compose ProductProfunctors using Profunctors's lmap and Applicative's pure, <$> / fmap and <*>. It's easy to make instances of ProductProfunctor. Just make instances 
    instance Profunctor MyProductProfunctor where
...

instance Applicative (MyProductProfunctor a) where
...
    and then write 
    instance ProductProfunctor MyProductProfunctor where
purePP = pure
(****) = (<*>)

  9. class Profunctor p => ProductProfunctor (p :: Type -> Type -> Type)

    product-profunctors Data.Profunctor.Product

    ProductProfunctor is a generalization of Applicative. It has the usual Applicative "output" (covariant) parameter on the right. Additionally it has an "input" (contravariant) type parameter on the left. The methods for ProductProfunctor correspond closely to those for Applicative as laid out in the following table. The only difference between them is that the ProductProfunctor has a contravariant type parameter on the left. We can use the contravariant to compose them in nice ways as described at Data.Profunctor.Product. 

    | Correspondence between Applicative and ProductProfunctor
|
|  Applicative f           ProductProfunctor p
|
|  pure                    purePP
|    :: b -> f b             :: b -> p a b
|
|  (<$>)                   (***$)
|    :: (b -> b')            :: (b -> b')
|    -> f b                  -> p a b
|    -> f b'                 -> p a b'
|
|  (<*>)                   (****)
|    :: f (b -> b')          :: p a (b -> b')
|    -> f b                  -> p a b
|    -> f b'                 -> p a b'
    If p is an instance of ProductProfunctor then p a a' represents a sort of process for turning as into a's that can be "laid out side-by-side" with other values of p to form "wider" processes. For example, if I have 
    p :: p a x -- a process for turning as into xs
q :: p b y -- a process for turning bs into ys
r :: p c z -- a process for turning cs into zs
    then I can combine them using p3 to get 
    p3 p q r :: p (a, b, c) (x, y, z)
-- a process for turning (a, b, c)s into (x, y, z)s
    You would typically compose ProductProfunctors using Profunctors's lmap and Applicative's pure, <$> / fmap and <*>. It's easy to make instances of ProductProfunctor. Just make instances 
    instance Profunctor MyProductProfunctor where
...

instance Applicative (MyProductProfunctor a) where
...
    and then write 
    instance ProductProfunctor MyProductProfunctor where
purePP = pure
(****) = (<*>)

  10. module Documentation.SBV.Examples.Optimization.Production

    Solves a simple linear optimization problem

Page 23 of many | Previous | Next