Types, valeurs et opérations

Types de base

Les types et valeurs suivants sont intégrés à Catala, s’appuyant sur des mots-clés du langage.

Booléens

Le type booléen n’a que deux valeurs, vrai et faux.

Opérations booléennes

Comparaisons

Opérations sur les entiers

Le type entier représente les entiers mathématiques, comme 564 614 ou -2. Notez que vous pouvez optionnellement utiliser le séparateur de nombres (espace) pour rendre les grands entiers plus lisibles.

Voir aussi le module Entier de la bibliothèque standard pour plus d’opérations.

Décimaux

Le type décimal représente les nombres décimaux mathématiques (ou rationnels), comme 0,21 ou -988 453,6842541. Notez que vous pouvez optionnellement utiliser le séparateur de nombres (espace) pour rendre les grands décimaux plus lisibles. Les nombres décimaux sont stockés avec une précision infinie en Catala, mais vous pouvez les arrondir à volonté.

Opérations sur les décimaux

Voir aussi le module Décimal de la bibliothèque standard pour plus d’opérations.

Argent

Le type argent représente un montant d’argent, positif ou négatif, dans une unité monétaire (dans la version française de Catala, le symbole monétaire € est utilisé), avec une précision au centime et pas en dessous. Les valeurs monétaires sont notées comme des valeurs décimales avec au maximum deux chiffres fractionnaires et le symbole monétaire, comme 12,36 € ou -871 84,1 €.

Opérations sur l’argent

Voir aussi le module Argent de la bibliothèque standard pour plus d’opérations.

Dates

Le type date représente des dates dans le calendrier grégorien. Ce type ne peut pas représenter de dates invalides comme 2025-02-31. Les valeurs de ce type sont notées suivant la notation ISO8601 (AAAA-MM-JJ) entourée de barres verticales, comme |1930-09-11| ou |2012-02-03|.

Sémantique de l’addition de dates

L’addition de dates en Catala consiste à ajouter une durée à une date, donnant une nouvelle date dans le passé ou dans le futur selon que la durée est négative ou positive. La valeur de cette nouvelle date dépend du contenu de la durée :

• si la durée est un nombre de jours, alors Catala ajoutera ou soustraira simplement ce nombre de jours au jour de la date originale, en passant aux mois précédents ou suivants si nécessaire ;
• si la durée est un nombre d’années (disons, x), alors Catala se comportera comme si la durée était de 12 * x mois ;
• si la durée est un nombre de mois, Catala ajoutera ou soustraira simplement ce nombre de mois au mois de la date originale, en passant à l’année précédente ou suivante si nécessaire ; mais cette opération pourrait donner une date invalide (comme 31 janv. + 1 mois -> 31 fév.), qui doit être arrondie.

Il existe trois modes d’arrondi en Catala, dont la description est ci-dessous :

Par défaut, Catala est en mode “Pas d’arrondi”. Pour définir le mode d’arrondi vers le haut ou vers le bas, pour toutes les opérations de date à l’intérieur d’un champ d’application entier, voir la section de référence pertinente.

Enfin, si la durée à ajouter est composée de plusieurs unités (comme 2 mois + 21 jour), alors Catala commencera par ajouter la composante avec la plus grande unité (ici, mois), puis la composante avec la plus petite unité (ici, jour).

Opérations sur les dates

Voir aussi le module Date de la bibliothèque standard pour plus d’opérations.

Durées

Le type durée représente des durées en termes de jours, mois et/ou années, comme 254 jour, 4 mois ou 1 an. Les durées peuvent être négatives et combiner un nombre de jours et de mois ensemble, comme 1 mois + 15 jour.

Opérations sur les durées

Conversion des types numériques de base

La conversion entre les types de base est explicite ; la syntaxe est <nom du type désiré> de <argument>.

Types déclarés par l’utilisateur

Les types déclarés par l’utilisateur doivent être déclarés avant d’être utilisés dans le reste du programme. Cependant, la déclaration n’a pas besoin d’être placée avant l’utilisation dans l’ordre textuel.

Structures

Les structures combinent plusieurs éléments de données ensemble dans un seul type. Chaque élément de données est un “champ” de la structure. Si vous avez une structure, vous pouvez accéder à chacun de ses champs, mais vous avez besoin de tous les champs pour construire la valeur de la structure.

Les types de structure sont déclarés par l’utilisateur, et chaque type de structure a un nom choisi par l’utilisateur. Les noms de structure commencent par une majuscule et doivent suivre la convention de nommage CamelCase. Un exemple de déclaration de structure est :

déclaration structure Individu:
  donnée date_naissance contenu date
  donnée revenu contenu argent
  donnée nombre_enfants contenu entier

Le type de chaque champ de la structure est obligatoire et introduit par contenu. Il est possible d’imbriquer des structures (déclarer le type d’un champ d’une structure comme une autre structure ou énumération), mais pas récursivement.

Les valeurs de structure sont construites avec la syntaxe suivante :

Individu {
  -- date_naissance: |1930-09-11|
  -- revenu: 100 000 €
  -- nombre_enfants: 2
}

Pour accéder au champ d’une structure, utilisez simplement la syntaxe <valeur struct>.<nom champ>, comme individu.revenu.

Énumérations

Les énumérations représentent une alternative entre différents choix, chacun encapsulant un modèle spécifique de données. En ce sens, les énumérations sont des “types somme” à part entière comme dans les langages de programmation fonctionnelle, et plus puissantes que les énumérations de type C qui listent juste des codes alternatifs qu’une valeur peut avoir. Chaque choix ou alternative de l’énumération est appelé un “cas” ou une “variante”.

Les types d’énumération sont déclarés par l’utilisateur, et chaque type d’énumération a un nom choisi par l’utilisateur. Les noms d’énumération commencent par une majuscule et doivent suivre la convention de nommage CamelCase. Un exemple de déclaration d’énumération est :

déclaration énumération PasDeCreditImpot:
  -- PasDeCreditImpot
  -- CreditImpotPourIndividu contenu Individu
  -- CreditImpotApresDate contenu date

Le type de chaque cas de l’énumération est obligatoire et introduit par contenu. Il est possible d’imbriquer des énumérations (déclarer le type d’un champ d’une énumération comme une autre énumération ou structure), mais pas récursivement.

Les valeurs d’énumération sont construites avec la syntaxe suivante :

# Premier cas
PasDeCreditImpot,
# Deuxième cas
CreditImpotPourIndividu contenu Individu {
    -- date_naissance: |1930-09-11|
    -- revenu: 100 000 €
    -- nombre_enfants: 2
},
# Troisième cas
CreditImpotApresDate contenu |2000-01-01|

Pour inspecter les valeurs d’énumération, voir dans quel cas vous êtes et utiliser les données associées, utilisez le filtrage par motif.

Listes

Le type liste de <autre type> représente un tableau de taille fixe d’un autre type. Par exemple, liste de entier représente un tableau de taille fixe d’entiers.

Vous pouvez construire des valeurs de liste en utilisant la syntaxe suivante :

[1; 6; -4; 846645; 0]

Opérations sur les listes

transforme chaque (x, y) parmi (lst1, lst2) en x + y

N-uplets

Le type (<type 1>, <type 2>) représente une paire d’éléments, le premier étant de type 1, le second étant type 2. Il est possible d’étendre le type paire en un type triplet, ou même un n-uplet pour un nombre arbitraire n en répétant les éléments après ,.

Vous pouvez construire des valeurs de n-uplet avec la syntaxe suivante :

(|2024-04-01|, 30 €, 1%) # Cette valeur a le type (date, argent, décimal)

Vous pouvez accéder au n-ième élément d’un n-uplet, commençant à 1, avec la syntaxe <n-uplet>.n.

Valeurs optionnelles

Le type optionnel de <type> peut être utilisé pour contenir une valeur de <type> qui pourrait être absente. Par exemple, optionnel de entier est équivalent à l’énumération :

déclaration énumération EntierOptionnel:
  -- Absent
  -- Présent contenu entier

Mais l’avantage de optionnel de entier par rapport à un tel EntierOptionnel est qu’il n’a pas besoin d’être déclaré pour chaque type avec lequel il est utilisé. Comme une énumération, les valeurs de type optionnel peuvent être créées en utilisant Présent contenu <expr>, et utilisées dans les formes selon <expr> sous forme et <expr> sous forme <constr>, par ex.

si foo sous forme Présent de bar et bar > 3 alors ...

Fonctions

Les types de fonction représentent des valeurs de fonction, c’est-à-dire des valeurs qui nécessitent d’être appelées avec des arguments pour produire un résultat. Les fonctions sont des valeurs de première classe car Catala est un langage de programmation fonctionnelle.

La syntaxe générale pour décrire un type de fonction est :

<type du résultat> dépend de
  <nom de l'argument 1> contenu <type de l'argument 1>,
  <nom de l'argument 2> contenu <type de l'argument 2>,
  ...

Par exemple, argent dépend de revenu contenu argent, nombre_enfants contenu entier peut être le type d’une fonction de calcul d’impôt.

Cependant, contrairement à la plupart des langages de programmation, il n’est pas possible de construire directement une fonction comme une valeur ; les fonctions sont créées et passées avec d’autres mécanismes du langage.

Fonctions polymorphes

Une fonctionnalité clé d’un langage de programmation est sa capacité à éviter la duplication de code ; le programmeur devrait réutiliser autant de code que possible à travers des abstractions, telles que des fonctions et des modules. De plus, une fonctionnalité standard du génie logiciel moderne est le polymorphisme, c’est-à-dire écrire des morceaux de code qui peuvent opérer sur plusieurs types de valeurs à la fois, évitant au programmeur la nécessité de dupliquer le même code plusieurs fois selon le type des arguments.

Concrètement, lors de la définition d’une fonction en Catala, vous pouvez donner le type n'importe quel à un argument ou au type de retour. Cela signifie que lorsque vous appelez la fonction, vous pouvez l’appeler avec un argument qui a n’importe lequel des types possibles. Nous pouvons appeler un tel argument “générique”, ou dire qu’il a un type “joker”. Par exemple, il est pratique de pouvoir écrire la fonction est_vide une fois pour des listes d’ éléments de n’importe quel type :

déclaration est_vide contenu booléen
  dépend de argument contenu liste de n'importe quel
  égal à (nombre de argument = 0)

Bien que les arguments génériques soient puissants, ils ont aussi l’inconvénient que vous ne pouvez pas vraiment “faire” grand-chose avec une valeur qui a le type n'importe quel puisque vous ne savez pas quel type elle a. En particulier, il est impossible d’utiliser les opérateurs comme +, *, -, /, <=, etc. puisque ces opérateurs ne fonctionnent que pour les types de base (entier, décimal, etc.) et pas tous les autres types qui peuvent être définis par l’utilisateur (structures, énumérations, etc.).

Parfois, il y a plusieurs arguments génériques ou types de retour dans la même fonction mais vous voulez qu’ils partagent le même type générique. Par exemple, si une fonction inverse les éléments d’une liste, le type des éléments de la liste sera le même à l’entrée et à la sortie de la fonction. Les types n'importe quel peuvent être nommés à cette fin, en utilisant n'importe quel de type <nom>. Par exemple :

déclaration inverser contenu liste de n'importe quel de type type_element
  dépend de argument contenu liste de n'importe quel de type type_element

Si vous ne nommez pas le type n'importe quel explicitement, il sera supposé que chaque n'importe quel est un n'importe quel frais et indépendant des autres n'importe quel. Cela peut conduire à des messages d’erreur complexes du compilateur, alors rappelez-vous de donner le même nom aux types n'importe quel que vous savez devoir être liés ensemble.

Les signatures de fonctions polymorphes peuvent être vraiment utiles lors de la définition d’interfaces pour des modules implémentés en externe.