Aller au contenu

Le système de types de Pine v6, dans la pratique

10 min de lecture

PineScript v6 est plus typé qu’on ne le croit. Règles d’inférence, pièges — et ce qu’on a appris en livrant un transpileur sur ce qui compte vraiment au runtime.

Pine Script a la réputation d’être faiblement typé. Cette réputation est en partie méritée, et surtout fausse. Elle vient de ce que int est élargi silencieusement en float, que na est accepté presque partout et que le langage exige rarement une annotation explicite. Mais sous cette surface permissive se cache un système de types qui a de vraies dents, et dès qu’il faut le transpiler vers un langage à typage statique, chaque dent compte.

Ce billet passe en revue ce que sont réellement les types de Pine v6, où la couche d’inférence cache la complexité, et trois pièges qui comptent dès qu’on compile du Pine en C++.

Réputation et réalité

Un développeur qui débute en Pine écrit :

x = 5
y = close + x

Pas d’annotations. Pas de plainte du compilateur. Le développeur en conclut que « Pine n’a pas de types ». Pourtant, Pine a inféré exactement ce que sont ces variables : x est un const int (un littéral, connu à la compilation), et y un series float (une valeur à virgule flottante, barre par barre). L’inférence fait un vrai travail ; il est simplement invisible.

La différence entre const int et series float n’a rien de cosmétique. Les deux n’ont ni le même comportement à l’exécution, ni les mêmes règles de compatibilité avec les opérateurs, ni la même représentation dans une sortie transpilée. Le langage est typé ; il ne vous oblige simplement pas à écrire les types.

Les familles de types

On s’intéresse ici à quatre niveaux du système de types de Pine v6. La plupart des utilisateurs ne rencontrent que le premier.

Les primitifs

Les types primitifs sont int, float, bool, string et color. Il y a aussi na, qui mérite sa propre section plus bas. Ce sont les types feuilles, ceux qui portent des valeurs scalaires.

int et float participent à l’élargissement implicite : quand on les mélange dans une expression, l’int est élargi en float. C’est ce comportement qui vaut à Pine l’étiquette « faiblement typé », mais il s’agit d’une règle délibérée et cohérente, pas d’un cas particulier. Le C++ fait de même pour les types numériques.

Les composites

Pine v6 prend en charge trois types composites : array<T>, matrix<T> et map<K, V>. Tous trois sont paramétrés par leurs types d’éléments, qui peuvent être des UDT, à ceci près que les clés d’une map doivent être d’un type valeur, comme int ou string. On peut avoir array<float>, array<int>, et même array<MyUDT>.

Les types composites sont des objets mutables. Ce sont des types référence, au sens où passer un array<float> à une fonction lui donne un accès au même stockage sous-jacent. Si la fonction modifie le tableau, l’appelant voit le changement.

Les types définis par l’utilisateur (UDT)

Pine v5 a introduit le mot-clé type en décembre 2022, puis le mot-clé method en février 2023. Ensemble, ils permettent de définir des types enregistrement nommés, avec des champs et des méthodes facultatives :

type Order
    float price
    int   qty
    bool  filled = false
 
method fill(Order this, float fillPrice) =>
    this.price  := fillPrice
    this.filled := true

Les UDT sont ce que Pine a de plus proche des structs. Leurs champs peuvent avoir des valeurs par défaut (comme filled = false ci-dessus). Les méthodes s’appellent avec la notation pointée et reçoivent l’instance de l’UDT comme premier paramètre, nommé ici this. Les champs sont modifiables par affectation :=.

Qualificateurs de forme : series ou simple

En Pine, chaque valeur (pas seulement les primitifs, mais aussi les composites et les UDT) porte un qualificateur de forme, qui décrit son rapport à la chronologie des barres.

  • series — la valeur peut changer d’une barre à l’autre. Elle a un historique : x[1] donne la valeur de x sur la barre précédente. C’est le cas par défaut pour la plupart des expressions qui font intervenir des données de prix.
  • simple — la valeur est fixée sur la première barre et ne bouge plus jusqu’à la fin de l’exécution, comme syminfo.ticker.
  • input — la valeur vient des paramètres du script, via input.int() et ses cousines : fixe pendant l’exécution, connue au démarrage du script.
  • const — la valeur est connue à la compilation : tout littéral, et tout ce qui est déclaré comme const int VERSION = 6. Le codegen peut l’écrire directement dans le C++ (le premier piège, plus bas, montre comment).

Les qualificateurs forment une hiérarchie, const < input < simple < series, et une expression prend le qualificateur le plus fort parmi ceux de ses composants : simple int + series float donne series float.

La sémantique de na

na n’est pas un null universel : Pine doit quand même savoir quel type manque. C’est pourquoi cette ligne ne compile pas :

x = na

Rien ne permet d’en inférer le type. Déclarez-le plutôt :

float x = na

L’arithmétique sur na se propage : na + 1 vaut na. C’est voulu et cohérent : si une valeur est inconnue, toute expression qui en dépend l’est aussi. La porte de sortie, c’est nz(x, 0), qui remplace na par une valeur par défaut.

Les comparaisons se comportent autrement : ==, != et toutes les autres comparaisons donnent false dès qu’un opérande vaut na, et écrire na lui-même comme opérande, par exemple x == na, ne compile pas. Utilisez plutôt le prédicat intégré na(x).

Dans le C++ de PineForge, na est une valeur sentinelle du type même de la variable, et na(x) devient is_na(x). Les comparaisons générées testent d’abord les deux opérandes avec is_na : une comparaison avec na donne donc false.

L’inférence de types en détail

Pine infère les types à partir du membre de droite des affectations. Les règles sont simples une fois qu’on connaît la hiérarchie des qualificateurs de forme :

a = 5           // const int
b = 5.0         // const float
c = close       // series float  (close is always series float)
d = close + 1   // series float  (int widens to float; series promotes)
e = bar_index   // series int    (bar_index is series int, always)

Le cas intéressant, c’est l’inférence à travers les branches :

x = condition ? close : 0

condition peut être un series bool. close est un series float. 0 est un const int. Pine élargit 0 en series float, et le résultat est un series float. Le compilateur retient toujours la forme la plus générale et le type le plus englobant.

Les arguments de fonction contraignent aussi l’inférence. Si une fonction intégrée attend un simple int et que vous lui passez bar_index (qui est un series int), vous obtenez une erreur de compilation. C’est là que la rigueur du système de types affleure : impossible de passer une valeur qui varie d’une barre à l’autre à un paramètre qui exige une valeur fixée au démarrage.

Comment le codegen C++ représente ces types

Traduire le système de types de Pine en C++ suppose d’associer à chaque forme et à chaque type Pine une représentation C++ qui a le bon comportement à l’exécution.

Les détails qui suivent correspondent aux en-têtes du moteur v1.0.0 et au C++ que génère le codegen 1.0.0.

Les primitifs deviennent des scalaires C++ : double pour float, int ou int64_t pour int (certaines valeurs int calculées, dont bar_index et hour, sont stockées dans un double), bool pour bool, std::string pour string et int64_t pour color.

Les series sont des tampons circulaires d’historique. Voici la classe du moteur, tirée de include/pineforge/series.hpp :

template <typename T>
class Series {
public:
    void push(T value);             // a new bar
    void update(T value);           // the same bar again (bar magnifier)
    T operator[](int offset) const; // offset bars back; na if out of range
    T current() const;
};

Quand le code Pine écrit close[2], le C++ généré lit _s_close[2].

na est une sentinelle du type même de la valeur (include/pineforge/na.hpp) : na<double>() est un NaN silencieux (quiet NaN), na<int>() est le plus petit int, et na<bool>() vaut false. is_na(x) la détecte, et nz(x, y) devient un is_na(x) ? y : x en ligne.

Les UDT deviennent des handles : le struct généré contient un identifiant, les champs vivent dans des enregistrements détenus par la stratégie (pour qu’un checkpoint puisse les restaurer), et chaque méthode devient une fonction qui prend le handle, par exemple _udt_Acc_add(Acc self, double v). Écrire un champ revient à affecter le champ de l’enregistrement ; il n’y a pas de setters.

Les tableaux deviennent des std::vector<T>. Les matrices utilisent NumericMatrix, la classe du moteur bâtie sur MatrixXd d’Eigen, pour matrix<float>, et GenericMatrix<T> pour tous les autres types d’éléments, matrix<int> compris ; le code généré les nomme toujours PineMatrix et PineGenericMatrix<T>, des alias que le moteur v1.0.0 conserve.

Trois pièges

1. Une valeur qui ne change jamais n’est pas forcément const

atrLen     = 14
fastLength = input.int(22, "Fast EMA Length")
atr  = ta.atr(atrLen)
fast = ta.ema(close, fastLength)

Aucune des deux longueurs ne change pendant une exécution, mais une seule est connue à la compilation. atrLen est un const int : un littéral est const, et une variable initialisée avec un littéral hérite de ce qualificateur. fastLength est un input int : sa valeur vient des paramètres du script, au démarrage.

Le C++ généré trace la même frontière. Dans le corpus ouvert, atrLen = 14 suivi de ta.atr(atrLen) se compile en ta::ATR(14), le 14 étant écrit en dur dans le code. fastLength = input.int(22, "Fast EMA Length") se compile en get_input_int("Fast EMA Length", 22), lu au démarrage du backtest. C’est ce qui permet à une même stratégie générée de tourner avec des inputs différents : l’outil backtest_pine_grid du serveur MCP local transpile le Pine une seule fois, puis exécute le même C++ avec chaque combinaison de valeurs d’input.

2. Affecter un champ d’UDT ne déclenche aucune méthode, et c’est voulu

type Box
    float value
 
method doubled(Box this) =>
    this.value * 2
 
b = Box.new(value = 10.0)
b.value := 20.0   // direct field write, no notification

Dans un langage orienté objet, on pourrait s’attendre à ce que b.value := 20.0 passe par un setter capable d’appeler doubled() ou de déclencher n’importe quel autre comportement. En Pine, non. Les champs sont publics et directement modifiables. Les méthodes ne sont que des fonctions rattachées au type. Si vous construisez une machine à états dans un UDT et voulez une validation à l’écriture, vous devez appeler explicitement une méthode qui fait cette validation : les écritures de champ court-circuitent tout.

C’est le principal endroit où un programme Pine peut sembler encapsulé sans l’être. Le C++ généré le reflète : écrire un champ revient à affecter le champ de l’enregistrement, sans aucune méthode entre les deux.

3. request.security est causal par défaut, mais le lookahead par défaut a changé selon les versions

htf_close = request.security(syminfo.tickerid, "D", close)

Cet appel est correctement typé et compile sans avertissement. Il renvoie la clôture journalière telle qu’elle est connue à l’heure de la barre courante. Si la barre courante est une barre de 15 minutes en milieu de journée, htf_close contient la clôture de la veille jusqu’à ce que la nouvelle barre journalière se clôture : c’est l’interprétation causale.

Le piège historique : en Pine v2, security utilisait par défaut lookahead=barmerge.lookahead_on, ce qui permettait de jeter un œil à la future barre journalière avant sa clôture. Les résultats de backtest des stratégies utilisant des données HTF s’en trouvaient gonflés. Pine v3 a changé la valeur par défaut pour lookahead_off (causal), le bon comportement, et toutes les versions depuis, v6 comprise, l’ont conservée.

Le système de types ne vous en avertit pas, car les deux modes sont correctement typés. Sans argument lookahead, le codegen PineForge applique la sémantique lookahead_off, conformément à la valeur par défaut de Pine v6.

Pourquoi transpiler Pine nous a rendus plus rigoureux

Chaque ambiguïté des règles de typage de Pine doit devenir une décision dans le codegen C++. Quand la documentation de référence de Pine dit « ceci dépend de l’implémentation », ou quand deux comportements sont tous deux techniquement compatibles avec la spécification, nous ne pouvons pas en choisir un et croiser les doigts. Nous devons tester contre la sortie réelle de TradingView, comprendre quelle branche TradingView a prise, et implémenter cette branche-là.

Ce processus nous a fait lire la référence du langage Pine v6 plus attentivement qu’aucun utilisateur ne prendrait la peine de le faire. Il a aussi produit de nombreuses stratégies du corpus ouvert : quand nous trouvons un cas limite de request.security ou de strategy.exit sur lequel notre codegen diverge de TradingView, nous écrivons un reproducteur minimal, l’ajoutons au corpus, et corrigeons le codegen jusqu’à ce que les deux sorties concordent.

C’est dans le système de types que se logent les cas limites. Les qualificateurs de forme (series, simple, const) ressemblent à un détail d’implémentation mineur, mais ils déterminent quelles opérations sont légales, quelles valeurs peuvent être passées à quelles fonctions, et quelles expressions peuvent être évaluées à la compilation plutôt qu’à chaque barre. Les maîtriser, c’est ce qui sépare un transpileur d’un bon transpileur.

Pour aller plus loin