How to gradually write a procedure using Guile?

[Tomas Volf <~@wolfsden.cz>]

[-- Attachment #1: Type: text/plain, Size: 1571 bytes --]

Hello,

I am looking for a workflow advice.  I am using Emacs with Geiser.

I am trying to write couple of procedures that are very imperative and I am not
sure how to do that nicely in REPL.  For example, let us assume I have a
procedure of following character:

    (define (foo)
      (let* ((x (bar-x))
             (y (bar-y x)))
        (step1 x)
        (step2 y)
        (step3 x y)
        ...))

Now, each step can be a procedure call, of just few expressions.  Now I would
like to write the additional steps while utilizing REPL somehow, but I am not
sure what is an efficient way.

Can I somehow run just to the `...' and get a REPL there so that I could C-x C-e
the steps within the let* (for x and y)?  Should I just (temporarily)

    (define x (bar-x))
    (define y (bar-y x))

in the REPL so that I can use C-x C-e on the steps?  I expect that to get messy
once the lets start nesting for example.

How do you do it?  Are there any resources (blog posts, toots, videos, ...)
regarding guile developer's workflow?  I did read few, and I (think I) know the
fundamentals of Geiser and the REPL, but I am straggling a bit in this case not
to fall back to the "normal" way of "write a function, run it whole against a
test".  Since this is Scheme, and I *can* evaluate single expressions in the
procedure body, I would like to use that to my advantage.  Somehow.

I realize this is a very open-ended question/email.

Have a nice day,
Tomas Volf

--
There are only two hard things in Computer Science:
cache invalidation, naming things and off-by-one errors.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]