Hoogle Search

Within LTS Haskell 24.37 (ghc-9.10.3)

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

Exact lookup

1. (.:) :: FromField a => NamedRecord -> ByteString -> Parser a

   csv-conduit	Data.CSV.Conduit.Conversion

   Alias for lookup.

2. (.=) :: ToField a => ByteString -> a -> (ByteString, ByteString)

   csv-conduit	Data.CSV.Conduit.Conversion

   Alias for namedField.

3. (.=) :: (KeyValue e kv, ToJSON v) => Key -> v -> kv

   ede	Text.EDE

   No documentation available.

4. (.$) :: forall x (xs :: [Type]) . Show x => Predicate (x ': xs) -> (Var, x) -> Predicate xs

   falsify	Test.Falsify.Predicate

   Infix version of at Typical usage example:

   assert $
   P.relatedBy ("equiv", equiv)
   .$ ("x", x)
   .$ ("y", y)
   

5. (...) :: (c -> d) -> (a -> b -> c) -> a -> b -> d

   fitspec	Test.FitSpec.Utils

   Compose composed with compose operator.

   (f ... g) x y === f (g x y)
   

6. (.>) :: (a -> b) -> (b -> c) -> a -> c

   flow	Flow

   Left-associative compose operator. Read as "compose forward" or "and then". Use this to create long chains of computation that suggest which direction things move in.

   >>> let f = succ .> recip .> negate
   
   >>> f 3
   -0.25
   

   Or use it anywhere you would use (>>>).

   \ x -> (f .> g) x == g (f x)
   

   \ x -> (f .> g .> h) x == h (g (f x))
   

7. (.:.) :: forall effect (m :: Type -> Type) (effects :: [(Type -> Type) -> Type]) . effect m -> Effects effects m -> Effects (effect ': effects) m

   free-vl	Control.Monad.Free.VanLaarhovenE

   Helper combinator for creating values of 'Effects effects m'

8. (...) :: a -> Proof p -> a ::: p

   gdp	Data.Refined

   Given a value and a proof, attach the proof as a ghost proof on the value.

9. (...>) :: (a ::: p) -> (p -> Proof q) -> a ::: q

   gdp	Data.Refined

   Apply an implication to the ghost proof attached to a value, leaving the value unchanged.

10. (...?) :: (forall name . () => (a ~~ name) -> b ~~ f name) -> (forall name . () => p name -> Proof (q (f name))) -> (a ? p) -> b ? q

    gdp	Data.Refined

    Take a simple function with one named argument and a named return, plus an implication relating a precondition to a postcondition of the function, and produce a function between refined input and output types.

    newtype NonEmpty xs = NonEmpty Defn
    type role Nonempty nominal -- disallows coercion of Nonempty's argument.
    
    newtype Reverse  xs = Reverse  Defn
    type role Reverse nominal
    
    rev :: ([a] ~~ xs) -> ([a] ~~ Reverse xs)
    rev xs = defn (reverse (the xs))
    
    rev_nonempty_lemma :: NonEmpty xs -> Proof (NonEmpty (Reverse xs))
    
    rev' :: ([a] ?NonEmpty) -> ([a] ?NonEmpty)
    rev' = rev ...? rev_nonempty_lemma
    

Page 58 of many | Previous | Next