AVC>А вот как обойтись вообще без побочных эффектов (ввод/вывод не в счет) — мы просто не знаем...

"State" is just a convenient concept for describing the set of parameters to a function. In imperative languages, that "state" is spread willy-nilly all around the program, and the history of the state has to be explicitly maintained. In a functional language, it is well specified.

-- Типа фабрика, генерирующая функции - прибавлятели числа n (на самом деле это обычное сложение (+) )
mkAdder n = \m -> n + m

-- Генерируем конкретный прибавлятель (семёрки) (на самом деле это сечение (7+) )
add7 = mkAdder 7
-- Другой конкретный прибавлятель (восьмёрки) (на самом деле это сечение (8+) )
add8 = mkAdder 8

-- сессия Hugs:
--   Main> add7 1
--   8 :: Int
--   Main> add7 2
--   9 :: Int
--   Main> add8 1
--   9 :: Int

-- (1) "Фабрика"
--      Любая функция двух (или более) произвольных аргументов (типы аргументов t1 и t2, возвращаемое значение t3)
f::t1->t2->t3 

-- (2) нуль-арная функция (или более сложное выражение) подходящего типа
v1::t1


-- порождают в результате частичного применения 
g = f v1 -- унарную функцию типа g :: t2->t3 


-- которую потом можно применить к какому-нибудь 
v2::t2
g v2 --  получив результат типа t3

AVC>Вот и разберись...

value <- getState   
putState (value + 1)   
value <- getState   
return value

-- Ну понятно, да, плюем на переменную, нас интересует только состояние
getState (variable, state) = (_, state)

-- А здесь передаем пару, новое состояние, и возвращаем пару с той же переменной, но с новым состоянием.
putState (variable, state) newState = (variable, newState)

-- допустим это наша переменная а, со значением 2.
state = ("a",2)
-- получаем значение нашего состояние, то есть выполняем строчку
-- value <- getState   
let (initialVariable, initialState) = get state in
-- здесь мы изменяем значение нашей переменной на значение initialState + 1, то бишь 2+1 = 3
-- то есть выполняем строчку putState (value + 1)   
    let (initialVariable, changedState) = put (initialVariable, initialState) initialState + 1 in
-- это мы уже проходили, получаем измененное значение.
        let (initialVariable, finalState) = get (initialVariable, changedState) in
--     и возвращаем результат
           return finalState

value <- readLine   
putState (value + 1)   
value <- getState   
writeLine value

public enum TransctionState
{
    Success,
    Error
}
public class TransationResult
{
    public object Result;
    public TransationState State;
}
public class TransactionalCalculation
{
    public TransactionResult Combine(TransactionCalculation calculation)
    {
   // Выполняем свои дела
     TransactionResult res = this.Execute();
     // Если все завершилось успешно
                if(res.State == TransactionState.Success)
        //          вызываем следующее вычисление
                    res = calculation.Execute();
        return res;
    }
    // А это метод который будет выполняться в каждой транзакции.
    public TransactionResult Execute;
    // Предположим, что он инициализируется в конструкторе.
    public TransactionCalculation(MethodToExecute )
    {
        Execute = MethodToExecute;
    }
    
}

public void Main()
{
    // создаем три транзакции
    TransactionCalculation t1  = new TransactionCalculaction(doSomething);
    TransactionCalculation t2  = new TransactionCalculaction(doSomethingElse);
    TransactionCalculation t3  = new TransactionCalculaction(doYetAnotherThing);
    
  // комбинируем их в одну транзакцию.
    TransactionResult = t1.Combine(t2.Combine(t3));

 //Без метода Combine код выглядел бы примерно так
    TransactionResult res = t1.Execute()
    if(res == TransactionState.Success)
    {
        res = t2.Execute();
        if(res == TransactionState.Success)
        {
            res = t3.Execute();
        }
    }
}

ICalculation
{
    put
    get
}

M>-- Ну понятно, да, плюем на переменную, нас интересует только состояние
M>getState (variable, state) = (_, state)

M>-- А здесь передаем пару, новое состояние, и возвращаем пару с той же переменной, но с новым состоянием.
M>putState (variable, state) newState = (variable, newState)
M>

M>-- допустим это наша переменная а, со значением 2.
M>state = ("a",2)
M>-- получаем значение нашего состояние, то есть выполняем строчку
M>-- value <- getState   
M>let (initialVariable, initialState) = get state in
M>-- здесь мы изменяем значение нашей переменной на значение initialState + 1, то бишь 2+1 = 3
M>-- то есть выполняем строчку putState (value + 1)   
M>    let (initialVariable, changedState) = put (initialVariable, initialState) initialState + 1 in
M>-- это мы уже проходили, получаем измененное значение.
M>        let (initialVariable, finalState) = get (initialVariable, changedState) in
M>--     и возвращаем результат
M>           return finalState
M>

int state = 2;
...
++state;

(define someOperation
  (let ((state 2))
    (lambda ()
      (set! state (+ state 1))
  state)))

AVC>(define someOperation
AVC>  (let ((state 2))
AVC>    (lambda ()
AVC>      (set! state (+ state 1))
AVC>  state)))
AVC>

interface ICalculation
{
    // Обрати особое внимание на то, что возвращает гет. 
    ICalculation get
    set
}

class Maybe : ICalculation
class State : ICalculation

(положи 2 в а)
(вынь состояние из a, прибавь к нему 1, положи обратно)

(положи 2 в а) ;
  (вынь состояние из a, прибавь к нему 1, положи обратно)

(положи 2 в а) >>=
  (вынь состояние из a, прибавь к нему 1, положи обратно)

let x=expression1 in expression2

computation1 >>= \x -> computation2

do x <- computation1
   computation2

do { x <- foo;
     y <- bar x;
     return (baz (x, y)) }

#include <iostream>
#include <sstream>

using namespace std;

template <class Machine>
void imperative_program(Machine machine)
{
    cout << machine
    // here's imperative program for our VM
        .inc()
        .inc()        
        .print() // outputs 2

        .dec()        
        .print() // outputs 1
     
        .inc()
        .inc()
        .inc()
        .print() // outputs 4

        .set(75)
        .print() // outputs 75

        .rand()
        .print() // outputs random number
        .rand()
        .print() // outputs another random number

   /////////////////////////////////////////
        .output;
}

string to_string(int x)
{
    ostringstream oss;
    oss << x;
    return oss.str();
}

int rand(int seed)
{
    const int a = 1664525;
    const int b = 1013467;
    const int m = 65536;
    return (a * seed + b) % m;
}


// Implementation with destructive updates

struct StatefulMachine
{
    int counter;
    string output;

    StatefulMachine () : counter(0) {}

    StatefulMachine& inc() { ++counter; return *this; }
    StatefulMachine& dec() { --counter; return *this; }
    StatefulMachine& set(int x) { counter=x; return *this; }
    StatefulMachine& rand() { counter=::rand(counter); return *this; }
    

    StatefulMachine& print()
    {
        output += to_string(counter) + "\n";
        return *this;
    }
};


// Purely functional implementation

struct StatelessMachine
{
    const int counter;
    const string output;

    StatelessMachine(int a_counter=0, string a_output="") :
        counter(a_counter),
        output(a_output) {}

    StatelessMachine inc() const { return StatelessMachine(counter+1, output); }
    StatelessMachine dec() const { return StatelessMachine(counter-1, output); }
    StatelessMachine set(int x) const { return StatelessMachine(x, output); }
    StatelessMachine rand() const  { return StatelessMachine(::rand(counter), output); }
    StatelessMachine print() const { return StatelessMachine(counter, 
                                                             output+to_string(counter)+"\n"); }
};

int main()
{ 
    imperative_program(StatefulMachine());
    imperative_program(StatelessMachine());

    return 0;
}

main = do x <- return 1
          print x
          x <- return 2
          print x
          x <- return (x + 3)
          print x

main = let unnamed1 x =
              (print x) >>
              let unnamed2 x = 
                     (print x) >>
                     let unnamed3 x =
                            print x
                     in  return (x + 3) >>= unnamed3
              in  return 2 >>= unnamed2
       in  return 1 >>= unnamed1

(define (main)
  (define (unnamed1 x)
    (define (unnamed2 x)
      (define (unnamed3 x)
        (printf "~a~n" x))
      (printf "~a~n" x)
      (unnamed3 (+ x 3)))
    (printf "~a~n" x)
    (unnamed2 2))
  (unnamed1 1))