Hoogle Search

Within LTS Haskell 23.24 (ghc-9.8.4)

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

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

base Prelude

($) 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
```
($) :: forall (repa :: RuntimeRep) (repb :: RuntimeRep) (a :: TYPE repa) (b :: TYPE repb) . (a -> b) -> a -> b

base Data.Function

($) 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
```
($) :: (a -> b) -> a -> b

base GHC.Base

($) 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
```
($) :: (a -> b) -> a -> b

hedgehog Hedgehog.Internal.Prelude

($) 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
```
($) :: (a -> b) -> a -> b

haskell-gi-base Data.GI.Base.ShortPrelude

($) 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
```
($) :: (a -> b) -> a -> b

rio RIO.Prelude

($) 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
```
($) :: (a -> b) -> a -> b

Cabal-syntax Distribution.Compat.Prelude

($) 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
```
($) :: (a -> b) -> a -> b

relude Relude.Function

($) 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
```
($) :: (a -> b) -> a -> b

protolude Protolude

($) 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
```
data ((c :: a -> Exp b) $ (d :: a)) (e :: b)

first-class-families Fcf

Note that this denotes the identity function, so ($) f can usually be replaced with f.

base	Prelude

base	Data.Function

base	GHC.Base

hedgehog	Hedgehog.Internal.Prelude

haskell-gi-base	Data.GI.Base.ShortPrelude

rio	RIO.Prelude

Cabal-syntax	Distribution.Compat.Prelude

relude	Relude.Function

protolude	Protolude

first-class-families	Fcf

Page 1 of many | Next

Hoogle Search

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)

Examples

Technical Remark (Representation Polymorphism)