News for hackers. Stuff that matters.
Re:Statistical Analysis with Lisp-Stat by taeric on Friday March 25, 2022 @02:18PM (#30805450)
I'll try iterate. For me it is just that loop is already very easy to read. Moving all things to s exprs doesn't seem like it would be that big of a deal.

And I should say that the construct that I find easiest is the "then" clause.

    (Loop repeat 8
          For a = 0 then b
          For b = 1 then c
          For c = 1 then (+ a b)
          Collect a)
That just reads very easily to me.

(Typed on phone...)

Re:Statistical Analysis with Lisp-Stat by maydup-nem on Friday March 25, 2022 @03:49PM (#30806389)
First of all, if you are going to try it out, I recommend using this macro:

   (defmacro itr (&rest rest)
     `(iterate:iterate ,@rest))
because it keeps all the clauses on the same indentation level.

Now, to the translation: iterate has previous clause. https://iterate.common-lisp.dev/doc/Previous-Values-of-Drive... which may help translate the loop form you provided into this:

   (itr (repeat 8)
        (for a previous b initially 0)
        (for b previous c initially 1)
        (for c = (+ a b))
        (collect a))
However, if you wanted that exact syntax, you could try:

   (defmacro-clause (FOR var = init-value THEN form)
     `(progn (with ,var = ,init-value)
             (after-each (setf ,var ,form))))
to get a direct translation:

   (itr (repeat 8)
        (for a = 0 then b)
        (for b = 1 then c)
        (for c = 1 then (+ a b))
        (collect a))
> Moving all things to s exprs doesn't seem like it would be that big of a deal.

One of the biggest things you will "miss" from LOOP is the do keyword. The control structures is just regular lisp code. Also, I found generators to be pretty handy (not often, but I am glad I had them when it was called for).

I mean, it's not exactly groundbreaking, but it does make a difference especially that a looping construct is probably the heaviest-used macro. You can certainly get away with LOOP, but I see iterate as more or less how LOOP should've been done.

I also recommend reading this short discussion in the manual https://iterate.common-lisp.dev/doc/Don_0027t-Loop-Iterate.h...

Re:Statistical Analysis with Lisp-Stat by taeric on Friday March 25, 2022 @06:52PM (#30807765)
Previous doesn't have the same flow, so does feel more cumbersome than I'd like. (That is, I specifically like the left to right flow of "this then that" for variables.)

I do have a softspot for how this is embracing the parens. :D

This is funny in that it seems to dodge the biggest complaint of loop, that it has different syntax for lists and vectors/hashtables.

Re:Statistical Analysis with Lisp-Stat by maydup-nem on Friday March 25, 2022 @09:04PM (#30808415)
It has in-sequence, however it uses elt I think. For efficiency reasons, there's a separation. Otherwise how should it work? In any case, you could probably write a macro that does the right thing based on type.

> Previous doesn't have the same flow,

I have provided a clause macro that uses the exact syntax you showed, you don't have to use previous.

Re:Statistical Analysis with Lisp-Stat by taeric on Friday March 25, 2022 @10:42PM (#30808818)
Apologies, I was agreeing with your macro on why I like "then" over "previous". I did not intend mine as a correction or challenge.

My point on "in-sequence" and such was more that the main complaint I ever hear regarding LOOP is that:

    (loop for c across "hello"
          collect c)
is not the same as

    (loop for c in '(#\h #\e #\l #\l #\o)
          collect c)
Specifically, "in" versus "across" seems to upset a lot of folks. I don't recall ever hearing too many complaints about the syntax not being more nested.

Again, though, looks neat and I'm excited to dive more into it.

Re:Statistical Analysis with Lisp-Stat by maydup-nem on Saturday March 26, 2022 @09:57AM (#30811807)
Okay, gotcha.

Yeah, I can see how having distinct keywords may be seen as inconvenient. I think if there were a general container-keyword that wouldn't introduce any cost based on a type declaration, that would be cool, but it's not something I have encountered a real need for.