Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

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

  1. Enum :: a -> Enum a

    unboxing-vector Data.Vector.Unboxing.Mutable

    No documentation available.

  2. class Enum a

    classy-prelude-yesod ClassyPrelude.Yesod

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

  3. class Enum a

    constrained-categories Control.Category.Constrained.Prelude

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

  4. class Enum a

    constrained-categories Control.Category.Hask

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

  5. class Enum a

    copilot-language Copilot.Language.Prelude

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

  6. Enum :: Ident -> TypeSpec

    language-c99-simple Language.C99.Simple.AST

    No documentation available.

  7. class (UpwardEnum a, DownwardEnum a) => Enum a

    prelude-safeenum Prelude.SafeEnum

    A class for types with a linear enumeration order. We require that the partial orders of the superclasses agree: 

    x `succeeds` y  ==  y `precedes` x
    That the enumeration order is preserved/reflected: 
    i `succeeds` j  ==  toEnum   i `succeeds` toEnum   j
x `succeeds` y  ==  fromEnum x `succeeds` fromEnum y
    And that toEnum and fromEnum form a weak isomorphism; i.e., for some p and q, the following must hold: 
    fromEnum <=< toEnum    ==  (\i -> if p i then Just i else Nothing)
toEnum   <=< fromEnum  ==  (\x -> if q x then Just x else Nothing)
    In other words, the following type-restricted functions form an isomorphism of linear orderings. 
    toEnum'   :: {i :: Int | toEnum   i == Just _} -> a
fromEnum' :: {x :: a   | fromEnum x == Just _} -> Int
    Minimal complete definition: toEnum, fromEnum. N.B., the default definitions for enumFromThen and enumFromThenTo only make sense when the type a is "smaller" than Int (i.e., fromEnum always succeeds); if fromEnum ever fails, then you must override the defaults in order to correctly infer the stride for values which cannot be converted to Int.

  8. data Enum

    proto-lens-protobuf-types Proto.Google.Protobuf.Type

    Fields :

    • name :: Lens' Enum Data.Text.Text
    • enumvalue :: Lens' Enum [EnumValue]
    • vec'enumvalue :: Lens' Enum (Data.Vector.Vector EnumValue)
    • options :: Lens' Enum [Option]
    • vec'options :: Lens' Enum (Data.Vector.Vector Option)
    • sourceContext :: Lens' Enum Proto.Google.Protobuf.SourceContext.SourceContext
    • maybe'sourceContext :: Lens' Enum (Prelude.Maybe Proto.Google.Protobuf.SourceContext.SourceContext)
    • syntax :: Lens' Enum Syntax
    • edition :: Lens' Enum Data.Text.Text

  9. class Enum a

    quaalude Essentials

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

  10. class Enum a

    verset Verset

    Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold: 

    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise                = minBound

Page 9 of many | Previous | Next