Next: `srfi.207`

- String-notated bytevectors, Previous: `srfi.196`

- Range objects, Up: Library modules - SRFIs [Contents][Index]

`srfi.197`

- Pipeline operators- Module:
**srfi.197**¶ -
This module provides a set of macros to compose multiple operations. It is similar to Clojure’s “threading macro”.

When you’re passing a result of some procedure to another procedure and so on, sometimes you get a deeply nested expression:

(g (f (e (d (c (b (a arg)))))))

In Gauche, you can also write the above expression with

`$`

macro (see Making procedures):($ g $ f $ e $ d $ c $ b $ a arg)

Deep nesting is avoided, but it’s still right-to-left, and the placement of argument to receive the previous result is limited to the last position.

With

`chain`

macro in this module, you can write it from left to right:(chain (a arg) (b _) (c _) (d _) (e _) (f _) (g _))

The

`_`

in the second expressions and after indicates the place where previous result is passed. It is conceptually expanded to the following:(let* ((tmp (a arg)) (tmp (b tmp)) (tmp (c tmp)) (tmp (d tmp)) (tmp (e tmp))) (g tmp))

Because the placeholder is explicit, you can pass additional arguments:

(chain x (y a _) (z _ b)) ≡ (let* ((tmp x) (tmp (y a tmp))) (z tmp b))

Or even use multiple values:

(chain mv-expr (f _ _) (g _ _)) ≡ (let*-values (((tmp1 tmp2) mv-expr) ((tmp1 tmp2) (f tmp1 tmp2))) (g tmp1 tmp2))

- Macro:
**chain***initial-value [placeholder [ellipsis]] step …*¶ [SRFI-197]{

`srfi.197`} The optional`placeholder`and`ellipsis`are, if given, literal symbols. It replaces the default placeholder and ellipsis symbols,`_`

and`...`

, respectively.Each

`step`is`(`

, where each`datum`…)`datum`must be either an expression, placeholder symbol, or the ellipsis symbol. The ellipsis symbol must appear in the last position, if any, and must immediately follow the placeholder symbol.Conceptually, each

`step`becomes a procedure that takes as many arguments as the placeholders. If the`step`ends with ellipsis symbol, the last placeholder works as the “rest” arguments.If a

`step`expects more than one value, the previous`step`or`initial-value`is expected to yield that many values.(chain expr (f _ a _ ...)) ≡ (let*-values (((tmp1 . tmp2) expr)) (apply f tmp1 a tmp2))

- Macro:
**chain-and***initial-value [placeholder] step …*¶ [SRFI-197]{

`srfi.197`} A variant of`chain`

that stops and returns`#f`

immedialy when the intermediate result becomes`#f`

.The

`initial-value`is an expression that yields one value. The`placeholder`is a literal symbol to be used as the placeholder in`step`; if omitted,`_`

is used.Unlike

`chain`

, a`step`can only contain zero or one placeholder symbol. If`step`doesn’t contain placeholder symbol, the previous`step`’s result isn’t passed, but it is still checked if it’s`#f`

.

- Macro:
**chain-when***initial-value [placeholder] ([guard] step) …*¶ [SRFI-197]{

`srfi.197`} A variant of`chain`

where you can select whether each`step`is applied or skipped.Each

`step`can have at most one placeholder symbol, just as`chain-and`

.Each

`guard`is an expression. For each step,`guard`is evaluated, and if it yields a true value, the previous result is passed to the placeholder in the corresponding`step`. If`guard`yields`#f`

, however,`step`is skipped and the previous value is passed through to the next step.(chain-when expr ((p? x) (f _)) ((q? x) (g _))) ≡ (let* ([tmp expr] [tmp (if (p? x) (f tmp) tmp)]) (if (q? x) (g tmp) tmp))

- Macro:
**chain-lambda***[placeholder [ellipsis]] step …*¶ [SRFI-197]{

`srfi.197`}(chain-lambda step …) ≡ (lambda args (chain (apply values args) step …))

- Macro:
**nest***[placeholder] step … initial-value*¶ [SRFI-197]{

`srfi.197`} Similar to`chain`

, except the order of steps is right-to-left.Each

`step`must have exactly one placeholder symbol, for this macro simply nests the steps:(nest (f a _) (g _ b) (h _) expr) ≡ (f a (g (h expr) b))

- Macro:
**nest-reverse***initial-value [placeholder] step …*¶ [SRFI-197]{

`srfi.197`} Similar to`nest`

except the nesting is in reverse order.Each

`step`must have exactly one placeholder symbol, for this macro simply nests the steps:(nest expr (h _) (g _ b) (f a _)) ≡ (f a (g (h expr) b))

`srfi.207`

- String-notated bytevectors, Previous: `srfi.196`

- Range objects, Up: Library modules - SRFIs [Contents][Index]

DRAFT