1

I'm new to Haskell and STM and I'm trying to understand the basics concept.

In Haskell and Functional Programming in general,correct me if I'm wrong, there's no such thing like assignment.

I cannot write x=3; all I can do is generate an other binding with x and 3.

Now when it comes to TVar and threads, if I have a number of threads sharing the same TVar, if one thread changes the value, with writeTVar, the others thread will see the changed value, am I right?

So if I have 2 thread sharing the same TVar Int var, and the first one add 1 to it, in case of success, the second thread will see the updated value?

Thaks

user1544128
  • 583
  • 4
  • 20

2 Answers2

3

Yes, the TVar is the container, that doesn't change when its content changes. All threads see the same container, and when one thread changes what was stored in the container, when another thread looks, it finds the changed value.

Daniel Fischer
  • 181,706
  • 17
  • 308
  • 431
  • ok, thanks for the confirmation, it just looked a bit weird at the beginning. – user1544128 Jan 05 '13 at 14:59
  • just a small extra question if I may: when I create a thread with `forkIO`, since the returned value is an `IOThread`, the only way to get the results calculated by the thread is by a making the thread writing in a `TVar` and the "main" reading from it? – user1544128 Jan 05 '13 at 15:04
  • 2
    It need not necessarily be a `TVar`, you could also use `TChan`, `Chan`, `MVar`, `IORef` and probably more. But the principle is indeed, if you want to communicate with a `forkIO`d thread, you need some kind of communication variable. – Daniel Fischer Jan 05 '13 at 15:10
3

It may be better to consider TVar not a variable, but a channel you can read from and write to.

A pure variable may be considered a pure function which always returns some value (and this value is bound only once, like in your example). A variable/function in a monad has some "context" (that's what monads are for), that may change its value (e.g. randomIO :: Random a => IO a from System.Random may be considered a "monadic value", value, which may be changed on any call).

Reading and writing to TVar are explicit operations that are not pure, that's why functions readTVar/writeTVar are wrapped into STM monad, they depend on some hidden context, which may change the result (making value transfer possible between threads). That bounds these operations into STM monad though, which can be escaped to IO only.

Dmytro Sirenko
  • 5,003
  • 21
  • 26