Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

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

productCE :: forall (m :: Type -> Type) mono o . (Monad m, MonoFoldable mono, Num (Element mono)) => ConduitT mono o m (Element mono)

classy-prelude-conduit ClassyPrelude.Conduit

Get the product of all elements in the chunked stream.
productNameAdjective :: Fake Text

fakedata Faker.Commerce

No documentation available.
productNameMaterial :: Fake Text

fakedata Faker.Commerce

No documentation available.
productNameProduct :: Fake Text

fakedata Faker.Commerce

No documentation available.
productE :: forall a s e (m :: Type -> Type) . Num a => Wire s e m (Event a) (Event a)

netwire Control.Wire.Event

Product of all events.
- Depends: now.
package product-profunctors

product-profunctors Product profunctors and tools for working with them
production :: ConstraintSet

sbv Documentation.SBV.Examples.Optimization.Production

Taken from http://people.brunel.ac.uk/~mastjjb/jeb/or/morelp.html A company makes two products (X and Y) using two machines (A and B).
- Each unit of X that is produced requires 50 minutes processing time on machine A and 30 minutes processing time on machine B.
- Each unit of Y that is produced requires 24 minutes processing time on machine A and 33 minutes processing time on machine B.
- At the start of the current week there are 30 units of X and 90 units of Y in stock. Available processing time on machine A is forecast to be 40 hours and on machine B is forecast to be 35 hours.
- The demand for X in the current week is forecast to be 75 units and for Y is forecast to be 95 units.
- Company policy is to maximise the combined sum of the units of X and the units of Y in stock at the end of the week.
How much of each product should we make in the current week? We have:
```
>>> optimize Lexicographic production
Optimal model:
X     = 45 :: Integer
Y     =  6 :: Integer
stock =  1 :: Integer
```
That is, we should produce 45 X's and 6 Y's, with the final maximum stock of just 1 expected!
productOfEdgesInBoundedWalk :: (SemiRing e, Ord n) => (e -> Occurrence) -> Graph n e -> n -> n -> Occurrence -> Maybe e

Agda Agda.TypeChecking.Positivity.Occurrence

productOfEdgesInBoundedWalk occ g u v bound returns a value distinct from Nothing iff there is a walk c (a list of edges) in g, from u to v, for which the product foldr1 otimes (map occ c) <= bound. In this case the returned value is Just (foldr1 otimes c) for one such walk c. Preconditions: u and v must belong to g, and bound must belong to the domain of boundToEverySome.
product' :: Expr -> Expr

code-conjure Conjure.Engine

product of Int elements lifted over the Expr type.
```
> product' xxs
product xs :: Int
```
```
> evl (product' $ expr [1,2,3::Int]) :: Int
6
```
product' :: Expr -> Expr

code-conjure Conjure.Expr

product of Int elements lifted over the Expr type.
```
> product' xxs
product xs :: Int
```
```
> evl (product' $ expr [1,2,3::Int]) :: Int
6
```

classy-prelude-conduit	ClassyPrelude.Conduit

fakedata	Faker.Commerce

fakedata	Faker.Commerce

fakedata	Faker.Commerce

netwire	Control.Wire.Event

sbv	Documentation.SBV.Examples.Optimization.Production

Agda	Agda.TypeChecking.Positivity.Occurrence

code-conjure	Conjure.Engine

code-conjure	Conjure.Expr

Page 78 of many | Previous | Next