<оператор присваивания> ::= <переменная> := <выражение> | <переменная>, <оператор присваивания>, <выражение>

x1, x2 := E2, E1  =>  x1 := E1

F>>А ещё я попытался построить автомат, который бы распознавал такие конструкции, но что-то никак не получается. Получается, что для него необходим в общем случае неограниченный объём памяти, т.е. реализуемая им грамматика не относится ни к LL(k), ни к LR(k), при том, что она линейная. Так?

aIb => axb

I => aIb
I => x

<оператор_присваивания>
  <переменная>a</переменная>
  <оператор_присваивания>
    <переменная>b</переменная>
    <выражение>c</выражение>
  </оператор_присваивания>
  <выражение>d</выражение>
</оператор_присваивания>

<оператор присваивания> ::= <список переменных> := <список выражений>
<список переменных> ::= <переменная> ( <запятая> <переменная> )*
<список выражений> ::= <выражение> ( <запятая> <выражение> )*

external function gmdate() returns (integer, integer, integer);
external function intToString(integer) returns string;

const genitiveMonthName: map[int => string] = (
  1 => "января", 2 => "февраля", 3 => "марта",
  4 => "апреля", 5 => "мая", 6 => "июня",
  7 => "июля", 8 => "августа", 9 =>"сентября",
  10 => "октября", 11 => "ноября", 12 => "декабря");

function dateAsString() returns string =
let
  (y, m, d) = gmdate()
in
  intToString(d) || " " ||
  genitiveMonthName[m] || " " ||
  intToString(y) || " года"
end;

F>x1, x2 := E2, E1  =>  x1 := E1
F>

F>А ещё я попытался построить автомат, который бы распознавал такие конструкции, но что-то никак не получается. Получается, что для него необходим в общем случае неограниченный объём памяти, т.е. реализуемая им грамматика не относится ни к LL(k), ни к LR(k), при том, что она линейная. Так?

<присваивание>{N} ::= <перименная> (<запятая> <присваивание>{N+1} | ':=' <список выражений>{N})

<список выражений>{N} ::= <выражение> <запятая> <список выражений>{N-1}
<список выражений>{1} ::= <выражение>

<множественное присваивание> ::= <присваивание>{1}
S><присваивание>{N} ::= <перименная> (<запятая> <присваивание>{N+1} | ':=' <список выражений>{N})

S><список выражений>{N} ::= <выражение> <запятая> <список выражений>{N-1}
S><список выражений>{1} ::= <выражение>
S>

($a, $b, $c)= reverse (3, 2, 1);

# python

# кортежу переменных можно присвоить кортеж значений
x,y,z = 1,2,3 # x=1, y=2, z=3

# переменной можно присвоить кортеж
xyz = 1,2,3 # x=(1, 2, 3)

# кортежу переменных можно присвоить значение-кортеж
x,y,z = xyz # x=1, y=2, z=3

# трюки
x,y = xyz # ошибка арности
x,y,z,t = xyz # опять ошибка арности
x,y,x = xyz # x=3, y=2 - присваивание идёт слева направо, запоминается последнее :)

#include <boost/tuple.hpp>
using namespace boost;
.....
int x, y, z;
tie(x, y, _, z) = make_tuple(1,2,3,4); // кажется, так

F>А ещё я попытался построить автомат, который бы распознавал такие конструкции, но что-то никак не получается. Получается, что для него необходим в общем случае неограниченный объём памяти, т.е. реализуемая им грамматика не относится ни к LL(k), ни к LR(k), при том, что она линейная. Так?

<Assign> ::= <Var> <Operator> <Expr>
<Operator> ::=  ':=' | ',' <Assign> ','

z, y, x := x0, y0, z0

F>>>А ещё я попытался построить автомат, который бы распознавал такие конструкции, но что-то никак не получается. Получается, что для него необходим в общем случае неограниченный объём памяти, т.е. реализуемая им грамматика не относится ни к LL(k), ни к LR(k), при том, что она линейная. Так?

       ':='
    ___/ \___
 ','         ','
 / \         / \
x   ','     t   ','
    / \         / \
   y   z       u   v

int main()
{
    int x, y, z;
    x <<= y <<= z <<=assign>> 3 >> 2 >> 1;
    // скобки расставятся так:
    x <<= (y <<= (z <<= (((assign >> 3) >> 2) >> 1)));
//        \      \      \\\___________/     /     ///
//         \      \      \\________________/     ///
//          \      \      \_____________________///
//           \      \___________________________//
//            \_________________________________/
}

set<<= x <<= y <<= z <<=equal_to>> 3 >> 2 >> 1;

                  '{' | Var(x)  --> '{' Var(x)            -- { x
               Var(x) | ','     --> Var(x) ','            -- x ,
           Var(y) ',' | Var(x)  --> Var(y) ',' Var(x)     -- y , x
               Var(x) | ':='    --> Var(x) ':='           -- x :=
          Var(x) ':=' | Expr(e) --> '<:=>'                -- x := e       -- выполняем присваивание, сворачиваем
    Var(x) ',' '<:=>' | ','     --> Var(x) ',' '<:=>' ',' -- x , <:=> ,
Var(x) ',' '<:=>' ',' | Expr(e) --> '<:=>'                -- x , <:=> , e -- выполняем присваивание, сворачиваем
           '{' '<:=>' | ';'     --> '{'                   -- { <:=> ;     -- стейтмент завершён, выбрасываем
           '{' '<:=>' | '}'     --> '{}'                  -- { <:=> }     -- стейтмент завершён, блок завершён
                  '{' | '}'     --> '{}'                  -- { }          -- блок завершён

                Block | Var(x)  --> Block Var(x)          -- { x
               Var(x) | ','     --> VarC(x)               -- x,
              VarC(y) | Var(x)  --> VarC(y) Var(x)        -- y, x
               Var(x) | ':='    --> VarA(x)               -- x:=
              VarA(x) | Expr(e) --> AE                    -- x:=e      --> <:=>
           VarC(x) AE | ','     --> VarA(x)               -- x, <:=> , --> x:=
             Block AE | ';'     --> Block                 -- { <:=> ;  --> {
             Block AE | '}'     --> Body                  -- { <:=> }  --> {}
                Block | '}'     --> Body                  -- {}

x=1;y=2;z=3;

(x,y,_,z) = func(5);