Hoogle Search

Within LTS Haskell 24.51 (ghc-9.10.3)

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

Exact lookup

1. (..:) :: FromJSON b => Setter' a b -> Text -> Object -> Parser (a -> a)

   configuration-tools	Configuration.Utils.ConfigFile

   A variant of the setProperty that uses the default parseJSON method from the FromJSON instance to parse the value of the property. Its usage pattern mimics the usage pattern of the .: operator from the aeson library.

   data Auth = Auth
   { _user ∷ !String
   , _pwd ∷ !String
   }
   
   user ∷ Functor f ⇒ (String → f String) → Auth → f Auth
   user f s = (\u → s { _user = u }) <$> f (_user s)
   
   pwd ∷ Functor f ⇒ (String → f String) → Auth → f Auth
   pwd f s = (\p → s { _pwd = p }) <$> f (_pwd s)
   
   -- or with lenses and TemplateHaskell just:
   -- $(makeLenses ''Auth)
   
   instance FromJSON (Auth → Auth) where
   parseJSON = withObject "Auth" $ \o → id
   <$< user ..: "user" % o
   <*< pwd ..: "pwd" % o
   

2. (.!) :: FromField a => Record -> Int -> Parser a

   csv-conduit	Data.CSV.Conduit.Conversion

   Alias for index.

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

   csv-conduit	Data.CSV.Conduit.Conversion

   Alias for lookup.

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

   csv-conduit	Data.CSV.Conduit.Conversion

   Alias for namedField.

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

   ede	Text.EDE

   No documentation available.

6. (.$) :: 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)
   

7. (...) :: (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)
   

8. (.>) :: (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))
   

9. (.:.) :: 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'

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

    gdp	Data.Refined

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

Page 58 of many | Previous | Next