Hoogle Search

Within LTS Haskell 24.67 (ghc-9.10.3)

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

  1. dimorphicSummands :: Int -> Int -> [Int]

    table-layout Text.Layout.Table.Justify

    Splits a given number into summands of 2 different values, where the first one is exactly one bigger than the second one. Splitting 40 spaces into 9 almost equal parts would result in:

    >>> dimorphicSummands 40 9
    [5,5,5,5,4,4,4,4,4]
    

  2. dimorphicSummandsBy :: (Int -> a) -> Int -> Int -> [a]

    table-layout Text.Layout.Table.Justify

    Split a number into almost-equal summands and transform each summand. Larger summands precede smaller ones.

  3. mixedDimorphicSummandsBy :: (Int -> a) -> Int -> Int -> [a]

    table-layout Text.Layout.Table.Justify

    Spread out summands evenly mixed as far as possible.

  4. timeZoneSummerOnly :: Lens' TimeZone Bool

    timelens Data.Time.Timelens

    No documentation available.

  5. subsumes :: forall (t :: Type -> Type) v (m :: Type -> Type) e em . (BindingMonad t v m, Fallible t v e, MonadTrans em, Functor (em m), MonadError e (em m)) => UTerm t v -> UTerm t v -> em m Bool

    unification-fd Control.Unification

    Determine whether the left term subsumes the right term. That is, whereas (tl =:= tr) will compute the most general substitution s such that (s tl === s tr), (tl <:= tr) computes the most general substitution s such that (s tl === tr). This means that tl is less defined than and consistent with tr. N.B., this function updates the monadic bindings just like unify does. However, while the use cases for unification often want to keep the bindings around, the use cases for subsumption usually do not. Thus, you'll probably want to use a binding monad which supports backtracking in order to undo the changes. Unfortunately, leaving the monadic bindings unaltered and returning the necessary substitution directly imposes a performance penalty or else requires specifying too much about the implementation of variables.

  6. package universe-dependent-sum

    Universe instances for types from dependent-sum A class for finite and recursively enumerable types and some helper functions for enumerating them defined in universe-base package:

    class Universe a where universe :: [a]
    class Universe a => Finite a where universeF :: [a]; universeF = universe
    
    This package adds
    class UniverseSome f where universeSome :: [Some f]
    class UniverseSome f => FiniteSome f where universeFSome :: [Some f]; universeFSome = universe
    
    classes.

  7. module Data.Universe.DependentSum

    Deprecated: Use universe-some package directly

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

    verset Verset

    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"
    

  9. consumeDescription :: MonadState Documentation m => m (Maybe Description)

    webgear-openapi WebGear.OpenApi.Handler

    No documentation available.

  10. consumeSummary :: MonadState Documentation m => m (Maybe Summary)

    webgear-openapi WebGear.OpenApi.Handler

    No documentation available.

Page 371 of many | Previous | Next