108 lines
1.8 KiB
Markdown
108 lines
1.8 KiB
Markdown
---
|
|
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. |