Édition 2027. Bogolang version 0.1.0.
Cette page définit le langage Bogolang. Les autres pages enseignent ; celle-ci énonce les règles.
Quand une autre page et celle-ci ne sont pas d'accord, cette page a raison et l'autre est en faute.
Quand cette page et la commande bogo ne sont pas d'accord, l'une des deux a une faute, et elle
est signalée comme un bogue.
Chaque règle a un numéro. Les programmes du dossier conformance sont liés à ces numéros :
chacun montre une règle à l'œuvre, et un seul test les exécute tous.
1. Ce qu'est Bogolang
1.1 Bogolang est un langage de programmation pour les ingénieurs réseau et télécommunications,
construit sur Python. Un programme Bogolang s'écrit dans des fichiers dont le nom se termine par .bogo.
1.2 Bogolang est défini comme Python 3.15 avec des ajouts et des restrictions :
- Ajouts : la ligne d'édition (section 3), les littéraux (section 4), les instructions (section 8) et les noms intégrés (section 9).
- Restrictions : la structure d'un programme (section 5) et les règles de types (section 6).
1.3 Tout ce que cette page n'énonce pas est comme dans Python 3.15, défini par The Python Language
Reference de cette version. Un fichier .bogo n'est pas un fichier Python : Python ne peut pas lire
les ajouts, et Bogolang refuse les programmes Python qui enfreignent les restrictions.
1.4 Un programme Bogolang s'exécute sur le moteur Python que Bogolang apporte. Chaque paquet Python peut être importé et utilisé (section 11).
2. Le texte source
2.1 Un fichier source est du texte en UTF-8. Une marque d'ordre des octets à son début est acceptée. Les lignes se terminent par un saut de ligne, ou par un retour chariot et un saut de ligne.
2.2 Les lignes, l'indentation, les commentaires, les noms, les chaînes, les nombres et les opérateurs sont ceux de Python, avec les ajouts des sections 3, 4 et 8.
2.3 Un ajout n'est reconnu qu'en dehors des chaînes et des commentaires. À l'intérieur d'une chaîne,
y compris une f-string et ses {}, et à l'intérieur d'un commentaire, le texte n'est jamais lu comme
du Bogolang.
2.4 Un fichier garde ses lignes : la ligne N d'un fichier .bogo est la ligne N de ce qui est vérifié
et exécuté. Chaque message nomme la ligne et la colonne du fichier .bogo.
3. La ligne d'édition
3.1 La forme est le mot edition, des espaces, et le nom d'une édition. Un commentaire peut
suivre. C'est la première ligne du fichier qui n'est ni vide ni un commentaire.
edition 2027
3.2 Les éditions connues sont : 2027. Un autre nom est une erreur qui liste celles qui sont connues.
3.3 Une édition fixe le sens du langage. Un fichier qui a une ligne d'édition a le sens de cette édition dans chaque version ultérieure de Bogolang (section 12).
3.4 Un fichier sans ligne d'édition prend l'édition de son projet (bogo.toml). Sans
projet, il prend l'édition la plus récente et reçoit un avertissement.
4. Les littéraux
Un littéral est une valeur écrite nue dans le source. Chaque littéral a un seul type.
4.1 Les adresses
| Forme | Type | Exemple |
|---|---|---|
| Quatre nombres décimaux joints par des points | IP |
192.0.2.10 |
La même chose, /, une longueur de préfixe |
Net quand la partie hôte vaut zéro, sinon IfAddr |
192.0.2.0/24, 192.0.2.10/24 |
| Six paires de chiffres hexadécimaux jointes par des deux-points | MAC |
00:1a:2b:3c:4d:5e |
4.1.1 Chaque nombre d'une adresse a un à trois chiffres, sans zéro en tête, et une valeur de 0 à 255. La longueur de préfixe va de 0 à 32. Aucune espace ne se trouve à l'intérieur du littéral.
4.1.2 Un littéral d'adresse commence là où le caractère qui le précède n'est ni une lettre, ni un
chiffre, ni un tiret bas, ni un point. Il se termine là où le caractère suivant n'est ni une lettre,
ni un chiffre, ni un tiret bas, et n'est pas un point suivi d'un chiffre. Ainsi 1.2.3.4.5 n'est pas
un littéral.
4.1.3 Une valeur qui a la forme et n'est pas valide, comme 192.0.2.256, est une erreur au
littéral.
4.2 Les quantités
4.2.1 Une quantité est un nombre suivi immédiatement d'une unité : 20Mbps, 1.5s. Le nombre est
fait de chiffres, avec un point facultatif et d'autres chiffres. Il n'a ni exposant ni tiret bas.
Aucune espace ne se trouve entre le nombre et l'unité.
4.2.2 L'unité décide du type. La casse d'une unité compte.
| Type | Unités |
|---|---|
Rate |
bps, kbps, Mbps, Gbps |
Duration |
ms, s, min, h, d |
Distance |
m, km, ft, mi |
Power |
dBm, dBW, mW, W |
Gain |
dB, dBi |
Frequency |
Hz, kHz, MHz, GHz |
Wavelength |
nm |
Size |
B, kB, MB, GB, KiB, MiB, GiB |
Percent |
pct |
Traffic |
erl |
PacketRate |
pps |
4.2.3 Un nombre suivi immédiatement de lettres qui ne sont pas une unité est une erreur au littéral.
Les formes de nombres de Python sont laissées à Python : 0x1F, 0o17, 0b101, 2.5e3, 3j. Il en
va de même des lettres qui sont un mot de Python, comme dans 1if x else 2.
4.2.4 Un signe moins devant une quantité appartient au littéral quand c'est un signe : au
début d'une ligne, après un opérateur, une parenthèse ouvrante, une virgule, = ou :, ou après un
mot de Python comme return. Après une valeur, c'est une soustraction : a - 3dB.
4.2.5 Une valeur que son type n'admet pas, comme 0W pour un Power, est une erreur au littéral.
4.3 Les textes préfixés
4.3.1 Un texte préfixé est l'un de cinq mots suivi immédiatement d'un texte entre guillemets sur une
seule ligne. Les guillemets sont " ou '. Le texte ne contient aucune barre oblique inverse.
| Forme | Type |
|---|---|
ip"..." |
IP, ou Net quand le texte contient un /. IPv4 et IPv6 |
mac"..." |
MAC, dans n'importe laquelle de ses formes écrites |
intf"..." |
Intf |
vlan"..." |
VlanSet |
time"..." |
ClockTime, sous la forme HH:MM |
4.3.2 Une adresse IPv6 ne s'écrit que de cette façon : ip"2001:db8::1". Il n'y a pas de littéral IPv6 nu.
4.3.3 Un texte qui n'est pas valide pour son type est une erreur au littéral.
4.4 Où un littéral est lu
4.4.1 Un littéral est lu partout où une expression de Python peut se trouver : après =, entre
parenthèses ou crochets, dans une liste, comme argument, dans un champ d'une classe.
4.4.2 Un littéral est vérifié à la lecture du fichier, avant la vérification des types et avant que le programme s'exécute. Un fichier qui contient un littéral faux ne s'exécute pas.
core: IP = 192.0.2.1
lan: Net = 192.0.2.0/24
gw: IfAddr = 192.0.2.1/24
link: Rate = 20Mbps
low: Power = -18.5dBm
v6: Net = ip"2001:db8::/32"
print(core in lan, gw.net == lan, link, low, v6.version, [1s, 250ms])
5. La structure d'un programme
5.1 Le haut d'un fichier
5.1.1 Le haut d'un fichier contient seulement : la ligne d'édition ; un texte descriptif comme première instruction ; des imports ; des classes. Un commentaire peut se trouver n'importe où.
5.1.2 Toute autre instruction en haut d'un fichier est une erreur : code must be inside a class.
Un bloc on en haut reçoit à la place le message de 8.10.3.
5.2 Le corps d'une classe
5.2.1 Le corps d'une classe contient seulement : un texte descriptif comme première instruction ; ... ;
pass ; des champs, avec ou sans type écrit ; des méthodes ; des classes ; des alias type ; des blocs
rule (8.9) ; des blocs on (8.10).
5.2.2 Toute autre instruction dans le corps d'une classe est une erreur : this line cannot stand in
the body of a class. La règle vaut pour chaque classe, où qu'elle soit écrite.
5.2.3 À l'intérieur d'une méthode, chaque instruction de Python et chaque instruction de la section 8
est permise, sauf on.
5.3 Où un programme démarre
5.3.1 La classe de départ d'un fichier est la classe de son haut dont le nom correspond au nom du
fichier. Seuls les lettres et les chiffres sont comparés, sans tenir compte de la casse :
link_check.bogo correspond à class LinkCheck.
5.3.2 Un programme démarre dans la méthode main de la classe de départ, écrite exactement ainsi :
@staticmethod
def main(args: list[str]) -> None:
5.3.3 args contient les mots donnés après le nom du fichier sur la ligne de commande.
5.3.4 Quand un programme s'exécute, le fichier est d'abord lu de haut en bas : les champs de chaque
classe reçoivent leurs valeurs, les règles sont enregistrées et les écouteurs s'ouvrent. Ensuite main
est appelée. Un fichier importé est lu de la même façon et sa méthode main n'est pas appelée.
5.3.5 Une classe de départ avec sa méthode main n'est exigée que d'un fichier qui est exécuté. Un
fichier qui est vérifié ou importé peut être une bibliothèque sans classe de départ.
edition 2027
"""Says which hosts answer."""
class Page:
hosts: list[IP] = [192.0.2.1, 192.0.2.10]
@staticmethod
def main(args: list[str]) -> None:
for h in Page.hosts:
print(h, tcping(h, 22))
5.4 Les tests
5.4.1 Un test est une méthode dont le nom commence par test_, dans une classe dont le nom commence
par Test, en haut d'un fichier.
5.4.2 Un test ne prend que self. Chaque test s'exécute sur un nouvel objet de sa classe. Les tests
s'exécutent dans l'ordre où ils sont écrits.
5.4.3 Un test ne contacte rien : chaque commande intégrée qui joindrait le réseau répond à partir des réponses enregistrées, ou fait échouer le test.
6. Les types
6.1 Chaque valeur a un type qui est connu avant que le programme s'exécute. La vérification des types a lieu avant chaque exécution. Un programme qui contient une erreur de type ne s'exécute pas.
6.2 Chaque méthode indique le type de chaque entrée et de son résultat. self et cls ne prennent pas
de type. __init__ peut omettre -> None quand l'une de ses entrées a un type.
6.3 Une variable a un seul type. Elle prend le type de sa première valeur, ou le type écrit sur
sa première ligne : rows: list[str] = []. Une valeur ultérieure d'un autre type est une erreur. Un
cas est comme dans Python : une variable qui contient un float accepte un int.
6.4 Aucune valeur ne peut avoir un type inconnu. Le type Any ne peut pas être écrit.
6.5 Une valeur qui vient de code Python sans types reçoit son type sur la ligne où elle
entre, dans une méthode : count: int = json.loads(text). Cette ligne est testée quand le programme
s'exécute : une valeur d'un autre type arrête le programme à cet endroit. Pour un conteneur comme
list[int], seul le conteneur est testé, pas ce qu'il contient.
6.6 Un objet d'un paquet sans types est déclaré Untyped. Il peut être appelé, lu, écrit,
indexé, parcouru par une boucle et utilisé dans un bloc with. Chaque résultat reçoit son type
sur une ligne à lui, selon 6.5 : après t: Untyped = lib.make(), la ligne n = t.count() est une
erreur, et n: int = t.count() est juste. Un résultat peut être déclaré Untyped à son tour, pour
le laisser sans vérification exprès. Ce qui est fait avec un objet Untyped n'est pas vérifié avant
l'exécution.
6.7 Une valeur qui peut être None (un type écrit T | None) est testée avant d'être utilisée comme
un T.
6.8 Les types des littéraux, et chaque type intégré, sont des classes ordinaires. Chacun peut être
créé pendant que le programme s'exécute. Un type d'adresse est créé à partir d'un seul texte :
IP("192.0.2.1"), Net("192.0.2.0/24"). Une quantité est créée à partir d'un nombre et du texte de
son unité : Rate(20, "Mbps"). Un texte faux lève alors ValueError avec le message que la
vérification donne pour le littéral.
7. Quantités et adresses : ce qui peut être fait avec quoi
7.1 Une quantité d'un type ne devient jamais un autre type d'elle-même.
7.2 Les opérations entre quantités. Tout ce qui n'est pas dans ce tableau est une erreur avant que le programme s'exécute.
| Opération | Résultat |
|---|---|
X + X, X - X, pour Rate, Duration, Distance, Size, Frequency, Wavelength, Percent, Traffic, PacketRate, Gain |
X |
X * number, number * X, X / number, pour chaque quantité sauf Power |
X |
-X, pour chaque quantité |
X |
X / X |
float |
X < X, <=, >, >= |
bool |
Rate * Duration, Duration * Rate |
Size |
Size / Duration |
Rate |
Size / Rate |
Duration |
Power - Power |
Gain |
Power + Gain, Gain + Power, Power - Gain |
Power |
Power + Power |
Une erreur. combine(a, b) additionne deux niveaux de puissance |
7.3 == et != sont permis entre deux valeurs quelconques. Une quantité ou une adresse n'est jamais
égale à une valeur d'un autre type. Entre deux valeurs de Python, == est comme dans Python.
7.4 Une taille compte des octets et un débit compte des bits : 100MB / 10s vaut 80Mbps.
7.5 Là où aucune vérification n'a lieu avant la ligne (dans bogo shell, ou sur une valeur venant d'un
objet Untyped), une opération que 7.2 ne permet pas lève TypeError quand la ligne s'exécute.
7.6 IP in Net est un bool. Une IP ne prend aucune arithmétique avec un float.
print(1Gbps + 500Mbps, 100MB / 10s, 20Mbps * 1min, 1GB / 100Mbps)
print(-18.5dBm - -21dBm, -18.5dBm + 3dB, combine(-10dBm, -10dBm))
print(20Mbps == 5s, 12.4km / 3.1km, 192.0.2.7 in 192.0.2.0/24)
8. Les instructions
Bogolang ajoute dix instructions. Chacune a un en-tête qui tient sur une seule ligne.
8.0.1 Un mot d'une instruction n'est spécial qu'à sa place dans cette instruction. Partout ailleurs,
c'est un nom ordinaire : every = 3 et watch(x) sont du Python simple.
8.0.2 À l'intérieur d'un en-tête, un mot comme where, parallel, timeout, every ou per n'est
lu comme une partie de l'instruction que là où il se trouve entre la fin d'une valeur et le
début de la suivante, en dehors des parenthèses et des crochets.
8.0.3 Dans les formes ci-dessous, les majuscules représentent une expression, et les crochets une
partie qui peut être omise. DURATION est une expression de type Duration.
8.1 for ... where ... parallel
for TARGET in ITEMS [where CONDITION] [parallel NUMBER]:
block
8.1.1 where n'exécute le bloc que pour les éléments pour lesquels CONDITION est vraie.
8.1.2 parallel NUMBER exécute le bloc pour jusqu'à NUMBER éléments en même temps. Une variable
qui reçoit une valeur dans le bloc appartient à cette seule exécution. Une erreur dans une exécution
n'arrête que cette exécution ; last_failures() donne les éléments qui ont échoué.
8.1.3 break et return dans un bloc parallèle sont des erreurs. continue saute l'élément.
8.2 wait until
wait until CONDITION timeout DURATION [every DURATION]
8.2.1 C'est une seule ligne, sans bloc. CONDITION est testée encore et encore, toutes les 5 secondes
ou selon la durée qui suit every, jusqu'à ce qu'elle soit vraie.
8.2.2 Quand le délai passe d'abord, BogoTimeout est levée.
8.2.3 timeout est obligatoire. Sans lui, la ligne est une erreur.
8.3 retry
retry NUMBER [every DURATION]:
block
8.3.1 Le bloc s'exécute. S'il lève une erreur, il s'exécute de nouveau, jusqu'à NUMBER exécutions en
tout, avec la pause de every entre deux exécutions. Après la dernière exécution, la dernière erreur
est levée.
8.3.2 Un bloc change (8.8) à l'intérieur d'un bloc retry est une erreur.
8.4 every
every DURATION:
block
8.4.1 Le bloc s'exécute, le programme attend que DURATION soit passée depuis le début de cette
exécution, et le bloc s'exécute de nouveau, jusqu'à ce que le programme soit arrêté ou que le bloc
utilise break.
8.5 only between
only between TIME and TIME ZONE:
block
8.5.1 Chaque TIME est un ClockTime. ZONE est un nom simple comme UTC, ou un nom entre
guillemets comme "Europe/Paris".
8.5.2 Le bloc s'exécute quand l'heure du jour dans ce fuseau est à l'intérieur de la fenêtre. Une
fenêtre peut traverser minuit. En dehors de la fenêtre, BogoWindowError est levée.
8.5.3 Dans un essai à blanc (--dry), le bloc est sauté en dehors de la fenêtre, avec une ligne qui
le dit, et sans erreur.
8.6 watch
watch EXPRESSION every DURATION [for DURATION]
8.6.1 C'est une seule ligne, sans bloc. La valeur de EXPRESSION est calculée de nouveau à chaque
période et affichée, jusqu'à ce que le programme soit arrêté ou que la durée qui suit for soit écoulée.
8.7 alert when
alert when CONDITION for DURATION [per KEY] [as NAME]:
block
8.7.1 Le bloc s'exécute une fois quand CONDITION a été vraie pendant DURATION, et une fois quand
elle est de nouveau fausse. NAME est une Alert, qui dit lequel des deux cas c'est.
8.7.2 Un alert when se trouve à l'intérieur d'un bloc every. En dehors d'un tel bloc, c'est une erreur.
8.7.3 À l'intérieur d'une boucle, il lui faut per KEY, pour que chaque élément ait sa propre mémoire.
Sans per, c'est une erreur.
8.7.4 Un bloc change à l'intérieur du bloc d'une alerte est une erreur.
8.8 change on
change on DEVICE [revert_after DURATION]:
apply:
device lines
rollback:
device lines
verify:
tests, one per line
8.8.1 Un bloc change contient les sections apply, rollback et verify, dans cet ordre, et
rien d'autre.
8.8.2 Un changement sans section rollback, ou avec une section vide, est une erreur. Un changement
sans lignes apply est une erreur. Un changement sans verify reçoit un avertissement.
8.8.3 Les lignes sous apply et rollback sont du texte d'équipement, pas du Bogolang : une adresse
y reste du texte. {EXPRESSION} dans une telle ligne met une valeur dans la ligne ; l'expression est
du Bogolang et elle est vérifiée. Une vraie accolade s'écrit deux fois : {{ et }}.
8.8.4 Chaque ligne sous verify est une expression qui est vraie ou fausse. Le nom show est
là pour cela : show(COMMAND) donne la sortie d'une commande show sur l'équipement.
8.8.5 Sens : les lignes apply sont envoyées ; puis chaque test de verify est fait ; si une ligne est
refusée par l'équipement ou si un test est faux, les lignes rollback sont envoyées et une erreur est
levée. Une session ouverte sur un équipement en dehors d'un bloc change est en lecture seule.
8.8.6 Dans un essai à blanc (--dry), les lignes qui seraient envoyées sont affichées et rien n'est envoyé.
8.9 rule
rule "NAME" for DEVICE_NAME [where CONDITION]:
tests, one per line
8.9.1 Chaque ligne du bloc est une expression qui est vraie ou fausse, sur une seule ligne. Une règle ne contient aucun bloc. Une règle sans test est une erreur.
8.9.2 Dans un test, DEVICE_NAME est l'équipement, config sa configuration et show ses commandes
show. audit(...) exécute les règles et donne ce qui a échoué.
8.9.3 Une règle se trouve dans le corps d'une classe ou dans une méthode.
8.10 on
on KIND [port NUMBER] [address IP] from SENDERS [matching TEXT] [as NAME]:
block
8.10.1 KIND est syslog, trap ou netflow. Le bloc s'exécute pour chaque événement reçu de
l'un des SENDERS. NAME est l'événement : un SyslogEvent, un Trap ou un Flow.
8.10.2 matching garde les événements qui contiennent TEXT (syslog) ou dont l'OID commence par ce
texte (trap). on netflow ne prend pas de matching : c'est une erreur.
8.10.3 Un bloc on se trouve dans le corps d'une classe seulement. Partout ailleurs, c'est une erreur.
Son écouteur s'ouvre quand la classe est lue, avant main (5.3.4).
8.10.4 Un bloc change à l'intérieur d'un bloc on est une erreur.
edition 2027
class Page:
devices: list[Device] = [Device(name="core-sw1", ip=192.0.2.1, platform="iosxe")]
rule "no telnet on the vty lines" for d where d.role != "server":
not config.has("transport input telnet")
on syslog port 5514 from devices matching "UPDOWN" as e:
print(e.received, e.device, e.message)
@staticmethod
def main(args: list[str]) -> None:
for d in Page.devices where d.platform == "iosxe" parallel 4:
print(d.name)
wait until tcping(192.0.2.1, 22) timeout 2min every 10s
retry 3 every 5s:
print(ping(192.0.2.1, count=2))
only between time"22:00" and time"04:00" UTC:
change on Page.devices[0]:
apply:
vlan 30
name users-{len(args)}
rollback:
no vlan 30
verify:
"30" in show("vlan brief").text
every 1min:
for d in Page.devices:
r: PingResult = ping(d.ip, count=4)
alert when r.loss > 5pct for 3min per d.name as a:
print(d.name, "raised" if a.raised else "cleared")
9. Les noms intégrés
9.1 Chaque fichier .bogo dispose des noms intégrés sans import. Ils sont listés, chacun avec
sa signature et son sens, dans reference.md, qui est produit à partir du code.
bogo doc NAME affiche une entrée.
9.2 Un fichier peut donner à un nom intégré un sens à lui, comme il le peut avec un nom intégré de Python. À l'intérieur de ce fichier, son propre sens l'emporte.
9.3 Un cas n'est pas permis : un fichier qui définit, en son haut, sa propre classe portant le nom du
type d'un littéral, comme Net ou Power, ne peut pas aussi écrire ce littéral. Une classe de
ce nom à l'intérieur d'une autre classe ne masque pas le type.
10. Vérifier et exécuter
10.1 Un programme n'est jamais compilé à l'avance. À chaque fois, il est lu (sections 3, 4, 8), vérifié (sections 5, 6, 7), puis exécuté. Les trois étapes sont dans cet ordre, et une étape qui contient une erreur arrête la suivante.
10.2 bogo check FILE fait les deux premières étapes. Son code de sortie vaut 0 sans erreur, 1 avec
des erreurs, 2 quand la vérification n'a pas pu être faite.
10.3 Une erreur nomme le fichier, la ligne, la colonne, ce qui ne va pas et, là où cela aide, ce qu'il faut écrire. Un avertissement n'arrête pas l'exécution.
10.4 Un fichier est vérifié avec les fichiers .bogo qu'il importe.
10.4.1 Un import d'un paquet qui n'est pas installé est une erreur à la ligne de l'import.
Un import à l'intérieur d'un try qui attrape ImportError est laissé au programme.
10.5 bogo run [OPTIONS] FILE [WORDS] vérifie et exécute. Les options de bogo se trouvent avant
le fichier. Chaque mot après le fichier est donné au programme (5.3.3).
10.6 Un mot après le fichier qui est une option de bogo, comme --replay ou --dry, est
refusé et rien ne s'exécute : à cet endroit il ne serait pas appliqué, et une exécution prévue sur des
réponses enregistrées serait une exécution réelle. Le programme reçoit un tel mot quand il se trouve
après --. Le -- lui-même n'est pas donné au programme.
11. Ce qui est Python tel quel
11.1 À l'intérieur d'une méthode : chaque expression et chaque instruction de Python 3.15.
11.2 Les classes, avec les limites de 5.2 : héritage, propriétés, méthodes statiques et méthodes de classe, classes de données, génériques.
11.3 La bibliothèque standard et chaque paquet Python, importés tels quels. Un paquet avec types s'utilise sans rien de plus. Un paquet sans types s'utilise selon 6.5 et 6.6.
11.4 Un simple fichier .py à côté d'un programme peut être importé. Les règles des sections 5 et 6
ne valent que pour les fichiers .bogo.
11.5 Les types de Bogolang sont des objets Python ordinaires, donc un paquet Python peut les
recevoir. .to_python() sur une IP ou un Net donne l'objet du module ipaddress de Python.
12. Les éditions et ce qui est promis
12.1 Un programme qui indique une édition et passe la vérification garde son sens dans chaque version ultérieure de Bogolang.
12.2 Un changement qui modifierait ce que fait un tel programme, ou retirerait quelque chose qu'il utilise, n'arrive que dans une nouvelle édition. L'édition qui la précède avertit d'abord.
12.3 Une nouvelle version peut ajouter des noms intégrés, des unités et des instructions à une édition, tant qu'aucun programme qui passait la vérification auparavant ne change de sens. Les noms propres à un fichier l'emportent sur les nouveaux noms intégrés (9.2).
12.4 Le moteur Python à l'intérieur de Bogolang peut passer à un Python plus récent. Ce que 1.3 laisse à Python suit alors cette version de Python, dans les limites de ce que Python lui-même garde compatible.
13. Les limites de la version 0.1.0
Ce sont des limites de la première version, pas des règles du langage. Elles sont énoncées pour que personne n'ait à les découvrir.
13.1 Un littéral à l'intérieur des {} d'une f-string n'est pas lu (2.3). Mettez d'abord la valeur
dans une variable.
13.2 L'en-tête d'une instruction de la section 8 tient sur une seule ligne.
13.3 where et parallel ne sont lus que dans l'en-tête d'un for, en dehors des parenthèses, des
crochets et des chaînes.
13.4 Un programme qui lit, après une boucle parallèle, une variable qui a reçu une valeur à l'intérieur n'est pas refusé par la vérification. Il s'arrête quand il s'exécute.
13.5 Les messages de la vérification des types pour les erreurs rares sont ceux du vérificateur de types sous-jacent, avec les noms des types tels que Bogolang les écrit.
13.6 La règle 6.6 trouve un objet Untyped par son nom : une variable, une entrée, un champ ou une
méthode déclarés Untyped, et le nom d'un for ou d'un with sur un tel objet. Un résultat d'un
objet Untyped atteint d'une autre façon, comme un élément d'une liste de tels objets, n'est pas refusé.