Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

Exact lookup

1. ArrowCaseAlt :: HsArrowMatchContext

   ghc-lib-parser	Language.Haskell.Syntax.Expr

   A case alternative inside arrow notation

2. ArrowExpr :: HsStmtContext fn

   ghc-lib-parser	Language.Haskell.Syntax.Expr

   do-notation in an arrow-command context

3. ArrowLamAlt :: HsLamVariant -> HsArrowMatchContext

   ghc-lib-parser	Language.Haskell.Syntax.Expr

   A , case or cases alternative inside arrow notation

4. ArrowMatchCtxt :: HsArrowMatchContext -> HsMatchContext fn

   ghc-lib-parser	Language.Haskell.Syntax.Expr

   A pattern match inside arrow notation

5. ArrowCmdOrigin :: CtOrigin

   ghc-typelits-presburger	GHC.TypeLits.Presburger.Compat

   No documentation available.

6. Arrows :: Extension

   hint	Language.Haskell.Interpreter

   No documentation available.

7. Arrows :: Extension

   hint	Language.Haskell.Interpreter.Extension

   No documentation available.

8. class Arrow a => ArrowApply (a :: Type -> Type -> Type)

   rebase	Rebase.Prelude

   Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:

   • first (arr (\x -> arr (\y ->
     (x,y)))) >>> app = id

   • first (arr (g >>>)) >>>
     app = second g >>> app

   • first (arr (>>> h)) >>>
     app = app >>> h

   Such arrows are equivalent to monads (see ArrowMonad).

9. class Arrow a => ArrowChoice (a :: Type -> Type -> Type)

   rebase	Rebase.Prelude

   Choice, for arrows that support it. This class underlies the if and case constructs in arrow notation. Instances should satisfy the following laws:

   • left (arr f) = arr (left
     f)

   • left (f >>> g) = left f >>>
     left g

   • f >>> arr Left = arr
     Left >>> left f

   • left f >>> arr (id +++ g) =
     arr (id +++ g) >>> left f

   • left (left f) >>> arr assocsum
     = arr assocsum >>> left f

   where

   assocsum (Left (Left x)) = Left x
   assocsum (Left (Right y)) = Right (Left y)
   assocsum (Right z) = Right (Right z)
   

   The other combinators have sensible default definitions, which may be overridden for efficiency.

10. class Arrow a => ArrowLoop (a :: Type -> Type -> Type)

    rebase	Rebase.Prelude

    The loop operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec value recursion construct in arrow notation. loop should satisfy the following laws:

    • extension loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))
    • left tightening loop (first h >>> f) = h >>> loop f
    • right tightening loop (f >>> first h) = loop f >>> h
    • sliding loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)
    • vanishing loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)
    • superposing second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)
    where

    assoc ((a,b),c) = (a,(b,c))
    unassoc (a,(b,c)) = ((a,b),c)
    

Page 17 of many | Previous | Next