From f33f4399381398b484ef2dd4cf76ee6d04d15a18 Mon Sep 17 00:00:00 2001
From: David Grudl <david@grudl.com>
Date: Tue, 14 May 2024 12:02:56 +0200
Subject: [PATCH] iteratewhile -> grouping

---
 latte/bg/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/bg/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/cs/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/cs/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/de/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/de/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/el/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/el/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/en/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/en/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/es/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/es/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/fr/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/fr/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/hu/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/hu/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/it/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/it/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/ja/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/ja/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/pl/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/pl/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/pt/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/pt/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/ro/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/ro/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/ru/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/ru/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/sl/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/sl/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/tr/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/tr/cookbook/iteratewhile.texy | 215 +---------------------------
 latte/uk/cookbook/grouping.texy     | 214 +++++++++++++++++++++++++++
 latte/uk/cookbook/iteratewhile.texy | 215 +---------------------------
 34 files changed, 3655 insertions(+), 3638 deletions(-)
 create mode 100644 latte/bg/cookbook/grouping.texy
 create mode 100644 latte/cs/cookbook/grouping.texy
 create mode 100644 latte/de/cookbook/grouping.texy
 create mode 100644 latte/el/cookbook/grouping.texy
 create mode 100644 latte/en/cookbook/grouping.texy
 create mode 100644 latte/es/cookbook/grouping.texy
 create mode 100644 latte/fr/cookbook/grouping.texy
 create mode 100644 latte/hu/cookbook/grouping.texy
 create mode 100644 latte/it/cookbook/grouping.texy
 create mode 100644 latte/ja/cookbook/grouping.texy
 create mode 100644 latte/pl/cookbook/grouping.texy
 create mode 100644 latte/pt/cookbook/grouping.texy
 create mode 100644 latte/ro/cookbook/grouping.texy
 create mode 100644 latte/ru/cookbook/grouping.texy
 create mode 100644 latte/sl/cookbook/grouping.texy
 create mode 100644 latte/tr/cookbook/grouping.texy
 create mode 100644 latte/uk/cookbook/grouping.texy

diff --git a/latte/bg/cookbook/grouping.texy b/latte/bg/cookbook/grouping.texy
new file mode 100644
index 0000000000..52370c801c
--- /dev/null
+++ b/latte/bg/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Всичко, което винаги сте искали да знаете за {iterateWhile}
+***********************************************************
+
+.[perex]
+Тагът `{iterateWhile}` е подходящ за различни трикове в цикли foreach.
+
+Да предположим, че имаме следната таблица в базата данни, в която елементите са разделени на категории:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Разбира се, много е лесно да изведете елементите в цикъла foreach като списък:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Но какво да направите, ако искате да изведете всяка категория като отделен списък? С други думи, как се решава проблемът с групирането на елементи от линеен списък в цикъл foreach. Резултатът трябва да изглежда така:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Ще ви покажем как да решите този проблем лесно и елегантно с помощта на iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Докато `{foreach}` се отнася до външната част на цикъла, т.е. изготвянето на списъци за всяка категория, таговете `{iterateWhile}` се отнасят до вътрешната част, т.е. отделните елементи.
+Условието в крайния таг гласи, че повторението ще продължи, докато текущият и следващият елемент принадлежат към една и съща категория (`$iterator->nextValue` - [следващ елемент |/tags#iterator]).
+
+Ако условието е винаги изпълнено, всички елементи се изтеглят във вътрешния цикъл:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Резултатът ще изглежда по следния начин:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Как е полезно да се използва iterateWhile по този начин? По какво се различава от решението, което показахме в началото на това ръководство? Разликата е, че ако таблицата е празна и не съдържа елементи, тя няма да се изведе празна `<ul></ul>`.
+
+
+Решение без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------
+
+Ако трябва да решим същия проблем, като използваме напълно елементарни шаблони, например в Twig, Blade или чист PHP, решението би изглеждало по следния начин
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+Този код обаче е неразбираем и неинтуитивен. Връзката между началния и крайния HTML таг не е съвсем ясна. От пръв поглед не е ясно дали има грешка. А това изисква помощни променливи като `$prevCategoryId`.
+
+За разлика от това решението с `{iterateWhile}` е чисто, ясно, не изисква помощни променливи и е надеждно.
+
+
+Условие в затварящия таг .[#toc-condition-in-the-closing-tag]
+-------------------------------------------------------------
+
+Ако посочите условие в отварящия таг `{iterateWhile}`, поведението се променя: условието (и преходът към следващия елемент) се изпълнява в началото на вътрешния цикъл, а не в края.
+Така, докато `{iterateWhile}` без условие се въвежда винаги, `{iterateWhile $cond}` се въвежда само когато е изпълнено условието `$cond`. В същото време следващият елемент се записва в `$item`.
+
+Това е полезно например в ситуация, в която първият елемент във всяка категория трябва да се показва по различен начин, напр:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Променете изходния код, като визуализираме първия елемент и след това допълнителни елементи от същата категория във вътрешния цикъл `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Вложени цикли .[#toc-nested-loops]
+----------------------------------
+
+Можем да създадем няколко вътрешни цикъла в един цикъл и дори да ги вложим един в друг. По този начин например подкатегориите могат да бъдат групирани заедно.
+
+Да предположим, че в таблицата има още една колона `subcategoryId` и освен че всяка категория е в отделна колона, всяка подкатегория ще бъде в отделна колона. `<ul>`, всяка подкатегория ще бъде в отделна колона. `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Филтриране | партида .[#toc-filter-batch]
+-----------------------------------------
+
+Групирането на елементите на реда се осигурява и от филтъра `batch`, в партида с фиксиран брой елементи:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Тя може да бъде заменена с iterateWhile, както следва:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/bg/cookbook/iteratewhile.texy b/latte/bg/cookbook/iteratewhile.texy
index 52370c801c..2d2d8ab663 100644
--- a/latte/bg/cookbook/iteratewhile.texy
+++ b/latte/bg/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Всичко, което винаги сте искали да знаете за {iterateWhile}
-***********************************************************
-
-.[perex]
-Тагът `{iterateWhile}` е подходящ за различни трикове в цикли foreach.
-
-Да предположим, че имаме следната таблица в базата данни, в която елементите са разделени на категории:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Разбира се, много е лесно да изведете елементите в цикъла foreach като списък:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Но какво да направите, ако искате да изведете всяка категория като отделен списък? С други думи, как се решава проблемът с групирането на елементи от линеен списък в цикъл foreach. Резултатът трябва да изглежда така:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Ще ви покажем как да решите този проблем лесно и елегантно с помощта на iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Докато `{foreach}` се отнася до външната част на цикъла, т.е. изготвянето на списъци за всяка категория, таговете `{iterateWhile}` се отнасят до вътрешната част, т.е. отделните елементи.
-Условието в крайния таг гласи, че повторението ще продължи, докато текущият и следващият елемент принадлежат към една и съща категория (`$iterator->nextValue` - [следващ елемент |/tags#iterator]).
-
-Ако условието е винаги изпълнено, всички елементи се изтеглят във вътрешния цикъл:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Резултатът ще изглежда по следния начин:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Как е полезно да се използва iterateWhile по този начин? По какво се различава от решението, което показахме в началото на това ръководство? Разликата е, че ако таблицата е празна и не съдържа елементи, тя няма да се изведе празна `<ul></ul>`.
-
-
-Решение без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------
-
-Ако трябва да решим същия проблем, като използваме напълно елементарни шаблони, например в Twig, Blade или чист PHP, решението би изглеждало по следния начин
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-Този код обаче е неразбираем и неинтуитивен. Връзката между началния и крайния HTML таг не е съвсем ясна. От пръв поглед не е ясно дали има грешка. А това изисква помощни променливи като `$prevCategoryId`.
-
-За разлика от това решението с `{iterateWhile}` е чисто, ясно, не изисква помощни променливи и е надеждно.
-
-
-Условие в затварящия таг .[#toc-condition-in-the-closing-tag]
--------------------------------------------------------------
-
-Ако посочите условие в отварящия таг `{iterateWhile}`, поведението се променя: условието (и преходът към следващия елемент) се изпълнява в началото на вътрешния цикъл, а не в края.
-Така, докато `{iterateWhile}` без условие се въвежда винаги, `{iterateWhile $cond}` се въвежда само когато е изпълнено условието `$cond`. В същото време следващият елемент се записва в `$item`.
-
-Това е полезно например в ситуация, в която първият елемент във всяка категория трябва да се показва по различен начин, напр:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Променете изходния код, като визуализираме първия елемент и след това допълнителни елементи от същата категория във вътрешния цикъл `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Вложени цикли .[#toc-nested-loops]
-----------------------------------
-
-Можем да създадем няколко вътрешни цикъла в един цикъл и дори да ги вложим един в друг. По този начин например подкатегориите могат да бъдат групирани заедно.
-
-Да предположим, че в таблицата има още една колона `subcategoryId` и освен че всяка категория е в отделна колона, всяка подкатегория ще бъде в отделна колона. `<ul>`, всяка подкатегория ще бъде в отделна колона. `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Филтриране | партида .[#toc-filter-batch]
------------------------------------------
-
-Групирането на елементите на реда се осигурява и от филтъра `batch`, в партида с фиксиран брой елементи:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Тя може да бъде заменена с iterateWhile, както следва:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/cs/cookbook/grouping.texy b/latte/cs/cookbook/grouping.texy
new file mode 100644
index 0000000000..24078125a2
--- /dev/null
+++ b/latte/cs/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Všechno, co jste kdy chtěli vědět o {iterateWhile}
+**************************************************
+
+.[perex]
+Značka `{iterateWhile}` se hodí na nejrůznější kejkle ve foreach cyklech.
+
+Dejme tomu, že máme následující databázovou tabulku, kde jsou položky rozdělené do kategorií:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Vykreslit položky ve foreach cyklu jako seznam je samozřejmě snadné:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Ale co kdybychom chtěli, aby každá kategorie byla v samostatném seznamu? Jinými slovy, řešíme úkol, jak seskupit položky v lineárním seznamu ve foreach cyklu do skupin. Výstup by měl vypadat takto:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Rovnou si ukážeme, jak snadno a elegantně se dá úkol vyřešit pomocí iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Zatímco `{foreach}` označuje vnější část cyklu, tedy vykreslování seznamů pro každou kategorii, tak značka `{iterateWhile}` označuje vnitřní část, tedy jednotlivé položky.
+Podmínka v koncové značce říká, že opakování bude probíhat do té doby, dokud aktuální i následující prvek patří do stejné kategorie (`$iterator->nextValue` je [následující položka|/tags#$iterator]).
+
+Kdyby podmínka byla splněná vždy, tak se ve vnitřním cyklu vykreslí všechny prvky:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Výsledek bude vypadat takto:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+K čemu je takové použití iterateWhile dobré? Jak se liší od řešení, které jsme si ukázali úplně na začátku tohoto návodu? Rozdíl je v tom, že když bude tabulka prázdná a nebude obsahovat žádné prvky, nevypíše se prázdné `<ul></ul>`.
+
+
+Řešení bez `{iterateWhile}`
+---------------------------
+
+Pokud bychom stejný úkol řešili zcela základními prostředky šablonovacích systému, například v Twig, Blade, nebo čistém PHP, vypadalo by řešení cca takto:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* změnila se kategorie *}
+
+		{* uzavřeme předchozí <ul>, pokud nejde o první položku *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* otevřeme nový seznam *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* uzavřeme poslední seznam *}
+	</ul>
+{/if}
+```
+
+Tento kód je však nesrozumitelný a neintuitivní. Není vůbec jasná vazba mezi otevíracími a zavíracími HTML značkami. Není na první pohled vidět, jestli tam není nějaká chyba. A vyžaduje pomocné proměnné jako `$prevCategoryId`.
+
+Oproti tomu řešení s `{iterateWhile}` je čisté, přehledné, nepotřebujeme pomocné proměnné a je blbuvzdorné.
+
+
+Podmínka v otevírací značce
+---------------------------
+
+Pokud uvedeme podmínku v otevírací značce `{iterateWhile}`, tak se chování změní: podmínka (a přechod na další prvek) se vykoná už na začátku vnitřního cyklu, nikoliv na konci.
+Tedy zatímco do `{iterateWhile}` bez podmínky se vstoupí vždy, do `{iterateWhile $cond}` jen při splnění podmínky `$cond`. A zároveň se s tím do `$item` zapíše následující prvek.
+
+Což se hodí například v situaci, kdy budeme chtít první prvek v každé kategorii vykreslit jiným způsobem, například takto:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Původní kód upravíme tak, že nejprve vykreslíme první položku a poté ve vnitřním cyklu `{iterateWhile}` vykreslíme další položky ze stejné kategorie:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Vnořené smyčky
+--------------
+
+V rámci jednoho cyklu můžeme vytvářet více vnitřních smyček a dokonce je zanořovat. Takto by se daly seskupovat třeba podkategorie atd.
+
+Dejme tomu, že v tabulce bude ještě další sloupec `subcategoryId` a kromě toho, že každá kategorie bude v samostatném `<ul>`, každá každý podkategorie samostatném `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtr |batch
+------------
+
+Seskupování lineárních položek obstarává také filtr `batch`, a to do dávek s pevným počtem prvků:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Lze jej nahradit za iterateWhile tímto způsobem:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/cs/cookbook/iteratewhile.texy b/latte/cs/cookbook/iteratewhile.texy
index 24078125a2..2d2d8ab663 100644
--- a/latte/cs/cookbook/iteratewhile.texy
+++ b/latte/cs/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Všechno, co jste kdy chtěli vědět o {iterateWhile}
-**************************************************
-
-.[perex]
-Značka `{iterateWhile}` se hodí na nejrůznější kejkle ve foreach cyklech.
-
-Dejme tomu, že máme následující databázovou tabulku, kde jsou položky rozdělené do kategorií:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Vykreslit položky ve foreach cyklu jako seznam je samozřejmě snadné:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Ale co kdybychom chtěli, aby každá kategorie byla v samostatném seznamu? Jinými slovy, řešíme úkol, jak seskupit položky v lineárním seznamu ve foreach cyklu do skupin. Výstup by měl vypadat takto:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Rovnou si ukážeme, jak snadno a elegantně se dá úkol vyřešit pomocí iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Zatímco `{foreach}` označuje vnější část cyklu, tedy vykreslování seznamů pro každou kategorii, tak značka `{iterateWhile}` označuje vnitřní část, tedy jednotlivé položky.
-Podmínka v koncové značce říká, že opakování bude probíhat do té doby, dokud aktuální i následující prvek patří do stejné kategorie (`$iterator->nextValue` je [následující položka|/tags#$iterator]).
-
-Kdyby podmínka byla splněná vždy, tak se ve vnitřním cyklu vykreslí všechny prvky:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Výsledek bude vypadat takto:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-K čemu je takové použití iterateWhile dobré? Jak se liší od řešení, které jsme si ukázali úplně na začátku tohoto návodu? Rozdíl je v tom, že když bude tabulka prázdná a nebude obsahovat žádné prvky, nevypíše se prázdné `<ul></ul>`.
-
-
-Řešení bez `{iterateWhile}`
----------------------------
-
-Pokud bychom stejný úkol řešili zcela základními prostředky šablonovacích systému, například v Twig, Blade, nebo čistém PHP, vypadalo by řešení cca takto:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* změnila se kategorie *}
-
-		{* uzavřeme předchozí <ul>, pokud nejde o první položku *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* otevřeme nový seznam *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* uzavřeme poslední seznam *}
-	</ul>
-{/if}
-```
-
-Tento kód je však nesrozumitelný a neintuitivní. Není vůbec jasná vazba mezi otevíracími a zavíracími HTML značkami. Není na první pohled vidět, jestli tam není nějaká chyba. A vyžaduje pomocné proměnné jako `$prevCategoryId`.
-
-Oproti tomu řešení s `{iterateWhile}` je čisté, přehledné, nepotřebujeme pomocné proměnné a je blbuvzdorné.
-
-
-Podmínka v otevírací značce
----------------------------
-
-Pokud uvedeme podmínku v otevírací značce `{iterateWhile}`, tak se chování změní: podmínka (a přechod na další prvek) se vykoná už na začátku vnitřního cyklu, nikoliv na konci.
-Tedy zatímco do `{iterateWhile}` bez podmínky se vstoupí vždy, do `{iterateWhile $cond}` jen při splnění podmínky `$cond`. A zároveň se s tím do `$item` zapíše následující prvek.
-
-Což se hodí například v situaci, kdy budeme chtít první prvek v každé kategorii vykreslit jiným způsobem, například takto:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Původní kód upravíme tak, že nejprve vykreslíme první položku a poté ve vnitřním cyklu `{iterateWhile}` vykreslíme další položky ze stejné kategorie:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Vnořené smyčky
---------------
-
-V rámci jednoho cyklu můžeme vytvářet více vnitřních smyček a dokonce je zanořovat. Takto by se daly seskupovat třeba podkategorie atd.
-
-Dejme tomu, že v tabulce bude ještě další sloupec `subcategoryId` a kromě toho, že každá kategorie bude v samostatném `<ul>`, každá každý podkategorie samostatném `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtr |batch
-------------
-
-Seskupování lineárních položek obstarává také filtr `batch`, a to do dávek s pevným počtem prvků:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Lze jej nahradit za iterateWhile tímto způsobem:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/de/cookbook/grouping.texy b/latte/de/cookbook/grouping.texy
new file mode 100644
index 0000000000..b645620f18
--- /dev/null
+++ b/latte/de/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Was Sie schon immer über {iterateWhile} wissen wollten
+******************************************************
+
+.[perex]
+Das Tag `{iterateWhile}` ist für verschiedene Tricks in foreach-Zyklen geeignet.
+
+Angenommen, wir haben die folgende Datenbanktabelle, in der die Elemente in Kategorien unterteilt sind:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Es ist natürlich einfach, Elemente in einer foreach-Schleife als Liste zu zeichnen:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Aber was ist zu tun, wenn Sie jede Kategorie in einer separaten Liste darstellen wollen? Mit anderen Worten, wie kann man die Aufgabe lösen, Elemente aus einer linearen Liste in einem foreach-Zyklus zu gruppieren. Die Ausgabe sollte wie folgt aussehen:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Wir werden Ihnen zeigen, wie einfach und elegant die Aufgabe mit iterateWhile gelöst werden kann:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Während `{foreach}` den äußeren Teil des Zyklus markiert, d.h. die Erstellung von Listen für jede Kategorie, geben die Tags `{iterateWhile}` den inneren Teil an, d.h. die einzelnen Elemente.
+Die Bedingung im End-Tag besagt, dass die Wiederholung so lange fortgesetzt wird, wie das aktuelle und das nächste Element zur selben Kategorie gehören (`$iterator->nextValue` ist das [nächste Element |/tags#$iterator]).
+
+Wenn die Bedingung immer erfüllt ist, werden alle Elemente im inneren Zyklus gezeichnet:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Das Ergebnis sieht dann so aus:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Wozu ist eine solche Verwendung von iterateWhile gut? Wie unterscheidet sie sich von der Lösung, die wir ganz am Anfang des Tutorials gezeigt haben? Der Unterschied besteht darin, dass die Tabelle, wenn sie leer ist und keine Elemente enthält, nicht leer dargestellt wird `<ul></ul>`.
+
+
+Lösung ohne `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------
+
+Würden wir die gleiche Aufgabe mit ganz einfachen Konstruktionen von Template-Systemen lösen, zum Beispiel in Twig, Blade oder reinem PHP, würde die Lösung etwa so aussehen:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* die Kategorie hat sich geändert *}
+
+		{* wir schließen das vorherige <ul>, wenn es nicht das erste Element ist *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* wir öffnen eine neue Liste *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* wir schließen die letzte Liste *}
+	</ul>
+{/if}
+```
+
+Dieser Code ist jedoch unverständlich und unintuitiv. Der Zusammenhang zwischen den öffnenden und schließenden HTML-Tags ist überhaupt nicht klar. Es ist nicht auf den ersten Blick klar, ob ein Fehler vorliegt. Und es werden Hilfsvariablen wie `$prevCategoryId` benötigt.
+
+Im Gegensatz dazu ist die Lösung mit `{iterateWhile}` sauber, klar, benötigt keine Hilfsvariablen und ist narrensicher.
+
+
+Bedingung im abschließenden Tag .[#toc-condition-in-the-closing-tag]
+--------------------------------------------------------------------
+
+Wenn wir im öffnenden Tag `{iterateWhile}` eine Bedingung angeben, ändert sich das Verhalten: Die Bedingung (und der Übergang zum nächsten Element) wird am Anfang des inneren Zyklus ausgeführt, nicht am Ende.
+Während also `{iterateWhile}` ohne Bedingung immer eingegeben wird, wird `{iterateWhile $cond}` nur eingegeben, wenn die Bedingung `$cond` erfüllt ist. Gleichzeitig wird das folgende Element in `$item` geschrieben.
+
+Dies ist z. B. dann nützlich, wenn Sie das erste Element in jeder Kategorie auf unterschiedliche Weise darstellen möchten, z. B:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Ändern wir den ursprünglichen Code, zeichnen wir das erste Element und dann weitere Elemente aus derselben Kategorie in der inneren Schleife `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Verschachtelte Schleifen .[#toc-nested-loops]
+---------------------------------------------
+
+Wir können mehrere innere Schleifen in einem Zyklus erstellen und sie sogar verschachteln. Auf diese Weise können zum Beispiel Unterkategorien gruppiert werden.
+
+Angenommen, es gibt eine weitere Spalte in der Tabelle `subcategoryId` und jede Kategorie befindet sich nicht nur in einer separaten `<ul>`befindet, wird jede Unterkategorie in einer separaten `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filter |Batch .[#toc-filter-batch]
+----------------------------------
+
+Die Gruppierung von linearen Elementen erfolgt ebenfalls über einen Filter `batch` in Stapel mit einer festen Anzahl von Elementen:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Er kann wie folgt durch iterateWhile ersetzt werden:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/de/cookbook/iteratewhile.texy b/latte/de/cookbook/iteratewhile.texy
index b645620f18..2d2d8ab663 100644
--- a/latte/de/cookbook/iteratewhile.texy
+++ b/latte/de/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Was Sie schon immer über {iterateWhile} wissen wollten
-******************************************************
-
-.[perex]
-Das Tag `{iterateWhile}` ist für verschiedene Tricks in foreach-Zyklen geeignet.
-
-Angenommen, wir haben die folgende Datenbanktabelle, in der die Elemente in Kategorien unterteilt sind:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Es ist natürlich einfach, Elemente in einer foreach-Schleife als Liste zu zeichnen:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Aber was ist zu tun, wenn Sie jede Kategorie in einer separaten Liste darstellen wollen? Mit anderen Worten, wie kann man die Aufgabe lösen, Elemente aus einer linearen Liste in einem foreach-Zyklus zu gruppieren. Die Ausgabe sollte wie folgt aussehen:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Wir werden Ihnen zeigen, wie einfach und elegant die Aufgabe mit iterateWhile gelöst werden kann:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Während `{foreach}` den äußeren Teil des Zyklus markiert, d.h. die Erstellung von Listen für jede Kategorie, geben die Tags `{iterateWhile}` den inneren Teil an, d.h. die einzelnen Elemente.
-Die Bedingung im End-Tag besagt, dass die Wiederholung so lange fortgesetzt wird, wie das aktuelle und das nächste Element zur selben Kategorie gehören (`$iterator->nextValue` ist das [nächste Element |/tags#$iterator]).
-
-Wenn die Bedingung immer erfüllt ist, werden alle Elemente im inneren Zyklus gezeichnet:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Das Ergebnis sieht dann so aus:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Wozu ist eine solche Verwendung von iterateWhile gut? Wie unterscheidet sie sich von der Lösung, die wir ganz am Anfang des Tutorials gezeigt haben? Der Unterschied besteht darin, dass die Tabelle, wenn sie leer ist und keine Elemente enthält, nicht leer dargestellt wird `<ul></ul>`.
-
-
-Lösung ohne `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------
-
-Würden wir die gleiche Aufgabe mit ganz einfachen Konstruktionen von Template-Systemen lösen, zum Beispiel in Twig, Blade oder reinem PHP, würde die Lösung etwa so aussehen:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* die Kategorie hat sich geändert *}
-
-		{* wir schließen das vorherige <ul>, wenn es nicht das erste Element ist *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* wir öffnen eine neue Liste *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* wir schließen die letzte Liste *}
-	</ul>
-{/if}
-```
-
-Dieser Code ist jedoch unverständlich und unintuitiv. Der Zusammenhang zwischen den öffnenden und schließenden HTML-Tags ist überhaupt nicht klar. Es ist nicht auf den ersten Blick klar, ob ein Fehler vorliegt. Und es werden Hilfsvariablen wie `$prevCategoryId` benötigt.
-
-Im Gegensatz dazu ist die Lösung mit `{iterateWhile}` sauber, klar, benötigt keine Hilfsvariablen und ist narrensicher.
-
-
-Bedingung im abschließenden Tag .[#toc-condition-in-the-closing-tag]
---------------------------------------------------------------------
-
-Wenn wir im öffnenden Tag `{iterateWhile}` eine Bedingung angeben, ändert sich das Verhalten: Die Bedingung (und der Übergang zum nächsten Element) wird am Anfang des inneren Zyklus ausgeführt, nicht am Ende.
-Während also `{iterateWhile}` ohne Bedingung immer eingegeben wird, wird `{iterateWhile $cond}` nur eingegeben, wenn die Bedingung `$cond` erfüllt ist. Gleichzeitig wird das folgende Element in `$item` geschrieben.
-
-Dies ist z. B. dann nützlich, wenn Sie das erste Element in jeder Kategorie auf unterschiedliche Weise darstellen möchten, z. B:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Ändern wir den ursprünglichen Code, zeichnen wir das erste Element und dann weitere Elemente aus derselben Kategorie in der inneren Schleife `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Verschachtelte Schleifen .[#toc-nested-loops]
----------------------------------------------
-
-Wir können mehrere innere Schleifen in einem Zyklus erstellen und sie sogar verschachteln. Auf diese Weise können zum Beispiel Unterkategorien gruppiert werden.
-
-Angenommen, es gibt eine weitere Spalte in der Tabelle `subcategoryId` und jede Kategorie befindet sich nicht nur in einer separaten `<ul>`befindet, wird jede Unterkategorie in einer separaten `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filter |Batch .[#toc-filter-batch]
-----------------------------------
-
-Die Gruppierung von linearen Elementen erfolgt ebenfalls über einen Filter `batch` in Stapel mit einer festen Anzahl von Elementen:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Er kann wie folgt durch iterateWhile ersetzt werden:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/el/cookbook/grouping.texy b/latte/el/cookbook/grouping.texy
new file mode 100644
index 0000000000..fa8c83a4e2
--- /dev/null
+++ b/latte/el/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Όλα όσα πάντα θέλατε να ξέρετε για το {iterateWhile}
+****************************************************
+
+.[perex]
+Η ετικέτα `{iterateWhile}` είναι κατάλληλη για διάφορα τεχνάσματα σε κύκλους foreach.
+
+Ας υποθέσουμε ότι έχουμε τον ακόλουθο πίνακα της βάσης δεδομένων, όπου τα στοιχεία χωρίζονται σε κατηγορίες:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Φυσικά, η σχεδίαση στοιχείων σε έναν βρόχο foreach ως λίστα είναι εύκολη:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Τι να κάνετε όμως αν θέλετε να αποδώσετε κάθε κατηγορία σε ξεχωριστή λίστα; Με άλλα λόγια, πώς να λύσετε το έργο της ομαδοποίησης στοιχείων από μια γραμμική λίστα σε έναν κύκλο foreach. Η έξοδος θα πρέπει να μοιάζει κάπως έτσι:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Θα σας δείξουμε πόσο εύκολα και κομψά μπορεί να επιλυθεί το έργο με το iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Ενώ το `{foreach}` σηματοδοτεί το εξωτερικό μέρος του κύκλου, δηλαδή την κατάρτιση των λιστών για κάθε κατηγορία, οι ετικέτες `{iterateWhile}` υποδεικνύουν το εσωτερικό μέρος, δηλαδή τα μεμονωμένα στοιχεία.
+Η συνθήκη στην ετικέτα end λέει ότι η επανάληψη θα συνεχιστεί εφόσον το τρέχον και το επόμενο στοιχείο ανήκουν στην ίδια κατηγορία (`$iterator->nextValue` είναι το [επόμενο στοιχείο |/tags#$iterator]).
+
+Εάν η συνθήκη ικανοποιείται πάντα, τότε όλα τα στοιχεία σχεδιάζονται στον εσωτερικό κύκλο:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Το αποτέλεσμα θα μοιάζει με αυτό:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Σε τι χρησιμεύει μια τέτοια χρήση της iterateWhile; Σε τι διαφέρει από τη λύση που δείξαμε στην αρχή αυτού του σεμιναρίου; Η διαφορά είναι ότι αν ο πίνακας είναι άδειος και δεν περιέχει κανένα στοιχείο, δεν θα αποδώσει κενό `<ul></ul>`.
+
+
+Λύση χωρίς `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+-----------------------------------------------------------------
+
+Αν λύναμε την ίδια εργασία με εντελώς βασικές κατασκευές συστημάτων προτύπων, για παράδειγμα σε Twig, Blade ή καθαρή PHP, η λύση θα έμοιαζε κάπως έτσι:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* η κατηγορία έχει αλλάξει *}
+
+		{* κλείνουμε το προηγούμενο <ul>, αν δεν είναι το πρώτο στοιχείο *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* θα ανοίξουμε μια νέα λίστα *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* κλείνουμε την προηγούμενη λίστα *}
+	</ul>
+{/if}
+```
+
+Ωστόσο, αυτός ο κώδικας είναι ακατανόητος και μη διαισθητικός. Η σύνδεση μεταξύ των ετικετών HTML που ανοίγουν και κλείνουν δεν είναι καθόλου σαφής. Δεν είναι σαφές με την πρώτη ματιά αν υπάρχει κάποιο λάθος. Και απαιτεί βοηθητικές μεταβλητές όπως το `$prevCategoryId`.
+
+Αντίθετα, η λύση με το `{iterateWhile}` είναι καθαρή, σαφής, δεν χρειάζεται βοηθητικές μεταβλητές και είναι αλάνθαστη.
+
+
+Προϋπόθεση στην ετικέτα κλεισίματος .[#toc-condition-in-the-closing-tag]
+------------------------------------------------------------------------
+
+Αν καθορίσουμε μια συνθήκη στην ετικέτα ανοίγματος `{iterateWhile}`, η συμπεριφορά αλλάζει: η συνθήκη (και η προώθηση στο επόμενο στοιχείο) εκτελείται στην αρχή του εσωτερικού κύκλου, όχι στο τέλος.
+Έτσι, ενώ το `{iterateWhile}` χωρίς συνθήκη εισάγεται πάντα, το `{iterateWhile $cond}` εισάγεται μόνο όταν ικανοποιείται η συνθήκη `$cond`. Ταυτόχρονα, το ακόλουθο στοιχείο εγγράφεται στο `$item`.
+
+Αυτό είναι χρήσιμο, για παράδειγμα, σε μια κατάσταση όπου θέλετε να αποδώσετε το πρώτο στοιχείο σε κάθε κατηγορία με διαφορετικό τρόπο, όπως π.χ:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Ας τροποποιήσουμε τον αρχικό κώδικα, σχεδιάζουμε το πρώτο στοιχείο και στη συνέχεια πρόσθετα στοιχεία από την ίδια κατηγορία στον εσωτερικό βρόχο `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Φωλιασμένοι βρόχοι .[#toc-nested-loops]
+---------------------------------------
+
+Μπορούμε να δημιουργήσουμε πολλαπλούς εσωτερικούς βρόχους σε έναν κύκλο και μάλιστα να τους φωλιάσουμε. Με αυτόν τον τρόπο, για παράδειγμα, θα μπορούσαν να ομαδοποιηθούν οι υποκατηγορίες.
+
+Ας υποθέσουμε ότι υπάρχει μια άλλη στήλη στον πίνακα `subcategoryId` και εκτός από το ότι κάθε κατηγορία βρίσκεται σε ξεχωριστή `<ul>`, κάθε υποκατηγορία θα βρίσκεται σε μια ξεχωριστή `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Φίλτρο |batch .[#toc-filter-batch]
+----------------------------------
+
+Η ομαδοποίηση των γραμμικών στοιχείων παρέχεται επίσης από ένα φίλτρο `batch`, σε παρτίδες με σταθερό αριθμό στοιχείων:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Μπορεί να αντικατασταθεί με το iterateWhile ως εξής:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/el/cookbook/iteratewhile.texy b/latte/el/cookbook/iteratewhile.texy
index fa8c83a4e2..2d2d8ab663 100644
--- a/latte/el/cookbook/iteratewhile.texy
+++ b/latte/el/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Όλα όσα πάντα θέλατε να ξέρετε για το {iterateWhile}
-****************************************************
-
-.[perex]
-Η ετικέτα `{iterateWhile}` είναι κατάλληλη για διάφορα τεχνάσματα σε κύκλους foreach.
-
-Ας υποθέσουμε ότι έχουμε τον ακόλουθο πίνακα της βάσης δεδομένων, όπου τα στοιχεία χωρίζονται σε κατηγορίες:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Φυσικά, η σχεδίαση στοιχείων σε έναν βρόχο foreach ως λίστα είναι εύκολη:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Τι να κάνετε όμως αν θέλετε να αποδώσετε κάθε κατηγορία σε ξεχωριστή λίστα; Με άλλα λόγια, πώς να λύσετε το έργο της ομαδοποίησης στοιχείων από μια γραμμική λίστα σε έναν κύκλο foreach. Η έξοδος θα πρέπει να μοιάζει κάπως έτσι:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Θα σας δείξουμε πόσο εύκολα και κομψά μπορεί να επιλυθεί το έργο με το iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Ενώ το `{foreach}` σηματοδοτεί το εξωτερικό μέρος του κύκλου, δηλαδή την κατάρτιση των λιστών για κάθε κατηγορία, οι ετικέτες `{iterateWhile}` υποδεικνύουν το εσωτερικό μέρος, δηλαδή τα μεμονωμένα στοιχεία.
-Η συνθήκη στην ετικέτα end λέει ότι η επανάληψη θα συνεχιστεί εφόσον το τρέχον και το επόμενο στοιχείο ανήκουν στην ίδια κατηγορία (`$iterator->nextValue` είναι το [επόμενο στοιχείο |/tags#$iterator]).
-
-Εάν η συνθήκη ικανοποιείται πάντα, τότε όλα τα στοιχεία σχεδιάζονται στον εσωτερικό κύκλο:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Το αποτέλεσμα θα μοιάζει με αυτό:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Σε τι χρησιμεύει μια τέτοια χρήση της iterateWhile; Σε τι διαφέρει από τη λύση που δείξαμε στην αρχή αυτού του σεμιναρίου; Η διαφορά είναι ότι αν ο πίνακας είναι άδειος και δεν περιέχει κανένα στοιχείο, δεν θα αποδώσει κενό `<ul></ul>`.
-
-
-Λύση χωρίς `{iterateWhile}` .[#toc-solution-without-iteratewhile]
------------------------------------------------------------------
-
-Αν λύναμε την ίδια εργασία με εντελώς βασικές κατασκευές συστημάτων προτύπων, για παράδειγμα σε Twig, Blade ή καθαρή PHP, η λύση θα έμοιαζε κάπως έτσι:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* η κατηγορία έχει αλλάξει *}
-
-		{* κλείνουμε το προηγούμενο <ul>, αν δεν είναι το πρώτο στοιχείο *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* θα ανοίξουμε μια νέα λίστα *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* κλείνουμε την προηγούμενη λίστα *}
-	</ul>
-{/if}
-```
-
-Ωστόσο, αυτός ο κώδικας είναι ακατανόητος και μη διαισθητικός. Η σύνδεση μεταξύ των ετικετών HTML που ανοίγουν και κλείνουν δεν είναι καθόλου σαφής. Δεν είναι σαφές με την πρώτη ματιά αν υπάρχει κάποιο λάθος. Και απαιτεί βοηθητικές μεταβλητές όπως το `$prevCategoryId`.
-
-Αντίθετα, η λύση με το `{iterateWhile}` είναι καθαρή, σαφής, δεν χρειάζεται βοηθητικές μεταβλητές και είναι αλάνθαστη.
-
-
-Προϋπόθεση στην ετικέτα κλεισίματος .[#toc-condition-in-the-closing-tag]
-------------------------------------------------------------------------
-
-Αν καθορίσουμε μια συνθήκη στην ετικέτα ανοίγματος `{iterateWhile}`, η συμπεριφορά αλλάζει: η συνθήκη (και η προώθηση στο επόμενο στοιχείο) εκτελείται στην αρχή του εσωτερικού κύκλου, όχι στο τέλος.
-Έτσι, ενώ το `{iterateWhile}` χωρίς συνθήκη εισάγεται πάντα, το `{iterateWhile $cond}` εισάγεται μόνο όταν ικανοποιείται η συνθήκη `$cond`. Ταυτόχρονα, το ακόλουθο στοιχείο εγγράφεται στο `$item`.
-
-Αυτό είναι χρήσιμο, για παράδειγμα, σε μια κατάσταση όπου θέλετε να αποδώσετε το πρώτο στοιχείο σε κάθε κατηγορία με διαφορετικό τρόπο, όπως π.χ:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Ας τροποποιήσουμε τον αρχικό κώδικα, σχεδιάζουμε το πρώτο στοιχείο και στη συνέχεια πρόσθετα στοιχεία από την ίδια κατηγορία στον εσωτερικό βρόχο `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Φωλιασμένοι βρόχοι .[#toc-nested-loops]
----------------------------------------
-
-Μπορούμε να δημιουργήσουμε πολλαπλούς εσωτερικούς βρόχους σε έναν κύκλο και μάλιστα να τους φωλιάσουμε. Με αυτόν τον τρόπο, για παράδειγμα, θα μπορούσαν να ομαδοποιηθούν οι υποκατηγορίες.
-
-Ας υποθέσουμε ότι υπάρχει μια άλλη στήλη στον πίνακα `subcategoryId` και εκτός από το ότι κάθε κατηγορία βρίσκεται σε ξεχωριστή `<ul>`, κάθε υποκατηγορία θα βρίσκεται σε μια ξεχωριστή `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Φίλτρο |batch .[#toc-filter-batch]
-----------------------------------
-
-Η ομαδοποίηση των γραμμικών στοιχείων παρέχεται επίσης από ένα φίλτρο `batch`, σε παρτίδες με σταθερό αριθμό στοιχείων:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Μπορεί να αντικατασταθεί με το iterateWhile ως εξής:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/en/cookbook/grouping.texy b/latte/en/cookbook/grouping.texy
new file mode 100644
index 0000000000..30c3fccc50
--- /dev/null
+++ b/latte/en/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Everything You Always Wanted to Know About {iterateWhile}
+*********************************************************
+
+.[perex]
+The tag `{iterateWhile}` is suitable for various tricks in foreach cycles.
+
+Suppose we have the following database table, where the items are divided into categories:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Of course, drawing items in a foreach loop as a list is easy:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+But what to do if you want render each category in a separate list? In other words, how to solve the task of grouping items from a linear list in a foreach cycle. The output should look like this:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+We will show you how easily and elegantly the task can be solved with iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+While `{foreach}` marks the outer part of the cycle, ie the drawing of lists for each category, the tags `{iterateWhile}` indicate the inner part, ie the individual items.
+The condition in the end tag says that the repetition will continue as long as the current and the next element belong to the same category (`$iterator->nextValue` is [next item |/tags#$iterator]).
+
+If the condition is always met, then all elements are drawn in the inner cycle:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+The result will look like this:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+What good is such an use of iterateWhile? How it differs from the solution we showed at the very beginning of this tutorial? The difference is that if the table is empty and does not contain any elements, it will not render empty `<ul></ul>`.
+
+
+Solution Without `{iterateWhile}`
+---------------------------------
+
+If we solved the same task with completely basic constructions of template systems, for example in Twig, Blade, or pure PHP, the solution would look something like this:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+However, this code is incomprehensible and unintuitive. The connection between the opening and closing HTML tags is not clear at all. It is not clear at first glance if there is a mistake. And it requires auxiliary variables like `$prevCategoryId`.
+
+In contrast, the solution with `{iterateWhile}` is clean, clear, does not need auxiliary variables and is foolproof.
+
+
+Condition in the Closing Tag
+----------------------------
+
+If we specify a condition in the opening tag `{iterateWhile}`, the behavior changes: the condition (and the advance to the next element) is executed at the beginning of the inner cycle, not at the end.
+Thus, while `{iterateWhile}` without condition is always entered, `{iterateWhile $cond}` is entered only when condition `$cond` is met. At the same time, the following element is written to `$item`.
+
+This is useful, for example, in a situation where you want to render the first element in each category in a different way, such as:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Lets modify the original code, we draw first item and then additional items from the same category in the inner loop `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Nested Loops
+------------
+
+We can create multiple inner loops in one cycle and even nest them. In this way, for example, subcategories could be grouped.
+
+Suppose there is another column in the table `subcategoryId` and in addition to each category being in a separate `<ul>`, each subcategory will be in a separate `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filter |batch
+-------------
+
+The grouping of linear items is also provided by a filter `batch`, into batches with a fixed number of elements:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+It can be replaced with iterateWhile as follows:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/en/cookbook/iteratewhile.texy b/latte/en/cookbook/iteratewhile.texy
index 30c3fccc50..2d2d8ab663 100644
--- a/latte/en/cookbook/iteratewhile.texy
+++ b/latte/en/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Everything You Always Wanted to Know About {iterateWhile}
-*********************************************************
-
-.[perex]
-The tag `{iterateWhile}` is suitable for various tricks in foreach cycles.
-
-Suppose we have the following database table, where the items are divided into categories:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Of course, drawing items in a foreach loop as a list is easy:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-But what to do if you want render each category in a separate list? In other words, how to solve the task of grouping items from a linear list in a foreach cycle. The output should look like this:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-We will show you how easily and elegantly the task can be solved with iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-While `{foreach}` marks the outer part of the cycle, ie the drawing of lists for each category, the tags `{iterateWhile}` indicate the inner part, ie the individual items.
-The condition in the end tag says that the repetition will continue as long as the current and the next element belong to the same category (`$iterator->nextValue` is [next item |/tags#$iterator]).
-
-If the condition is always met, then all elements are drawn in the inner cycle:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-The result will look like this:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-What good is such an use of iterateWhile? How it differs from the solution we showed at the very beginning of this tutorial? The difference is that if the table is empty and does not contain any elements, it will not render empty `<ul></ul>`.
-
-
-Solution Without `{iterateWhile}`
----------------------------------
-
-If we solved the same task with completely basic constructions of template systems, for example in Twig, Blade, or pure PHP, the solution would look something like this:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-However, this code is incomprehensible and unintuitive. The connection between the opening and closing HTML tags is not clear at all. It is not clear at first glance if there is a mistake. And it requires auxiliary variables like `$prevCategoryId`.
-
-In contrast, the solution with `{iterateWhile}` is clean, clear, does not need auxiliary variables and is foolproof.
-
-
-Condition in the Closing Tag
-----------------------------
-
-If we specify a condition in the opening tag `{iterateWhile}`, the behavior changes: the condition (and the advance to the next element) is executed at the beginning of the inner cycle, not at the end.
-Thus, while `{iterateWhile}` without condition is always entered, `{iterateWhile $cond}` is entered only when condition `$cond` is met. At the same time, the following element is written to `$item`.
-
-This is useful, for example, in a situation where you want to render the first element in each category in a different way, such as:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Lets modify the original code, we draw first item and then additional items from the same category in the inner loop `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Nested Loops
-------------
-
-We can create multiple inner loops in one cycle and even nest them. In this way, for example, subcategories could be grouped.
-
-Suppose there is another column in the table `subcategoryId` and in addition to each category being in a separate `<ul>`, each subcategory will be in a separate `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filter |batch
--------------
-
-The grouping of linear items is also provided by a filter `batch`, into batches with a fixed number of elements:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-It can be replaced with iterateWhile as follows:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/es/cookbook/grouping.texy b/latte/es/cookbook/grouping.texy
new file mode 100644
index 0000000000..9a96bc6c0d
--- /dev/null
+++ b/latte/es/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Todo lo que siempre quiso saber sobre {iterateWhile}
+****************************************************
+
+.[perex]
+La etiqueta `{iterateWhile}` es adecuada para varios trucos en ciclos foreach.
+
+Supongamos que tenemos la siguiente tabla de base de datos, donde los elementos se dividen en categorías:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Por supuesto, dibujar elementos en un bucle foreach como una lista es fácil:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Pero, ¿qué hacer si se desea representar cada categoría en una lista separada? En otras palabras, cómo resolver la tarea de agrupar elementos de una lista lineal en un ciclo foreach. La salida debería tener este aspecto:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Le mostraremos con qué facilidad y elegancia se puede resolver la tarea con iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Mientras que `{foreach}` marca la parte externa del ciclo, es decir, el dibujo de las listas para cada categoría, las etiquetas `{iterateWhile}` indican la parte interna, es decir, los elementos individuales.
+La condición en la etiqueta final dice que la repetición continuará mientras el elemento actual y el siguiente pertenezcan a la misma categoría (`$iterator->nextValue` es [siguiente elemento |/tags#$iterator]).
+
+Si la condición se cumple siempre, todos los elementos se dibujan en el ciclo interior:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+El resultado tendrá este aspecto:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+¿Para qué sirve este uso de iterateWhile? ¿En qué se diferencia de la solución que mostramos al principio de este tutorial? La diferencia es que si la tabla está vacía y no contiene ningún elemento, no se mostrará vacía `<ul></ul>`.
+
+
+Solución sin `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+-------------------------------------------------------------------
+
+Si resolviéramos la misma tarea con construcciones completamente básicas de sistemas de plantillas, por ejemplo en Twig, Blade, o PHP puro, la solución sería algo así:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+Sin embargo, este código es incomprensible y poco intuitivo. La conexión entre las etiquetas HTML de apertura y cierre no está nada clara. No está claro a primera vista si hay un error. Y requiere variables auxiliares como `$prevCategoryId`.
+
+En cambio, la solución con `{iterateWhile}` es limpia, clara, no necesita variables auxiliares y es infalible.
+
+
+Condición en la etiqueta de cierre .[#toc-condition-in-the-closing-tag]
+-----------------------------------------------------------------------
+
+Si especificamos una condición en la etiqueta de apertura `{iterateWhile}`, el comportamiento cambia: la condición (y el avance al elemento siguiente) se ejecuta al principio del ciclo interno, no al final.
+Así, mientras que `{iterateWhile}` sin condición se introduce siempre, `{iterateWhile $cond}` se introduce sólo cuando se cumple la condición `$cond`. Al mismo tiempo, el siguiente elemento se escribe en `$item`.
+
+Esto es útil, por ejemplo, en una situación en la que se desea renderizar el primer elemento de cada categoría de una forma diferente, como:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Modifiquemos el código original, dibujamos el primer elemento y luego los elementos adicionales de la misma categoría en el bucle interno `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Bucles anidados .[#toc-nested-loops]
+------------------------------------
+
+Podemos crear varios bucles internos en un ciclo e incluso anidarlos. De esta forma, por ejemplo, se podrían agrupar subcategorías.
+
+Supongamos que hay otra columna en la tabla `subcategoryId` y además de que cada categoría esté en una separada `<ul>`, cada subcategoría estará en un `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtro |batch .[#toc-filter-batch]
+----------------------------------
+
+La agrupación de elementos lineales también se realiza mediante un filtro `batch`, en lotes con un número fijo de elementos:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Puede sustituirse por iterateWhile de la siguiente manera:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/es/cookbook/iteratewhile.texy b/latte/es/cookbook/iteratewhile.texy
index 9a96bc6c0d..2d2d8ab663 100644
--- a/latte/es/cookbook/iteratewhile.texy
+++ b/latte/es/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Todo lo que siempre quiso saber sobre {iterateWhile}
-****************************************************
-
-.[perex]
-La etiqueta `{iterateWhile}` es adecuada para varios trucos en ciclos foreach.
-
-Supongamos que tenemos la siguiente tabla de base de datos, donde los elementos se dividen en categorías:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Por supuesto, dibujar elementos en un bucle foreach como una lista es fácil:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Pero, ¿qué hacer si se desea representar cada categoría en una lista separada? En otras palabras, cómo resolver la tarea de agrupar elementos de una lista lineal en un ciclo foreach. La salida debería tener este aspecto:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Le mostraremos con qué facilidad y elegancia se puede resolver la tarea con iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Mientras que `{foreach}` marca la parte externa del ciclo, es decir, el dibujo de las listas para cada categoría, las etiquetas `{iterateWhile}` indican la parte interna, es decir, los elementos individuales.
-La condición en la etiqueta final dice que la repetición continuará mientras el elemento actual y el siguiente pertenezcan a la misma categoría (`$iterator->nextValue` es [siguiente elemento |/tags#$iterator]).
-
-Si la condición se cumple siempre, todos los elementos se dibujan en el ciclo interior:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-El resultado tendrá este aspecto:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-¿Para qué sirve este uso de iterateWhile? ¿En qué se diferencia de la solución que mostramos al principio de este tutorial? La diferencia es que si la tabla está vacía y no contiene ningún elemento, no se mostrará vacía `<ul></ul>`.
-
-
-Solución sin `{iterateWhile}` .[#toc-solution-without-iteratewhile]
--------------------------------------------------------------------
-
-Si resolviéramos la misma tarea con construcciones completamente básicas de sistemas de plantillas, por ejemplo en Twig, Blade, o PHP puro, la solución sería algo así:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-Sin embargo, este código es incomprensible y poco intuitivo. La conexión entre las etiquetas HTML de apertura y cierre no está nada clara. No está claro a primera vista si hay un error. Y requiere variables auxiliares como `$prevCategoryId`.
-
-En cambio, la solución con `{iterateWhile}` es limpia, clara, no necesita variables auxiliares y es infalible.
-
-
-Condición en la etiqueta de cierre .[#toc-condition-in-the-closing-tag]
------------------------------------------------------------------------
-
-Si especificamos una condición en la etiqueta de apertura `{iterateWhile}`, el comportamiento cambia: la condición (y el avance al elemento siguiente) se ejecuta al principio del ciclo interno, no al final.
-Así, mientras que `{iterateWhile}` sin condición se introduce siempre, `{iterateWhile $cond}` se introduce sólo cuando se cumple la condición `$cond`. Al mismo tiempo, el siguiente elemento se escribe en `$item`.
-
-Esto es útil, por ejemplo, en una situación en la que se desea renderizar el primer elemento de cada categoría de una forma diferente, como:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Modifiquemos el código original, dibujamos el primer elemento y luego los elementos adicionales de la misma categoría en el bucle interno `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Bucles anidados .[#toc-nested-loops]
-------------------------------------
-
-Podemos crear varios bucles internos en un ciclo e incluso anidarlos. De esta forma, por ejemplo, se podrían agrupar subcategorías.
-
-Supongamos que hay otra columna en la tabla `subcategoryId` y además de que cada categoría esté en una separada `<ul>`, cada subcategoría estará en un `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtro |batch .[#toc-filter-batch]
-----------------------------------
-
-La agrupación de elementos lineales también se realiza mediante un filtro `batch`, en lotes con un número fijo de elementos:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Puede sustituirse por iterateWhile de la siguiente manera:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/fr/cookbook/grouping.texy b/latte/fr/cookbook/grouping.texy
new file mode 100644
index 0000000000..e7b3f21f67
--- /dev/null
+++ b/latte/fr/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Tout ce que vous avez toujours voulu savoir sur {iterateWhile}
+**************************************************************
+
+.[perex]
+La balise `{iterateWhile}` convient pour diverses astuces dans les cycles foreach.
+
+Supposons que nous ayons la table de base de données suivante, où les articles sont divisés en catégories :
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Bien sûr, dessiner les éléments d'une boucle foreach sous forme de liste est facile :
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Mais que faire si vous voulez rendre chaque catégorie dans une liste séparée ? En d'autres termes, comment résoudre la tâche consistant à regrouper les éléments d'une liste linéaire dans un cycle foreach. Le résultat devrait ressembler à ceci :
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Nous allons vous montrer comment cette tâche peut être résolue facilement et élégamment avec iterateWhile :
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Alors que `{foreach}` marque la partie extérieure du cycle, c'est-à-dire le dessin des listes pour chaque catégorie, les balises `{iterateWhile}` indiquent la partie intérieure, c'est-à-dire les éléments individuels.
+La condition dans la balise end indique que la répétition se poursuivra tant que l'élément actuel et le suivant appartiennent à la même catégorie (`$iterator->nextValue` est l'[élément suivant |/tags#$iterator]).
+
+Si la condition est toujours remplie, alors tous les éléments sont dessinés dans le cycle intérieur :
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Le résultat ressemblera à ceci :
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+A quoi sert une telle utilisation de iterateWhile ? En quoi diffère-t-elle de la solution que nous avons montrée au tout début de ce tutoriel ? La différence est que si la table est vide et ne contient pas d'éléments, elle ne rendra pas vide `<ul></ul>`.
+
+
+Solution sans `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+--------------------------------------------------------------------
+
+Si nous résolvions la même tâche avec des constructions complètement basiques de systèmes de templates, par exemple en Twig, Blade ou en PHP pur, la solution ressemblerait à ceci :
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* la catégorie a changé *}
+
+		{* nous fermons le précédent <ul>, si ce n'est pas le premier élément *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* nous allons ouvrir une nouvelle liste *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* on ferme la dernière liste *}
+	</ul>
+{/if}
+```
+
+Cependant, ce code est incompréhensible et peu intuitif. Le lien entre les balises HTML d'ouverture et de fermeture n'est pas du tout clair. Il n'est pas clair au premier coup d'œil s'il y a une erreur. Et il nécessite des variables auxiliaires comme `$prevCategoryId`.
+
+En revanche, la solution avec `{iterateWhile}` est propre, claire, ne nécessite pas de variables auxiliaires et est infaillible.
+
+
+Condition dans la balise de fermeture .[#toc-condition-in-the-closing-tag]
+--------------------------------------------------------------------------
+
+Si nous spécifions une condition dans la balise d'ouverture `{iterateWhile}`, le comportement change : la condition (et le passage à l'élément suivant) est exécutée au début du cycle interne, et non à la fin.
+Ainsi, alors que `{iterateWhile}` sans condition est toujours entré, `{iterateWhile $cond}` n'est entré que lorsque la condition `$cond` est remplie. En même temps, l'élément suivant est écrit sur `$item`.
+
+Ceci est utile, par exemple, dans une situation où vous souhaitez rendre le premier élément de chaque catégorie d'une manière différente, comme par exemple :
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Modifions le code original, nous dessinons le premier élément et ensuite les éléments supplémentaires de la même catégorie dans la boucle interne `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Boucles imbriquées .[#toc-nested-loops]
+---------------------------------------
+
+Nous pouvons créer plusieurs boucles internes dans un cycle et même les imbriquer. De cette façon, on peut par exemple regrouper des sous-catégories.
+
+Supposons qu'il y ait une autre colonne dans le tableau `subcategoryId` et qu'en plus de chaque catégorie se trouvant dans une colonne séparée, chaque sous-catégorie se trouve dans une colonne séparée. `<ul>`chaque sous-catégorie se trouvera dans une colonne distincte. `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filter |batch .[#toc-filter-batch]
+----------------------------------
+
+Le regroupement d'éléments linéaires est également assuré par un filtre `batch`, en lots d'un nombre fixe d'éléments :
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Il peut être remplacé par iterateWhile comme suit :
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/fr/cookbook/iteratewhile.texy b/latte/fr/cookbook/iteratewhile.texy
index e7b3f21f67..2d2d8ab663 100644
--- a/latte/fr/cookbook/iteratewhile.texy
+++ b/latte/fr/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Tout ce que vous avez toujours voulu savoir sur {iterateWhile}
-**************************************************************
-
-.[perex]
-La balise `{iterateWhile}` convient pour diverses astuces dans les cycles foreach.
-
-Supposons que nous ayons la table de base de données suivante, où les articles sont divisés en catégories :
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Bien sûr, dessiner les éléments d'une boucle foreach sous forme de liste est facile :
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Mais que faire si vous voulez rendre chaque catégorie dans une liste séparée ? En d'autres termes, comment résoudre la tâche consistant à regrouper les éléments d'une liste linéaire dans un cycle foreach. Le résultat devrait ressembler à ceci :
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Nous allons vous montrer comment cette tâche peut être résolue facilement et élégamment avec iterateWhile :
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Alors que `{foreach}` marque la partie extérieure du cycle, c'est-à-dire le dessin des listes pour chaque catégorie, les balises `{iterateWhile}` indiquent la partie intérieure, c'est-à-dire les éléments individuels.
-La condition dans la balise end indique que la répétition se poursuivra tant que l'élément actuel et le suivant appartiennent à la même catégorie (`$iterator->nextValue` est l'[élément suivant |/tags#$iterator]).
-
-Si la condition est toujours remplie, alors tous les éléments sont dessinés dans le cycle intérieur :
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Le résultat ressemblera à ceci :
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-A quoi sert une telle utilisation de iterateWhile ? En quoi diffère-t-elle de la solution que nous avons montrée au tout début de ce tutoriel ? La différence est que si la table est vide et ne contient pas d'éléments, elle ne rendra pas vide `<ul></ul>`.
-
-
-Solution sans `{iterateWhile}` .[#toc-solution-without-iteratewhile]
---------------------------------------------------------------------
-
-Si nous résolvions la même tâche avec des constructions complètement basiques de systèmes de templates, par exemple en Twig, Blade ou en PHP pur, la solution ressemblerait à ceci :
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* la catégorie a changé *}
-
-		{* nous fermons le précédent <ul>, si ce n'est pas le premier élément *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* nous allons ouvrir une nouvelle liste *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* on ferme la dernière liste *}
-	</ul>
-{/if}
-```
-
-Cependant, ce code est incompréhensible et peu intuitif. Le lien entre les balises HTML d'ouverture et de fermeture n'est pas du tout clair. Il n'est pas clair au premier coup d'œil s'il y a une erreur. Et il nécessite des variables auxiliaires comme `$prevCategoryId`.
-
-En revanche, la solution avec `{iterateWhile}` est propre, claire, ne nécessite pas de variables auxiliaires et est infaillible.
-
-
-Condition dans la balise de fermeture .[#toc-condition-in-the-closing-tag]
---------------------------------------------------------------------------
-
-Si nous spécifions une condition dans la balise d'ouverture `{iterateWhile}`, le comportement change : la condition (et le passage à l'élément suivant) est exécutée au début du cycle interne, et non à la fin.
-Ainsi, alors que `{iterateWhile}` sans condition est toujours entré, `{iterateWhile $cond}` n'est entré que lorsque la condition `$cond` est remplie. En même temps, l'élément suivant est écrit sur `$item`.
-
-Ceci est utile, par exemple, dans une situation où vous souhaitez rendre le premier élément de chaque catégorie d'une manière différente, comme par exemple :
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Modifions le code original, nous dessinons le premier élément et ensuite les éléments supplémentaires de la même catégorie dans la boucle interne `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Boucles imbriquées .[#toc-nested-loops]
----------------------------------------
-
-Nous pouvons créer plusieurs boucles internes dans un cycle et même les imbriquer. De cette façon, on peut par exemple regrouper des sous-catégories.
-
-Supposons qu'il y ait une autre colonne dans le tableau `subcategoryId` et qu'en plus de chaque catégorie se trouvant dans une colonne séparée, chaque sous-catégorie se trouve dans une colonne séparée. `<ul>`chaque sous-catégorie se trouvera dans une colonne distincte. `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filter |batch .[#toc-filter-batch]
-----------------------------------
-
-Le regroupement d'éléments linéaires est également assuré par un filtre `batch`, en lots d'un nombre fixe d'éléments :
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Il peut être remplacé par iterateWhile comme suit :
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/hu/cookbook/grouping.texy b/latte/hu/cookbook/grouping.texy
new file mode 100644
index 0000000000..d141fd8d4b
--- /dev/null
+++ b/latte/hu/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Minden, amit mindig is tudni akartál az {iterateWhile}
+******************************************************
+
+.[perex]
+A `{iterateWhile}` címke a foreach ciklusokban különböző trükkökre alkalmas.
+
+Tegyük fel, hogy a következő adatbázis táblával rendelkezünk, ahol az elemek kategóriákba vannak osztva:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Természetesen a foreach ciklusban az elemek listaként való kirajzolása egyszerű:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+De mit tegyünk, ha minden kategóriát külön listában szeretnénk megjeleníteni? Más szóval, hogyan oldjuk meg egy foreach ciklusban egy lineáris lista elemeinek csoportosítását. A kimenetnek így kellene kinéznie:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Megmutatjuk, milyen egyszerűen és elegánsan megoldható a feladat az iterateWhile segítségével:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Míg a `{foreach}` a ciklus külső részét jelöli, azaz az egyes kategóriákhoz tartozó listák rajzolását, addig a `{iterateWhile}` címkék a belső részt, azaz az egyes elemeket jelölik.
+Az end tagben lévő feltétel azt mondja, hogy az ismétlés addig folytatódik, amíg az aktuális és a következő elem ugyanahhoz a kategóriához tartozik (`$iterator->nextValue` a [következő elem |/tags#$iterator]).
+
+Ha a feltétel mindig teljesül, akkor a belső ciklusban minden elem kirajzolódik:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Az eredmény így fog kinézni:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Mire jó az iterateWhile ilyen használata? Miben különbözik attól a megoldástól, amit a bemutató legelején mutattunk? A különbség az, hogy ha a táblázat üres, és nem tartalmaz semmilyen elemet, akkor nem fog üresen renderelni `<ul></ul>`.
+
+
+Megoldás a `{iterateWhile}` nélkül .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------------
+
+Ha ugyanazt a feladatot a sablonrendszerek teljesen alapvető konstrukcióival oldanánk meg, például Twigben, Blade-ben vagy tiszta PHP-ben, a megoldás valahogy így nézne ki:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* új listát nyitunk *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* lezárjuk az utolsó listát *}
+	</ul>
+{/if}
+```
+
+Ez a kód azonban érthetetlen és nem intuitív. A nyitó és záró HTML-címkék közötti kapcsolat egyáltalán nem egyértelmű. Első pillantásra nem egyértelmű, hogy hiba van-e benne. És olyan segédváltozókat igényel, mint a `$prevCategoryId`.
+
+Ezzel szemben a `{iterateWhile}` megoldása tiszta, egyértelmű, nem igényel segédváltozókat, és bolondbiztos.
+
+
+Feltétel a záró tagben .[#toc-condition-in-the-closing-tag]
+-----------------------------------------------------------
+
+Ha a nyitó tagben adunk meg egy feltételt `{iterateWhile}`, a viselkedés megváltozik: a feltétel (és a következő elemre való továbblépés) a belső ciklus elején hajtódik végre, nem pedig a végén.
+Így míg a `{iterateWhile}` feltétel nélkül mindig belép, a `{iterateWhile $cond}` csak akkor lép be, ha a `$cond` feltétel teljesül. Ezzel egyidejűleg a következő elemet írja a `$item`.
+
+Ez hasznos például olyan helyzetekben, amikor az egyes kategóriák első elemét másképp szeretnénk megjeleníteni, például:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Módosítsuk az eredeti kódot, rajzoljuk az első elemet, majd további elemeket ugyanabból a kategóriából a belső ciklusban `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Beágyazott hurkok .[#toc-nested-loops]
+--------------------------------------
+
+Egy ciklusban több belső hurkot is létrehozhatunk, és akár egymásba is ágyazhatjuk őket. Így például alkategóriákat csoportosíthatunk.
+
+Tegyük fel, hogy van egy másik oszlop a `subcategoryId` táblázatban, és amellett, hogy minden kategória egy különálló `<ul>`, minden alkategória egy külön oszlopban lesz. `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Szűrő |batch .[#toc-filter-batch]
+---------------------------------
+
+A lineáris elemek csoportosítását szintén a `batch` szűrő biztosítja, mégpedig fix elemszámú tételekbe:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Ez helyettesíthető iterateWhile-val az alábbiak szerint:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/hu/cookbook/iteratewhile.texy b/latte/hu/cookbook/iteratewhile.texy
index d141fd8d4b..2d2d8ab663 100644
--- a/latte/hu/cookbook/iteratewhile.texy
+++ b/latte/hu/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Minden, amit mindig is tudni akartál az {iterateWhile}
-******************************************************
-
-.[perex]
-A `{iterateWhile}` címke a foreach ciklusokban különböző trükkökre alkalmas.
-
-Tegyük fel, hogy a következő adatbázis táblával rendelkezünk, ahol az elemek kategóriákba vannak osztva:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Természetesen a foreach ciklusban az elemek listaként való kirajzolása egyszerű:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-De mit tegyünk, ha minden kategóriát külön listában szeretnénk megjeleníteni? Más szóval, hogyan oldjuk meg egy foreach ciklusban egy lineáris lista elemeinek csoportosítását. A kimenetnek így kellene kinéznie:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Megmutatjuk, milyen egyszerűen és elegánsan megoldható a feladat az iterateWhile segítségével:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Míg a `{foreach}` a ciklus külső részét jelöli, azaz az egyes kategóriákhoz tartozó listák rajzolását, addig a `{iterateWhile}` címkék a belső részt, azaz az egyes elemeket jelölik.
-Az end tagben lévő feltétel azt mondja, hogy az ismétlés addig folytatódik, amíg az aktuális és a következő elem ugyanahhoz a kategóriához tartozik (`$iterator->nextValue` a [következő elem |/tags#$iterator]).
-
-Ha a feltétel mindig teljesül, akkor a belső ciklusban minden elem kirajzolódik:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Az eredmény így fog kinézni:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Mire jó az iterateWhile ilyen használata? Miben különbözik attól a megoldástól, amit a bemutató legelején mutattunk? A különbség az, hogy ha a táblázat üres, és nem tartalmaz semmilyen elemet, akkor nem fog üresen renderelni `<ul></ul>`.
-
-
-Megoldás a `{iterateWhile}` nélkül .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------------
-
-Ha ugyanazt a feladatot a sablonrendszerek teljesen alapvető konstrukcióival oldanánk meg, például Twigben, Blade-ben vagy tiszta PHP-ben, a megoldás valahogy így nézne ki:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* új listát nyitunk *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* lezárjuk az utolsó listát *}
-	</ul>
-{/if}
-```
-
-Ez a kód azonban érthetetlen és nem intuitív. A nyitó és záró HTML-címkék közötti kapcsolat egyáltalán nem egyértelmű. Első pillantásra nem egyértelmű, hogy hiba van-e benne. És olyan segédváltozókat igényel, mint a `$prevCategoryId`.
-
-Ezzel szemben a `{iterateWhile}` megoldása tiszta, egyértelmű, nem igényel segédváltozókat, és bolondbiztos.
-
-
-Feltétel a záró tagben .[#toc-condition-in-the-closing-tag]
------------------------------------------------------------
-
-Ha a nyitó tagben adunk meg egy feltételt `{iterateWhile}`, a viselkedés megváltozik: a feltétel (és a következő elemre való továbblépés) a belső ciklus elején hajtódik végre, nem pedig a végén.
-Így míg a `{iterateWhile}` feltétel nélkül mindig belép, a `{iterateWhile $cond}` csak akkor lép be, ha a `$cond` feltétel teljesül. Ezzel egyidejűleg a következő elemet írja a `$item`.
-
-Ez hasznos például olyan helyzetekben, amikor az egyes kategóriák első elemét másképp szeretnénk megjeleníteni, például:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Módosítsuk az eredeti kódot, rajzoljuk az első elemet, majd további elemeket ugyanabból a kategóriából a belső ciklusban `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Beágyazott hurkok .[#toc-nested-loops]
---------------------------------------
-
-Egy ciklusban több belső hurkot is létrehozhatunk, és akár egymásba is ágyazhatjuk őket. Így például alkategóriákat csoportosíthatunk.
-
-Tegyük fel, hogy van egy másik oszlop a `subcategoryId` táblázatban, és amellett, hogy minden kategória egy különálló `<ul>`, minden alkategória egy külön oszlopban lesz. `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Szűrő |batch .[#toc-filter-batch]
----------------------------------
-
-A lineáris elemek csoportosítását szintén a `batch` szűrő biztosítja, mégpedig fix elemszámú tételekbe:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Ez helyettesíthető iterateWhile-val az alábbiak szerint:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/it/cookbook/grouping.texy b/latte/it/cookbook/grouping.texy
new file mode 100644
index 0000000000..02d683c9fc
--- /dev/null
+++ b/latte/it/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Tutto quello che avete sempre voluto sapere su {iterateWhile}
+*************************************************************
+
+.[perex]
+Il tag `{iterateWhile}` è adatto a vari trucchi nei cicli foreach.
+
+Supponiamo di avere la seguente tabella di database, in cui gli articoli sono divisi in categorie:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Naturalmente, disegnare gli elementi in un ciclo foreach come elenco è facile:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Ma cosa fare se si vuole rendere ogni categoria in un elenco separato? In altre parole, come risolvere il compito di raggruppare gli elementi di un elenco lineare in un ciclo foreach. L'output dovrebbe essere simile a questo:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Vi mostreremo come questo compito possa essere risolto in modo semplice ed elegante con iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Mentre `{foreach}` segna la parte esterna del ciclo, cioè il disegno delle liste per ogni categoria, i tag `{iterateWhile}` indicano la parte interna, cioè i singoli elementi.
+La condizione nel tag end dice che la ripetizione continuerà finché l'elemento corrente e quello successivo appartengono alla stessa categoria (`$iterator->nextValue` è l'[elemento successivo |/tags#$iterator]).
+
+Se la condizione è sempre soddisfatta, allora tutti gli elementi vengono disegnati nel ciclo interno:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Il risultato sarà simile a questo:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+A cosa serve questo uso di iterateWhile? In cosa differisce dalla soluzione mostrata all'inizio di questo tutorial? La differenza è che se la tabella è vuota e non contiene alcun elemento, non verrà resa vuota `<ul></ul>`.
+
+
+Soluzione senza `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+----------------------------------------------------------------------
+
+Se risolvessimo lo stesso compito con costruzioni completamente elementari di sistemi di template, per esempio in Twig, Blade o PHP puro, la soluzione sarebbe simile a questa:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* chiudiamo la precedente <ul>, se non è il primo elemento *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* apriremo una nuova lista *}
+	<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* chiudiamo l'ultima lista *}
+	</ul>
+{/if}
+```
+
+Tuttavia, questo codice è incomprensibile e poco intuitivo. Il collegamento tra i tag HTML di apertura e di chiusura non è affatto chiaro. Non è chiaro a prima vista se c'è un errore. E richiede variabili ausiliarie come `$prevCategoryId`.
+
+Al contrario, la soluzione con `{iterateWhile}` è pulita, chiara, non necessita di variabili ausiliarie ed è a prova di errore.
+
+
+Condizione nel tag di chiusura .[#toc-condition-in-the-closing-tag]
+-------------------------------------------------------------------
+
+Se si specifica una condizione nel tag di apertura `{iterateWhile}`, il comportamento cambia: la condizione (e l'avanzamento all'elemento successivo) viene eseguita all'inizio del ciclo interno, non alla fine.
+Così, mentre `{iterateWhile}` senza condizione viene sempre inserito, `{iterateWhile $cond}` viene inserito solo quando la condizione `$cond` è soddisfatta. Allo stesso tempo, il seguente elemento viene scritto in `$item`.
+
+Questo è utile, ad esempio, in una situazione in cui si vuole rendere il primo elemento di ogni categoria in modo diverso, come ad esempio:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Modifichiamo il codice originale, disegniamo il primo elemento e poi altri elementi della stessa categoria nel ciclo interno `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Cicli annidati .[#toc-nested-loops]
+-----------------------------------
+
+È possibile creare più cicli interni in un ciclo e persino annidarli. In questo modo, ad esempio, si possono raggruppare le sottocategorie.
+
+Supponiamo che ci sia un'altra colonna nella tabella `subcategoryId` e che, oltre ad avere ogni categoria in una sezione separata, ogni sottocategoria sia in una sezione separata. `<ul>`ogni sottocategoria sarà in una colonna separata `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtro |batch .[#toc-filter-batch]
+----------------------------------
+
+Il raggruppamento degli elementi lineari è fornito anche da un filtro `batch`, in lotti con un numero fisso di elementi:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Può essere sostituito da iterateWhile come segue:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/it/cookbook/iteratewhile.texy b/latte/it/cookbook/iteratewhile.texy
index 02d683c9fc..2d2d8ab663 100644
--- a/latte/it/cookbook/iteratewhile.texy
+++ b/latte/it/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Tutto quello che avete sempre voluto sapere su {iterateWhile}
-*************************************************************
-
-.[perex]
-Il tag `{iterateWhile}` è adatto a vari trucchi nei cicli foreach.
-
-Supponiamo di avere la seguente tabella di database, in cui gli articoli sono divisi in categorie:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Naturalmente, disegnare gli elementi in un ciclo foreach come elenco è facile:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Ma cosa fare se si vuole rendere ogni categoria in un elenco separato? In altre parole, come risolvere il compito di raggruppare gli elementi di un elenco lineare in un ciclo foreach. L'output dovrebbe essere simile a questo:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Vi mostreremo come questo compito possa essere risolto in modo semplice ed elegante con iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Mentre `{foreach}` segna la parte esterna del ciclo, cioè il disegno delle liste per ogni categoria, i tag `{iterateWhile}` indicano la parte interna, cioè i singoli elementi.
-La condizione nel tag end dice che la ripetizione continuerà finché l'elemento corrente e quello successivo appartengono alla stessa categoria (`$iterator->nextValue` è l'[elemento successivo |/tags#$iterator]).
-
-Se la condizione è sempre soddisfatta, allora tutti gli elementi vengono disegnati nel ciclo interno:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Il risultato sarà simile a questo:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-A cosa serve questo uso di iterateWhile? In cosa differisce dalla soluzione mostrata all'inizio di questo tutorial? La differenza è che se la tabella è vuota e non contiene alcun elemento, non verrà resa vuota `<ul></ul>`.
-
-
-Soluzione senza `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-----------------------------------------------------------------------
-
-Se risolvessimo lo stesso compito con costruzioni completamente elementari di sistemi di template, per esempio in Twig, Blade o PHP puro, la soluzione sarebbe simile a questa:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* chiudiamo la precedente <ul>, se non è il primo elemento *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* apriremo una nuova lista *}
-	<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* chiudiamo l'ultima lista *}
-	</ul>
-{/if}
-```
-
-Tuttavia, questo codice è incomprensibile e poco intuitivo. Il collegamento tra i tag HTML di apertura e di chiusura non è affatto chiaro. Non è chiaro a prima vista se c'è un errore. E richiede variabili ausiliarie come `$prevCategoryId`.
-
-Al contrario, la soluzione con `{iterateWhile}` è pulita, chiara, non necessita di variabili ausiliarie ed è a prova di errore.
-
-
-Condizione nel tag di chiusura .[#toc-condition-in-the-closing-tag]
--------------------------------------------------------------------
-
-Se si specifica una condizione nel tag di apertura `{iterateWhile}`, il comportamento cambia: la condizione (e l'avanzamento all'elemento successivo) viene eseguita all'inizio del ciclo interno, non alla fine.
-Così, mentre `{iterateWhile}` senza condizione viene sempre inserito, `{iterateWhile $cond}` viene inserito solo quando la condizione `$cond` è soddisfatta. Allo stesso tempo, il seguente elemento viene scritto in `$item`.
-
-Questo è utile, ad esempio, in una situazione in cui si vuole rendere il primo elemento di ogni categoria in modo diverso, come ad esempio:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Modifichiamo il codice originale, disegniamo il primo elemento e poi altri elementi della stessa categoria nel ciclo interno `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Cicli annidati .[#toc-nested-loops]
------------------------------------
-
-È possibile creare più cicli interni in un ciclo e persino annidarli. In questo modo, ad esempio, si possono raggruppare le sottocategorie.
-
-Supponiamo che ci sia un'altra colonna nella tabella `subcategoryId` e che, oltre ad avere ogni categoria in una sezione separata, ogni sottocategoria sia in una sezione separata. `<ul>`ogni sottocategoria sarà in una colonna separata `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtro |batch .[#toc-filter-batch]
-----------------------------------
-
-Il raggruppamento degli elementi lineari è fornito anche da un filtro `batch`, in lotti con un numero fisso di elementi:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Può essere sostituito da iterateWhile come segue:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/ja/cookbook/grouping.texy b/latte/ja/cookbook/grouping.texy
new file mode 100644
index 0000000000..f7c425458f
--- /dev/null
+++ b/latte/ja/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+iterateWhile}について、あなたがいつも知りたかったことすべて。
+*************************************
+
+.[perex]
+`{iterateWhile}` というタグは、foreach サイクルでの様々なトリックに適しています。
+
+次のようなデータベースのテーブルがあり、項目がカテゴリに分けられているとします。
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+もちろん、foreachループのアイテムをリストとして描画するのは簡単です。
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+しかし、各カテゴリを別々のリストで表示したい場合はどうすればよいのだろうか？言い換えれば、foreachサイクルで線形リストからアイテムをグループ化するタスクをどのように解決するかということです。出力はこのようになるはずだ。
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+このタスクをiterateWhileでいかに簡単かつエレガントに解決できるかをお見せします。
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+`{foreach}` がサイクルの外側、つまり各カテゴリのリストの描画を示すのに対して、`{iterateWhile}` タグは内側、つまり個々の項目を示しています。
+終了タグの条件は、現在の要素と次の要素が同じカテゴリに属している限り、繰り返しを続けるというものです（`$iterator->nextValue` は[次のアイテム |/tags#$iterator]）。
+
+もし、この条件が常に満たされるなら、すべての要素が内部のサイクルで描かれることになる。
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+結果は次のようになる。
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+このような iterateWhile の使い方にどんな利点があるのでしょうか？このチュートリアルの一番最初に紹介した解決策とどう違うのでしょうか？違いは、テーブルが空で要素を含んでいない場合、レンダリングが空にならないことです。 `<ul></ul>`.
+
+
+`{iterateWhile}` のない場合の解決策 .[#toc-solution-without-iteratewhile]
+----------------------------------------------------------------
+
+もし、同じタスクを完全に基本的な構造のテンプレートシステム、例えばTwigやBlade、あるいは純粋なPHPで解決するとしたら、解決策は次のようになります。
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+しかし、このコードは理解しがたく、直感的ではありません。HTMLタグの開始と終了の間の接続がまったく明確ではありません。間違いがあっても一目瞭然ではありません。しかも、`$prevCategoryId` のような補助変数を必要とする。
+
+これに対して、`{iterateWhile}` を使った解決策は、すっきりしていて、明確で、補助変数が必要なく、間違いがありません。
+
+
+終了タグの条件  .[#toc-condition-in-the-closing-tag]
+---------------------------------------------
+
+開始タグ`{iterateWhile}` で条件を指定すると、動作が変わります。条件 (と次の要素への移動) は内部サイクルの最初で実行され、最後では実行されなくなります。
+したがって、条件なしの`{iterateWhile}` は常に入力されますが、`{iterateWhile $cond}` は条件`$cond` が満たされたときだけ入力されます。同時に、次の要素が`$item` に書き込まれる。
+
+これは，たとえば，各カテゴリーの最初の要素を異なる方法でレンダリングしたいような場合に便利である．
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+元のコードを修正して、最初の項目を描画し、次に同じカテゴリから追加の項目を内部ループで描画することにしましょう`{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+ネストされたループ .[#toc-nested-loops]
+------------------------------
+
+1つのサイクルで複数の内部ループを作成し、さらにそれらを入れ子にすることができる。この方法で、例えば、サブカテゴリーをグループ化することができる。
+
+テーブル`subcategoryId` に別のカラムがあるとします。各カテゴリが別のカラムにあることに加えて、各サブカテゴリは別のカラムにあります。 `<ul>`にあることに加え、各サブカテゴリーは別々の `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+フィルタ｜バッチ .[#toc-filter-batch]
+-----------------------------
+
+線形項目のグループ化は、フィルタ`batch` によっても提供され、一定の要素数を持つバッチに分けられます。
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+これは，次のように iterateWhile で置き換えることができます．
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/ja/cookbook/iteratewhile.texy b/latte/ja/cookbook/iteratewhile.texy
index f7c425458f..2d2d8ab663 100644
--- a/latte/ja/cookbook/iteratewhile.texy
+++ b/latte/ja/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-iterateWhile}について、あなたがいつも知りたかったことすべて。
-*************************************
-
-.[perex]
-`{iterateWhile}` というタグは、foreach サイクルでの様々なトリックに適しています。
-
-次のようなデータベースのテーブルがあり、項目がカテゴリに分けられているとします。
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-もちろん、foreachループのアイテムをリストとして描画するのは簡単です。
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-しかし、各カテゴリを別々のリストで表示したい場合はどうすればよいのだろうか？言い換えれば、foreachサイクルで線形リストからアイテムをグループ化するタスクをどのように解決するかということです。出力はこのようになるはずだ。
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-このタスクをiterateWhileでいかに簡単かつエレガントに解決できるかをお見せします。
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-`{foreach}` がサイクルの外側、つまり各カテゴリのリストの描画を示すのに対して、`{iterateWhile}` タグは内側、つまり個々の項目を示しています。
-終了タグの条件は、現在の要素と次の要素が同じカテゴリに属している限り、繰り返しを続けるというものです（`$iterator->nextValue` は[次のアイテム |/tags#$iterator]）。
-
-もし、この条件が常に満たされるなら、すべての要素が内部のサイクルで描かれることになる。
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-結果は次のようになる。
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-このような iterateWhile の使い方にどんな利点があるのでしょうか？このチュートリアルの一番最初に紹介した解決策とどう違うのでしょうか？違いは、テーブルが空で要素を含んでいない場合、レンダリングが空にならないことです。 `<ul></ul>`.
-
-
-`{iterateWhile}` のない場合の解決策 .[#toc-solution-without-iteratewhile]
-----------------------------------------------------------------
-
-もし、同じタスクを完全に基本的な構造のテンプレートシステム、例えばTwigやBlade、あるいは純粋なPHPで解決するとしたら、解決策は次のようになります。
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-しかし、このコードは理解しがたく、直感的ではありません。HTMLタグの開始と終了の間の接続がまったく明確ではありません。間違いがあっても一目瞭然ではありません。しかも、`$prevCategoryId` のような補助変数を必要とする。
-
-これに対して、`{iterateWhile}` を使った解決策は、すっきりしていて、明確で、補助変数が必要なく、間違いがありません。
-
-
-終了タグの条件  .[#toc-condition-in-the-closing-tag]
----------------------------------------------
-
-開始タグ`{iterateWhile}` で条件を指定すると、動作が変わります。条件 (と次の要素への移動) は内部サイクルの最初で実行され、最後では実行されなくなります。
-したがって、条件なしの`{iterateWhile}` は常に入力されますが、`{iterateWhile $cond}` は条件`$cond` が満たされたときだけ入力されます。同時に、次の要素が`$item` に書き込まれる。
-
-これは，たとえば，各カテゴリーの最初の要素を異なる方法でレンダリングしたいような場合に便利である．
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-元のコードを修正して、最初の項目を描画し、次に同じカテゴリから追加の項目を内部ループで描画することにしましょう`{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-ネストされたループ .[#toc-nested-loops]
-------------------------------
-
-1つのサイクルで複数の内部ループを作成し、さらにそれらを入れ子にすることができる。この方法で、例えば、サブカテゴリーをグループ化することができる。
-
-テーブル`subcategoryId` に別のカラムがあるとします。各カテゴリが別のカラムにあることに加えて、各サブカテゴリは別のカラムにあります。 `<ul>`にあることに加え、各サブカテゴリーは別々の `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-フィルタ｜バッチ .[#toc-filter-batch]
------------------------------
-
-線形項目のグループ化は、フィルタ`batch` によっても提供され、一定の要素数を持つバッチに分けられます。
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-これは，次のように iterateWhile で置き換えることができます．
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/pl/cookbook/grouping.texy b/latte/pl/cookbook/grouping.texy
new file mode 100644
index 0000000000..ae4f6a196c
--- /dev/null
+++ b/latte/pl/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Wszystko, co kiedykolwiek chciałeś wiedzieć o {iterateWhile}.
+*************************************************************
+
+.[perex]
+Znacznik `{iterateWhile}` jest przydatny do wszelkiego rodzaju sztuczek w pętlach foreach.
+
+Załóżmy, że mamy następującą tabelę bazy danych, w której przedmioty są skategoryzowane:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Renderowanie elementów w pętli foreach jako listy jest oczywiście proste:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Ale co jeśli chcielibyśmy, aby każda kategoria była na osobnej liście? Innymi słowy, rozwiązujemy problem, jak pogrupować elementy na liście liniowej w pętli foreach. Dane wyjściowe powinny wyglądać tak:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Zobaczymy jak łatwo i elegancko można rozwiązać to zadanie używając iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Podczas gdy `{foreach}` oznacza zewnętrzną część pętli, czyli renderowanie list dla każdej kategorii, znacznik `{iterateWhile}` oznacza część wewnętrzną, czyli poszczególne elementy.
+Warunek w znaczniku end mówi, że iteracja będzie trwała tak długo, jak długo bieżący i następny element należą do tej samej kategorii (`$iterator->nextValue` jest [następnym |/tags#iterator] elementem).
+
+Gdyby warunek był zawsze spełniony, wszystkie elementy byłyby renderowane w wewnętrznej pętli:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Wynik wyglądałby tak:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Jakie jest zastosowanie iterateWhile? Czym różni się ono od rozwiązania, które pokazaliśmy na samym początku tego tutorialu? Różnica polega na tym, że jeśli tablica jest pusta i nie zawiera żadnych elementów, nie zostanie wypisana pusta tablica `<ul></ul>`.
+
+
+Rozwiązanie bez `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+----------------------------------------------------------------------
+
+Gdybyśmy mieli rozwiązać to samo zadanie używając bardzo podstawowych systemów templatowania, na przykład w Twigu, Blade, czy czystym PHP, rozwiązanie wyglądałoby coś takiego:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* kategoria zmieniona *}
+
+		{* zamknij poprzedni, <ul> jeśli nie jest pierwszym elementem *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* otwórz nową listę *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* zamknij ostatnią listę *}
+	</ul>
+{/if}
+```
+
+Jednak ten kod jest niezrozumiały i nieintuicyjny. Związek pomiędzy otwierającymi i zamykającymi znacznikami HTML nie jest wcale jasny. Nie widać na pierwszy rzut oka, czy jest jakiś błąd. I wymaga zmiennych pomocniczych, takich jak `$prevCategoryId`.
+
+W przeciwieństwie do tego, rozwiązanie `{iterateWhile}` jest czyste, jasne, nie potrzebuje zmiennych pomocniczych i jest bloatproof.
+
+
+Warunek w tagu otwierającym .[#toc-condition-in-the-closing-tag]
+----------------------------------------------------------------
+
+Jeśli określisz warunek w znaczniku otwierającym `{iterateWhile}`, to zachowanie się zmieni: warunek (i przejście do następnego elementu) jest wykonywany na początku pętli wewnętrznej, a nie na końcu.
+O ile więc `{iterateWhile}` bez warunku jest wpisywany zawsze, to `{iterateWhile $cond}` jest wpisywany dopiero po spełnieniu warunku `$cond`. I w tym samym czasie na stronę `$item` wchodzi kolejny element.
+
+Co jest przydatne np. jeśli chcemy wyrenderować pierwszy element w każdej kategorii w inny sposób, np:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Zmodyfikuj oryginalny kod, najpierw renderując pierwszy element, a następnie renderując pozostałe elementy z tej samej kategorii w wewnętrznej pętli strony `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Pętle zagnieżdżone .[#toc-nested-loops]
+---------------------------------------
+
+Możemy tworzyć wiele pętli wewnętrznych w ramach jednej pętli, a nawet je zagnieżdżać. W ten sposób można by grupować np. podkategorie itp.
+
+Załóżmy, że w tabeli `subcategoryId` jest jeszcze jedna kolumna i oprócz tego, że każda kategoria jest w osobnej `<ul>`każda podkategoria w osobnym `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtr |wszystkie .[#toc-filter-batch]
+-------------------------------------
+
+Filtr `batch` obsługuje również grupowanie elementów liniowych w partie o stałej liczbie elementów:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Można go zastąpić iterateWhile w następujący sposób:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/pl/cookbook/iteratewhile.texy b/latte/pl/cookbook/iteratewhile.texy
index ae4f6a196c..2d2d8ab663 100644
--- a/latte/pl/cookbook/iteratewhile.texy
+++ b/latte/pl/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Wszystko, co kiedykolwiek chciałeś wiedzieć o {iterateWhile}.
-*************************************************************
-
-.[perex]
-Znacznik `{iterateWhile}` jest przydatny do wszelkiego rodzaju sztuczek w pętlach foreach.
-
-Załóżmy, że mamy następującą tabelę bazy danych, w której przedmioty są skategoryzowane:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Renderowanie elementów w pętli foreach jako listy jest oczywiście proste:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Ale co jeśli chcielibyśmy, aby każda kategoria była na osobnej liście? Innymi słowy, rozwiązujemy problem, jak pogrupować elementy na liście liniowej w pętli foreach. Dane wyjściowe powinny wyglądać tak:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Zobaczymy jak łatwo i elegancko można rozwiązać to zadanie używając iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Podczas gdy `{foreach}` oznacza zewnętrzną część pętli, czyli renderowanie list dla każdej kategorii, znacznik `{iterateWhile}` oznacza część wewnętrzną, czyli poszczególne elementy.
-Warunek w znaczniku end mówi, że iteracja będzie trwała tak długo, jak długo bieżący i następny element należą do tej samej kategorii (`$iterator->nextValue` jest [następnym |/tags#iterator] elementem).
-
-Gdyby warunek był zawsze spełniony, wszystkie elementy byłyby renderowane w wewnętrznej pętli:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Wynik wyglądałby tak:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Jakie jest zastosowanie iterateWhile? Czym różni się ono od rozwiązania, które pokazaliśmy na samym początku tego tutorialu? Różnica polega na tym, że jeśli tablica jest pusta i nie zawiera żadnych elementów, nie zostanie wypisana pusta tablica `<ul></ul>`.
-
-
-Rozwiązanie bez `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-----------------------------------------------------------------------
-
-Gdybyśmy mieli rozwiązać to samo zadanie używając bardzo podstawowych systemów templatowania, na przykład w Twigu, Blade, czy czystym PHP, rozwiązanie wyglądałoby coś takiego:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* kategoria zmieniona *}
-
-		{* zamknij poprzedni, <ul> jeśli nie jest pierwszym elementem *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* otwórz nową listę *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* zamknij ostatnią listę *}
-	</ul>
-{/if}
-```
-
-Jednak ten kod jest niezrozumiały i nieintuicyjny. Związek pomiędzy otwierającymi i zamykającymi znacznikami HTML nie jest wcale jasny. Nie widać na pierwszy rzut oka, czy jest jakiś błąd. I wymaga zmiennych pomocniczych, takich jak `$prevCategoryId`.
-
-W przeciwieństwie do tego, rozwiązanie `{iterateWhile}` jest czyste, jasne, nie potrzebuje zmiennych pomocniczych i jest bloatproof.
-
-
-Warunek w tagu otwierającym .[#toc-condition-in-the-closing-tag]
-----------------------------------------------------------------
-
-Jeśli określisz warunek w znaczniku otwierającym `{iterateWhile}`, to zachowanie się zmieni: warunek (i przejście do następnego elementu) jest wykonywany na początku pętli wewnętrznej, a nie na końcu.
-O ile więc `{iterateWhile}` bez warunku jest wpisywany zawsze, to `{iterateWhile $cond}` jest wpisywany dopiero po spełnieniu warunku `$cond`. I w tym samym czasie na stronę `$item` wchodzi kolejny element.
-
-Co jest przydatne np. jeśli chcemy wyrenderować pierwszy element w każdej kategorii w inny sposób, np:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Zmodyfikuj oryginalny kod, najpierw renderując pierwszy element, a następnie renderując pozostałe elementy z tej samej kategorii w wewnętrznej pętli strony `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Pętle zagnieżdżone .[#toc-nested-loops]
----------------------------------------
-
-Możemy tworzyć wiele pętli wewnętrznych w ramach jednej pętli, a nawet je zagnieżdżać. W ten sposób można by grupować np. podkategorie itp.
-
-Załóżmy, że w tabeli `subcategoryId` jest jeszcze jedna kolumna i oprócz tego, że każda kategoria jest w osobnej `<ul>`każda podkategoria w osobnym `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtr |wszystkie .[#toc-filter-batch]
--------------------------------------
-
-Filtr `batch` obsługuje również grupowanie elementów liniowych w partie o stałej liczbie elementów:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Można go zastąpić iterateWhile w następujący sposób:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/pt/cookbook/grouping.texy b/latte/pt/cookbook/grouping.texy
new file mode 100644
index 0000000000..98970df485
--- /dev/null
+++ b/latte/pt/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Tudo o que você sempre quis saber sobre {alfabetizar-assim}
+***********************************************************
+
+.[perex]
+A etiqueta `{iterateWhile}` é adequada para vários truques em ciclos anteriores.
+
+Suponha que tenhamos a seguinte tabela de banco de dados, onde os itens são divididos em categorias:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Naturalmente, desenhar itens em um laço na frente como uma lista é fácil:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Mas o que fazer se você quiser apresentar cada categoria em uma lista separada? Em outras palavras, como resolver a tarefa de agrupar itens de uma lista linear em um ciclo foreach. A saída deve se parecer com isto:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Mostraremos a facilidade e a elegância com que a tarefa pode ser resolvida com iteração:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Enquanto `{foreach}` marca a parte externa do ciclo, ou seja, o desenho de listas para cada categoria, as tags `{iterateWhile}` indicam a parte interna, ou seja, os itens individuais.
+A condição na etiqueta final diz que a repetição continuará enquanto o elemento atual e o próximo elemento pertencerem à mesma categoria (`$iterator->nextValue` é o [próximo item |/tags#$iterator]).
+
+Se a condição for sempre preenchida, então todos os elementos são desenhados no ciclo interno:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+O resultado será o seguinte:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+De que serve tal uso da iteração enquanto? De que forma difere da solução que mostramos logo no início deste tutorial? A diferença é que se a tabela estiver vazia e não contiver nenhum elemento, ela não irá tornar vazia `<ul></ul>`.
+
+
+Solução Sem `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------
+
+Se resolvêssemos a mesma tarefa com construções completamente básicas de sistemas de modelos, por exemplo em Twig, Blade ou PHP puro, a solução seria algo parecido com isto:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* abriremos uma nova lista *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+No entanto, este código é incompreensível e pouco intuitivo. A conexão entre as tags HTML de abertura e fechamento não é clara em absoluto. Não é clara à primeira vista, se houver um erro. E requer variáveis auxiliares como `$prevCategoryId`.
+
+Em contraste, a solução com `{iterateWhile}` é limpa, clara, não necessita de variáveis auxiliares e é infalível.
+
+
+Condição na Etiqueta de Fechamento .[#toc-condition-in-the-closing-tag]
+-----------------------------------------------------------------------
+
+Se especificarmos uma condição na etiqueta de abertura `{iterateWhile}`, o comportamento muda: a condição (e o avanço para o próximo elemento) é executada no início do ciclo interno, não no final.
+Assim, enquanto `{iterateWhile}` sem condição é sempre inserido, `{iterateWhile $cond}` é inserido somente quando a condição `$cond` é cumprida. Ao mesmo tempo, o seguinte elemento é escrito para `$item`.
+
+Isto é útil, por exemplo, em uma situação em que você quer renderizar o primeiro elemento de cada categoria de uma maneira diferente, como por exemplo:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Vamos modificar o código original, primeiro desenhamos um item e depois itens adicionais da mesma categoria no laço interno `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Laços aninhados .[#toc-nested-loops]
+------------------------------------
+
+Podemos criar vários loops internos em um ciclo e até mesmo aninhá-los. Desta forma, por exemplo, as subcategorias poderiam ser agrupadas.
+
+Suponha que haja outra coluna na tabela `subcategoryId` e que, além de cada categoria estar em uma `<ul>`cada subcategoria estará em uma subcategoria separada `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtro |batch .[#toc-filter-batch]
+----------------------------------
+
+O agrupamento de itens lineares também é fornecido por um filtro `batch`, em lotes com um número fixo de elementos:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Ela pode ser substituída por iteração, enquanto que, como se segue:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/pt/cookbook/iteratewhile.texy b/latte/pt/cookbook/iteratewhile.texy
index 98970df485..2d2d8ab663 100644
--- a/latte/pt/cookbook/iteratewhile.texy
+++ b/latte/pt/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Tudo o que você sempre quis saber sobre {alfabetizar-assim}
-***********************************************************
-
-.[perex]
-A etiqueta `{iterateWhile}` é adequada para vários truques em ciclos anteriores.
-
-Suponha que tenhamos a seguinte tabela de banco de dados, onde os itens são divididos em categorias:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Naturalmente, desenhar itens em um laço na frente como uma lista é fácil:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Mas o que fazer se você quiser apresentar cada categoria em uma lista separada? Em outras palavras, como resolver a tarefa de agrupar itens de uma lista linear em um ciclo foreach. A saída deve se parecer com isto:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Mostraremos a facilidade e a elegância com que a tarefa pode ser resolvida com iteração:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Enquanto `{foreach}` marca a parte externa do ciclo, ou seja, o desenho de listas para cada categoria, as tags `{iterateWhile}` indicam a parte interna, ou seja, os itens individuais.
-A condição na etiqueta final diz que a repetição continuará enquanto o elemento atual e o próximo elemento pertencerem à mesma categoria (`$iterator->nextValue` é o [próximo item |/tags#$iterator]).
-
-Se a condição for sempre preenchida, então todos os elementos são desenhados no ciclo interno:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-O resultado será o seguinte:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-De que serve tal uso da iteração enquanto? De que forma difere da solução que mostramos logo no início deste tutorial? A diferença é que se a tabela estiver vazia e não contiver nenhum elemento, ela não irá tornar vazia `<ul></ul>`.
-
-
-Solução Sem `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------
-
-Se resolvêssemos a mesma tarefa com construções completamente básicas de sistemas de modelos, por exemplo em Twig, Blade ou PHP puro, a solução seria algo parecido com isto:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* abriremos uma nova lista *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-No entanto, este código é incompreensível e pouco intuitivo. A conexão entre as tags HTML de abertura e fechamento não é clara em absoluto. Não é clara à primeira vista, se houver um erro. E requer variáveis auxiliares como `$prevCategoryId`.
-
-Em contraste, a solução com `{iterateWhile}` é limpa, clara, não necessita de variáveis auxiliares e é infalível.
-
-
-Condição na Etiqueta de Fechamento .[#toc-condition-in-the-closing-tag]
------------------------------------------------------------------------
-
-Se especificarmos uma condição na etiqueta de abertura `{iterateWhile}`, o comportamento muda: a condição (e o avanço para o próximo elemento) é executada no início do ciclo interno, não no final.
-Assim, enquanto `{iterateWhile}` sem condição é sempre inserido, `{iterateWhile $cond}` é inserido somente quando a condição `$cond` é cumprida. Ao mesmo tempo, o seguinte elemento é escrito para `$item`.
-
-Isto é útil, por exemplo, em uma situação em que você quer renderizar o primeiro elemento de cada categoria de uma maneira diferente, como por exemplo:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Vamos modificar o código original, primeiro desenhamos um item e depois itens adicionais da mesma categoria no laço interno `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Laços aninhados .[#toc-nested-loops]
-------------------------------------
-
-Podemos criar vários loops internos em um ciclo e até mesmo aninhá-los. Desta forma, por exemplo, as subcategorias poderiam ser agrupadas.
-
-Suponha que haja outra coluna na tabela `subcategoryId` e que, além de cada categoria estar em uma `<ul>`cada subcategoria estará em uma subcategoria separada `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtro |batch .[#toc-filter-batch]
-----------------------------------
-
-O agrupamento de itens lineares também é fornecido por um filtro `batch`, em lotes com um número fixo de elementos:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Ela pode ser substituída por iteração, enquanto que, como se segue:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/ro/cookbook/grouping.texy b/latte/ro/cookbook/grouping.texy
new file mode 100644
index 0000000000..83dfc45836
--- /dev/null
+++ b/latte/ro/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Tot ce ați vrut să știți despre {iterateWhile}
+**********************************************
+
+.[perex]
+Eticheta `{iterateWhile}` este potrivită pentru diverse trucuri în ciclurile foreach.
+
+Să presupunem că avem următorul tabel de bază de date, în care articolele sunt împărțite în categorii:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Desigur, este ușor să desenezi elementele dintr-o buclă foreach sub forma unei liste:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Dar ce să faceți dacă doriți să redați fiecare categorie într-o listă separată? Cu alte cuvinte, cum să rezolvați sarcina de a grupa elementele dintr-o listă liniară într-un ciclu foreach. Rezultatul ar trebui să arate astfel:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Vă vom arăta cât de ușor și elegant poate fi rezolvată această sarcină cu iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+În timp ce `{foreach}` marchează partea exterioară a ciclului, adică întocmirea listelor pentru fiecare categorie, etichetele `{iterateWhile}` indică partea interioară, adică elementele individuale.
+Condiția din tag-ul end spune că repetiția va continua atâta timp cât elementul curent și cel următor aparțin aceleiași categorii (`$iterator->nextValue` este [elementul următor |/tags#$iterator]).
+
+Dacă condiția este întotdeauna îndeplinită, atunci toate elementele sunt desenate în ciclul interior:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Rezultatul va arăta astfel:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+La ce este bună o astfel de utilizare a iterateWhile? Prin ce diferă de soluția pe care am arătat-o la începutul acestui tutorial? Diferența constă în faptul că, dacă tabelul este gol și nu conține niciun element, nu se va afișa gol `<ul></ul>`.
+
+
+Soluție fără `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+-------------------------------------------------------------------
+
+Dacă am rezolva aceeași sarcină cu sisteme de șabloane complet de bază, de exemplu în Twig, Blade sau PHP pur, soluția ar arăta cam așa:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* categoria s-a schimbat *}
+
+		{* închidem pagina anterioară <ul>, dacă nu este primul element *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* vom deschide o nouă listă *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* închidem ultima listă *}
+	</ul>
+{/if}
+```
+
+Cu toate acestea, acest cod este de neînțeles și neintuitiv. Legătura dintre etichetele HTML de deschidere și închidere nu este deloc clară. Nu este clar la prima vedere dacă este vorba de o greșeală. Și este nevoie de variabile auxiliare precum `$prevCategoryId`.
+
+În schimb, soluția cu `{iterateWhile}` este curată, clară, nu are nevoie de variabile auxiliare și este infailibilă.
+
+
+Condiția din eticheta de închidere .[#toc-condition-in-the-closing-tag]
+-----------------------------------------------------------------------
+
+Dacă specificăm o condiție în tag-ul de deschidere `{iterateWhile}`, comportamentul se schimbă: condiția (și avansarea la elementul următor) este executată la începutul ciclului interior, nu la sfârșitul acestuia.
+Astfel, în timp ce `{iterateWhile}` fără condiție este introdus întotdeauna, `{iterateWhile $cond}` este introdus doar atunci când este îndeplinită condiția `$cond`. În același timp, următorul element este scris în `$item`.
+
+Acest lucru este util, de exemplu, în situația în care doriți să redați primul element din fiecare categorie într-un mod diferit, cum ar fi:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Să modificăm codul original, desenăm primul element și apoi elementele suplimentare din aceeași categorie în bucla interioară `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Bucle imbricate .[#toc-nested-loops]
+------------------------------------
+
+Putem crea mai multe bucle interioare într-un ciclu și chiar le putem anina. În acest fel, de exemplu, se pot grupa subcategorii.
+
+Să presupunem că există o altă coloană în tabelul `subcategoryId` și, pe lângă faptul că fiecare categorie se află într-o coloană separată `<ul>`, fiecare subcategorie va fi într-o coloană separată `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtru |batch .[#toc-filter-batch]
+----------------------------------
+
+Gruparea elementelor liniare este, de asemenea, asigurată de un filtru `batch`, în loturi cu un număr fix de elemente:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Acesta poate fi înlocuit cu iterateWhile după cum urmează:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/ro/cookbook/iteratewhile.texy b/latte/ro/cookbook/iteratewhile.texy
index 83dfc45836..2d2d8ab663 100644
--- a/latte/ro/cookbook/iteratewhile.texy
+++ b/latte/ro/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Tot ce ați vrut să știți despre {iterateWhile}
-**********************************************
-
-.[perex]
-Eticheta `{iterateWhile}` este potrivită pentru diverse trucuri în ciclurile foreach.
-
-Să presupunem că avem următorul tabel de bază de date, în care articolele sunt împărțite în categorii:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Desigur, este ușor să desenezi elementele dintr-o buclă foreach sub forma unei liste:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Dar ce să faceți dacă doriți să redați fiecare categorie într-o listă separată? Cu alte cuvinte, cum să rezolvați sarcina de a grupa elementele dintr-o listă liniară într-un ciclu foreach. Rezultatul ar trebui să arate astfel:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Vă vom arăta cât de ușor și elegant poate fi rezolvată această sarcină cu iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-În timp ce `{foreach}` marchează partea exterioară a ciclului, adică întocmirea listelor pentru fiecare categorie, etichetele `{iterateWhile}` indică partea interioară, adică elementele individuale.
-Condiția din tag-ul end spune că repetiția va continua atâta timp cât elementul curent și cel următor aparțin aceleiași categorii (`$iterator->nextValue` este [elementul următor |/tags#$iterator]).
-
-Dacă condiția este întotdeauna îndeplinită, atunci toate elementele sunt desenate în ciclul interior:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Rezultatul va arăta astfel:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-La ce este bună o astfel de utilizare a iterateWhile? Prin ce diferă de soluția pe care am arătat-o la începutul acestui tutorial? Diferența constă în faptul că, dacă tabelul este gol și nu conține niciun element, nu se va afișa gol `<ul></ul>`.
-
-
-Soluție fără `{iterateWhile}` .[#toc-solution-without-iteratewhile]
--------------------------------------------------------------------
-
-Dacă am rezolva aceeași sarcină cu sisteme de șabloane complet de bază, de exemplu în Twig, Blade sau PHP pur, soluția ar arăta cam așa:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* categoria s-a schimbat *}
-
-		{* închidem pagina anterioară <ul>, dacă nu este primul element *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* vom deschide o nouă listă *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* închidem ultima listă *}
-	</ul>
-{/if}
-```
-
-Cu toate acestea, acest cod este de neînțeles și neintuitiv. Legătura dintre etichetele HTML de deschidere și închidere nu este deloc clară. Nu este clar la prima vedere dacă este vorba de o greșeală. Și este nevoie de variabile auxiliare precum `$prevCategoryId`.
-
-În schimb, soluția cu `{iterateWhile}` este curată, clară, nu are nevoie de variabile auxiliare și este infailibilă.
-
-
-Condiția din eticheta de închidere .[#toc-condition-in-the-closing-tag]
------------------------------------------------------------------------
-
-Dacă specificăm o condiție în tag-ul de deschidere `{iterateWhile}`, comportamentul se schimbă: condiția (și avansarea la elementul următor) este executată la începutul ciclului interior, nu la sfârșitul acestuia.
-Astfel, în timp ce `{iterateWhile}` fără condiție este introdus întotdeauna, `{iterateWhile $cond}` este introdus doar atunci când este îndeplinită condiția `$cond`. În același timp, următorul element este scris în `$item`.
-
-Acest lucru este util, de exemplu, în situația în care doriți să redați primul element din fiecare categorie într-un mod diferit, cum ar fi:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Să modificăm codul original, desenăm primul element și apoi elementele suplimentare din aceeași categorie în bucla interioară `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Bucle imbricate .[#toc-nested-loops]
-------------------------------------
-
-Putem crea mai multe bucle interioare într-un ciclu și chiar le putem anina. În acest fel, de exemplu, se pot grupa subcategorii.
-
-Să presupunem că există o altă coloană în tabelul `subcategoryId` și, pe lângă faptul că fiecare categorie se află într-o coloană separată `<ul>`, fiecare subcategorie va fi într-o coloană separată `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtru |batch .[#toc-filter-batch]
-----------------------------------
-
-Gruparea elementelor liniare este, de asemenea, asigurată de un filtru `batch`, în loturi cu un număr fix de elemente:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Acesta poate fi înlocuit cu iterateWhile după cum urmează:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/ru/cookbook/grouping.texy b/latte/ru/cookbook/grouping.texy
new file mode 100644
index 0000000000..b4c81fa52f
--- /dev/null
+++ b/latte/ru/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Все, что вы всегда хотели знать о {iterateWhile}
+************************************************
+
+.[perex]
+Тег `{iterateWhile}` подходит для различных трюков в циклах foreach.
+
+Предположим, у нас есть следующая таблица базы данных, в которой элементы разделены на категории:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Конечно, вывести элементы в цикле foreach в виде списка очень просто:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Но что делать, если вы хотите вывести каждую категорию в отдельный список? Другими словами, как решить задачу группировки элементов из линейного списка в цикле foreach. Вывод должен выглядеть следующим образом:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Мы покажем вам, как легко и элегантно можно решить эту задачу с помощью iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Если `{foreach}` обозначает внешнюю часть цикла, то есть составление списков для каждой категории, то теги `{iterateWhile}` указывают на внутреннюю часть, то есть на отдельные элементы.
+Условие в теге end говорит, что повторение будет продолжаться до тех пор, пока текущий и следующий элемент принадлежат одной категории (`$iterator->nextValue` - [следующий элемент |/tags#iterator]).
+
+Если условие всегда выполняется, то во внутреннем цикле рисуются все элементы:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Результат будет выглядеть следующим образом:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Чем полезно такое использование iterateWhile? Чем оно отличается от решения, которое мы показали в самом начале этого руководства? Разница в том, что если таблица пуста и не содержит элементов, то она не будет выводиться пустой `<ul></ul>`.
+
+
+Решение без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------
+
+Если бы мы решали ту же задачу с помощью совершенно базовых конструкций систем шаблонов, например, в Twig, Blade или чистом PHP, то решение выглядело бы примерно так:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+Однако этот код непонятен и неинтуитивен. Связь между открывающим и закрывающим HTML-тегами совершенно не ясна. С первого взгляда не ясно, есть ли ошибка. И для этого требуются вспомогательные переменные, такие как `$prevCategoryId`.
+
+В отличие от этого, решение с `{iterateWhile}` чистое, понятное, не требует вспомогательных переменных и является надежным.
+
+
+Условие в закрывающем теге .[#toc-condition-in-the-closing-tag]
+---------------------------------------------------------------
+
+Если указать условие в открывающем теге `{iterateWhile}`, то поведение меняется: условие (и переход к следующему элементу) выполняется в начале внутреннего цикла, а не в конце.
+Таким образом, если `{iterateWhile}` без условия вводится всегда, то `{iterateWhile $cond}` вводится только при выполнении условия `$cond`. В то же время, следующий элемент записывается в `$item`.
+
+Это полезно, например, в ситуации, когда нужно по-разному отобразить первый элемент в каждой категории, например:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Изменим исходный код, мы отрисовываем первый элемент, а затем дополнительные элементы из той же категории во внутреннем цикле `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Вложенные циклы .[#toc-nested-loops]
+------------------------------------
+
+Мы можем создать несколько внутренних циклов в одном цикле и даже вложить их друг в друга. Таким образом, например, можно сгруппировать подкатегории.
+
+Предположим, что в таблице `subcategoryId` есть еще один столбец, и в дополнение к тому, что каждая категория будет находиться в отдельном столбце, каждая подкатегория будет находиться в отдельном столбце. `<ul>`, каждая подкатегория будет находиться в отдельной колонке `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Фильтр | пакетный .[#toc-filter-batch]
+--------------------------------------
+
+Группировка линейных элементов также обеспечивается фильтром `batch`, в партии с фиксированным количеством элементов:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Его можно заменить на iterateWhile следующим образом:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/ru/cookbook/iteratewhile.texy b/latte/ru/cookbook/iteratewhile.texy
index b4c81fa52f..2d2d8ab663 100644
--- a/latte/ru/cookbook/iteratewhile.texy
+++ b/latte/ru/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Все, что вы всегда хотели знать о {iterateWhile}
-************************************************
-
-.[perex]
-Тег `{iterateWhile}` подходит для различных трюков в циклах foreach.
-
-Предположим, у нас есть следующая таблица базы данных, в которой элементы разделены на категории:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Конечно, вывести элементы в цикле foreach в виде списка очень просто:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Но что делать, если вы хотите вывести каждую категорию в отдельный список? Другими словами, как решить задачу группировки элементов из линейного списка в цикле foreach. Вывод должен выглядеть следующим образом:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Мы покажем вам, как легко и элегантно можно решить эту задачу с помощью iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Если `{foreach}` обозначает внешнюю часть цикла, то есть составление списков для каждой категории, то теги `{iterateWhile}` указывают на внутреннюю часть, то есть на отдельные элементы.
-Условие в теге end говорит, что повторение будет продолжаться до тех пор, пока текущий и следующий элемент принадлежат одной категории (`$iterator->nextValue` - [следующий элемент |/tags#iterator]).
-
-Если условие всегда выполняется, то во внутреннем цикле рисуются все элементы:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Результат будет выглядеть следующим образом:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Чем полезно такое использование iterateWhile? Чем оно отличается от решения, которое мы показали в самом начале этого руководства? Разница в том, что если таблица пуста и не содержит элементов, то она не будет выводиться пустой `<ul></ul>`.
-
-
-Решение без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------
-
-Если бы мы решали ту же задачу с помощью совершенно базовых конструкций систем шаблонов, например, в Twig, Blade или чистом PHP, то решение выглядело бы примерно так:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-Однако этот код непонятен и неинтуитивен. Связь между открывающим и закрывающим HTML-тегами совершенно не ясна. С первого взгляда не ясно, есть ли ошибка. И для этого требуются вспомогательные переменные, такие как `$prevCategoryId`.
-
-В отличие от этого, решение с `{iterateWhile}` чистое, понятное, не требует вспомогательных переменных и является надежным.
-
-
-Условие в закрывающем теге .[#toc-condition-in-the-closing-tag]
----------------------------------------------------------------
-
-Если указать условие в открывающем теге `{iterateWhile}`, то поведение меняется: условие (и переход к следующему элементу) выполняется в начале внутреннего цикла, а не в конце.
-Таким образом, если `{iterateWhile}` без условия вводится всегда, то `{iterateWhile $cond}` вводится только при выполнении условия `$cond`. В то же время, следующий элемент записывается в `$item`.
-
-Это полезно, например, в ситуации, когда нужно по-разному отобразить первый элемент в каждой категории, например:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Изменим исходный код, мы отрисовываем первый элемент, а затем дополнительные элементы из той же категории во внутреннем цикле `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Вложенные циклы .[#toc-nested-loops]
-------------------------------------
-
-Мы можем создать несколько внутренних циклов в одном цикле и даже вложить их друг в друга. Таким образом, например, можно сгруппировать подкатегории.
-
-Предположим, что в таблице `subcategoryId` есть еще один столбец, и в дополнение к тому, что каждая категория будет находиться в отдельном столбце, каждая подкатегория будет находиться в отдельном столбце. `<ul>`, каждая подкатегория будет находиться в отдельной колонке `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Фильтр | пакетный .[#toc-filter-batch]
---------------------------------------
-
-Группировка линейных элементов также обеспечивается фильтром `batch`, в партии с фиксированным количеством элементов:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Его можно заменить на iterateWhile следующим образом:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/sl/cookbook/grouping.texy b/latte/sl/cookbook/grouping.texy
new file mode 100644
index 0000000000..41aa3a7588
--- /dev/null
+++ b/latte/sl/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Vse, kar ste vedno želeli vedeti o {iterateWhile}
+*************************************************
+
+.[perex]
+Oznaka `{iterateWhile}` je primerna za različne trike v ciklih foreach.
+
+Recimo, da imamo naslednjo tabelo podatkovne zbirke, v kateri so predmeti razdeljeni v kategorije:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Seveda je risanje elementov v zanki foreach kot seznam enostavno:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Kaj pa storiti, če želite vsako kategorijo prikazati na ločenem seznamu? Z drugimi besedami, kako rešiti nalogo združevanja elementov z linearnega seznama v ciklu foreach. Rezultat mora biti videti takole:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Pokazali vam bomo, kako enostavno in elegantno lahko to nalogo rešimo z iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Medtem ko `{foreach}` označuje zunanji del cikla, tj. izris seznamov za vsako kategorijo, oznake `{iterateWhile}` označujejo notranji del, tj. posamezne elemente.
+Pogoj v končni oznaki pove, da se bo ponavljanje nadaljevalo, dokler trenutni in naslednji element pripadata isti kategoriji (`$iterator->nextValue` je [naslednji element |/tags#$iterator]).
+
+Če je pogoj vedno izpolnjen, so v notranjem ciklu narisani vsi elementi:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Rezultat bo videti takole:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Kaj dobrega prinaša takšna uporaba iterateWhile? Kako se razlikuje od rešitve, ki smo jo prikazali na samem začetku tega učbenika? Razlika je v tem, da če je tabela prazna in ne vsebuje nobenih elementov, se ne bo prikazala prazna `<ul></ul>`.
+
+
+Rešitev brez spletne strani `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+----------------------------------------------------------------------------------
+
+Če bi isto nalogo reševali s povsem osnovnimi konstrukcijami sistemov predlog, na primer v Twigu, Bladeu ali čistem PHP, bi bila rešitev videti nekako takole:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* kategorija se je spremenila *}
+
+		{* zapremo prejšnji <ul>, če to ni prvi element *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* odpremo nov seznam *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* zapremo zadnji seznam *}
+	</ul>
+{/if}
+```
+
+Vendar je ta koda nerazumljiva in neintuitivna. Povezava med začetnimi in zaključnimi oznakami HTML sploh ni jasna. Na prvi pogled ni jasno, ali gre za napako. In zahteva pomožne spremenljivke, kot je `$prevCategoryId`.
+
+V nasprotju s tem je rešitev s `{iterateWhile}` čista, jasna, ne potrebuje pomožnih spremenljivk in je zanesljiva.
+
+
+Pogoj v zaključni oznaki .[#toc-condition-in-the-closing-tag]
+-------------------------------------------------------------
+
+Če določimo pogoj v začetni oznaki `{iterateWhile}`, se obnašanje spremeni: pogoj (in prehod na naslednji element) se izvede na začetku notranjega cikla in ne na koncu.
+Tako se `{iterateWhile}` brez pogoja vedno vnese, `{iterateWhile $cond}` pa se vnese šele, ko je izpolnjen pogoj `$cond`. Hkrati se v `$item` zapiše naslednji element.
+
+To je uporabno na primer v primeru, ko želite prvi element v vsaki kategoriji prikazati na drugačen način, npr:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Spremenimo prvotno kodo, v notranji zanki izrišemo prvi element in nato dodatne elemente iz iste kategorije `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Vgnezdene zanke .[#toc-nested-loops]
+------------------------------------
+
+V enem ciklu lahko ustvarimo več notranjih zank in jih celo ugnezdimo. Na ta način lahko na primer združimo podkategorije.
+
+Recimo, da je v preglednici še en stolpec `subcategoryId` in poleg tega, da je vsaka kategorija v ločenem `<ul>`, bo vsaka podkategorija v ločenem `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtriranje `|batch` .[#toc-filter-batch]
+-----------------------------------------
+
+Združevanje linearnih elementov v skupine omogoča tudi filter `batch`, in sicer v serije s fiksnim številom elementov:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Zamenjamo ga lahko z iterateWhile, kot sledi:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/sl/cookbook/iteratewhile.texy b/latte/sl/cookbook/iteratewhile.texy
index 41aa3a7588..2d2d8ab663 100644
--- a/latte/sl/cookbook/iteratewhile.texy
+++ b/latte/sl/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Vse, kar ste vedno želeli vedeti o {iterateWhile}
-*************************************************
-
-.[perex]
-Oznaka `{iterateWhile}` je primerna za različne trike v ciklih foreach.
-
-Recimo, da imamo naslednjo tabelo podatkovne zbirke, v kateri so predmeti razdeljeni v kategorije:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Seveda je risanje elementov v zanki foreach kot seznam enostavno:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Kaj pa storiti, če želite vsako kategorijo prikazati na ločenem seznamu? Z drugimi besedami, kako rešiti nalogo združevanja elementov z linearnega seznama v ciklu foreach. Rezultat mora biti videti takole:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Pokazali vam bomo, kako enostavno in elegantno lahko to nalogo rešimo z iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Medtem ko `{foreach}` označuje zunanji del cikla, tj. izris seznamov za vsako kategorijo, oznake `{iterateWhile}` označujejo notranji del, tj. posamezne elemente.
-Pogoj v končni oznaki pove, da se bo ponavljanje nadaljevalo, dokler trenutni in naslednji element pripadata isti kategoriji (`$iterator->nextValue` je [naslednji element |/tags#$iterator]).
-
-Če je pogoj vedno izpolnjen, so v notranjem ciklu narisani vsi elementi:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Rezultat bo videti takole:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Kaj dobrega prinaša takšna uporaba iterateWhile? Kako se razlikuje od rešitve, ki smo jo prikazali na samem začetku tega učbenika? Razlika je v tem, da če je tabela prazna in ne vsebuje nobenih elementov, se ne bo prikazala prazna `<ul></ul>`.
-
-
-Rešitev brez spletne strani `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-----------------------------------------------------------------------------------
-
-Če bi isto nalogo reševali s povsem osnovnimi konstrukcijami sistemov predlog, na primer v Twigu, Bladeu ali čistem PHP, bi bila rešitev videti nekako takole:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* kategorija se je spremenila *}
-
-		{* zapremo prejšnji <ul>, če to ni prvi element *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* odpremo nov seznam *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* zapremo zadnji seznam *}
-	</ul>
-{/if}
-```
-
-Vendar je ta koda nerazumljiva in neintuitivna. Povezava med začetnimi in zaključnimi oznakami HTML sploh ni jasna. Na prvi pogled ni jasno, ali gre za napako. In zahteva pomožne spremenljivke, kot je `$prevCategoryId`.
-
-V nasprotju s tem je rešitev s `{iterateWhile}` čista, jasna, ne potrebuje pomožnih spremenljivk in je zanesljiva.
-
-
-Pogoj v zaključni oznaki .[#toc-condition-in-the-closing-tag]
--------------------------------------------------------------
-
-Če določimo pogoj v začetni oznaki `{iterateWhile}`, se obnašanje spremeni: pogoj (in prehod na naslednji element) se izvede na začetku notranjega cikla in ne na koncu.
-Tako se `{iterateWhile}` brez pogoja vedno vnese, `{iterateWhile $cond}` pa se vnese šele, ko je izpolnjen pogoj `$cond`. Hkrati se v `$item` zapiše naslednji element.
-
-To je uporabno na primer v primeru, ko želite prvi element v vsaki kategoriji prikazati na drugačen način, npr:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Spremenimo prvotno kodo, v notranji zanki izrišemo prvi element in nato dodatne elemente iz iste kategorije `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Vgnezdene zanke .[#toc-nested-loops]
-------------------------------------
-
-V enem ciklu lahko ustvarimo več notranjih zank in jih celo ugnezdimo. Na ta način lahko na primer združimo podkategorije.
-
-Recimo, da je v preglednici še en stolpec `subcategoryId` in poleg tega, da je vsaka kategorija v ločenem `<ul>`, bo vsaka podkategorija v ločenem `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtriranje `|batch` .[#toc-filter-batch]
------------------------------------------
-
-Združevanje linearnih elementov v skupine omogoča tudi filter `batch`, in sicer v serije s fiksnim številom elementov:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Zamenjamo ga lahko z iterateWhile, kot sledi:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/tr/cookbook/grouping.texy b/latte/tr/cookbook/grouping.texy
new file mode 100644
index 0000000000..be9636178d
--- /dev/null
+++ b/latte/tr/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+iterateWhile} Hakkında Her Zaman Bilmek İstediğiniz Her Şey
+***********************************************************
+
+.[perex]
+`{iterateWhile}` etiketi foreach döngülerinde çeşitli hileler için uygundur.
+
+Öğelerin kategorilere ayrıldığı aşağıdaki veritabanı tablosuna sahip olduğumuzu varsayalım:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Elbette, bir foreach döngüsündeki öğeleri liste olarak çizmek kolaydır:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Ancak her kategoriyi ayrı bir listede işlemek istiyorsanız ne yapmalısınız? Başka bir deyişle, doğrusal bir listedeki öğeleri bir foreach döngüsü içinde gruplama görevi nasıl çözülür? Çıktı şöyle görünmelidir:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+iterateWhile ile bu görevin ne kadar kolay ve zarif bir şekilde çözülebileceğini göstereceğiz:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+`{foreach}` döngünün dış kısmını, yani her kategori için listelerin çizilmesini işaret ederken, `{iterateWhile}` etiketleri iç kısmı, yani tek tek öğeleri gösterir.
+Bitiş etiketindeki koşul, mevcut ve bir sonraki [öğe |/tags#$iterator] aynı kategoriye ait olduğu sürece tekrarın devam edeceğini söyler (`$iterator->nextValue` bir sonraki öğedir).
+
+Koşul her zaman karşılanırsa, tüm öğeler iç döngüde çizilir:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Sonuç şu şekilde görünecektir:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+iterateWhile'ın böyle bir kullanımı ne işe yarar? Bu eğitimin en başında gösterdiğimiz çözümden ne farkı var? Aradaki fark, tablo boşsa ve herhangi bir öğe içermiyorsa, boş olarak işlenmeyecektir `<ul></ul>`.
+
+
+`{iterateWhile}` Olmadan Çözüm .[#toc-solution-without-iteratewhile]
+--------------------------------------------------------------------
+
+Aynı görevi şablon sistemlerinin tamamen temel yapılarıyla, örneğin Twig, Blade veya saf PHP ile çözmüş olsaydık, çözüm şuna benzer bir şey olurdu:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* kategori değişti *}
+
+		{* <ul> ilk öğe değilse</ul>bir öncekini kapatıyoruz <ul>*}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+Ancak, bu kod anlaşılmaz ve sezgisel değildir. Açılış ve kapanış HTML etiketleri arasındaki bağlantı hiç açık değildir. Bir hata olup olmadığı ilk bakışta anlaşılmıyor. Ve `$prevCategoryId` gibi yardımcı değişkenler gerektirir.
+
+Buna karşılık, `{iterateWhile}` ile çözüm temiz, net, yardımcı değişkenlere ihtiyaç duymaz ve hatasızdır.
+
+
+Kapanış Etiketindeki Koşul .[#toc-condition-in-the-closing-tag]
+---------------------------------------------------------------
+
+Açılış etiketinde bir koşul belirtirsek `{iterateWhile}`, davranış değişir: koşul (ve bir sonraki öğeye ilerleme) iç döngünün sonunda değil başında yürütülür.
+Böylece, koşul olmadan `{iterateWhile}` her zaman girilirken, `{iterateWhile $cond}` yalnızca `$cond` koşulu karşılandığında girilir. Aynı zamanda, aşağıdaki eleman `$item` adresine yazılır.
+
+Bu, örneğin, her kategorideki ilk öğeyi farklı bir şekilde oluşturmak istediğiniz bir durumda kullanışlıdır:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Orijinal kodu değiştirelim, `{iterateWhile}` iç döngüsünde ilk öğeyi ve ardından aynı kategoriden ek öğeleri çizelim:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+İç İçe Döngüler .[#toc-nested-loops]
+------------------------------------
+
+Bir döngüde birden fazla iç döngü oluşturabilir ve hatta bunları iç içe yerleştirebiliriz. Bu şekilde, örneğin alt kategoriler gruplandırılabilir.
+
+Tabloda başka bir sütun olduğunu varsayalım `subcategoryId` ve her kategorinin ayrı bir kategoride olmasına ek olarak `<ul>`her bir alt kategori ayrı bir `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Filtre | yığın .[#toc-filter-batch]
+-----------------------------------
+
+Doğrusal öğelerin gruplandırılması da bir filtre tarafından sağlanır `batch`, sabit sayıda öğeye sahip gruplar halinde:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Aşağıdaki gibi iterateWhile ile değiştirilebilir:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/tr/cookbook/iteratewhile.texy b/latte/tr/cookbook/iteratewhile.texy
index be9636178d..2d2d8ab663 100644
--- a/latte/tr/cookbook/iteratewhile.texy
+++ b/latte/tr/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-iterateWhile} Hakkında Her Zaman Bilmek İstediğiniz Her Şey
-***********************************************************
-
-.[perex]
-`{iterateWhile}` etiketi foreach döngülerinde çeşitli hileler için uygundur.
-
-Öğelerin kategorilere ayrıldığı aşağıdaki veritabanı tablosuna sahip olduğumuzu varsayalım:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Elbette, bir foreach döngüsündeki öğeleri liste olarak çizmek kolaydır:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Ancak her kategoriyi ayrı bir listede işlemek istiyorsanız ne yapmalısınız? Başka bir deyişle, doğrusal bir listedeki öğeleri bir foreach döngüsü içinde gruplama görevi nasıl çözülür? Çıktı şöyle görünmelidir:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-iterateWhile ile bu görevin ne kadar kolay ve zarif bir şekilde çözülebileceğini göstereceğiz:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-`{foreach}` döngünün dış kısmını, yani her kategori için listelerin çizilmesini işaret ederken, `{iterateWhile}` etiketleri iç kısmı, yani tek tek öğeleri gösterir.
-Bitiş etiketindeki koşul, mevcut ve bir sonraki [öğe |/tags#$iterator] aynı kategoriye ait olduğu sürece tekrarın devam edeceğini söyler (`$iterator->nextValue` bir sonraki öğedir).
-
-Koşul her zaman karşılanırsa, tüm öğeler iç döngüde çizilir:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Sonuç şu şekilde görünecektir:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-iterateWhile'ın böyle bir kullanımı ne işe yarar? Bu eğitimin en başında gösterdiğimiz çözümden ne farkı var? Aradaki fark, tablo boşsa ve herhangi bir öğe içermiyorsa, boş olarak işlenmeyecektir `<ul></ul>`.
-
-
-`{iterateWhile}` Olmadan Çözüm .[#toc-solution-without-iteratewhile]
---------------------------------------------------------------------
-
-Aynı görevi şablon sistemlerinin tamamen temel yapılarıyla, örneğin Twig, Blade veya saf PHP ile çözmüş olsaydık, çözüm şuna benzer bir şey olurdu:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* kategori değişti *}
-
-		{* <ul> ilk öğe değilse</ul>bir öncekini kapatıyoruz <ul>*}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-Ancak, bu kod anlaşılmaz ve sezgisel değildir. Açılış ve kapanış HTML etiketleri arasındaki bağlantı hiç açık değildir. Bir hata olup olmadığı ilk bakışta anlaşılmıyor. Ve `$prevCategoryId` gibi yardımcı değişkenler gerektirir.
-
-Buna karşılık, `{iterateWhile}` ile çözüm temiz, net, yardımcı değişkenlere ihtiyaç duymaz ve hatasızdır.
-
-
-Kapanış Etiketindeki Koşul .[#toc-condition-in-the-closing-tag]
----------------------------------------------------------------
-
-Açılış etiketinde bir koşul belirtirsek `{iterateWhile}`, davranış değişir: koşul (ve bir sonraki öğeye ilerleme) iç döngünün sonunda değil başında yürütülür.
-Böylece, koşul olmadan `{iterateWhile}` her zaman girilirken, `{iterateWhile $cond}` yalnızca `$cond` koşulu karşılandığında girilir. Aynı zamanda, aşağıdaki eleman `$item` adresine yazılır.
-
-Bu, örneğin, her kategorideki ilk öğeyi farklı bir şekilde oluşturmak istediğiniz bir durumda kullanışlıdır:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Orijinal kodu değiştirelim, `{iterateWhile}` iç döngüsünde ilk öğeyi ve ardından aynı kategoriden ek öğeleri çizelim:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-İç İçe Döngüler .[#toc-nested-loops]
-------------------------------------
-
-Bir döngüde birden fazla iç döngü oluşturabilir ve hatta bunları iç içe yerleştirebiliriz. Bu şekilde, örneğin alt kategoriler gruplandırılabilir.
-
-Tabloda başka bir sütun olduğunu varsayalım `subcategoryId` ve her kategorinin ayrı bir kategoride olmasına ek olarak `<ul>`her bir alt kategori ayrı bir `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Filtre | yığın .[#toc-filter-batch]
------------------------------------
-
-Doğrusal öğelerin gruplandırılması da bir filtre tarafından sağlanır `batch`, sabit sayıda öğeye sahip gruplar halinde:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Aşağıdaki gibi iterateWhile ile değiştirilebilir:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}
diff --git a/latte/uk/cookbook/grouping.texy b/latte/uk/cookbook/grouping.texy
new file mode 100644
index 0000000000..22c6797409
--- /dev/null
+++ b/latte/uk/cookbook/grouping.texy
@@ -0,0 +1,214 @@
+Все, що ви завжди хотіли знати про {iterateWhile}
+*************************************************
+
+.[perex]
+Тег `{iterateWhile}` підходить для різних трюків у циклах foreach.
+
+Припустимо, у нас є така таблиця бази даних, у якій елементи розділені на категорії:
+
+| id  | categoryId | name
+|------------------
+| 1   |      1  | Apple
+| 2   |      1  | Banana
+| 3   |      2  | PHP
+| 4   |      3  | Green
+| 5   |      3  | Red
+| 6   |      3  | Blue
+
+Звичайно, вивести елементи в циклі foreach у вигляді списку дуже просто:
+
+```latte
+<ul>
+{foreach $items as $item}
+	<li>{$item->name}</li>
+{/foreach}
+</ul>
+```
+
+Але що робити, якщо ви хочете вивести кожну категорію в окремий список? Інакше кажучи, як розв'язати задачу групування елементів із лінійного списку в циклі foreach. Виведення має мати такий вигляд:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+</ul>
+
+<ul>
+	<li>PHP</li>
+</ul>
+
+<ul>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Ми покажемо вам, як легко й елегантно можна вирішити це завдання за допомогою iterateWhile:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}</li>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+Якщо `{foreach}` позначає зовнішню частину циклу, тобто складання списків для кожної категорії, то теги `{iterateWhile}` вказують на внутрішню частину, тобто на окремі елементи.
+Умова в тезі end говорить, що повторення триватиме доти, доки поточний і наступний елемент належать до однієї категорії (`$iterator->nextValue` - [наступний елемент |/tags#iterator]).
+
+Якщо умова завжди виконується, то у внутрішньому циклі малюються всі елементи:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<li>{$item->name}
+		{/iterateWhile true}
+	</ul>
+{/foreach}
+```
+
+Результат матиме такий вигляд:
+
+```latte
+<ul>
+	<li>Apple</li>
+	<li>Banana</li>
+	<li>PHP</li>
+	<li>Green</li>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Чим корисне таке використання iterateWhile? Чим воно відрізняється від рішення, яке ми показали на самому початку цього посібника? Різниця в тому, що якщо таблиця порожня і не містить елементів, то вона не буде виводитися порожньою `<ul></ul>`.
+
+
+Рішення без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
+------------------------------------------------------------------
+
+Якби ми вирішували ту саму задачу за допомогою абсолютно базових конструкцій систем шаблонів, наприклад, у Twig, Blade або чистому PHP, то рішення виглядало б приблизно так:
+
+```latte
+{var $prevCategoryId = null}
+{foreach $items as $item}
+	{if $item->categoryId !== $prevCategoryId}
+		{* the category has changed *}
+
+		{* we close the previous <ul>, if it is not the first item *}
+		{if $prevCategoryId !== null}
+			</ul>
+		{/if}
+
+		{* we will open a new list *}
+		<ul>
+
+		{do $prevCategoryId = $item->categoryId}
+	{/if}
+
+	<li>{$item->name}</li>
+{/foreach}
+
+{if $prevCategoryId !== null}
+	{* we close the last list *}
+	</ul>
+{/if}
+```
+
+Однак цей код незрозумілий і неінтуїтивний. Зв'язок між HTML-тегами, що відкривають і закривають, абсолютно не зрозумілий. З першого погляду не зрозуміло, чи є помилка. І для цього потрібні допоміжні змінні, такі як `$prevCategoryId`.
+
+На відміну від цього, рішення з `{iterateWhile}` чисте, зрозуміле, не потребує допоміжних змінних і є надійним.
+
+
+Умова в закриваючому тезі .[#toc-condition-in-the-closing-tag]
+--------------------------------------------------------------
+
+Якщо вказати умову у відкриваючому тезі `{iterateWhile}`, то поведінка змінюється: умова (і перехід до наступного елемента) виконується на початку внутрішнього циклу, а не в кінці.
+Таким чином, якщо `{iterateWhile}` без умови вводиться завжди, то `{iterateWhile $cond}` вводиться тільки при виконанні умови `$cond`. Водночас, наступний елемент записується в `$item`.
+
+Це корисно, наприклад, у ситуації, коли потрібно по-різному відобразити перший елемент у кожній категорії, наприклад:
+
+```latte
+<h1>Apple</h1>
+<ul>
+	<li>Banana</li>
+</ul>
+
+<h1>PHP</h1>
+<ul>
+</ul>
+
+<h1>Green</h1>
+<ul>
+	<li>Red</li>
+	<li>Blue</li>
+</ul>
+```
+
+Змінимо вихідний код, ми відтворюємо перший елемент, а потім додаткові елементи з тієї ж категорії у внутрішньому циклі `{iterateWhile}`:
+
+```latte
+{foreach $items as $item}
+	<h1>{$item->name}</h1>
+	<ul>
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+			<li>{$item->name}</li>
+		{/iterateWhile}
+	</ul>
+{/foreach}
+```
+
+
+Вкладені цикли .[#toc-nested-loops]
+-----------------------------------
+
+Ми можемо створити кілька внутрішніх циклів в одному циклі і навіть вкласти їх один в одного. Таким чином, наприклад, можна згрупувати підкатегорії.
+
+Припустімо, що в таблиці `subcategoryId` є ще один стовпчик, і на додаток до того, що кожна категорія перебуватиме в окремому стовпчику, кожна підкатегорія перебуватиме в окремому стовпчику. `<ul>`, кожна підкатегорія буде знаходитися в окремій колонці `<ol>`:
+
+```latte
+{foreach $items as $item}
+	<ul>
+		{iterateWhile}
+			<ol>
+				{iterateWhile}
+					<li>{$item->name}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
+			</ol>
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
+	</ul>
+{/foreach}
+```
+
+
+Фільтр | пакетний .[#toc-filter-batch]
+--------------------------------------
+
+Групування лінійних елементів також забезпечується фільтром `batch`, у партії з фіксованою кількістю елементів:
+
+```latte
+<ul>
+{foreach ($items|batch:3) as $batch}
+	{foreach $batch as $item}
+		<li>{$item->name}</li>
+	{/foreach}
+{/foreach}
+</ul>
+```
+
+Його можна замінити на iterateWhile таким чином:
+
+```latte
+<ul>
+{foreach $items as $item}
+	{iterateWhile}
+		<li>{$item->name}</li>
+	{/iterateWhile $iterator->counter0 % 3}
+{/foreach}
+</ul>
+```
+
+{{leftbar: /@left-menu}}
diff --git a/latte/uk/cookbook/iteratewhile.texy b/latte/uk/cookbook/iteratewhile.texy
index 22c6797409..2d2d8ab663 100644
--- a/latte/uk/cookbook/iteratewhile.texy
+++ b/latte/uk/cookbook/iteratewhile.texy
@@ -1,214 +1 @@
-Все, що ви завжди хотіли знати про {iterateWhile}
-*************************************************
-
-.[perex]
-Тег `{iterateWhile}` підходить для різних трюків у циклах foreach.
-
-Припустимо, у нас є така таблиця бази даних, у якій елементи розділені на категорії:
-
-| id  | categoryId | name
-|------------------
-| 1   |      1  | Apple
-| 2   |      1  | Banana
-| 3   |      2  | PHP
-| 4   |      3  | Green
-| 5   |      3  | Red
-| 6   |      3  | Blue
-
-Звичайно, вивести елементи в циклі foreach у вигляді списку дуже просто:
-
-```latte
-<ul>
-{foreach $items as $item}
-	<li>{$item->name}</li>
-{/foreach}
-</ul>
-```
-
-Але що робити, якщо ви хочете вивести кожну категорію в окремий список? Інакше кажучи, як розв'язати задачу групування елементів із лінійного списку в циклі foreach. Виведення має мати такий вигляд:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-</ul>
-
-<ul>
-	<li>PHP</li>
-</ul>
-
-<ul>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Ми покажемо вам, як легко й елегантно можна вирішити це завдання за допомогою iterateWhile:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}</li>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-Якщо `{foreach}` позначає зовнішню частину циклу, тобто складання списків для кожної категорії, то теги `{iterateWhile}` вказують на внутрішню частину, тобто на окремі елементи.
-Умова в тезі end говорить, що повторення триватиме доти, доки поточний і наступний елемент належать до однієї категорії (`$iterator->nextValue` - [наступний елемент |/tags#iterator]).
-
-Якщо умова завжди виконується, то у внутрішньому циклі малюються всі елементи:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<li>{$item->name}
-		{/iterateWhile true}
-	</ul>
-{/foreach}
-```
-
-Результат матиме такий вигляд:
-
-```latte
-<ul>
-	<li>Apple</li>
-	<li>Banana</li>
-	<li>PHP</li>
-	<li>Green</li>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Чим корисне таке використання iterateWhile? Чим воно відрізняється від рішення, яке ми показали на самому початку цього посібника? Різниця в тому, що якщо таблиця порожня і не містить елементів, то вона не буде виводитися порожньою `<ul></ul>`.
-
-
-Рішення без `{iterateWhile}` .[#toc-solution-without-iteratewhile]
-------------------------------------------------------------------
-
-Якби ми вирішували ту саму задачу за допомогою абсолютно базових конструкцій систем шаблонів, наприклад, у Twig, Blade або чистому PHP, то рішення виглядало б приблизно так:
-
-```latte
-{var $prevCategoryId = null}
-{foreach $items as $item}
-	{if $item->categoryId !== $prevCategoryId}
-		{* the category has changed *}
-
-		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCategoryId !== null}
-			</ul>
-		{/if}
-
-		{* we will open a new list *}
-		<ul>
-
-		{do $prevCategoryId = $item->categoryId}
-	{/if}
-
-	<li>{$item->name}</li>
-{/foreach}
-
-{if $prevCategoryId !== null}
-	{* we close the last list *}
-	</ul>
-{/if}
-```
-
-Однак цей код незрозумілий і неінтуїтивний. Зв'язок між HTML-тегами, що відкривають і закривають, абсолютно не зрозумілий. З першого погляду не зрозуміло, чи є помилка. І для цього потрібні допоміжні змінні, такі як `$prevCategoryId`.
-
-На відміну від цього, рішення з `{iterateWhile}` чисте, зрозуміле, не потребує допоміжних змінних і є надійним.
-
-
-Умова в закриваючому тезі .[#toc-condition-in-the-closing-tag]
---------------------------------------------------------------
-
-Якщо вказати умову у відкриваючому тезі `{iterateWhile}`, то поведінка змінюється: умова (і перехід до наступного елемента) виконується на початку внутрішнього циклу, а не в кінці.
-Таким чином, якщо `{iterateWhile}` без умови вводиться завжди, то `{iterateWhile $cond}` вводиться тільки при виконанні умови `$cond`. Водночас, наступний елемент записується в `$item`.
-
-Це корисно, наприклад, у ситуації, коли потрібно по-різному відобразити перший елемент у кожній категорії, наприклад:
-
-```latte
-<h1>Apple</h1>
-<ul>
-	<li>Banana</li>
-</ul>
-
-<h1>PHP</h1>
-<ul>
-</ul>
-
-<h1>Green</h1>
-<ul>
-	<li>Red</li>
-	<li>Blue</li>
-</ul>
-```
-
-Змінимо вихідний код, ми відтворюємо перший елемент, а потім додаткові елементи з тієї ж категорії у внутрішньому циклі `{iterateWhile}`:
-
-```latte
-{foreach $items as $item}
-	<h1>{$item->name}</h1>
-	<ul>
-		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-			<li>{$item->name}</li>
-		{/iterateWhile}
-	</ul>
-{/foreach}
-```
-
-
-Вкладені цикли .[#toc-nested-loops]
------------------------------------
-
-Ми можемо створити кілька внутрішніх циклів в одному циклі і навіть вкласти їх один в одного. Таким чином, наприклад, можна згрупувати підкатегорії.
-
-Припустімо, що в таблиці `subcategoryId` є ще один стовпчик, і на додаток до того, що кожна категорія перебуватиме в окремому стовпчику, кожна підкатегорія перебуватиме в окремому стовпчику. `<ul>`, кожна підкатегорія буде знаходитися в окремій колонці `<ol>`:
-
-```latte
-{foreach $items as $item}
-	<ul>
-		{iterateWhile}
-			<ol>
-				{iterateWhile}
-					<li>{$item->name}
-				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
-			</ol>
-		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
-	</ul>
-{/foreach}
-```
-
-
-Фільтр | пакетний .[#toc-filter-batch]
---------------------------------------
-
-Групування лінійних елементів також забезпечується фільтром `batch`, у партії з фіксованою кількістю елементів:
-
-```latte
-<ul>
-{foreach ($items|batch:3) as $batch}
-	{foreach $batch as $item}
-		<li>{$item->name}</li>
-	{/foreach}
-{/foreach}
-</ul>
-```
-
-Його можна замінити на iterateWhile таким чином:
-
-```latte
-<ul>
-{foreach $items as $item}
-	{iterateWhile}
-		<li>{$item->name}</li>
-	{/iterateWhile $iterator->counter0 % 3}
-{/foreach}
-</ul>
-```
-
-{{leftbar: /@left-menu}}
+{{redirect:grouping}}