Hoogle Search

Within LTS Haskell 24.31 (ghc-9.10.3)

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

  1. (:#) :: a -> Substitution' a -> Substitution' a

    Agda Agda.Syntax.Internal

    Substitution extension, `cons'. Γ ⊢ u : Aρ Γ ⊢ ρ : Δ ---------------------- Γ ⊢ u :# ρ : Δ, A

  2. (:#) :: a -> Substitution' a -> Substitution' a

    Agda Agda.TypeChecking.Substitute

    Substitution extension, `cons'. Γ ⊢ u : Aρ Γ ⊢ ρ : Δ ---------------------- Γ ⊢ u :# ρ : Δ, A

  3. (:|) :: a -> [a] -> NonEmpty a

    Agda Agda.Utils.List1

    No documentation available.

  4. (:#) :: Text -> [SeriesElem] -> Message

    Blammo Blammo.Logging

    No documentation available.

  5. newtype ((t2 :: Type -> Type -> Type -> Type) :.: (t1 :: Type -> Type -> Type -> Type)) (m :: Type -> Type) a

    capability Capability.Accessors

    Compose two accessors. This is not necessary in deriving via clauses, but in places where a transformer is expected as a type argument. E.g. wrapError.

  6. (:.:) :: m a -> (:.:) (t2 :: (Type -> Type) -> Type -> Type) (t1 :: (Type -> Type) -> Type -> Type) (m :: Type -> Type) a

    capability Capability.Accessors

    No documentation available.

  7. (:$) :: Expr -> Expr -> Expr

    code-conjure Conjure.Engine

    function application between expressions

  8. (:$) :: Expr -> Expr -> Expr

    code-conjure Conjure.Expr

    function application between expressions

  9. data base :<> assoc

    composable-associations Data.ComposableAssociation

    A type representing the composition of a base type (which can be serialized into a key-value structure) along with a key-value type. This type exists as a way to compose a haskell value that has a key-value representation (ex: a haskell record where its fields are keys to their values) with additional key-value associations into a single key-value object. This is intended for use with Association to add additional key-values to a type for the purposes of serialization/deserialization. For example: 

    >>> data User = User { name :: String, age :: Int }

>>> let alice = User "Alice" 26

>>> let bob = User "Bob" 25

>>> let charlie = User "Charlie" 27

>>> let bobsFriends = [alice, charlie]

>>> bobAndFriends :: User :<> Association "friends" [User]

>>> let bobAndFriends = bob :<> Association Proxy bobsFriends
    While (bob, bobsFriends) contains the same values as bobAndFriends, it lacks information about how to combine bob and bobsFriends together into a single serialized key-value object (as well as how to deserialize that back into haskell values).

  10. (:<>) :: base -> assoc -> (:<>) base assoc

    composable-associations Data.ComposableAssociation

    No documentation available.

Page 52 of many | Previous | Next