Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

  1. ($) :: (a -> b) -> a -> b

    verset Verset

    ($) is the function application operator. Applying ($) to a function f and an argument x gives the same result as applying f to x directly. The definition is akin to this: 

    ($) :: (a -> b) -> a -> b
($) f x = f x
    This is id specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is the same as (a -> b) -> a -> b. On the face of it, this may appear pointless! But it's actually one of the most useful and important operators in Haskell. The order of operations is very different between ($) and normal function application. Normal function application has precedence 10 - higher than any operator - and associates to the left. So these two definitions are equivalent: 
    expr = min 5 1 + 5
expr = ((min 5) 1) + 5
    ($) has precedence 0 (the lowest) and associates to the right, so these are equivalent: 
    expr = min 5 $ 1 + 5
expr = (min 5) (1 + 5)

    Examples

    A common use cases of ($) is to avoid parentheses in complex expressions. For example, instead of using nested parentheses in the following Haskell function: 
    -- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum (mapMaybe readMaybe (words s))
    we can deploy the function application operator: 
    -- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum $ mapMaybe readMaybe $ words s
    ($) is also used as a section (a partially applied operator), in order to indicate that we wish to apply some yet-unspecified function to a given value. For example, to apply the argument 5 to a list of functions: 
    applyFive :: [Int]
applyFive = map ($ 5) [(+1), (2^)]
>>> [6, 32]

    Technical Remark (Representation Polymorphism)

    ($) is fully representation-polymorphic. This allows it to also be used with arguments of unlifted and even unboxed kinds, such as unboxed integers: 
    fastMod :: Int -> Int -> Int
fastMod (I# x) (I# m) = I# $ remInt# x m

  2. ($) :: (a -> b) -> a -> b

    xmonad-contrib XMonad.Config.Prime

    ($) is the function application operator. Applying ($) to a function f and an argument x gives the same result as applying f to x directly. The definition is akin to this: 

    ($) :: (a -> b) -> a -> b
($) f x = f x
    This is id specialized from a -> a to (a -> b) -> (a -> b) which by the associativity of (->) is the same as (a -> b) -> a -> b. On the face of it, this may appear pointless! But it's actually one of the most useful and important operators in Haskell. The order of operations is very different between ($) and normal function application. Normal function application has precedence 10 - higher than any operator - and associates to the left. So these two definitions are equivalent: 
    expr = min 5 1 + 5
expr = ((min 5) 1) + 5
    ($) has precedence 0 (the lowest) and associates to the right, so these are equivalent: 
    expr = min 5 $ 1 + 5
expr = (min 5) (1 + 5)

    Examples

    A common use cases of ($) is to avoid parentheses in complex expressions. For example, instead of using nested parentheses in the following Haskell function: 
    -- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum (mapMaybe readMaybe (words s))
    we can deploy the function application operator: 
    -- | Sum numbers in a string: strSum "100  5 -7" == 98
strSum :: String -> Int
strSum s = sum $ mapMaybe readMaybe $ words s
    ($) is also used as a section (a partially applied operator), in order to indicate that we wish to apply some yet-unspecified function to a given value. For example, to apply the argument 5 to a list of functions: 
    applyFive :: [Int]
applyFive = map ($ 5) [(+1), (2^)]
>>> [6, 32]

    Technical Remark (Representation Polymorphism)

    ($) is fully representation-polymorphic. This allows it to also be used with arguments of unlifted and even unboxed kinds, such as unboxed integers: 
    fastMod :: Int -> Int -> Int
fastMod (I# x) (I# m) = I# $ remInt# x m

  3. ($!) :: (a -> b) -> a -> b

    base Prelude

    Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

  4. ($>) :: Functor f => f a -> b -> f b

    base Data.Functor

    Flipped version of <$.

    Examples

    Replace the contents of a Maybe Int with a constant String: 
    >>> Nothing $> "foo"
Nothing

    >>> Just 90210 $> "foo"
Just "foo"
    Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String: 
    >>> Left 8675309 $> "foo"
Left 8675309

    >>> Right 8675309 $> "foo"
Right "foo"
    Replace each element of a list with a constant String: 
    >>> [1,2,3] $> "foo"
["foo","foo","foo"]
    Replace the second element of a pair with a constant String: 
    >>> (1,2) $> "foo"
(1,"foo")

  5. ($<) :: Contravariant f => f b -> b -> f a

    base Data.Functor.Contravariant

    This is >$ with its arguments flipped.

  6. ($!) :: (a -> b) -> a -> b

    base GHC.Base

    Strict (call-by-value) application operator. It takes a function and an argument, evaluates the argument to weak head normal form (WHNF), then calls the function with that value.

  7. ($!!) :: NFData a => (a -> b) -> a -> b

    deepseq Control.DeepSeq

    the deep analogue of $!. In the expression f $!! x, x is fully evaluated before the function f is applied to it.

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

    template-haskell Language.Haskell.TH.PprLib

    No documentation available.

  9. ($+$) :: Doc -> Doc -> Doc

    template-haskell Language.Haskell.TH.PprLib

    No documentation available.

  10. ($$) :: Monad m => Source m a -> Sink a m b -> m b

    conduit Data.Conduit

    Deprecated: Use runConduit and .|

Page 6 of many | Previous | Next