 <p>The problem to be solved is that you have an input and a series of functions, and you want to apply the functions to the input in order.</p> <p>If the functions are purely state-changing functions, <code>s -&gt; s</code> on an input of type <code>s</code>, then you don't <em>need</em> <code>State</code> to use them. Haskell is very good at chaining together functions like these, e.g. with the standard composition operator <code>.</code>, or something like <code>foldr (.) id</code>, or <code>foldr id</code>.</p> <p>However, if the functions both mutate a state <em>and</em> report some result of doing so, so that you could give them the type <code>s -&gt; (s,a)</code>, then gluing them all together is a bit of a nuisance. You have to unpack the result tuple and pass the new state value to the next function, use the reported value somewhere else, and then unpack <em>that</em> result, and so on. It's easy to pass the wrong state to an input function because you have to name each result and input explicitly to do the unpacking. You end up with something like this:</p> <pre><code>let (res1, s1) = fun1 s0 (res2, s2) = fun2 s1 (res3, s3) = fun3 res1 res2 s1 ... in resN </code></pre> <p>There, I accidentally passed <code>s1</code> instead of <code>s2</code>, maybe because I added the second line in later and didn't realise the third line needed changing. When composing the <code>s -&gt; s</code> functions, this problem can't possibly arise because there are no names to get right:</p> <pre><code>let resN = fun1 . fun2 . fun3 . -- etc. </code></pre> <p>So we invented <code>State</code> to do the same trick. <code>State</code> is essentially just a way of gluing functions like <code>s -&gt; (s,a)</code> together in such a way that the right state always gets passed to the right function.</p> <p>So it's not so much that people went "we want to use <code>State</code>, let's use <code>s -&gt; (s,a)</code>" but rather "we're writing functions like <code>s -&gt; (s,a)</code>, let's invent <code>State</code> to make that easy". With functions <code>s -&gt; s</code>, it's already easy and we don't have to invent anything.</p> <p>As an example of how <code>s -&gt; (s,a)</code> arises naturally, consider parsing: a parser will be given some input, consume some of the input and return a value. In Haskell, this is naturally modelled as taking an input list, and returning a pair of the value and the remaining input - i.e. <code>[Input] -&gt; ([Input], a)</code>, or <code>State [Input]</code>.</p>