[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: Newbie packagers
From: |
Vincent Legoll |
Subject: |
Re: Newbie packagers |
Date: |
Thu, 21 Jul 2016 19:13:32 +0200 |
Hello,
Thanks a lot, this is really helpful !
On Thu, Jul 21, 2016 at 5:52 PM, Ricardo Wurmus <address@hidden> wrote:
>> - the comma operator
>> - the backquote operator
>> - the quote operator
>> - the arobase operator (is it for list unpacking ?)
>
> These are all about list quoting.
> This is code:
>
> (+ 1 2 3)
>
> It evaluates to 6.
>
> This is quoted code (aka data):
>
> '(+ 1 2 3)
Those I knew/remembered from my CS student days, it's the other
2 I didn't grok...
> It doesn’t get evaluated any further.
> This is pretty much the same as:
>
> `(+ 1 2 3)
>
> But with the backtick (called “quasiquote”) you are permitted to
> temporarily switch from “data mode” to “code mode”. That’s what the
> comma (“unquote”) does:
>
> `(+ 1 2 3 4 ,(+ 3 2) 6)
> ^ ^
> data mode code mode
>
> The result is the same as
>
> '(+ 1 2 3 4 5 6)
>
> What’s nice about this is that we can use the same syntax for code that
> is to be evaluated right now and for code that we want to pass somewhere
> else as inert data which will be evaluated at a later point.
>
> This allows for “staging”. When you look at a typical package
> expression you see that the value of the “arguments” field is quoted.
> It is not evaluated right away but in a second stage.
>
> The value of the inputs field is also quoted. You see that we unquote
> the values of package variables there. Package expressions in Guix are
> just Scheme values. The inputs field does not merely hold a list of
> symbols that somehow represent the packages — it actually contains the
> very values themselves!
>
> “,@” is for splicing lists:
That one I guessed, but wasn't sure because of the still unknown comma...
Python has something similar, but it does not look as useful as this, especially
with that quasiquote thing...
> (let ((moo '(1 2 3)))
> `(foo bar ,@moo meh))
>
> This binds the list '(1 2 3) to the name “moo” and then splices it into
> another list. This results in
>
> '(foo bar 1 2 3 meh)
>
> Without the address@hidden and just a regular unquote comma it would be a
> nested
> list:
>
> (let ((moo '(1 2 3)))
> `(foo bar ,moo meh))
>
> => '(foo bar (1 2 3) meh)
>
> Quoting and unquoting is a very useful feature. I hope my explanations
> above are easy to understand.
Perfect, clear, that was just what I needed. I will not immediately
be used to those concepts, but I understand what they do, that's
sufficient to read code...
The big problem with the abbreviated forms is that they're not easily
googlable, if I knew their long names, I could've found them in online
doc...
>> - the percent operator
>
> That’s no operator. It’s part of the name. We use the percent as a
> prefix for variables that are “special”, e.g. global variables or
OK, only a naming convention then ?
> values that appear without having to be explicitly let-bound.
That could use a little pointer, because the idea is strange, you
mean implicit variables (bindings), kind of like perl's $_ ?
>> - the #: operator
>
> These are called keyword arguments. They are no operators either.
> Using keyword arguments allows you to specify arguments by name, not in
> some fixed order.
That I also guessed (I'm coming from **kwargs-land...), but they also look
more powerful...
>> - the different module import things (#:use-module vs (use-modules) vs ...)
>
> That’s probably explained in the Guile reference manual.
Yes, I read a bit about that in there, but the following is what I
wanted to know :
> We use “#:use-module” only in module definitions.
> “(use-modules …)” can be used anywhere else.
> Yeah, I agree. There should be a quick crash course. I spent half the
> day yesterday to introduce all these things to a colleague who will
> create a few Guix packages in the future. It would be cool to have this
> as part of the manual.
Thanks a lot, this is just what's missing, and looks like Ludo's covered the
.texi part !
--
Vincent Legoll