← SASnRLoop Inside a Macro

Introduction

Clinical programs often need to repeat the same logic for a list of items — generate a summary for each PARAMCD, apply a transformation to each dataset, or produce a table for each visit.
SAS handles this with %DO loops and %SCAN inside a macro. R uses for loops, lapply(), or purrr’s map() family.
This lesson shows two common patterns: looping over a numbered counter, and looping over a space-delimited list of values.
We use a small ADLB-like dataset and produce a mean summary for each PARAMCD — the kind of loop that drives many TFL programs.
After running, we confirm that one summary block is produced for each parameter in the list.

Loop Inside a Macro

SAS (Base SAS)+

*==============================================================================;
* Create sample ADLB data;
*==============================================================================;

data adlb;
    input usubjid $ paramcd $ aval;
    datalines;
SUBJ001 ALT  25
SUBJ001 AST  30
SUBJ001 BILI 0.8
SUBJ002 ALT  40
SUBJ002 AST  35
SUBJ002 BILI 1.2
SUBJ003 ALT  22
SUBJ003 AST  28
SUBJ003 BILI 0.6
SUBJ004 ALT  38
SUBJ004 AST  42
SUBJ004 BILI 1.5
;
run;

*==============================================================================;
* Pattern 1: %DO loop with a counter;
*==============================================================================;

%macro loop_counter(n=3);
    %do i = 1 %to &n.;
        %put Iteration &i. of &n.;
    %end;
%mend loop_counter;

%loop_counter(n=3);

*==============================================================================;
* Pattern 2: %SCAN over a space-delimited list;
*==============================================================================;

%macro summarise_params(ds=adlb, params=ALT AST BILI);
    %local i param;
    %let i = 1;
    %let param = %scan(&params., &i., %str( ));

    %do %while(&param. ne );

        proc means data=&ds. n mean std min max;
            where paramcd = "&param.";
            var aval;
            title "Summary for &param.";
        run;

        %let i = %eval(&i. + 1);
        %let param = %scan(&params., &i., %str( ));
    %end;
%mend summarise_params;

%summarise_params(params=ALT AST BILI);

SAS macros support two loop styles: a counted %DO i = 1 %TO n and a conditional %DO %WHILE.
The counted loop is straightforward: %do i = 1 %to &n. repeats the body exactly n times, incrementing &i each pass.
For iterating over a list of values, we combine %SCAN with %DO %WHILE.
%scan(&params., &i., %str( )) extracts the i-th word from the space-delimited string. When it runs out of words, it returns blank.
The %DO %WHILE(&param. ne ) condition stops the loop once %SCAN returns an empty string.
Inside the loop body, we run a PROC MEANS filtered to the current &param. value — one output block per PARAMCD.
%LOCAL i param; declares the loop variables as local to the macro, preventing them from leaking into the global symbol table.
After running, we see three separate PROC MEANS outputs: one for ALT, one for AST, one for BILI.

R (tidyverse)+

library(tidyverse)

#==============================================================================
# Create sample ADLB data
#==============================================================================

adlb <- tribble(
  ~usubjid,  ~paramcd, ~aval,
  "SUBJ001", "ALT",    25,
  "SUBJ001", "AST",    30,
  "SUBJ001", "BILI",   0.8,
  "SUBJ002", "ALT",    40,
  "SUBJ002", "AST",    35,
  "SUBJ002", "BILI",   1.2,
  "SUBJ003", "ALT",    22,
  "SUBJ003", "AST",    28,
  "SUBJ003", "BILI",   0.6,
  "SUBJ004", "ALT",    38,
  "SUBJ004", "AST",    42,
  "SUBJ004", "BILI",   1.5
)

#==============================================================================
# Pattern 1: walk() for side effects (like printing)
#==============================================================================

params <- c("ALT", "AST", "BILI")

walk(params, function(p) {
  cat("Processing:", p, "\n")
})

#==============================================================================
# Pattern 2: map_dfr() to loop and combine results
#==============================================================================

summary_all <- map_dfr(params, function(p) {
  adlb %>%
    filter(paramcd == p) %>%
    summarise(
      paramcd = p,
      n       = n(),
      mean    = mean(aval),
      sd      = sd(aval),
      min     = min(aval),
      max     = max(aval)
    )
})

summary_all

In tidyverse, the purrr package provides walk() and map() as clean alternatives to explicit loops.
walk(params, function(p) { ... }) calls the function once for each element of params, purely for side effects like printing — it returns nothing.
map_dfr(params, function(p) { ... }) calls the function for each element and row-binds all the returned tibbles into one combined result.
Inside the function, we filter adlb to the current p value and compute summary statistics, exactly mirroring the SAS PROC MEANS inside the loop.
We add paramcd = p to the summarise output so each row in the final tibble identifies which parameter it belongs to.
The result is a single tibble with one row per PARAMCD — a tidy format that is easy to pass to further analysis or export.
For tasks where we do not need to combine results, walk() is the right choice; for tasks that produce data, map_dfr() is the workhorse.
After running, we confirm summary_all has three rows: ALT, AST, and BILI, each with the correct statistics.

Happy learning!

Search lessons

Introduction

Loop Inside a Macro