7

Possible Duplicate:
Haskell: difference between . (dot) and $ (dollar sign)

Ok I understand that this:

f(g(x))

can be rewritten:

f $ g(x)

and can also be rewritten:

f . g(x)

What I don't fully grasp is where the two DO NOT overlap in functionality. I conceptually understand that they don't fully overlap, but could someone clarify this for me once and for all?

Community
  • 1
  • 1
Ramy
  • 20,541
  • 41
  • 103
  • 153
  • 1
    Look, you actually can'twrite like in your second example. Tryi ghci! – fuz Feb 02 '11 at 16:13
  • 6
    Also, parens are not needed (and not recommended) for function calls. In summary, the examples should be `f (g x)`, `f $ g x` and `(f . g) x`. –  Feb 02 '11 at 16:16

3 Answers3

21
Prelude> :t ($)
($) :: (a -> b) -> a -> b
Prelude> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

$ applies a function to a value. . composes two functions.

So I can write f $ g x which is "apply f to (g of x)" or f . g $ x which is "apply the composition of f and g to x". One common style is to pile up dots on the left with a dollar trailing. The reason is that f $ g $ x means the same thing as f . g $ x but the expression f $ g on its own is often meaningless (in fact, possibly a type error) while the expression f . g means "the composition of f and g"

sclv
  • 38,665
  • 7
  • 99
  • 204
  • 3
    `f $ g` is perfectly possible and well-typed for countless `f` and `g` (consider `(\f -> f 0) $ (\x -> x + 1)`), it's just identical to `f g`. Otherwise, correct. –  Feb 02 '11 at 16:20
  • @delnan I can't think of a `f $ g` that is well-typed on its own *and* in the context of `f $ g $ x`. But that could be a failure of imagination. – sclv Feb 02 '11 at 16:40
  • edited to take into account your point. thanks. – sclv Feb 03 '11 at 01:58
14

Additionaly to what was already said, you need the $ as "function application glue" in cases like this:

map ($3) [(4+),(5-),(6*),(+4),(*5),(^6)]
--[7,2,18,7,15,729]

Neither (.3) nor (3) will work in the example.

Landei
  • 54,104
  • 13
  • 100
  • 195
1

"f $ g x" cannot be rewritten to "f . g x". In fact, the compiler won't even accept the second function, because "(.)" has the type "(b -> c) -> (a -> b) -> (a -> c)". I.e the second argument must be a function, but "g x" is a value not a function.

keiter
  • 3,534
  • 28
  • 38