I think you're being downvoted justly, but I think you still deserve an answer to your question (rather than just an onslaught of "hey, don't judge everything b

I think you're being downvoted justly, but I think you still deserve an answer to your question (rather than just an onslaught of "hey, don't judge everything by this one thing" type posts). Haskell's main libraries are based on a simpler model of computation than conventional languages (Scheme/C/JS/Python/...). In this model of computation only two things happen: (a) you define things, (b) expressions are reduced by the language to simpler forms. Furthermore, Haskell's default tendency is to wait when reducing a structure until it's absolutely necessary to reduce it, meaning that you get some nice features (like every list being a generator which can refer to itself in its definition). Anything which doesn't have an easy model as an expression-reduction (i.e. any side-effect) is more complicated in Haskell. Writing code which is performance-critical (and thus managing when those reductions actually happen) is a bit complicated too. If only one complicated thing is at play, things are actually pretty tame. So you need multiple of these happening at once before things look a little dicey. So, in Python you can easily write this: state = 0 for x in list: if x % 2 == 0: state += x else: state = state * (x + 1) - x print(state) In Haskell, the I/O side-effect of `print` is complicated and threading stateful updates through this sort of for-loop is likewise complicated. One way is to use a high-level idea called "Monad transformers" to keep the complexity down: import Control.Monad.State.Strict flip runStateT 0 $ forM_ list $ do state <- get if even x then put (x + state) else put (state * (x + 1) - x) state <- get lift $ putStrLn $ show state A different way (doing it all with a recursive function) looks like this: compute list (return 0) where compute [] prog = prog compute (x : xs) prog = compute xs $ do state <- prog let new_state = if even x then state + x else state * (x + 1) - x putStrLn $ show $ new_state return new_state This works by having an "accumulating parameter" (prog) which is a computer program; each time we run this recursive function we create another program (do) which reads the last value that prog yielded (state), transforms it into new_state, does the side-effect, and then yields the new_state. Both of these get the point across but neither one is quite as simple as the Python syntax. On the flip side, we've been speaking about the above Python code as if we knew exactly what it does, but we actually don't, because we don't know the type of x, so we don't know what x.__mod__ does. For that matter, the list could have two different things with different `__mod__` values and it's possible that the type of `x` could taint the type of `state` so that `print(state)` does something completely unexpected. In Haskell you can prevent all of this by changing `list` into `(list :: [Integer])`.