mirror of
https://github.com/bitemyapp/learnhaskell.git
synced 2024-11-03 23:15:18 +00:00
55 lines
2.5 KiB
Markdown
55 lines
2.5 KiB
Markdown
|
# Dialogues from the IRC channel or other places
|
||
|
|
|
||
|
|
## On $ and . operator
|
||
|
|
|
||
|
|
```haskell
|
||
|
|
doubleEveryOther :: [Integer] -> [Integer]
|
||
|
|
doubleEveryOther list = reverse .doubleEveryOtherForward . reverse $ list
|
||
|
|
```
|
||
|
|
|
||
|
|
```
|
||
|
|
03:28 < bitemyapp> fbernier: reverse the list, double every other number, re-reverse the list.
|
||
|
|
03:28 < bitemyapp> fbernier: the "dot" operator is just function composition.
|
||
|
|
03:28 < bitemyapp> it's nothing special, just another function.
|
||
|
|
03:28 < bitemyapp> :t (.)
|
||
|
|
03:28 < lambdabot> (b -> c) -> (a -> b) -> a -> c
|
||
|
|
03:30 < bitemyapp> fbernier: the use of $ in that function is a little idiosyncratic and unnecessary, but not problematic.
|
||
|
|
03:37 < ReinH> fbernier: there's a missing space after the . is all
|
||
|
|
03:38 < ReinH> fbernier: f x = foo $ x ==> f = foo
|
||
|
|
03:39 < ReinH> so f x = foo . bar $ x ==> f = foo . bar
|
||
|
|
03:39 < bitemyapp> fbernier: I think it's just making it point-free in this case.
|
||
|
|
03:39 < bitemyapp> @pl f x = c . b . a $ x
|
||
|
|
03:39 < lambdabot> f = c . b . a
|
||
|
|
03:39 < bitemyapp> yeah, that ^^
|
||
|
|
03:39 < bitemyapp> fbernier: identical ^^
|
||
|
|
03:40 < ReinH> fbernier: generally, when you see a $ you can wrap the things on either side with parens and get the same expression:
|
||
|
|
03:40 < ReinH> f x = foo . bar . bazz $ x ==> f x = (foo . bar . bazz) x
|
||
|
|
03:40 < ReinH> since (x) = x, ofc
|
||
|
|
03:41 < bitemyapp> @src ($)
|
||
|
|
03:41 < lambdabot> f $ x = f x
|
||
|
|
03:41 < bitemyapp> fbernier: That's the definition of $, only other thing missing is the high precedence set for it.
|
||
|
|
03:41 < ReinH> the exception is chains of $, like foo $ bar $ baz, where you have to parenthesize in the right direction
|
||
|
|
03:41 < ReinH> or the left direction, depending on how you look at it
|
||
|
|
03:42 < bitemyapp> fbernier: http://hackage.haskell.org/package/base-4.7.0.1/docs/Prelude.html ctrl-f for $ to see more
|
||
|
|
03:42 < bitemyapp> fbernier: infixr 0 is the precedence, highest there is AFAIK
|
||
|
|
03:42 < bitemyapp> fbernier: the "infixr" means it's right associative
|
||
|
|
03:42 < bitemyapp> fbernier: as opposed to infixl which would mean left associative
|
||
|
|
03:43 < ReinH> bitemyapp: or lowest, depending on how you look at it. ;)
|
||
|
|
03:43 < bitemyapp> foo $ bar $ baz ~ foo (bar (baz))
|
||
|
|
03:43 < bitemyapp> but if it was infixl
|
||
|
|
03:43 < bitemyapp> (((foo) bar) baz)
|
||
|
|
```
|
||
|
|
|
||
|
|
## Infix operators as prefix
|
||
|
|
|
||
|
|
```
|
||
|
|
04:12 < ReinH> all infix operators can be written prefix
|
||
|
|
04:12 < ReinH> with this one weird trick. Other haskellers hate him.
|
||
|
|
04:13 < bitemyapp> > ($) id 1
|
||
|
|
04:13 < lambdabot> 1
|
||
|
|
04:13 < bitemyapp> > id $ 1
|
||
|
|
04:13 < lambdabot> 1
|
||
|
|
04:13 < bitemyapp> > id 1
|
||
|
|
04:13 < lambdabot> 1
|
||
|
|
```
|