Re: Advantage using mapc over dolist

[Tomas Hlavaty <tom@logand.com>]

On Tue 03 Dec 2024 at 12:24, Stefan Monnier <monnier@iro.umontreal.ca> wrote:
>>    > on the contrary, it is better to use specific tools and avoid more
>>    > general tools when possible in order to lower cognitive load.
>>    Again, that's a personal preference.  If you have to learn the more
>>    general tool anyway, then having to additionally learn the more specific
>>    tool may increase rather than lower the cognitive load.
>> Then why not use COND*?  
>
> AFAICT, the "cognitive load" of a complex pattern language is about the
> same for `pcase` as for `match*` since the two pattern languages are
> very similar.
>
> And in the case of code that can use `case/ecase`, `cond*` doesn't seem
> to provide much benefit over just `cond` or `pcase`.  Compare:

not only syntax but also semantics is important

not only things that are possible are important
but also things that are not possible

very limited stuff can happen using case/ecase

this is not the case with pcase so one has to keep in mind many more
possibilities

compare IF and WHEN.  IF is more general and using your logic, one
should use IF and forget WHEN.  however, the reduction of cognitive load
comes also from _things that cannot happen_, e.g. there is no "else"
branch to watch out for when using WHEN.  Thus writing (if x 42) is
worse than writing (when x 42).  It conveys the intention much better.
And is more robust.

>     (pcase actm
>      ('armg (do-this))
>      ('go (do-that))))

(let ((x 'go))
  (pcase x
    ('armg 1)
    ('go 2)))
=> 2
(let ((x 'go))
  (pcase x
    (armg 1)
    (go 2)))
=> 1

here the PATTERN leads to many more possibilities

>     (case actm
>      (armg (do-this))
>      (go (do-that))))

(let ((x 'go))
  (cl-case x
    ('armg 1)
    ('go 2)))
=> 2
(let ((x 'go))
  (cl-case x
    (armg 1)
    (go 2)))
=> 2

here the KEYLIST leads to much less possibilities

>     (cond
>      ((eq actm 'armg (do-this)))
>      ((eq actm 'go (do-that))))
>
> vs
>
>     (cond*
>      ((eq actm 'armg) (do-this))
>      ((eq actm 'go) (do-that)))
>
> or
>
>     (cond*
>      ((match* `armg actm) (do-this)))
>      ((match* `go actm) (do-that))))

obviously these examples are significantly worse than CASE

you meant:
(cond
  ((eq actm 'armg) (do-this))
  ((eq actm 'go) (do-that)))

and cond is simpler and more specific than cond*

so again, use simpler, more specific tool for the job and the code will
be more readable and maintainable

pushing for general omnipotent
use-me-i-can-do-everything-youll-ever-need macro is a bad idea