> > > > 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
