From 9ea6f45f0b0cc7808e5e3335fc08edf5116e014c Mon Sep 17 00:00:00 2001
From: David Grudl <david@grudl.com>
Date: Tue, 14 May 2024 12:45:20 +0200
Subject: [PATCH] it

---
 latte/bg/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/cs/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/de/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/el/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/en/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/es/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/fr/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/hu/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/it/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/ja/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/pl/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/pt/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/ro/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/ru/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/sl/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/tr/cookbook/grouping.texy | 24 ++++++++++++------------
 latte/uk/cookbook/grouping.texy | 24 ++++++++++++------------
 17 files changed, 204 insertions(+), 204 deletions(-)

diff --git a/latte/bg/cookbook/grouping.texy b/latte/bg/cookbook/grouping.texy
index 4b112f2705..7acb916049 100644
--- a/latte/bg/cookbook/grouping.texy
+++ b/latte/bg/cookbook/grouping.texy
@@ -6,7 +6,7 @@
 
 Да предположим, че имаме следната таблица в базата данни, в която елементите са разделени на категории:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@
 Ако трябва да решим същия проблем, като използваме напълно елементарни шаблони, например в Twig, Blade или чист PHP, решението би изглеждало по следния начин
 
 ```latte
-{var $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{if $prevCategoryId !== null}
 	{* we close the last list *}
 	</ul>
 {/if}
 ```
 
-Този код обаче е неразбираем и неинтуитивен. Връзката между началния и крайния HTML таг не е съвсем ясна. От пръв поглед не е ясно дали има грешка. А това изисква помощни променливи като `$prevCatId`.
+Този код обаче е неразбираем и неинтуитивен. Връзката между началния и крайния HTML таг не е съвсем ясна. От пръв поглед не е ясно дали има грешка. А това изисква помощни променливи като `$prevCategoryId`.
 
 За разлика от това решението с `{iterateWhile}` е чисто, ясно, не изисква помощни променливи и е надеждно.
 
@@ -154,7 +154,7 @@
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@
 
 Можем да създадем няколко вътрешни цикъла в един цикъл и дори да ги вложим един в друг. По този начин например подкатегориите могат да бъдат групирани заедно.
 
-Да предположим, че в таблицата има още една колона `subCatId` и освен че всяка категория е в отделна колона, всяка подкатегория ще бъде в отделна колона. `<ul>`, всяка подкатегория ще бъде в отделна колона. `<ol>`:
+Да предположим, че в таблицата има още една колона `subcategoryId` и освен че всяка категория е в отделна колона, всяка подкатегория ще бъде в отделна колона. `<ul>`, всяка подкатегория ще бъде в отделна колона. `<ol>`:
 
 ```latte
 {foreach $items as $item}
@@ -176,9 +176,9 @@
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/cs/cookbook/grouping.texy b/latte/cs/cookbook/grouping.texy
index 7d5291aa8e..3b2d6bf60a 100644
--- a/latte/cs/cookbook/grouping.texy
+++ b/latte/cs/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Rovnou si ukážeme, jak snadno a elegantně se dá úkol vyřešit pomocí iter
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ K čemu je takové použití iterateWhile dobré? Jak se liší od řešení, kt
 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* změnila se kategorie *}
 
 		{* uzavřeme předchozí <ul>, pokud nejde o první položku *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* otevřeme nový seznam *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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é.
 
@@ -154,7 +154,7 @@ Původní kód upravíme tak, že nejprve vykreslíme první položku a poté ve
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` a kromě toho, že každá kategorie bude v samostatném `<ul>`, každá každý podkategorie samostatném `<ol>`:
+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}
@@ -176,9 +176,9 @@ Dejme tomu, že v tabulce bude ještě další sloupec `subCatId` a kromě toho,
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/de/cookbook/grouping.texy b/latte/de/cookbook/grouping.texy
index 10d820d9f8..e58a9d6754 100644
--- a/latte/de/cookbook/grouping.texy
+++ b/latte/de/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Wir werden Ihnen zeigen, wie einfach und elegant die Aufgabe mit iterateWhile ge
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* die Kategorie hat sich geändert *}
 
 		{* wir schließen das vorherige <ul>, wenn es nicht das erste Element ist *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* wir öffnen eine neue Liste *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId` benötigt.
+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.
 
@@ -154,7 +154,7 @@ Dies ist z. B. dann nützlich, wenn Sie das erste Element in jeder Kategorie auf
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` und jede Kategorie befindet sich nicht nur in einer separaten `<ul>`befindet, wird jede Unterkategorie in einer separaten `<ol>`:
+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}
@@ -176,9 +176,9 @@ Angenommen, es gibt eine weitere Spalte in der Tabelle `subCatId` und jede Kateg
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/el/cookbook/grouping.texy b/latte/el/cookbook/grouping.texy
index 877b3d24c9..6b83dd9939 100644
--- a/latte/el/cookbook/grouping.texy
+++ b/latte/el/cookbook/grouping.texy
@@ -6,7 +6,7 @@
 
 Ας υποθέσουμε ότι έχουμε τον ακόλουθο πίνακα της βάσης δεδομένων, όπου τα στοιχεία χωρίζονται σε κατηγορίες:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@
 Αν λύναμε την ίδια εργασία με εντελώς βασικές κατασκευές συστημάτων προτύπων, για παράδειγμα σε Twig, Blade ή καθαρή PHP, η λύση θα έμοιαζε κάπως έτσι:
 
 ```latte
-{var $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* η κατηγορία έχει αλλάξει *}
 
 		{* κλείνουμε το προηγούμενο <ul>, αν δεν είναι το πρώτο στοιχείο *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* θα ανοίξουμε μια νέα λίστα *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{if $prevCategoryId !== null}
 	{* κλείνουμε την προηγούμενη λίστα *}
 	</ul>
 {/if}
 ```
 
-Ωστόσο, αυτός ο κώδικας είναι ακατανόητος και μη διαισθητικός. Η σύνδεση μεταξύ των ετικετών HTML που ανοίγουν και κλείνουν δεν είναι καθόλου σαφής. Δεν είναι σαφές με την πρώτη ματιά αν υπάρχει κάποιο λάθος. Και απαιτεί βοηθητικές μεταβλητές όπως το `$prevCatId`.
+Ωστόσο, αυτός ο κώδικας είναι ακατανόητος και μη διαισθητικός. Η σύνδεση μεταξύ των ετικετών HTML που ανοίγουν και κλείνουν δεν είναι καθόλου σαφής. Δεν είναι σαφές με την πρώτη ματιά αν υπάρχει κάποιο λάθος. Και απαιτεί βοηθητικές μεταβλητές όπως το `$prevCategoryId`.
 
 Αντίθετα, η λύση με το `{iterateWhile}` είναι καθαρή, σαφής, δεν χρειάζεται βοηθητικές μεταβλητές και είναι αλάνθαστη.
 
@@ -154,7 +154,7 @@
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@
 
 Μπορούμε να δημιουργήσουμε πολλαπλούς εσωτερικούς βρόχους σε έναν κύκλο και μάλιστα να τους φωλιάσουμε. Με αυτόν τον τρόπο, για παράδειγμα, θα μπορούσαν να ομαδοποιηθούν οι υποκατηγορίες.
 
-Ας υποθέσουμε ότι υπάρχει μια άλλη στήλη στον πίνακα `subCatId` και εκτός από το ότι κάθε κατηγορία βρίσκεται σε ξεχωριστή `<ul>`, κάθε υποκατηγορία θα βρίσκεται σε μια ξεχωριστή `<ol>`:
+Ας υποθέσουμε ότι υπάρχει μια άλλη στήλη στον πίνακα `subcategoryId` και εκτός από το ότι κάθε κατηγορία βρίσκεται σε ξεχωριστή `<ul>`, κάθε υποκατηγορία θα βρίσκεται σε μια ξεχωριστή `<ol>`:
 
 ```latte
 {foreach $items as $item}
@@ -176,9 +176,9 @@
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/en/cookbook/grouping.texy b/latte/en/cookbook/grouping.texy
index 8324cdb0bd..6e94eefdb0 100644
--- a/latte/en/cookbook/grouping.texy
+++ b/latte/en/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ We will show you how easily and elegantly the task can be solved with iterateWhi
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Lets modify the original code, we draw first item and then additional items from
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` and in addition to each category being in a separate `<ul>`, each subcategory will be in a separate `<ol>`:
+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}
@@ -176,9 +176,9 @@ Suppose there is another column in the table `subCatId` and in addition to each
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/es/cookbook/grouping.texy b/latte/es/cookbook/grouping.texy
index 5c2e2c06df..f3a741dcca 100644
--- a/latte/es/cookbook/grouping.texy
+++ b/latte/es/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Le mostraremos con qué facilidad y elegancia se puede resolver la tarea con ite
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Modifiquemos el código original, dibujamos el primer elemento y luego los eleme
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` y además de que cada categoría esté en una separada `<ul>`, cada subcategoría estará en un `<ol>`:
+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}
@@ -176,9 +176,9 @@ Supongamos que hay otra columna en la tabla `subCatId` y además de que cada cat
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/fr/cookbook/grouping.texy b/latte/fr/cookbook/grouping.texy
index 97a4719db3..5b88220cb3 100644
--- a/latte/fr/cookbook/grouping.texy
+++ b/latte/fr/cookbook/grouping.texy
@@ -6,7 +6,7 @@ La balise `{iterateWhile}` convient pour diverses astuces dans les cycles foreac
 
 Supposons que nous ayons la table de base de données suivante, où les articles sont divisés en catégories :
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Nous allons vous montrer comment cette tâche peut être résolue facilement et
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{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 $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* nous allons ouvrir une nouvelle liste *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Modifions le code original, nous dessinons le premier élément et ensuite les 
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` 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>`:
+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}
@@ -176,9 +176,9 @@ Supposons qu'il y ait une autre colonne dans le tableau `subCatId` et qu'en plus
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/hu/cookbook/grouping.texy b/latte/hu/cookbook/grouping.texy
index e24112c93d..935c4a0672 100644
--- a/latte/hu/cookbook/grouping.texy
+++ b/latte/hu/cookbook/grouping.texy
@@ -6,7 +6,7 @@ A `{iterateWhile}` címke a foreach ciklusokban különböző trükkökre alkalm
 
 Tegyük fel, hogy a következő adatbázis táblával rendelkezünk, ahol az elemek kategóriákba vannak osztva:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Megmutatjuk, milyen egyszerűen és elegánsan megoldható a feladat az iterateW
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* új listát nyitunk *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Módosítsuk az eredeti kódot, rajzoljuk az első elemet, majd további elemeke
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` 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>`:
+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}
@@ -176,9 +176,9 @@ Tegyük fel, hogy van egy másik oszlop a `subCatId` táblázatban, és amellett
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/it/cookbook/grouping.texy b/latte/it/cookbook/grouping.texy
index d34f93292a..8996318c98 100644
--- a/latte/it/cookbook/grouping.texy
+++ b/latte/it/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Vi mostreremo come questo compito possa essere risolto in modo semplice ed elega
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* chiudiamo la precedente <ul>, se non è il primo elemento *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* apriremo una nuova lista *}
 	<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Modifichiamo il codice originale, disegniamo il primo elemento e poi altri eleme
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` 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>`:
+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}
@@ -176,9 +176,9 @@ Supponiamo che ci sia un'altra colonna nella tabella `subCatId` e che, oltre ad
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/ja/cookbook/grouping.texy b/latte/ja/cookbook/grouping.texy
index 9cfe8946f4..b3516b0a65 100644
--- a/latte/ja/cookbook/grouping.texy
+++ b/latte/ja/cookbook/grouping.texy
@@ -6,7 +6,7 @@
 
 次のようなデータベースのテーブルがあり、項目がカテゴリに分けられているとします。
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@
 もし、同じタスクを完全に基本的な構造のテンプレートシステム、例えばTwigやBlade、あるいは純粋なPHPで解決するとしたら、解決策は次のようになります。
 
 ```latte
-{var $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{if $prevCategoryId !== null}
 	{* we close the last list *}
 	</ul>
 {/if}
 ```
 
-しかし、このコードは理解しがたく、直感的ではありません。HTMLタグの開始と終了の間の接続がまったく明確ではありません。間違いがあっても一目瞭然ではありません。しかも、`$prevCatId` のような補助変数を必要とする。
+しかし、このコードは理解しがたく、直感的ではありません。HTMLタグの開始と終了の間の接続がまったく明確ではありません。間違いがあっても一目瞭然ではありません。しかも、`$prevCategoryId` のような補助変数を必要とする。
 
 これに対して、`{iterateWhile}` を使った解決策は、すっきりしていて、明確で、補助変数が必要なく、間違いがありません。
 
@@ -154,7 +154,7 @@
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@
 
 1つのサイクルで複数の内部ループを作成し、さらにそれらを入れ子にすることができる。この方法で、例えば、サブカテゴリーをグループ化することができる。
 
-テーブル`subCatId` に別のカラムがあるとします。各カテゴリが別のカラムにあることに加えて、各サブカテゴリは別のカラムにあります。 `<ul>`にあることに加え、各サブカテゴリーは別々の `<ol>`:
+テーブル`subcategoryId` に別のカラムがあるとします。各カテゴリが別のカラムにあることに加えて、各サブカテゴリは別のカラムにあります。 `<ul>`にあることに加え、各サブカテゴリーは別々の `<ol>`:
 
 ```latte
 {foreach $items as $item}
@@ -176,9 +176,9 @@
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/pl/cookbook/grouping.texy b/latte/pl/cookbook/grouping.texy
index 37c9edf46f..beb09a592d 100644
--- a/latte/pl/cookbook/grouping.texy
+++ b/latte/pl/cookbook/grouping.texy
@@ -6,7 +6,7 @@ Znacznik `{iterateWhile}` jest przydatny do wszelkiego rodzaju sztuczek w pętla
 
 Załóżmy, że mamy następującą tabelę bazy danych, w której przedmioty są skategoryzowane:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Zobaczymy jak łatwo i elegancko można rozwiązać to zadanie używając iterat
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* kategoria zmieniona *}
 
 		{* zamknij poprzedni, <ul> jeśli nie jest pierwszym elementem *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* otwórz nową listę *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Zmodyfikuj oryginalny kod, najpierw renderując pierwszy element, a następnie r
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` jest jeszcze jedna kolumna i oprócz tego, że każda kategoria jest w osobnej `<ul>`każda podkategoria w osobnym `<ol>`:
+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}
@@ -176,9 +176,9 @@ Załóżmy, że w tabeli `subCatId` jest jeszcze jedna kolumna i oprócz tego, 
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/pt/cookbook/grouping.texy b/latte/pt/cookbook/grouping.texy
index cad98e653e..7d820f1355 100644
--- a/latte/pt/cookbook/grouping.texy
+++ b/latte/pt/cookbook/grouping.texy
@@ -6,7 +6,7 @@ A etiqueta `{iterateWhile}` é adequada para vários truques em ciclos anteriore
 
 Suponha que tenhamos a seguinte tabela de banco de dados, onde os itens são divididos em categorias:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Mostraremos a facilidade e a elegância com que a tarefa pode ser resolvida com
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* abriremos uma nova lista *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Vamos modificar o código original, primeiro desenhamos um item e depois itens a
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` e que, além de cada categoria estar em uma `<ul>`cada subcategoria estará em uma subcategoria separada `<ol>`:
+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}
@@ -176,9 +176,9 @@ Suponha que haja outra coluna na tabela `subCatId` e que, além de cada categori
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/ro/cookbook/grouping.texy b/latte/ro/cookbook/grouping.texy
index cb139ffb37..1d74820b98 100644
--- a/latte/ro/cookbook/grouping.texy
+++ b/latte/ro/cookbook/grouping.texy
@@ -6,7 +6,7 @@ Eticheta `{iterateWhile}` este potrivită pentru diverse trucuri în ciclurile f
 
 Să presupunem că avem următorul tabel de bază de date, în care articolele sunt împărțite în categorii:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Vă vom arăta cât de ușor și elegant poate fi rezolvată această sarcină c
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* categoria s-a schimbat *}
 
 		{* închidem pagina anterioară <ul>, dacă nu este primul element *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* vom deschide o nouă listă *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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ă.
 
@@ -154,7 +154,7 @@ Să modificăm codul original, desenăm primul element și apoi elementele supli
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` și, pe lângă faptul că fiecare categorie se află într-o coloană separată `<ul>`, fiecare subcategorie va fi într-o coloană separată `<ol>`:
+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}
@@ -176,9 +176,9 @@ Să presupunem că există o altă coloană în tabelul `subCatId` și, pe lâng
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/ru/cookbook/grouping.texy b/latte/ru/cookbook/grouping.texy
index a76ef13eba..b20404fee6 100644
--- a/latte/ru/cookbook/grouping.texy
+++ b/latte/ru/cookbook/grouping.texy
@@ -6,7 +6,7 @@
 
 Предположим, у нас есть следующая таблица базы данных, в которой элементы разделены на категории:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@
 Если бы мы решали ту же задачу с помощью совершенно базовых конструкций систем шаблонов, например, в Twig, Blade или чистом PHP, то решение выглядело бы примерно так:
 
 ```latte
-{var $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{if $prevCategoryId !== null}
 	{* we close the last list *}
 	</ul>
 {/if}
 ```
 
-Однако этот код непонятен и неинтуитивен. Связь между открывающим и закрывающим HTML-тегами совершенно не ясна. С первого взгляда не ясно, есть ли ошибка. И для этого требуются вспомогательные переменные, такие как `$prevCatId`.
+Однако этот код непонятен и неинтуитивен. Связь между открывающим и закрывающим HTML-тегами совершенно не ясна. С первого взгляда не ясно, есть ли ошибка. И для этого требуются вспомогательные переменные, такие как `$prevCategoryId`.
 
 В отличие от этого, решение с `{iterateWhile}` чистое, понятное, не требует вспомогательных переменных и является надежным.
 
@@ -154,7 +154,7 @@
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@
 
 Мы можем создать несколько внутренних циклов в одном цикле и даже вложить их друг в друга. Таким образом, например, можно сгруппировать подкатегории.
 
-Предположим, что в таблице `subCatId` есть еще один столбец, и в дополнение к тому, что каждая категория будет находиться в отдельном столбце, каждая подкатегория будет находиться в отдельном столбце. `<ul>`, каждая подкатегория будет находиться в отдельной колонке `<ol>`:
+Предположим, что в таблице `subcategoryId` есть еще один столбец, и в дополнение к тому, что каждая категория будет находиться в отдельном столбце, каждая подкатегория будет находиться в отдельном столбце. `<ul>`, каждая подкатегория будет находиться в отдельной колонке `<ol>`:
 
 ```latte
 {foreach $items as $item}
@@ -176,9 +176,9 @@
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/sl/cookbook/grouping.texy b/latte/sl/cookbook/grouping.texy
index 71ce8fb222..e00e82ca82 100644
--- a/latte/sl/cookbook/grouping.texy
+++ b/latte/sl/cookbook/grouping.texy
@@ -6,7 +6,7 @@ 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  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ Pokazali vam bomo, kako enostavno in elegantno lahko to nalogo rešimo z iterate
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ Rešitev brez spletne strani `{iterateWhile}` .[#toc-solution-without-iteratewhi
 Č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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* kategorija se je spremenila *}
 
 		{* zapremo prejšnji <ul>, če to ni prvi element *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* odpremo nov seznam *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId`.
+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.
 
@@ -154,7 +154,7 @@ Spremenimo prvotno kodo, v notranji zanki izrišemo prvi element in nato dodatne
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ 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 `subCatId` in poleg tega, da je vsaka kategorija v ločenem `<ul>`, bo vsaka podkategorija v ločenem `<ol>`:
+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}
@@ -176,9 +176,9 @@ Recimo, da je v preglednici še en stolpec `subCatId` in poleg tega, da je vsaka
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/tr/cookbook/grouping.texy b/latte/tr/cookbook/grouping.texy
index a83af04596..09b777819f 100644
--- a/latte/tr/cookbook/grouping.texy
+++ b/latte/tr/cookbook/grouping.texy
@@ -6,7 +6,7 @@ Gruplama Hakkında Her Zaman Bilmek İstediğiniz Her Şey
 
 Öğelerin kategorilere ayrıldığı aşağıdaki veritabanı tablosuna sahip olduğumuzu varsayalım:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@ iterateWhile ile bu görevin ne kadar kolay ve zarif bir şekilde çözülebilec
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@ iterateWhile'ın böyle bir kullanımı ne işe yarar? Bu eğitimin en başında
 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 $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* kategori değişti *}
 
 		{* <ul> ilk öğe değilse</ul>bir öncekini kapatıyoruz <ul>*}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{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 `$prevCatId` gibi yardımcı değişkenler gerektirir.
+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.
 
@@ -154,7 +154,7 @@ Orijinal kodu değiştirelim, `{iterateWhile}` iç döngüsünde ilk öğeyi ve
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@ Orijinal kodu değiştirelim, `{iterateWhile}` iç döngüsünde ilk öğeyi ve
 
 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 `subCatId` ve her kategorinin ayrı bir kategoride olmasına ek olarak `<ul>`her bir alt kategori ayrı bir `<ol>`:
+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}
@@ -176,9 +176,9 @@ Tabloda başka bir sütun olduğunu varsayalım `subCatId` ve her kategorinin ay
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
diff --git a/latte/uk/cookbook/grouping.texy b/latte/uk/cookbook/grouping.texy
index b719498f7e..ee3fc44373 100644
--- a/latte/uk/cookbook/grouping.texy
+++ b/latte/uk/cookbook/grouping.texy
@@ -6,7 +6,7 @@
 
 Припустимо, у нас є така таблиця бази даних, у якій елементи розділені на категорії:
 
-| id  |  catId  |  name
+| id  | categoryId | name
 |------------------
 | 1   |      1  | Apple
 | 2   |      1  | Banana
@@ -51,7 +51,7 @@
 	<ul>
 		{iterateWhile}
 			<li>{$item->name}</li>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```
@@ -93,32 +93,32 @@
 Якби ми вирішували ту саму задачу за допомогою абсолютно базових конструкцій систем шаблонів, наприклад, у Twig, Blade або чистому PHP, то рішення виглядало б приблизно так:
 
 ```latte
-{var $prevCatId = null}
+{var $prevCategoryId = null}
 {foreach $items as $item}
-	{if $item->catId !== $prevCatId}
+	{if $item->categoryId !== $prevCategoryId}
 		{* the category has changed *}
 
 		{* we close the previous <ul>, if it is not the first item *}
-		{if $prevCatId !== null}
+		{if $prevCategoryId !== null}
 			</ul>
 		{/if}
 
 		{* we will open a new list *}
 		<ul>
 
-		{do $prevCatId = $item->catId}
+		{do $prevCategoryId = $item->categoryId}
 	{/if}
 
 	<li>{$item->name}</li>
 {/foreach}
 
-{if $prevCatId !== null}
+{if $prevCategoryId !== null}
 	{* we close the last list *}
 	</ul>
 {/if}
 ```
 
-Однак цей код незрозумілий і неінтуїтивний. Зв'язок між HTML-тегами, що відкривають і закривають, абсолютно не зрозумілий. З першого погляду не зрозуміло, чи є помилка. І для цього потрібні допоміжні змінні, такі як `$prevCatId`.
+Однак цей код незрозумілий і неінтуїтивний. Зв'язок між HTML-тегами, що відкривають і закривають, абсолютно не зрозумілий. З першого погляду не зрозуміло, чи є помилка. І для цього потрібні допоміжні змінні, такі як `$prevCategoryId`.
 
 На відміну від цього, рішення з `{iterateWhile}` чисте, зрозуміле, не потребує допоміжних змінних і є надійним.
 
@@ -154,7 +154,7 @@
 {foreach $items as $item}
 	<h1>{$item->name}</h1>
 	<ul>
-		{iterateWhile $item->catId === $iterator->nextValue->catId}
+		{iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 			<li>{$item->name}</li>
 		{/iterateWhile}
 	</ul>
@@ -167,7 +167,7 @@
 
 Ми можемо створити кілька внутрішніх циклів в одному циклі і навіть вкласти їх один в одного. Таким чином, наприклад, можна згрупувати підкатегорії.
 
-Припустімо, що в таблиці `subCatId` є ще один стовпчик, і на додаток до того, що кожна категорія перебуватиме в окремому стовпчику, кожна підкатегорія перебуватиме в окремому стовпчику. `<ul>`, кожна підкатегорія буде знаходитися в окремій колонці `<ol>`:
+Припустімо, що в таблиці `subcategoryId` є ще один стовпчик, і на додаток до того, що кожна категорія перебуватиме в окремому стовпчику, кожна підкатегорія перебуватиме в окремому стовпчику. `<ul>`, кожна підкатегорія буде знаходитися в окремій колонці `<ol>`:
 
 ```latte
 {foreach $items as $item}
@@ -176,9 +176,9 @@
 			<ol>
 				{iterateWhile}
 					<li>{$item->name}
-				{/iterateWhile $item->subCatId === $iterator->nextValue->subCatId}
+				{/iterateWhile $item->subcategoryId === $iterator->nextValue->subcategoryId}
 			</ol>
-		{/iterateWhile $item->catId === $iterator->nextValue->catId}
+		{/iterateWhile $item->categoryId === $iterator->nextValue->categoryId}
 	</ul>
 {/foreach}
 ```