Nested foreach loop

You're right, that is a bit cumbersome. What you need is a recursive macro - doing this avoids the need for any run-time evaluation:

defmacro(TOForeachNest (Symbols Lists @rest Commands)
  `foreach(,car(Symbols) ,car(Lists)
     ,if(cdr(Symbols)
        `TOForeachNest(,cdr(Symbols) ,cdr(Lists) ,@Commands)
        `{,@Commands}
     )
   )
) 

TOForeachNest((Temp VSupply) (VSupplyL TempL)
	printf("Temperature: %e, Supply Voltage: %e\n", Temp VSupply)
	)

Regards,

Andrew.

Thanks a lot Andrew! Your solution is more elegant and runs fluently. I played around with the idea of a recursive macro, but I was unable to get the syntax right. Could I suggest that the future publications of the Skill User Manual contain more examples on this?

Regards,

Tjaart

Tjaart,

Macros are a bit of an art - there's an increasing number of them covered in Articles (formerly known as Solutions) on Cadence Online Support, and also in (say) the SKILL for the skilled blog on the Cadence web site - but I agree, having more examples in the SKILL User Guide would be a good idea.

That said, I tend to advise against creating too many macros. As Peter Norvig writes in Paradigms of Artificial Intelligence [Case Studies in Common Lisp]:

"The first step in writing a macro is to recognize that every time you write one, you are defining a new language that is just like Lisp except for your new macro. The programmer who thinks that way will rightfuly be extremely frugal in defining macros. (Besides, when someone asks, "What did you get done today?" ti sounds more impressive to say "I defined a new language and wrote a compiler for it" than to say "I just hacked up a couple of macros.") Introducing a macro puts much more memory strain on the reader of your program than does introducing a function, variable, or data type, and so it should not be taken lightly. Introduce macros only when there is a clear need, and when the macro fits in well with your existing system. As C.A.R. Hoare put it, "One thing the language designer should not do is include untried ideas of his own."

Regards,

Andrew.

Tjaart, Andrew,

I couldn't resist coming up with a non-macro version for completeness (also at http://s.crosstwine.com/spb/8cda9957).

I usually implement iteration constructs via higher-order functions, and sugar-coat them in a thin layer of macrology where/when it really improves readability.

This one is a bit nasty because a function cannot know the number of nested loops at compile time; moreover, it reuses/mutates a single list of arguments across the whole iteration to mimimize consing.

A "pure macro" implementation is arguably nicer in this case, even if less generic. Anyway, here you are:

defun(MyMapnested1 (fn args argsTail lists)
  cond(
    (lists
     let( ((moreLists cdr(lists))
           (nextArgsTail cdr(argsTail)))
       foreach(item car(lists)
         rplaca(argsTail item)
         MyMapnested1(fn args nextArgsTail moreLists)
       )
     )
    )
    (t
     apply(fn args)
    )
  )
)

defun(MyMapnested (fn @rest lists)
  let( ((args mapcar(lambda( (_ignore) nil) lists)))
    MyMapnested1(fn args args lists)
  )
)

Usage via higher-order functions:

let( ((TempL '(-40 27 85))
      (VSupplyL '(3.2 3.3 3.4)))
  MyMapnested(
    lambda( (Temp VSupply)
      printf("Temperature: %L, Supply Voltage: %L\n" Temp VSupply)
    )
    TempL
    VSupplyL
  )
)

And here is TOForeachNest implemented in terms of MyMapnested:

defmacro(TOForeachNest (Symbols Lists @rest Commands)
  `MyMapnested(
     lambda( ,Symbols
       ,@Commands
     )
     ,@Lists
   )
)

Cheers, -D

Andrew,

Ideally, I want to be able to use this macro inside a generic custom sweep function. The arguments would then have to be lists.

For example:

VddLV = '(2.0 2.3)

VddHV = '(Vlow 3.3)

Symbols = '(Vlow Vhigh)

TOForeachNest(Symbols list(VddLV VddHV)

    foreach(Symbol Symbols

        printf("%s %e\n" sprintf(nil "%L" Symbol)

            evalstring(sprintf(nil "%L" Symbol)))

        )

)

Should expand to:

foreach(Vlow '(2.0 2.3)

    foreach(Vhigh '(Vlow 3.3)

        foreach(Symbol Symbols

            printf("%s %e\n"

                sprintf(nil "%L" Symbol

                    evalstring(sprintf(nil "%L" Symbol)))

                )

             )

        )

)

It can't really expand the outer loops at macro expansion time because it depends on the run-time value of the Symbols variable. However, you want the body (the foreach(Symbol Symbols) bit) not to be expanded - so you can't just make it a recursive function.

I don't think you can easily do that without run-time evaluation.  I'd have to think about it a bit more...

Andrew.

To address this issue I wrote a function that calls the macro using evalstring. The lists are modified into enclosed arguments. To pass the commands to the functions one needs to declare a lambda function. I got this idea from ztzg (thanks!).

procedure(TOForeachList(Symbols Lists Fun)
 let(((Symstring "") (Liststring ""))
  foreach(Sym Symbols Symstring=sprintf(nil "%s %s" Symstring Sym))
  foreach(List Lists Liststring=sprintf(nil "%s %L" Liststring List))
  evalstring(sprintf(nil "TOForeachNest((%s) (%s) funcall(Fun))" Symstring Liststring ) )
 )
)

VddLV = '(2.0 2.3)
VddHV = '(Vlow 3.3)
Symbols = '(Vlow Vhigh)

TOForeachList(Symbols '(VddLV VddHV) lambda( ()
 foreach(Symbol Symbols
  printf("%s %.1e\n" Symbol eval(eval(Symbol)))
 )
))

Vlow 2.0e+00
Vhigh 2.0e+00
Vlow 2.0e+00
Vhigh 3.3e+00
Vlow 2.3e+00
Vhigh 2.3e+00
Vlow 2.3e+00
Vhigh 3.3e+00

So far this approach seems to work.