Design syntax like Haskell's `where`

[stylewarning]

The Lisp tradition of stacking bindings top-down is reasonably well understood, but in some cases, it's a distraction from the meat of the program. I think we should give an option to put bindings after an expression. Maybe we can use PROGN?

(progn
  (start-gui x)
  (clean-up y)
  (do-laundry clothes)
 :where 
  (start-gui x) =
    (open-blah ...)
  (clean-up y) =
    ...
  (do-laundry z) =
    ...
  clothes = ...)

A big negative with this example is that it's just very different than the rest of the syntax of Coalton.

(let ((foo ...)
      (bar ...))
  ...)

(let x = ...)
(let y = ...)
...

Anyway, something to consider.

[macrologist]

(progn 
    (start-gui x)
    (clean-up y)
    (do-laundry clothes)
    (where 
       (start-gui x) = (open-blah ...)
       (clean-up y) = ....
        (do-laundry clothes) = ....
        x = ...
        y = ...
        clothes = ...))

This would, perhaps in an unwelcome way, permit multiple where forms throughout a prog body.

(define (cook-dinner meal) 
    (let gathered = (gather-ingredients ingredients)
    (where 
         ingredients = (internet:lookup-ingredients meal)
         (gather-ingredients xs) = (grocery:order xs credit-card))
    (prep-kitchen gathered)
    (where 
        (prep-kitchen xs) = ...)
   ...)

[stylewarning]

@macrologist What are your thoughts on the idea more broadly?

[macrologist]

@macrologist What are your thoughts on the idea more broadly?

@stylewarning

I'm generally in favor of it. I like seeing the intended effect of a computation first. However, I'm even more in favor if conventions, idioms, and syntactic support that disfavors long function bodies.

Because Coalton auto-curries applications, I think there is slightly less of a benefit to this kind of thing than there would be in, say, Common Lisp.

In CL, crowding the top of a defun with a salad of flet, lables, let* does tend to distract from the "buisiness end" of the function. As such, in CL something like

(defun-where cool  (zs) 
       (loop :for z : in zs :do (do-cool-stuff 10 z))
        (where-labels 
             ((do-cool-stuff (y x) ...))))

actually seems useful.

But in Coalton, we might as well just

(define (do-cool-stuff y x) ...)

(define (cool zs) 
    (for-each! (do-cool-stuff 10) (into-iter zs)))

or something like that.

But, again, Im generally in favor of it.

E.g, being able to do this would be nice

(define (cool zs) 
    (duplicate-map coolest zs)
    :where 
       (duplicate-map f xs) = (double (map f xs))
       (double ys) = (<> ys ys)
       (coolest z) = (do-cool-stuff 10 z))