Hoogle Search

Within LTS Haskell 24.46 (ghc-9.10.3)

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

Exact lookup

1. osum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono

   mono-traversable	Data.MonoTraversable

   osum computes the sum of the numbers of a monomorphic container.

2. asum :: (Foldable t, Alternative f) => t (f a) -> f a

   rio	RIO.Prelude

   The sum of a collection of actions using (<|>), generalizing concat. asum is just like msum, but generalised to Alternative.

   Examples

   Basic usage:

   >>> asum [Just "Hello", Nothing, Just "World"]
   Just "Hello"
   

3. biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a

   rio	RIO.Prelude

   The sum of a collection of actions, generalizing biconcat.

   Examples

   Basic usage:

   >>> biasum (Nothing, Nothing)
   Nothing
   

   >>> biasum (Nothing, Just 42)
   Just 42
   

   >>> biasum (Just 18, Nothing)
   Just 18
   

   >>> biasum (Just 18, Just 42)
   Just 18
   

4. bisum :: (Bifoldable t, Num a) => t a a -> a

   rio	RIO.Prelude

   The bisum function computes the sum of the numbers of a structure.

   Examples

   Basic usage:

   >>> bisum (42, 17)
   59
   

   >>> bisum (Right 42)
   42
   

   >>> bisum (BiList [13, 29, 4] [18, 1, 7])
   72
   

   >>> bisum (BiList [13, 29, 4] [])
   46
   

   >>> bisum (BiList [] [])
   0
   

5. msum :: (Foldable t, MonadPlus m) => t (m a) -> m a

   rio	RIO.Prelude

   The sum of a collection of actions using (<|>), generalizing concat. msum is just like asum, but specialised to MonadPlus.

   Examples

   Basic usage, using the MonadPlus instance for Maybe:

   >>> msum [Just "Hello", Nothing, Just "World"]
   Just "Hello"
   

6. timeZoneSummerOnly :: TimeZone -> Bool

   rio	RIO.Time

   Is this time zone just persisting for the summer?

7. package dependent-sum

   Dependent sum type A dependent sum is a generalization of a particular way of thinking about the Either type. Either a b can be thought of as a 2-tuple (tag, value), where the value of the tag determines the type of the value. In particular, either tag = Left and value :: a or tag = Right and value :: b. This package allows you to define your own dependent sum types by using your own "tag" types.

8. data DSum (tag :: k -> Type) (f :: k -> Type)

   dependent-sum	Data.Dependent.Sum

   A basic dependent sum type where the first component is a tag that specifies the type of the second. For example, think of a GADT such as:

   data Tag a where
   AString :: Tag String
   AnInt   :: Tag Int
   Rec     :: Tag (DSum Tag Identity)
   

   Then we can write expressions where the RHS of (:=>) has different types depending on the Tag constructor used. Here are some expressions of type DSum Tag Identity:

   AString :=> Identity "hello!"
   AnInt   :=> Identity 42
   

   Often, the f we choose has an Applicative instance, and we can use the helper function (==>). The following expressions all have the type Applicative f => DSum Tag f:

   AString ==> "hello!"
   AnInt   ==> 42
   

   We can write functions that consume DSum Tag f values by matching, such as:

   toString :: DSum Tag Identity -> String
   toString (AString :=> Identity str) = str
   toString (AnInt   :=> Identity int) = show int
   toString (Rec     :=> Identity sum) = toString sum
   

   The (:=>) constructor and (==>) helper are chosen to resemble the (key => value) construction for dictionary entries in many dynamic languages. The :=> and ==> operators have very low precedence and bind to the right, making repeated use of these operators behave as you'd expect:

   -- Parses as: Rec ==> (AnInt ==> (3 + 4))
   -- Has type: Applicative f => DSum Tag f
   Rec ==> AnInt ==> 3 + 4
   

   The precedence of these operators is just above that of $, so foo bar $ AString ==> "eep" is equivalent to foo bar (AString ==> "eep"). To use the Eq, Ord, Read, and Show instances for DSum tag f, you will need an ArgDict instance for your tag type. Use deriveArgDict from the constraints-extras package to generate this instance.

9. SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION :: SSLOption

   HsOpenSSL	OpenSSL.Session

   When performing renegotiation as a server, always start a new session (i.e., session resumption requests are only accepted in the initial handshake). This option is not needed for clients.

10. robustSumVar :: Vector v Double => Double -> v Double -> Double

    statistics	Statistics.Sample.Internal

    No documentation available.

Page 106 of many | Previous | Next