updated version

Author: venom1204

vignettes/datatable-joins.Rmd

@@ -194,40 +194,6 @@ Products[ProductReceived,
          on = .(id = product_id)]
 ```
 
-#### 3.1.2. Using Named Lists for Explicit Joins
-In `data.table`, joins can be performed using unnamed lists `(list())` or named lists. Named lists provide greater clarity and reduce ambiguity when matching column names, especially when joining on multiple columns.
-
-- Using Unnamed
-```{r}
-dt1 <- data.table(id = c(1, 2, 3), value = c("A", "B", "C"))
-dt2 <- data.table(id = c(2, 3, 4), info = c("X", "Y", "Z"))
-dt1[dt2, on = "id"]
-```
-- Using a named list for explicit joins:
-```{r}
-dt1[dt2, on = .(id = id)]
-```
-- Here, .() is a shorthand for list(), and explicitly naming the column (id = id) makes the join easier to understand.
-
-#####  Named Lists for Multiple Column Joins
-When joining on multiple columns, named lists prevent mismatches and make the query more readable:
-```{r}
-dt1 <- data.table(id = c(1, 2, 3), key1 = c("A", "B", "C"), value = c(10, 20, 30))
-dt2 <- data.table(id = c(2, 3, 4), key1 = c("B", "C", "D"), info = c("X", "Y", "Z"))
-
-# Unnamed list approach (less readable)
-dt1[dt2, on = c("id", "key1")]
-
-# Named list approach (explicit and clear)
-dt1[dt2, on = .(id = id, key1 = key1)]
-```
-This ensures that column names are explicitly matched, which is especially useful when working with complex datasets.
-
-- When Should You Use Named Lists?
-There is potential ambiguity in column names.
-You are joining on multiple columns.
-You want to make your joins self-documenting and more readable.
-
 #### 3.1.2. Alternatives to define the `on` argument
 
 In all the prior example we have pass the column names we want to match to the `on` argument but `data.table` also have alternatives to that syntax.

vignettes/datatable-secondary-indices-and-auto-indexing.Rmd

@@ -192,7 +192,7 @@ flights[.("JFK", "LAX"), on = c("origin", "dest")][1:5]
 * Since the time to compute the secondary index is quite small, we don't have to use `setindex()`, unless, once again, the task involves repeated subsetting on the same column.
 
 ### b) Using named list elements in `i` 
-When subsetting using the on argument, values in `i` are typically passed as unnamed elements. However, naming elements explicitly in `i` improves readability, especially when dealing with multiple keys.
+When subsetting using the `on` argument, values in `i` are typically passed as unnamed elements. However, naming elements explicitly in `i` improves readability, especially when dealing with multiple keys.
 
 - Example: Standard subsetting using unnamed elements
 ```{r}
@@ -204,20 +204,21 @@ While this syntax is concise, it may not be immediately clear which value corres
 ```{r}
 flights[.(origin = "LGA", dest = "TPA"), max(arr_delay), on = c("origin", "dest")]
 ```
-Here, naming the elements explicitly `(origin = "LGA", dest = "TPA")` makes it clear which variable each value corresponds to. This improves code maintainability, especially in complex queries.
+Naming elements explicitly `(origin = "LGA", dest = "TPA")` clarifies variable correspondence.
 
 - Using named lists with multiple values
 When multiple values are passed, named elements further enhance clarity:
-```{r}
+```{r unnamed_elemts}
 flights[.("LGA", "JFK", "EWR"), mult = "last", on = c("origin", "dest"), nomatch = 0L]
 ```
-- Named elements
-```{r}
+
+```{r named_elements}
 flights[.(origin = c("LGA", "JFK", "EWR"), dest = "XNA"), mult = "last", on = c("origin", "dest"), nomatch = 0L]
 ```
 - Impact of named elements on key order
-It's important to note that naming elements in `i` only affects ordering when `on` is specified. If `on` is not used, data.table will match values based on key order, regardless of the names used.
-
+```{r} 
+flights[.(dest = "TPA", origin = "LGA"), on = .(origin, dest)]  
+```
 - When to use named list elements in `i`.
 when working with multiple keys in `on`, as it improves readability.