macro list_new [name*]
{
   forward
      name equ
}

macro list_append list*, [item*]
{
   forward
      list equ list, item
}

macro list_foreach list*, action*
{
   local lst
   match =,lst, list
   \{
      \local item
      \irp item, lst
      \\{
         action item
      \\}
   \}
}
    

macro list_insert list*, [item*]
{
   forward
      local has
      ; find
      has = 0
      macro equal it*
      \{
         if it eq item
            has = 1
         end if
      \}
      list_foreach list, equal
      ; append
      if has = 0
         display "insert: ", `item, 10
         list_append list, item
      end if
}
    

    macro append list*, [item*]
     {
       match any, list \{
       if ~ item in <list>
       list equ list,item
       end if
       \}
       match , list \{ list equ item \}
     } 
    

Look at my idea (I don't know why it doesn't work correctly):

    macro append list*, [item*]
     {
       match any, list \{
       list equ list,item
       \}
       match , list \{ list equ item \}
     } 
    

macro list_insert list*, [item*]
{
   forward
      local has
      ; find
      has equ no
      macro equal it*
      \{
         \match =it, item
         \\{
            has equ yes
         \\}
      \}
      list_foreach list, equal
      ; append
      match =no, has
      \{
         list_append list, item
      \}
}
    

; Adding unique items to list
; by Kazyaka

macro ListAddItem list*, item*
{
 match , list \{ list equ item \}
 match params, list
 \{
 ListAddUniqueItem list, item, params
 \}
}

macro ListAddUniqueItem list*, newItem*, [oldItem*]
{
rep equ no
 forward
 match  newItem, oldItem
 \{
 rep equ yes
 \}
common
 match  =no, rep
 \{
 list equ list, newItem
 \}
}

MyList equ

ListAddItem MyList, 'a'
ListAddItem MyList, 'b'
ListAddItem MyList, 'c'
ListAddItem MyList, 'b'

display MyList
    

match  newItem, oldItem    

match =newItem, oldItem ; <- add an '='    

macro __InitStringsEngine {
local c, r, v

   c equ 0

  struc text [val] \{
    \common
    \local flag

    \flag equ

    rept c x \\{
       match val, v\\#x \\\{
         flag equ r\\\#x
       \\\}
    \\}

    match lbl, flag \\{
      if defined lbl
        . = lbl
        .len = lbl\\#\\.len
      end if
    \\}

    match , flag \\{
      rept 1 x:c+1 \\\{
        c equ x
        r\\\#x equ .
        v\\\#x equ val
      \\\}
    \\}
  \}


  macro __IncludeAllStrings \{
  \common
    rept c x \\{
        r\\#x db v\\#x
        .len = $-r\\#x
             db 0
             rb ($ + 3) and $fffffffc - $
    \\}
  \}
}

__InitStringsEngine

str1 text 'text1', $0d, $0a
str2 text 'text2'
str3 text 'text3'
str4 text 'text4'
str5 text 'text2'
str6 text 'text2'
str7 text 'text1', $0d, $0a

__IncludeAllStrings
    

The only problem is with the strings that contains ","

directive fix struc; since here they aren't 'struc's in any sense

directive reEqu [value] {
; Sets symbolic to 'value' while keeping 'restore' stack clean
common
  match _value, value \{; accounts for 'value' containing references to '.'
    restore .; without 'match' this will clobber 'value' if it refers to '.'
    . equ _value
  \}
}

directive add [value*] {
; Adds 'value's as separate items
  match =., . \{ . equ \}; initialize list if not already
  match some, . \{ . reEqu some, <value> \}; append if not empty
  match , . \{ . reEqu <value> \}; set if empty (guess why not 2 lines earier 
}

directive addItem [value*] {
; Helper macro: adds 'value' as single item
common . add <value>
}

directive forEach action*, [args] {
; Generic iterator - invokes 'action' for each item in 'list', passing additional 'args'
common
  match _., . \{; because 'irp' doesn't expand symbolics in list of parameters
    irp item, _. \\{
      action <item>, args
    \\}
  \}
}

directive escape symbol*, [items*] {
; Helper macro: escape each token in 'items' with 'symbol'
common; used instead of implicit 'forward' to ignore "first comma" case
  . equ
  match _items, items \{
    irps item, items \\{
      match _., . \\\{ . reEqu _. symbol item \\\}
      match , . \\\{ . equ symbol item \\\}
    \\}
  \}
}

macro ifMatch x*, y*, action* {
; Pretty convoluted macro, follow the comments
  _x escape =, x; escape tokens for 'match'
  match __x, _x \{; expand escaped 'x'
    singleToken equ +; assume 'y' is single token
    match =<anything=>, y \\{
    ; multiple-token 'y' - matching 'x' is already unwrapped, so wrap it again
      match =<__x=>, y \\\{ action \\\}
      restore singleToken; signal that 'y' is processed
    \\}
    match +, singleToken \\{
    ; 'y' is not processed yet, so it's single token
      match __x, y \\\{ action \\\}
      restore singleToken; clean-up
    \\}
  \}
  restore _x
}

directive addUnique [item*] {
; Adds 'item's if not already in list
  found equ -
  . forEach ifMatch, <item>, found reEqu +
  match -, found \{ . add item \}
  restore found; depends on 'reEqu' for proper cleanup
}

directive addUniqueItem [value*] {
; Helper macro: adds unique 'value' as single item
common
  . addUnique <<value>>; twice because each macro invocation unwraps arguments
                       ; and 'add' macro invocation is two levels deeper
}

directive unwrap item*, [args] {
; Helper macro: removes <>, optionally appending 'args'
common
  match , args \{ . item \}
  match some, args \{ . item, args \}
}

strings addItem "Hello, world!", 13, 10
strings addItem "Goodbye, world!", 13, 10

bytes add 1, 2, 3
bytes add 9, 8, 7, <"The answer", 42>
bytes addUnique 2, 5; adds only 5
; 'ifMatch' madness is all about this case:
bytes addUniqueItem "The answer", 42

db "Here it starts:", 13, 10
strings forEach db unwrap, "|"; without 'unwrap' 'db' directive will fail due to <>s
bytes forEach db unwrap, "."    

directive fix struc

directive reEqu [value] {
common
  match _value, value \{; expand to protect from 'restore'
    restore .
    . equ _value
  \}
}

directive add [item*] {
  match _count, .count \{; expand list.count
    .#\.\#_count equ item; second dot should be protected from 'struc' expansion
    rept 1 count:_count+1 \\{ .count reEqu count \\}; increment counter
  \}
}

directive forEach action* {
  rept .count index:0 \{
    match <item>, <.#\.\#index> \\{; retrieve item
      action item; apply action (it may have own arguments, then add comma as done below)
    \\}
  \}
}

directive escape [list] {
; Escape tokens with = for exact 'match'
common
  . equ
  irps token, list \{ . reEqu . =token \}
}

macro _match literal*, body*, [value*] {
; Helper macro to use with 'forEach'
common
  match literal, value \{ body \}
}

directive addUnique [item*] {
  found equ -; assume not found
  .item escape item
  match _item, .item \{
    . forEach <_match <_item>, restore found,>; last comma is important
  \}
  match -, found \{
    .add <item>
    restore found
  \}
}

macro newList name* {
  name#.count equ 0; initialize counter
  macro name#.add [item*] \{ common name add item \}
  macro name#.addUnique [item*] \{ common name addUnique item \}
  macro name#.forEach action* \{ common name forEach action \}
}

newList strings
strings.add <"Hi there!", 10, 0>, <"Regards, baldr.", 10, 0>
strings.addUnique <"Hi there!", 10, 0>, <"Regards, baldr.", 10, 0>,\
  <"P.S. And thanks for all the fish.", 10, 0>
strings.forEach db    

macro imports { common
  local ..first

  macro P3 [A*] \{
    match B,A \\{
      irp api,B \\\{
        .\\\#api dq RVA api\\\#_STR
      \\\}
    \\}
  \}
  macro P2 [A*] \{
    match B,A \\{
      irp api,B \\\{
        rb 2 - RVA $ AND 1
        label api\\\#_STR at $-2
        db \\\`api
      \\\}
    \\}
  \}
  macro P1 [A*] \{
    match lib,A \\{
      rb (8 - RVA $ AND 7) AND ..first
      ..first = 15
      lib:
      P3 DLL_\\#lib
    \\}
  \}
  macro P0 [A*] \{
    match lib,A \\{
      lib\\#_STR db \\`lib
      P2 DLL_\\#lib
    \\}
    db 0
  \}
  macro P5 lib*,[dummy] \{
    dd 0,0,0,RVA lib\#_STR,RVA lib
  \}

  ..first = 7
  DLL forEach P0,<>
  DLL forEach P1,<>
  data import
    DLL forEach P5,<>
    rd 5
  end data
  purge P0,P1,P2,P3,P5
}

macro call [A] { common
  match =[B C=],A \{
    DLL addUnique B
    DLL_\#B addUnique C
    call [B\#.\#C]
  \}
}

format PE64 CONSOLE 6.0 at $10000
section '' readable writeable executable
    entry $
    enter 32,0
    call [kernel32 GetCommandLineW]
    xchg rcx,rax
    lea edx,[rbp] ; #32#
    jrcxz .exit
    call [shell32 CommandLineToArgvW]
    mov [rbp+8],rax

    ; do something interesting...

    mov rcx,[rbp+8]
    call [kernel32 LocalFree]
.exit:
    leave
    call [kernel32 ExitProcess]

imports    

;;; simpleList.finc

struc newList {
  .count equ 0; list is empty
  .index equ 0; 'find' hasn't found item
  macro .find item \{ . find item \}
}

struc reequ [value] {
; Helper macro: replace symbolic's value
common
  restore .
  . equ value
}

struc reequ! [expression] {
; Helper macro: replace symbolic's value with that of expression
common
  rept 1 value:expression \{ . reequ value \}
}

struc add [item*] {
; Unconditionally add item to list
  .count reequ! .count+1
  match _count, .count \{ .\#\.\#_count equ item \}
}

struc find item* {
; Find item in list; set '.index' to its index (or 0 if not found)
  .index reequ 0
  rept .count index \{
    match =item, .\#\.\#index \\{ .index reequ index \\}
  \}
}

struc addUnique [item*] {
  .find item
  match =0, .index \{ . add item \}
}

macro define_recursive_forEach {
  struc forEach list \{
    define_recursive_forEach
    rept list\#\\.count index \\{
      match item, list\#\\.\\#index \\\{ . item \\\}
    \\}
    purge forEach
  \}
} define_recursive_forEach    

include "simpleList.finc"

DLL newList

macro imports { common
  local first

  first = 7
  macro make_hint_names name* \{
    rb 2 - rva $ and 1
    label name\#.hint at $-2
    db \`name
  \}

  macro make_names lib* \{
    lib\#.name db \`lib
    \\\make_hint_names forEach DLL_\#lib
    db 0
  \}

  macro make_iat_entry name* \{ .\#name dq rva name\#.hint \}

  macro make_iat lib* \{
    rb (8 - rva $ and 7) and first
    first = 15
    lib: \\\make_iat_entry forEach DLL_\#lib
  \}

  macro make_import_directory_entry lib* \{
    dd 0, 0, 0, RVA lib\#.name, RVA lib
  \}

  \\make_names forEach DLL
  \\make_iat forEach DLL
  data import
    \\make_import_directory_entry forEach DLL
    rd 5
  end data
  purge make_hint_names, make_names, make_iat_entry, make_iat, make_import_directory_entry
}

macro call [A] { common
  match =[B C=],A \{
    DLL addUnique B
    match =0, DLL.index \\{ DLL_\#B newList \\}
    DLL_\#B addUnique C
    call [B\#.\#C]
  \}
}

format PE64 CONSOLE 6.0 at $10000
section '' readable writeable executable
    entry $
    enter 32,0
    call [kernel32 GetCommandLineW]
    xchg rcx,rax
    lea edx,[rbp] ; #32#
    jrcxz .exit
    call [shell32 CommandLineToArgvW]
    mov [rbp+8],rax

    ; do something interesting...

    mov rcx,[rbp+8]
    call [kernel32 LocalFree]
.exit:
    leave
    call [kernel32 ExitProcess]

imports    

minint equ 0x8000'0000'0000'0000
maxint equ 0x7FFF'FFFF'FFFF'FFFF
macro classify value {
  match =0, value \{ display "Zero", 13, 10 \}
  rept 1 and ((value) or (-(value))) shr 63 \{ display "Non-zero", 13, 10 \}
}
irp value, minint, maxint, 0 { classify value }