Currying 3 Arguments in Haskell

by

All you need here is the following three “laws” of operator sections:

(a `op` b) = (a `op`) b = (`op` b) a = op a b
          (1)          (2)          (3)

so that the operand goes into the free slot near the operator.

For (.) this means that: (a . b) = (a .) b = (. b) a = (.) a b. So,

f (g x) y !! n      
= (!!) (f (g x) y) n              by (3) 
= ((!!) . f (g x)) y n
= ((!!) . (f . g) x) y n
= ((!!) .) ((f . g) x) y n        by (1)
= (((!!) .) . (f . g)) x y n
= (((!!) .) . f . g) x y n

You should only do as much pointfree transformation as you’re comfortable with, so that the resulting expression is still readable for you – and in fact, clearer than the original. The “pointfree” tool can at times produce unreadable results.

It is perfectly OK to stop in the middle. If it’s too hard for you to complete it manually, probably it will be hard for you to read it, too.

((a .) . b) x y = (a .) (b x) y = (a . b x) y = a (b x y) is a common pattern that you will quickly learn to recognize immediately. So the above expression can be read back fairly easily as

(!!) ((f . g) x y) n = f (g x) y !! n

considering that (.) is associative:

(a . b . c) = ((a . b) . c) = (a . (b . c))

More Related Contents:

  1. How is this fibonacci-function memoized?
  2. What does (f .) . g mean in Haskell?
  3. Haskell function composition operator of type (c→d) → (a→b→c) → (a→b→d)
  4. How to use (->) instances of Monad and confusion about (->)
  5. Composing function composition: How does (.).(.) work?
  6. What is the difference between . (dot) and $ (dollar sign)?
  7. Good examples of Not a Functor/Functor/Applicative/Monad?
  8. Haskell ranges and floats
  9. Defining a function by equations with different number of arguments
  10. Small Haskell program compiled with GHC into huge binary
  11. Multi-line commands in GHCi
  12. DatatypeContexts Deprecated in Latest GHC: Why?
  13. What does the exclamation mark mean in a Haskell declaration?
  14. Unwrapping a monad
  15. Haskell: Lists, Arrays, Vectors, Sequences
  16. What are “n+k patterns” and why are they banned from Haskell 2010?
  17. How do I write, “if typeclass a, then a is also an instance of b by this definition.”
  18. Haskell read raw keyboard input
  19. Should do-notation be avoided in Haskell?
  20. Why doesn’t Haskell sequence these IO actions properly?
  21. Why doesn’t this function work if I use “[xs]” instead of “xs”?
  22. What is fusion in Haskell?
  23. What does the `forall` keyword in Haskell/GHC do?
  24. How does deriving work in Haskell?
  25. Foldr/Foldl for free when Tree is implementing Foldable foldMap?
  26. What characters are permitted for Haskell operators?
  27. Converting IO Int to Int
  28. Convert String to Integer/Float in Haskell?
  29. Haskell – depth for each node in binary tree using Reader monad
  30. Why does OCaml sometimes require eta expansion?

Leave a Comment