Equal (=) Vs left arrow (

by

To understand the real difference, you have to understand monads, and the desugaring described by @rightfold in their answer.

For the specific case of the IO monad, as in your getArgs example, a rough but useful intuition can be made as follows:

  • x <- action runs the IO action, gets its result, and binds it to x
  • let x = action defines x to be equivalent to action, but does not run anything. Later on, you can use y <- x meaning y <- action.

Programmers coming from imperative languages which allow closures, may draw this rough parallel comparison with JavaScript:

var action = function() { print(3); return 5; }

// roughly equivalent to x <- action
print('test 1')
var x = action()  // output:3
// x is 5

// roughly equivalent to let y = action
print('test 2')
var y = action    // output: nothing
// y is a function

// roughly equivalent to z <- y
print('test 3')
var z = y()       // output:3
// z is 5

Again: this comparison focuses on IO, only. For other monads, you need to check what >>= actually is, and think about the desugaring of do.

More Related Contents:

  1. How to run a for loop in Haskell
  2. Getting started with Haskell
  3. Does Haskell have tail-recursive optimization?
  4. How is this fibonacci-function memoized?
  5. runST and function composition
  6. Explain this chunk of haskell code that outputs a stream of primes
  7. Memory footprint of Haskell data types
  8. How to create a polyvariadic haskell function?
  9. What does (f .) . g mean in Haskell?
  10. Why does length return 1 for a tuple with 2 elements, and gives an error for a tuple with more elements?
  11. Finite comprehension of an infinite list
  12. Are there pronounceable names for common Haskell operators? [closed]
  13. Split a number into its digits with Haskell
  14. What indentation is required for a case statement within a let statement?
  15. What is the difference between Int and Integer?
  16. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  17. Euler 43 – is there a monad to help write this list comprehension?
  18. Using Maybe type in Haskell
  19. Is there a way to place some impure code inside pure functions?
  20. How to increment a variable in functional programming?
  21. What part of Hindley-Milner do you not understand?
  22. Why is GHC complaining about non-exhaustive patterns?
  23. foldl Implementation with Runtime Errors
  24. Exception handling in Haskell
  25. How to make a type with restrictions
  26. Given a Haskell type signature, is it possible to generate the code automatically?
  27. Why does OCaml sometimes require eta expansion?
  28. Explanation of “tying the knot”
  29. What is predicativity?
  30. Return specific type within Haskell

Leave a Comment