Re: Newbie packagers

[Vincent Legoll <vincent.legoll@gmail.com>]

Hello,

Thanks a lot, this is really helpful !

On Thu, Jul 21, 2016 at 5:52 PM, Ricardo Wurmus <rekado@elephly.net> 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 “@” 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