### 3.3. Lijsten, lijsten en nog meer lijsten

We hebben u getraind in variabelen en functies en leiden u nu naar de modderige moerassen van lijsten in Scheme.

#### 3.3.1. Een lijst definiëren

Voordat we meer over lijsten gaan praten, is het noodzakelijk dat u het verschil weet tussen atomic-waarden en lijsten.

U hebt al enkele atomic-waarden gezien toen we variabelen initialiseerden in de vorige les. Een atomic-waarde is een enkele waarde. Dus, bijvoorbeeld, we kunnen de variabele “`x`” toewijzen aan de enkele waarde 8 in het volgende argument:

    (let* ( (x 8) ) x)

(We added the expression `x` at the end to print out the value assigned to `x`—normally you won't need to do this. Notice how `let*` operates just like a function: The value of the last statement is the value returned.)

Een variabele mag ook verwijzen naar een lijst met waarden, in plaats van naar een enkele waarde. We zouden, om de variabele `x` toe te wijzen aan de lijst met waarden 1, 3, 5, typen:

    (let* ( (x '(1 3 5))) x)

Probeer beide argumenten in de Script-Fu Console en merk op hoe het antwoord geeft. Wanneer u het eerste argument intypt, antwoordt het eenvoudigweg met het resultaat:

    8

Echter, wanneer u het andere argument intypt, antwoordt het met het volgende resultaat:

    (1 3 5)

Wanneer het antwoord met de waarde 8, informeert het u dat `x` de atomic-waarde 8 bevat. Echter, wanneer het antwoord met `(1 3 5)`, dan informeert het u dat `x` niet een enkele waarde bevat, maar een lijst met waarden. Merk op dat er geen komma's in onze declaratie of toewijzing van de lijst staan, noch in het afgedrukte resultaat.

De syntaxis voor het definiëren van een lijst is:

    '(a b c)

waar `a`, `b` en `c` letterlijk zijn. We gebruiken de apostrof (`'`) om aan te geven dat wat volgt in de haakjes een lijst is met letterlijke waarden, in plaats van een functie of uitdrukking.

Een lege lijst kan ook als zodanig worden gedefinieerd:

    '()

of nog eenvoudiger:

    ()

Lijsten mogen atomic-waarden bevatten, maar ook andere lijsten:

    (let*
       (
            (x
               '("GIMP" (1 2 3) ("is" ("fantastisch" () ) ) )
            )
        )
        x
    )

Merk op dat, na de eerste apostrof, u niet langer een apostrof hoeft te gebruiken bij het definiëren van de binnenste lijsten. Ga door en kopieer het argument in de Script-Fu Console en kijk wat het teruggeeft.

Het zou u moeten opvallen dat het teruggegeven resultaat niet een lijst is met enkele, atomic-waarden; in plaats daarvan is het een lijst met letterlijk `("GIMP")`, de lijst `(1 2 3)`, etc.

#### 3.3.2. Hoe aan lijsten te denken

Het is nuttig om aan lijsten te denken als dat ze zijn samengesteld uit een “kop” en een “staart”. De kop is het eerste element van de lijst, de staart is de rest van de lijst. U zult zien waarom dit belangrijk is als we bespreken hoe lijsten toe te voegen en hoe toegang te krijgen tot elementen in de lijst.

#### 3.3.3. Lijsten maken door samenvoegen (de functie Cons)

One of the more common functions you'll encounter is the cons function. It takes a value and places it to its second argument, a list. From the previous section, I suggested that you think of a list as being composed of an element (the head) and the remainder of the list (the tail). This is exactly how cons functions — it adds an element to the head of a list. Thus, you could create a list as follows:

    (cons 1 '(2 3 4) )

Het resultaat is de lijst `(1 2 3 4)`.

U zou ook een lijst met een element kunnen maken:

    (cons 1 () )

U mag eerder gedeclareerde variabelen gebruiken in plaats van elke letterlijke, zoals u al zou verwachten.

#### 3.3.4. Definiëren van een lijst met de functie `list`

Definiëren van een lijst die is samengesteld uit letterlijken of eerder gedeclareerde variabelen, gebruik de functie `list`:

    (list 5 4 3 a b c)

Dat zal een lijst samenstellen en teruggeven die de waarden bevat van de variabelen `a`, `b` en `c`. Bijvoorbeeld:

            (let*  (
                      (a 1)
                      (b 2)
                      (c 3)
                   )

                   (list 5 4 3 a b c)
            )

Deze code maakt de lijst `(5 4 3 1 2 3)`.

#### 3.3.5. Toegang tot waarden in een lijst

Gebruik, voor toegang tot de waarden in een lijst, de functies `car` en `cdr`, die respectievelijk het eerste element van de lijst teruggeven en de rest van de lijst. Deze functies verdelen de lijst in de constructie kop::staart, die ik eerder vermeldde.

#### 3.3.6. De functie `car`

`car` geeft het eerste element terug uit de lijst (de kop van de lijst). De lijst moet niet null zijn (niet leeg). Dus, het volgende geeft het eerste element van de lijst terug:

    (car '("eerste" 2 "derde"))

wat is:

    "eerste"

#### 3.3.7. De functie `cdr`

`cdr` geeft de rest van de lijst terug, na het eerste element (de staart van de lijst). Als er slechts een element in de lijst staat, geeft het een lege lijst terug.

    (cdr '("eerste" 2 "derde"))

geeft terug:

    (2 "derde")

terwijl het volgende:

    (cdr '("de enige echte"))

geeft terug:

    ()

#### 3.3.8. Toegang tot andere elementen in een lijst

OK, fantastisch, we kunnen het eerste element in een lijst ophalen, en ook de rest van de lijst, maar hoe krijgen we toegang tot het tweede, derde of andere elementen van een list? Er bestaan verscheidene "handige" functies voor toegang tot, bijvoorbeeld, de kop van de kop van de staart van een lijst (`caadr`), de staart van de staart van een lijst (`cddr`), etc.

De basis conventie voor de naam is gemakkelijk: De a's en d's geven de koppen en staarten van de lijsten aan, dus

    (car (cdr (car x) ) )

zou kunnen worden geschreven als:

    (cadar x)

Om wat te oefenen met functies voor toegang tot lijsten, probeer het volgende in te typen (behalve dat alles op een regel moet als u de console gebruikt); gebruik verschillende variaties van `car` en `cdr` om toegang te krijgen tot de verschillende elementen in de lijst:

            (let* (
                     (x  '( (1 2 (3 4 5) 6)  7  8  (9 10) )
                     )
                  )
                  ; plaats uw code voor car/cdr hier
            )

Probeer toegang te krijgen tot het getal 3 in de lijst door slechts twee functie-aanroepen te gebruiken. Als u dat kunt doen, bent u op weg om een Script-Fu Master te worden!

| Opmerking
In Scheme markeert een puntkomma (`;`) het begin van een opmerking. Dat, en alles dat erop volgt op dezelfde regel, wordt genegeerd door de script-interpreter, dus kunt u dat gebruiken om opmerkingen toe te voegen om uw geheugen op te frissen, als u later naar het script kijkt.

3.2. Variabelen en functies |  | 3.4. Uw eerste script voor Script-Fu

Report a bug in GIMP Rapporteer een fout in de documentatie