• Отсутствие аппарата/практики для работы с одновременными действиями нескольких акторов над одним объектом
  
• Ограниченность стандартного понятийного аппарата "фоновыми" (не требующими внимания) асинхронными задачами. Такие задачи должны быть независимыми и высокоуровневыми от "основной" задачи.
  
• Традиционное решение координации между многими акторами (субъектами) состоит из выдачи конкретных инструкций (или сценариев) отдельным участникам и координации этих действий "старшим в иерархии" (супервизором). Такой режим работы нарушает инкапсуляцию активностей и очень плохо ложится в предыдущий аппарат "фоновых" действий.

val ordersOp = userService.getRecentOrders(user.id); //Async[Seq[Orders]]
val inventoryOp = inventoryService.getCurrentInventory(); //Async[Inventory]

val orders = await ordersOp;
val inventory = await inventoryOp;

val items = orders.flatMap(_.items).filter(item => inventory.getCount(item.id) > 0);

let ordersOp = userService.getRecentOrders(user.id); //Async[Seq[Orders]]
let inventoryOp = inventoryService.getCurrentInventory(); //Async[Inventory]

ordersOp.then(orders => 
  inventoryOp.then(inventory =>
    let items = ...
  )
)

for {
  orders <- userSerivce.getRecentOrders(user.id)
  inventory <- inventoryService.getCurrentInventory()
  items = ...
} yield {
  ...
}

val x = Future { doSomething() }
x.flatMap { v => ...
}

for[M] def getTopOffers(user: User): Seq[Item] = {
  val userOrdersOp = par userService.getRecentOrders()
  val inventory = inventoryService.getCurrentInventory()
  val userOrders = userOrdersOp

  val items = orders.flatMap(_.items).filter(item => inventory.getCount(item.id) > 0);
  items
}

def getTopOffers[M: Monad](user: User): Seq[Item] = {
  val userOrdersOp: M[Seq[Order]] = userService.getRecentOrders()
  for {
    (inventory: Inventory) <- (inventoryService.getCurrentInventory(): M[Inventory])
    (userOrders: Seq[Order]) <- userOrdersOp
    (items: Seq[Item]) = orders.flatMap(_.items).filter(item => inventory.getCount(item.id) > 0)
  } yield 
    items
}

def getTopOffers[M](user: User)(implicit md: Monad[M]): Seq[Item] = {
  val userOrdersOp: M[Seq[Order]] = userService.getRecentOrders()
  
  md.bind(
    inventoryService.getCurrentInventory(),
    inventory => {
      md.mmap(userOrdersOp),
      userOrders => {
        va items = orders.flatMap(_.items).filter(item => inventory.getCount(item.id) > 0)
        items
      }
    }
  )
}

def makePayment(order):
  val paymentClass = order.vendor == '123' ? 'Reliable' : 'Cheap'
  val paymentId = newUUID()
  val paymentRequest = Payment(
    id = paymentId,
    currencies = ...,
    amount = ...,
    customer = ...,
    paymentClass = paymentClass,
    items = order.items
  )
  order.state = Order.PAYMENT_IN_PROGRESS
  order.payments.push(paymentRequest)
  notify paymentSvc of paymentRequest
  wait paymentRequest in paymentSvc to { p ->
    p.status != Payment.AUTHORIZING
  }
  updatemPayment.status match {
    case Payment.REDIRECT => // redirect to URL...
    case Payment.REJECTED => // handle rejected status,
  }

def cancelPayment(my payment, cancelRequest):
  payment.cancelRequests.push(cancelRequest)
  wait payment in self to { p ->
    p.authorization.state != Auth.AUTHORIZING
  }
  payment.authorization.state match {
    case Auth.REJECTED | Auth.CANCELLING | Auth.CANCELLED => 
      cancelRequest.status = Cancel.IGNORED
    case Auth.ACCEPTED =>
      cancelRequest.status = Cancel.IN_PROGRESS
      payment.status = Payment.CANCELLING
      native callExternalService(payment)
  }

• Повторы внешних REST-операций
  
• "Отсутствие гонок" между вызовами внешних сервисов
  
• "Предикативное ожидание" на объектах (как своих, так и внешних) в рамках одного потока выполнения
  
• Возможность реализовать "только один активный процесс" для определенных состояний. Т.е. даже не пытаться выполнять новые методы над сущностью, если у нас сейчас активен метод/операция. Сервис может ответить 202 Accepted и выполнить операцию тогда, когда будет возможно
  
• Метрики и мониторинг.

Поровнявшись с кондитерской Миллера, я вдруг остановился как вкопанный и стал смотреть на ту сторону улицы, как будто предчувствуя, что вот сейчас со мной случится что-то необыкновенное, и в это-то самое мгновение на противоположной стороне я увидел старика и его собаку.

Мартин понял, что сейчас ему не помешает лишняя чашечка кофе. Он дал организму мысленный зарок по возвращении на Землю неделю пить отвратительный бескофеиновый кофе и подошёл к стойке бара.

initial() ->
    receive
        {accept, Request} -> accepted(Request);
        stop -> stopped()
    end.

accepted(Request) -> 
    Reply = process(Request),
    reply(Reply).

reply(Reply) ->
    send(Reply),
    initial().

process(Request) ->
    ask_for_payment_data(Request),
    ask_for_inventory_data(Request),
    multi_receive
        {Payment, Inventory} -> intersect(Payment, Inventory).

M>P.S. Извините за длинный пост. Часть из него — для меня. Я наконец-то начал понимать, чего именно я хочу от абстракций над монадами .

Преподаватель другому говорит:
— "Вот студенты тупые, я им раз объясняю – не понимают, второй раз объясняю – не понимают, третий раз объясняю, уже сам понял, а они не понимают".

public class Order
{
  public List<OrderItem> Items {get; init;}
  
  public decimal Total { get; init;}
  public Order(List<OrderItems> items)
  {
    Items = items; 
    Total = items.Select(i=>i.LineTotal).Sum();
  }
}

...
var invoiceAmount = 0m;
List<OrderItems> orderItems;
foreach(var attachment in message.GetAttachments())
{
   orderItems.AddRange(ParseEDIOrder(attachment));
   var o = new Order(ediOrder.OrderLines);
   invoiceAmount += o.Total;
   orderCollection.Add(o);
   orderItems.Clear();
}
...

public class Order
{
  public List<OrderItem> Items {get; init;}
  
  public decimal Total { get; init;}
  public Order(List<OrderItems> items)
  {
    Items = new List<OrderItems>(items); 
    Total = items.Select(i=>i.LineTotal).Sum();
  }
}

...
if (o.Total > 100)
   o.Items.Add(new OrderItem("Volume discount", -o.Total * 3/100);
...

public class Order
{
  public IReadOnlyList<OrderItem> Items {get; init;}
  
  public decimal Total { get; init;}
  public Order(List<OrderItems> items)
  {
    Items = new List<OrderItems>(items); 
    Total = items.Select(i=>i.LineTotal).Sum();
  }
}

...
if (o.Total > 100)
   ((List<OrderItem>)o.Items).Add(new OrderItem("Volume discount", -o.Total * 3/100);
...

public class Order
{
  private List<OrderItem> _items;
  public IReadOnlyList<OrderItem> Items {get => new List<OrderItem>(_items); }
  
  public decimal Total { get; init;}
  public Order(List<OrderItems> items)
  {
    _items = new List<OrderItems>(items); 
    Total = items.Select(i=>i.LineTotal).Sum();
  }
}

public static int Main(string[] args)
{
  var mask = args.Length > 1 ? args[1] : "*.*";
  List<string> filePaths = GetFilePathsRecursive(mask);  
  SetAllCompressed(filePaths);                              // I
  List<IgnoreMask> ignoredMasks = LoadMasksFromGitIgnore(); 

  filePaths.Remove(f => ignoredMasks.Any(m=>m.IsMatch(f))); // II
  var totalSize = GetTotalSize(filePaths);
  Console.WriteLine($"Total size of ignored files is {totalSize} bytes");
}
  
public static void SetAllCompressed(List<string> filePaths)
{
  for(var i = 0; i < filePaths.Length; i++)
    SetCompressed(filePaths[i]);
}
...

public static int Main(string[] args)
{
  var mask = args.Length > 1 ? args[1] : "*.*";
  List<string> filePaths = GetFilePathsRecursive(mask);  
  Task compressTask = SetAllCompressed(filePaths);          // I
  List<IgnoreMask> ignoredMasks = LoadMasksFromGitIgnore(); 

  filePaths.Remove(f => ignoredMasks.Any(m=>m.IsMatch(f))); // II
  var totalSize = GetTotalSize(filePaths);
  Console.WriteLine($"Total size of ignored files is {totalSize} bytes");
  compressTask.Wait();
}

public static Task SetAllCompressed(List<string> filePaths)
{
  return new Task(
    () => 
    {
      for(var i = 0; i < filePaths.Length; i++)
        SetCompressed(filePaths[i]);
    }
  );
}

public static Task SetAllCompressed(IReadOnlyList<string> filePaths)
{
  return new Task(
    () => 
    {
      for(var i = 0; i < filePaths.Length; i++)
        SetCompressed(filePaths[i]);
    }
  );
}

public static Task SetAllCompressed(IReadOnlyList<string> filePaths)
{
  var localPaths = new List<string(filePaths) // выполняем в вызывающем потоке
  return new Task(
    () => 
    {
      for(var i = 0; i < localPaths.Length; i++)
        SetCompressed(localPaths[i]);
    }
  );
}

const / mutable

sync / async

virtual / direct

ref / value

public / private / ...

Константность: всё константно, если надо иначе пиши mutable (конверт из константной ссылки с copy-on-write)
Асинхронность: всё асинхронно, хочешь синхронный вызов добавь sync
Виртуальность: всё виртуально, хочешь прямой вызов объяви снаружи/статический
Передача: всё по ссылке, для копии нужно указать value на типе или на переменной.
Видимость: всё публичное, если надо спрятать добавляешь private и ко.

Какой язык мне посоветуете?

process(Request) ->
    ask_for_payment_data(Request),
    ask_for_inventory_data(Request),
    multi_receive
        {Payment, Inventory} -> intersect(Payment, Inventory).

trait TxHandler {
  def onCommit(): Unit;
  def onRollback(): Unit;
}

M>Спасибо, интересное наблюдение. Особенно с учетом того, что я специально хотел отойти от явного описания конечных автоматов . Но дело здесь скорее в том, что я пытаюсь решать немного другую задачу. В первую очередь — избежать комбинаторного взрыва состояний там, где он возможен.

notify paymentSvc of paymentRequest

SD>notify paymentSvc of paymentRequest
SD>

• Order определяет, что у нас есть новый платеж, генерирует ID.
  
• Order посылает сообщение Payments — "а ты знаешь, что запрос на платеж ID=123 выглядит так: ...?"
  
• Payments получает запрос. Смотрит, есть ли у нее подобные данные. Может синхронно ответить "не согласен (409, conflit)! платеж ID=123 выглядит так: ...!". Или создать новый платеж и ответить "OK, я не против (201, Created)". Или найти существующий и ответить "да я уже знаю (200 OK/204 no content)".
  
• Payments посылает широковещательный запрос "а знаете, у меня новая информация про платеж ID=123!"
  
• Payments обрабатывает платеж через провайдера.
  
• Когда получен ответ от провайдера, payments помещает новое состояние (например, successful). И опять посылает уведомление "а знаете, у меня еще более новая информация про платеж ID=123!".
  
• Order получает это уведомление (вероятно, в рамках процесса, т.е. вызова await), считывает новое состояние и продолжает выполнение.

• Будет автоматически повторен (до победного конца) в случае проблем на принимающей стороне (это легко сделать с существующими библиотеками).
  
• Имеет из коробки метрики вокруг вызова: длительность и количество успехов/неудач (это тоже легко).
  
• Вычисление переживает прямое попадание небольшого метеорита (до 3м диаметром) в сервер, на котором выполняется код. В случае подобного события выполнение будет продолжено с той же точки на другой машине (а вот это с существующими библиотеками сложно делать. Каждый случай нужно обрабатывать вручную).
  
• "Атомарность" предыдущих изменений в коде и операции. Если мы видим в базе изменения, которые были сделаны до notify, то мы можем быть уверены, что и notify когда-нибудь произойдет и код продолжит выполнение (это почти аналогично предыдущему, с существующими библиотеками приходится реализовывать для каждого отдельного случая).