---
title: "Listes" 
weight: 20
---

# Listes algébriques

## Séquences fixes

```
+list(a b c d);
```

## Pile de constantes

```
+list(a(b(c(d(e)))));
```

## Listes générales

Si on souhaite lister des rayons arbitraires alors on peut utiliser n'importe
quel symbole de fonction binaire et notamment le symbole spécial `:` qui
correspond à un symbole binaire `:(_, _)` en interne (associatif à droite) :

```
+list(a:b:c:d:e);
+list(cons(a, cons(b, cons(c, cons(d, e)))));
```

On peut aussi opter pour une représentation avec polarités internes :

```
+cons(a, +cons(b, +cons(c, +cons(d, e))));
```

## Quelques opérations sur les listes générales

### Test liste vide

```
+empty(e);

@-empty(e) ok;
@-empty(1:e) ok;
```

### Concaténation

```
+append(e L L);
-append(T L R) +append(H:T L H:R);

@-append(a:b:e c:d:e R) R;
```

### Inverse d'une liste

```
+rev_acc(e ACC ACC);
-rev_acc(T H:ACC R) +rev_acc(H:T ACC R);
-rev_acc(L e R) +rev(L R);

@-rev(a:b:c:d:e R) R;
```

### Map

```
+funcall(f X f(X));

+map(X e e);
-funcall(F H FH) -map(F T R) +map(F H:T FH:R);

@-map(f a:b:c:d:e R) R;
```

# Listes interactives

Une liste interactive est définie par un enchaînement d'étoiles. On ne
représente plus la liste mais le processus de création de liste :

```
+l(0 a:X) -l(1 X);
+l(1 b:X) -l(2 X);
+l(2 c:X) -l(3 X);
+l(3 d:X) -l(4 X);
+l(4 e);

@-l(0 X) X;
```

En remplaçant le `0` de `@-l(0 X) X`, cela nous permet de demander la liste à
partir d'un certain indice :

```
+l(0 a:X) -l(1 X);
+l(1 b:X) -l(2 X);
+l(2 c:X) -l(3 X);
+l(3 d:X) -l(4 X);
+l(4 e);

@-l(2 X) X;
```

On peut aussi imaginer des variantes de représentations qui permettent d'agir
sur les éléments de la liste. On peut aussi imaginer jouer avec des boucles
pour former des listes circulaires ou alors générer une liste automatiquement. 