A series of independent if statements in haskell - haskell

Question

Probably a silly question but I can't for the life of me figure this out.
I want to append to the end of a list based on a series of if statements.
In python (or most other languages I am familiar with) I could do something like this:
x = ["hi"]
if True:
x.append("hello")
if not True:
x.append("wait a minute...")
if True:
x.append("goodbye")
Which would give me:
['hi', 'hello', 'goodbye']
How does one achieve such a thing in Haskell?
I can get as far as:
res :: [[Char]]
res =
let x = ["Hi"]
in
if (True)
then x ++ ["hello"]
... what goes here???
else x
Or am I going about this totally wrong?
I am very new to Haskell so please don't bite...

Answer 1

Idiomatically,
x = concat [ [ "hi" ],
[ "hello" | True ],
[ "wait a minute..." | not True ],
[ "goodbye" | True ] ]

Answer 2

In Haskell every if expression must have an else clause. In that regard it's similar to the Python conditional operator:
a if test else b
In Haskell it would be written as:
if test then a else b
So how do you write the following in Haskell?
x = ["hi"]
if True:
x.append("hello")
You would do something like:
let x = ["hi"] in
if True then x ++ ["hello"] else x
See the else clause? It just returns the value as is.
However writing code like this sucks. We want to write code like in Python, and Python is stateful. The variable x is the state. In Haskell we have the State monad for writing code like that. Consider:
import Control.Monad.State
append a = modify (++ [a])
foo :: [String] -> [String]
foo = execState $ do
when True $ append "hello"
when (not True) $ append "wait a minute..."
when True $ append "goodbye"
x = ["hi"]
res = foo x
main = print res
Simple right?

Answer 3

In addition to #AaditMShah's answer, if you only want to append to a value, without other modifications, the writer monad would be the proper abstraction:
import Control.Monad
import Control.Monad.Writer
append :: a -> Writer [a] ()
append = tell . (: [])
x :: [String]
x = execWriter $ do
tell ["hi"]
when True $
append "hello"
when (not True) $
append "wait a minute..."
when True $
append "goodbye"

Answer 4

Haskell is different than the way it is done in Python or other languages:
List (and most other data structures) are immutable.
if else is an expression in Haskell as opposed to statement which is seen in other languages. You cannot ignore the else part in Haskell like what you did with Python.
Looking at your python code, it seems what you want to do is that if the condition is True, then you want to append an element to the list. That pattern can be abstracted in the following function:
appendIfTrue :: Bool -> a -> [a] -> [a]
appendIfTrue b x xs = if b
then xs ++ [x]
else xs
Once you have written the function you can achieve the same functionality using the following code:
x = ["hi"]
main = do
let x1 = appendIfTrue True "hello" x
x2 = appendIfTrue False "wait a minute" x1
x3 = appendIfTrue True "goodbye" x2
print x3
The thing to note here that is you are creating a new list here instead of modifying them as you did in your Python code.
Demo:
λ> main
["hi","hello","goodbye"]

Answer 5

You need to understand that in Haskell you cannot just modify x as in your python example. You need to thread a value (a list of Strings) though your conditionals, where each step appends or does not append another String. So you can't get away with nested if-then-else statement alone. You need access to the intermediate List of Strings built so far.
So the elementary operation is to append or not append a String to a List of Strings based on a boolean. A function which does this kind of conditionall appending could look like:
condAppend :: Bool -> String -> [String] -> [String]
condAppend c suff pref = if c then pref ++ [suff]
else pref
No you just have to chain a series of condAppends and apply it to an inial List of Strings:
res = condAppend True "goodby"
$ condAppend False "wait a minute"
$ condAppend True "hello" ["Hi"]
This gives you:
["Hi","hello","goodby"]
Note that the order of execution in res is bottom to top (or right to left if you write it all in one line) or inside-out if you like as as in f (g (h x)) where the leftmost function f is applied last.
If you don't like that, you need an alternative to ($) which operates left to right. You can write your own function (>>>) as in
res'= (
condAppend True "hello"
>>>
condAppend False "wait a minute"
>>>
condAppend True "goodbye"
) ["Hi"]
where
f >>> g = g . f
and it so happens that (a much generalized version of) (>>>) is already defined in Control.Arrow.