Re: Guile Assembler

[Panicz Maciej Godek <godek.maciek@gmail.com>]

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

>
> > > Hm. Where's the difference to Guile's define? And why do you have
> double
> > > parentheses in your example?
> > >
> > > Still a bit lost.
> >
> > hmm...do you read the pasted code in the repo? ;-)
>
> Not yet, I must admit. But nevermind, got it. It looks like a definition
> for a parametric func or for a half-curried func, depending on how you
> squint at it ;-)
>
> That explains the second set of parens.
>

Hi,
sorry to answer that late, but I erroneously sent the previous answer only
to Nala.

I have another project (in another repo) which provides the (extra common)
module, which redefines "define" and "lambda" forms (among others):

https://bitbucket.org/panicz/slayer/src/cbfb3187edaba890b12b307d84bb9c4538407d20/guile-modules/extra/common.scm?at=default

(The module is rather huge -- it is a bag that I carry around)

The modification of "define" originates, I believe, from the book
"Structure and Interpretation of Classical Mechanics" by Gerald Sussman and
Jack Wisdom [1], but I stole that idea directly from Guile's (ice-9
curried-definitions) module [2]. The idea is that

(define ((f x) y)
  (list x y))

is equivalent to

(define f
  (lambda (x)
    (lambda (y)
       (list x y))))

This behaviour is consequent with the idea that

(define (g x)
  (* x x))

should be equivalent to

(define g
  (lambda (x)
    (* x x)))

The derivative variants are easier to read, because they make it apparent,
that e.g. (g 5) can be substituted with (* 5 5), and -- similarly -- ((f 2)
3) can be substituted with (list 2 3).

The other difficulty is that the original function header looked like this:

(define ((number/base base) (l ...))

so that the form of the second argument is "(l ...)". This is because the
(extra common) module allows to destructure the arguments using the (ice-9
match) pattern matcher, so that the above header is actually equivalent to

(define number/base
  (lambda (base)
    (lambda x
      (match x
        ((l ...)

In practice that form of argument doesn't do much. It just tells the reader
that the argument is a proper list (because only a proper list matches such
pattern)

Similarly, I could write code like

(map (lambda ((a . b)) (+ a b)) '((1 . 2)(3 . 4)(5 . 6)))

I also use that trick with let and let* forms:

(let (((x y) '(1 2)))
  (+ x y))

In addition, the module allows me to use the "let" and "let*" forms with
multiple values:

(let ((a (b c) (values 1 '(2 3))))
  (+ a b c))

Best regards

[1]
http://mitpress.mit.edu/sites/default/files/titles/content/sicm/book-Z-H-11.html
[2]
https://www.gnu.org/software/guile/manual/html_node/Curried-Definitions.html

[-- Attachment #2: Type: text/html, Size: 4199 bytes --]