...
  let f = foo()   //Вызов мееедленой функции возвращающей Int
  ...             //Делаем что-то пока foo выполняется
  let s = f + 1   //Здесь останавливаемся и ждём пока foo вернёт результат(ели ещё не вернула)
  ..

  let bar = {)    //Это функция bar
  ...
  foo()           //Вызов мееедленой функции
  ...
  (}              //Не выходим пока foo не завершится

  doer d = {) foo(); stop() (}          //main
  def foo = {) stop(); bar() (}
  def bar = {) stop(); stop() (}
  def stop = {) while true => nothing (}

   def procData = {l:LIST[String])   //Функция подсчитывает количество символов в списке строк.
     let s = LIST[Int]               //Список int'ов 
     foreach i in l => s :: size(i)  //Число символов подсчитывается для каждой строки, затем результат помещается список int'ов(без сохранения порядка).
     let r = 0                       //Для суммирования
     foreach i in s => r := r + i    //Сложение всех int'ов*
     r
   (Int}

  doer d = {) foo(); bar() (}
  def foo = {) v1 := v1 + v2 (}
  def bat = {) v2 := v2 + v1 (}
  var v1 = 0
  vat v2 = 0

  def foo = {v:Int) v1 := v1 + v (}

  //Поток-отправитель
  ...
  while(...){
    ...
    trd.send("Some message")
    ...
  }
  ...
  //Поток-получаетль
  ...
  while(...){
    val m = waitMessage() //Ждём сообщение
    ...                   //Обрабатываем
  }
  ...

  //Поток-отправитель
  ...
  while(...){
    ...
    massageProcessor("Some message")
    ...
  }
  ...
  //Поток-получаетль
  def massageProcessor(m:String) = {
    ...        //Обработка сообщения
  }

  shared int a;
  shared int b;

  void foobar()
  {
    foo();  // spawn потока, захват переменной "a", возврат управления
    bar();  // spawn потока, захват переменной "b", возврат управления - все успешно проходит
  }

  void foo()
  {
    use(a);

    ... // тут чего-то долго делаем

    bar();  // ВЫЗОВ НОМЕР 2: попытка захвата переменной "b", а вот и дедлок
  }

  void bar()
  {
    use(b);
  }

  void bar()
  {
    use(b);

    ... // тут чего-то долго делаем

    foo();  // дедлок
  }

ARK>Понятно. Нечто вроде SCOOP в Eiffel. Но как быть, когда между потоками нет отношения "родитель-подчиненный"? К примеру, один поток — это диспетчер IO-вызовов, а другой — наша программа. Диспетчер мы создать не можем, он существовал в операционной системе до того, как мы появились на свет, и останется после того, как мы умрем. (И наоборот — наша программа не создается этим диспетчером, ее запускает пользователь.) А общаться с ним надо. Тут для вашей модели нужен какой-то аналог общих переменных на уровне ОС.

  //Очередь сообщений
  def q = LIST[Strin]
  //Поток-отправитель
  ...
  while(...){
    ...
    send("Some message")
    ...
  }
  ...
  def send = {m:String) //Функция-писатель
    q := q :: m
  (}
  //Поток-получаетль
  ...
  while(...){
    if isEmpty(q) => sleep(50)
    else => ... //Обработка   
  }
  ...

ARK>  void foo()
ARK>  {            //!!Для читаемых перменных здесь(пред выполнением тела функции) выполняется чтение(копирование) значения,                
ARK>               //т.е. foo() не начнёт выполнение пока не прочтиает "a", и  затем сразу освободи его, так что новый вызов foo() так же сможет выполнить чтение.
ARK>               //Для записываемых переменных здесь выполнятся захват(с освобождением по завершении выполнения тела функции),  так что новый вызов foo() не начнётся пока не будет
ARK>               //выполнен предыдущий.
ARK>    use(a);
ARK>    ... // тут чего-то долго делаем
ARK>    bar();  // ВЫЗОВ НОМЕР 2: попытка захвата переменной "b", а вот и дедлок
ARK>  }
ARK>

  ...
  if(n != null){   //n - разделяемая переменная
    n.m()}         //Здесь поток иногда вылетает по NullPointerException, потому-что другой поток обнулил n между проверкой и вызовов метода m()
  ...

  var v1 = 0
  def w = {)    //Функция-писатель
    let s = r()
    v1 := 1 + s
  (}
  def r = {)   //Функция-читатель
    v1 
  (}

  //Очередь сообщений
  def q = LIST[Strin]
  //Поток-отправитель
  ...
  while(...){
    ...
    send("Some message")
    ...
  }
  ...
  def send = {m:String) //Функция-писатель
    q := q :: m
  (}
  //Поток-получаетль
  ...
  while(...){
    if isEmpty() => sleep(50)
    else => ... //Обработка 
  }
  ...
  def isEmpty = {)  
     size(q) == 0
  (Bool}

  var v1 = 0
  doer a = {)
    while(ra()){   //Будет крутится и ждать v1 == 0
      ...
    }
    v1 := 1
  (}
  def ra = {)
    v1 == 0
  (Bool}
  doer b = {)      //Будет крутится и ждать v1 == 1
    while(rb()){
      ...
    }
    v1 := 1
  (}
  def rb = {)
    v1 == 1
  (Bool}

  def apendOne(hm:MyHighArray):MyHighArray = {
    hm.add(1)
  }