List.unique()

---

List.unique()

List.unique

This returns List-type data of the unique values in the list, as a sorted but de-duped list. Hitherto, de-duping required passing data into a Set-type attribute and back. For the same reason this operator really only makes sense to use on List-type lists as a Set cannot support duplicate items. Trailing parentheses are optional for this function.

Be aware that this function results in a case insensitive A-Z sort, thus not 'bee;ant;cow' as might otherwise be assumed (to get such an outcome see further below). For example, if $MyList is 'bee;ant;cow;bee':

$MyList = $MyList.unique; 

results in a list value 'ant;bee;cow'.

The function can be chained with .sort-type actions and .reverse.

$MyList = $MyList("Another note").unique; 

$SomeList = collect(children, $MyNumberList).unique.nsort; 

$MyList = collect(children, $MyList).unique.reverse; 

The last above sets $MyList to a list of all the unique, discrete, values to be found in $MyList in every child of the current note. Use with collect() or collect_if() to act on a particular attribute across a group of notes. If a collect() with query scope is the designator 'all' the result will be every discrete value for the referenced list attribute across the whole document.

This function does not apply to Set-type lists because Sets automatically de-duplicate items so are always a list of unique values.

De-duping a list whilst retaining original sort order

The basic method is this:

   $MyList.each(anItem){
      if(!$MyList2.contains(anItem)){
         $MyList2+=anItem;
      }
   };

If is it desired to de-dupe $MyList back to itself, use a list-type variable:

   var:list vList;
   $MyList.each(anItem){
      if(!vList.contains(anItem)){
         vList+=anItem;
      }
   };
   $MyList = vList;

A further consideration is whether the tested list's items are in varying case ('ant' vs. 'Ant' vs. 'ANT' etc.). For instance, to take a mixed case list with duplicates and end up with a de-duped all-lowercase version, use:

   var:list vList;
   $MyList.lowercase.each(anItem){
      if(!vList.contains(anItem)){
         vList+=anItem;
      }
   };
   $MyList = vList;

Resulting order

.unique() preserves the order of elements in a list. Originally, this operator forced an A-Z order, but this was not ideal as one feature of List-type lists is that they allow duplicates do not auto-sort—unlike Set-type lists). Thus now:

"C:A;A;B".unique; 

now returns "C;A;B" (previously it would have been "A;B;C", destroying the original ordering). The output retains the first-occurring item, by list order, of any list value. The underlying assumptions is dupes gat added to the end of the list so the first occurrence is the desired item.

---

See also—notes linking to here:

• Authors
• Look-up tables
• List-Type Attributes