Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Fun with Macros: If-Let and When-Let

stevelosh.com

Post reply on HN
Print view View original

11–20 of 31 posts

Re: Fun with Macros: If-Let and When-Let

#11

Post by stevelosh »

cryptonector wrote: post #9

Paul Graham called these "anaphoric" macros in On LISP.

The "anaphora" in "anaphoric" typically refers to how it binds the variable "it" automatically, without having to specify the variable name. Since if-let and when-let require you to explicitly specify the variable name, I don't think most people would consider them anaphoric macros. https://en.wikipedia.org/wiki/Anaphoric_macro

If you want actual anaphoric macros in CL, here they are: https://www.common-lisp.net/project/anaphora/

Re: Fun with Macros: If-Let and When-Let

#12

Post by kazinator »

WalterGR wrote: post #2

What’s a example of these macros being used usefully? All I can find are contrived examples. Why not use `if` and `when` directly? Is creating new names for variables — which is what `if-let` and `when-let` seems to contribute — that common of a pattern? I must be missing something.

TXR Lisp has iflet, whenlet and condlet built in. They are used in places in the standard library. A bunch of occurrences (of all three!) are in the compiler, for example:

http://www.kylheku.com/cgit/txr/tree/share/txr/stdlib/compil...

Note that they all support multiple bindings, but not the and semantics: only the last binding is tested. Treating a nil value out of any of the bindings as a failure is way too constraining.

It is also permissible to omit the variable name from the last binding; in that case the expression is used as the controlling expression; e.g.

  (whenlet ((a (expr1))
            (b (expr2))) ;; we can delete b, if not needed
    ...)
Therefore, this is possible:

  (whenlet ((x (expr1))
            (y (expr2))
            ...
            ((complex-expr x y ...)))
    ...)
That is, bind some variables (that may or may not be nil: they are not being tested), and then reference them in a complex test expression.

Re: Fun with Macros: If-Let and When-Let

#14

Post by nickdrozd »

You could save a little work by noting that when is a special case of if and then writing when-let as a special case of if-let. Something like:

  (defmacro when-let (bindings &rest body)
    `(if-let ,bindings
         (progn ,body)))
That's how it's implemented in Emacs at least. Maybe there are some edge cases involving declarations or whatever where this wouldn't work.

Re: Fun with Macros: If-Let and When-Let

#15

Post by stevelosh »

nickdrozd wrote: post #14

You could save a little work by noting that when is a special case of if and then writing when-let as a special case of if-let . Something like: (defmacro when-let (bindings &rest body) `(if-let ,bindings (progn ,body))) That's how it's implemented in Emacs at least. Maybe there are some edge cases involving declarations or whatever where this wouldn't work.

You'd need to parse out the declarations, yeah. Otherwise they'd get shoved inside the progn which wouldn't work.

Re: Fun with Macros: If-Let and When-Let

#16

Post by masklinn »

steveklabnik wrote: post #7
Sharlin wrote: post #4

Earlier quoted context omitted.

I find them pretty useful in Clojure. Note that it’s practically never about assigning a strictly boolean-valued expression (which would indeed be pretty useless) but rather something that is ”truthy” or ”falsy” ie. implicitly convertible to boolean and you want to do something with the actual value if it is truthy. Other languages have similar constructs, eg. C++: if(auto p = get_ptr()) ... And Rust: if let Some(val…

We stole it from Swift. To your parent, the RFC is pretty short and has good motivation: https://github.com/rust-lang/rfcs/blob/master/text/0160-if-l...

> We stole it from Swift.

Stole is probably too harsh a statement given the semantics are pretty different: Swift's if-let has closer semantics to TFA's as it only works with Optional but allows multiple patterns (bindings in TFA's version) while Rust's works with any pattern but only allows a single pattern (AFAIK).

Re: Fun with Macros: If-Let and When-Let

#17

Post by SolarNet »

WalterGR wrote: post #2

What’s a example of these macros being used usefully? All I can find are contrived examples. Why not use `if` and `when` directly? Is creating new names for variables — which is what `if-let` and `when-let` seems to contribute — that common of a pattern? I must be missing something.

> that common of a pattern?

The point of homoiconic languages like lisps, where the language is just the syntax tree, is that you can make your own nodes. `if-let` and `when-let` are patterns, they don't have to be common, the definition of which remove at least one node. It's not any different than the idea of having lots of small functions but at the syntax layer. Do this enough time and your actual business logic starts get pretty terse.

Re: Fun with Macros: If-Let and When-Let

#18

Post by brlewis »

I like the macro transformers in R5RS Scheme. Here's how the multi-binding if-let and when-let look:

  (define-syntax if-let
    (syntax-rules ()
      ((if-let ((var value) ...)
              consequent ...)
       (let ((var value) ...)
         (if (and var ...)
             consequent ...)))))
          
  (define-syntax when-let
    (syntax-rules ()
      ((when-let (binding)
                 body ...)
       (if-let (binding)
               (begin body ...)))))

Re: Fun with Macros: If-Let and When-Let

#19

Post by junke »

stevelosh wrote: post #15
nickdrozd wrote: post #14

You could save a little work by noting that when is a special case of if and then writing when-let as a special case of if-let . Something like: (defmacro when-let (bindings &rest body) `(if-let ,bindings (progn ,body))) That's how it's implemented in Emacs at least. Maybe there are some edge cases involving declarations or whatever where this wouldn't work.

You'd need to parse out the declarations, yeah. Otherwise they'd get shoved inside the progn which wouldn't work.

You could also introduce a "locally" form (for those wondering: http://www.lispworks.com/documentation/lw61/CLHS/Body/s_loca...)

Re: Fun with Macros: If-Let and When-Let

#20

Post by shawn »

brlewis wrote: post #18

I like the macro transformers in R5RS Scheme. Here's how the multi-binding if-let and when-let look: (define-syntax if-let (syntax-rules () ((if-let ((var value) ...) consequent ...) (let ((var value) ...) (if (and var ...) consequent ...))))) (define-syntax when-let (syntax-rules () ((when-let (binding) body ...) (if-let (binding) (begin body ...)))))

Arc has corrupted me to barely be able to tolerate all those parens.

  (mac iflet (var condition . body)
    `(let ,var ,condition
      (if ,var ,@body)))

  (mac whenlet (var condition . body)
    `(iflet ,var ,condition (do ,@body)))
Post reply on HN