Hoogle Search

Within LTS Haskell 24.38 (ghc-9.10.3)

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

  1. PromotedDataConFlavour :: TyConFlavour tc

    ghc GHC.Core.TyCon

    No documentation available.

  2. data PiTyBinder

    ghc GHC.Core.Type

    A PiTyBinder represents an argument to a function. PiTyBinders can be dependent (Named) or nondependent (Anon). They may also be visible or not. See Note [PiTyBinders]

  3. type PredType = Type

    ghc GHC.Core.Type

    A type of the form p of constraint kind represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type. We use PredType as documentation to mark those types that we guarantee to have this kind. It can be expanded into its representation, but:

    • The type checker must treat it as opaque
    • The rest of the compiler treats it as transparent
    Consider these examples: 
    f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}
    Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

  4. module GHC.CoreToStg.Prep

    No documentation available.

  5. Parens :: LBooleanFormula a -> BooleanFormula a

    ghc GHC.Data.BooleanFormula

    No documentation available.

  6. data PtrString

    ghc GHC.Data.FastString

    A PtrString is a pointer to some array of Latin-1 encoded chars.

  7. PtrString :: !Ptr Word8 -> Int -> PtrString

    ghc GHC.Data.FastString

    No documentation available.

  8. class Semigroup node => PureSupernode node

    ghc GHC.Data.Graph.Collapse

    A "supernode" stands for a collection of one or more nodes (basic blocks) that have been coalesced by the Hecht-Ullman algorithm. A collection in a supernode constitutes a reducible subgraph of a control-flow graph. (When an entire control-flow graph is collapsed to a single supernode, the flow graph is reducible.) The idea of node splitting is to collapse a control-flow graph down to a single supernode, then materialize (`inflate') the reducible equivalent graph from that supernode. The Supernode class defines only the methods needed to collapse; rematerialization is the responsibility of the client. During the Hecht-Ullman algorithm, every supernode has a unique entry point, which is given by superLabel. But this invariant is not guaranteed by the class methods and is not a law of the class. The mapLabels function rewrites all labels that appear in a supernode (both definitions and uses). The freshen function replaces every appearance of a defined label with a fresh label. (Appearances include both definitions and uses.) Laws: superLabel (n <> n') == superLabel n blocks (n <> n') == blocks n union blocks n' mapLabels f (n <> n') = mapLabels f n <> mapLabels f n' mapLabels id == id mapLabels (f . g) == mapLabels f . mapLabels g (We expect freshen to distribute over <>, but because of the fresh names involved, formulating a precise law is a bit challenging.)

  9. type Path = [Node]

    ghc GHC.Data.Graph.Inductive.Graph

    Unlabeled path

  10. module GHC.Data.Graph.Inductive.PatriciaTree

    An efficient implementation of Graph using big-endian patricia tree (i.e. Data.IntMap). This module provides the following specialised functions to gain more performance, using GHC's RULES pragma:

    Code is from Hackage fgl package version 5.7.0.3

Page 117 of many | Previous | Next