How to write a for loop in Haskell?

There's not a single replacement for a for loop in Haskell. The replacement depends on exactly what you want to do. In this case, a map would be appropriate:

replace_two = map go
  where
    go 2 = 3
    go x = x

And it works like this:

Prelude> replace_two [1,2,2,4,1]
[1,3,3,4,1]
Prelude>

Haskell uses a combination of different ways to 'sort of' loop over data, e.g. list.

The two important things helping this is:

1. Ease of declaring a function and passing it around similar to what we do to a variable in oops languages
2. Extensive pattern matching

So for example I declare a function in haskell to return 2 if input is 3 else return input.

return2 x = if x == 3 then 2 else x

Now we want to apply this function to every element of the list. So we will use pattern matching.

apply (x:xs) = return2 x : apply xs
apply [] = []

Here the pattern x:xs will break the list and take the first element in x while xs will have the remainder of the list. Inside the function you can see we have applied it recursively.

I have not checked the above code in IDE so it might have syntax errors, also there are other things you will want to validate (end of list, in above code the function would cause exception).

The above pattern is quite common, so there is another function in the core libraries that can do this, and is called map. So you could do:

map return2 [your list]

As I said, in haskell there are many ways to essentially loop over things, but at the base they break down to applying the function to individual items in the data structure. There are many haskell functions built on top of it like map, fold, etc.

I would suggest you use one of the several resources online to get more familiar with Haskell constructs. One that I liked and was easy to follow is Learn you a Haskell

Using map with an anonymous function:

λ> map (\x -> if x==2 then 3 else x) [1,2,2,4,1]
[1,3,3,4,1]

Another basic approach using patterns and recursion.

replace :: [Int] -> [Int]
replace [] = [] -- base case
replace (2:x)  = 3:replace(x) --if 2 then replace by 3
replace (y:x) = y:replace(x) -- do nothing

Except map, maybe you can use forM from Control.Monad to mimic the for loop in other imperative languages:

import Control.Monad
arr = [1, 2, 2, 4, 1]
forM arr $ \i ->
    if i == 2 then return 3 else return i

However, you need to understand what is Monad.