Modify current list by adding an element - Haskell 101 - list

Question

I'd like to add an element on the "movies" list of a data type Director variable called billy.
type Name = String
type Movie = String
data Director = Director {name:: Name, movies::[Movie]}
deriving (Show)
let billy = Director "Billy J." ["Good movie 1"]
--addMovieToDirector :: Movie -> Director -> Director
addMovieToDirector m (Director n ms) = Director n (m:ms)
The problem is previous function doesn't update billy's list of movies, it creates a new Director with the desired list (the changes are not stored on billy). How can I operate on billy's list without creating another Director? I understand, that Haskell works with constants, but then should I create a different 'billy' "variable" every time I modify the list?
Thanks!

Answer 1

What you would like to do can be described as "in-place modification", or "using mutable data".
There are ways for Haskell to do this. Since in-place modification of anything almost always considered as a "side-effect", such things can only be done in the IO monad, or with dirty tricks like unsafePerformIO.
These are somewhat advanced topics, and at a beginner level it is arguably beneficial to think about Haskell values as being totally immutable.
So yes, you can't modify variables. Actually there are no "variables" at all.
Think about billy as a name for a value, not a variable.
All a function can do in Haskell is to take arguments, and calculate some result without any side effects.
This is probably the biggest mental barrier for people coming from imperative languages: "how should I work with data if I can't modify it"?
The answer is: you should structure your program like giant assembly line: raw materials (raw data, initial parameters, etc.) are put on the line at the beginning (the first function you call), and each workstation (function) does something useful (returns a value), consuming the result of the previous workstation. At the end, something valuable might fall off the line.
What I described is simple function composition: if you need to do c task after b, after a, on a value x, then you can write it as (c . b . a) x, or c (b (a x)) or rather c $ b $ a x.
This way, you can write programs without ever changing anything explicitly, and only describing how to create new things out of old ones.
This sounds awfully inefficient, and indeed, there are some performance implications of functional programming (let alone laziness). However the compiler is smart enough to figure out a whole lot thing about programs written in Haskell, and optimize it in certain ways.
I hope it'll all make sense soon. :)
Oh, and welcome to Haskell. ;)

Answer 2

You can use a State monad if you want to have a mutable state in your program, for some reason. Here's an example:
module Main where
import Control.Monad.State
type GameValue = Int
type GameState = (Bool, Int)
type Name = String
type Movie = String
data Director = Director {name:: Name, movies::[Movie]}
deriving (Show)
addMovieToDirector :: Movie -> Director -> Director
addMovieToDirector m (Director n ms) = Director n (m:ms)
handleDirector :: Name -> State Director Director
handleDirector m = do
director <- get
put (addMovieToDirector m director)
returnDirector
returnDirector = do
director <- get
return director
startState = Director "Billy J." ["Good movie 1"]
main = print $ evalState (handleDirector "Good movie 2") startState
The printed result will be
Director {name = "Billy J.", movies = ["Good movie 2","Good movie 1"]}
Here handleDirector function of type Name -> State Director Director has a mutable state inside it of type Director and a "result" value of type, again, Director. get means get the state, put is used to change it and evalstate is used to "calculate" the result, enveloped by the constructed State monad.