Unions discriminées (F#)

Les unions discriminées assurent la prise en charge de valeurs. Celles-ci peuvent correspondre à l'un des nombreux cas nommés, chacun d'eux pouvant avoir des valeurs et des types différents. Les unions discriminées sont utiles pour les données hétérogènes ; les données qui peuvent avoir des cas spéciaux, notamment des cas valides et cas d'erreur ; les données dont le type varie d'une instance à une autre ; et comme alternative pour les petites hiérarchies d'objets. De plus, les unions discriminées récursives sont utilisées pour représenter des structures de données d'arborescence.

type type-name =
   | case-identifier1 [of type1 [ * type2 ...]
   | case-identifier2 [of type3 [ * type4 ...]
   ...

Notes

Les unions discriminées sont semblables aux types union dans d'autres langages, mais il existe des différences. Comme avec un type union en C++ ou un type variant en Visual Basic, les données stockées dans la valeur ne sont pas fixes ; elles peuvent revêtir l'une des diverses options distinctes. Contrairement aux unions de ces autres langages, toutefois, chacune des options possibles reçoit un identificateur de cas. Les identificateurs de cas correspondent aux noms des différents types de valeurs que peuvent prendre les objets de ce type ; les valeurs sont facultatives. Si les valeurs sont absentes, le cas équivaut à un cas d'énumération. Si les valeurs sont présentes, chaque valeur peut être une valeur unique d'un type spécifié, ou un tuple qui regroupe plusieurs valeurs du même type ou de types différents.

Le type option est une union discriminée simple de la bibliothèque principale F#. Le type option est déclaré comme suit.

// The option type is a discriminated union.
type Option<'a> =
    | Some of 'a
    | None

Le code précédent spécifie que le type Option est une union discriminée qui a deux cas, Some et None. Le cas Some a une valeur associée dont le type est représenté par le paramètre de type 'a. Le cas None n'a aucune valeur associée. Donc, le type option spécifie un type générique qui a soit une valeur d'un certain type, soit aucune valeur. Le type Option a également un alias de type en minuscules, option, plus communément utilisé.

Les identificateurs de cas peuvent être utilisés comme constructeurs pour le type union discriminée. Par exemple, le code suivant est utilisé pour créer des valeurs du type option.

let myOption1 = Some(10.0)
let myOption2 = Some("string")
let myOption3 = None

Les identificateurs de cas sont également utilisés dans les expressions à critères spéciaux. Dans une expression à critères spéciaux, les identificateurs sont fournis pour les valeurs associées aux cas individuels. Par exemple, dans le code suivant, x est l'identificateur qui reçoit la valeur associée au cas Some du type option.

let printValue opt =
    match opt with
    | Some x -> printfn "%A" x
    | None -> printfn "No value."

Normalement, les identificateurs de cas peuvent être utilisés sans être qualifiés avec le nom de l'union. Si vous souhaitez que le nom soit toujours qualifié avec le nom de l'union, vous pouvez appliquer l'attribut RequireQualifiedAccess à la définition de type union.

Utilisation d'unions discriminées à la place de hiérarchies d'objets

Vous pouvez souvent utiliser une union discriminée comme alternative plus simple à une petite hiérarchie d'objets. Par exemple, l'union discriminée suivante pourrait être utilisée à la place d'une classe de base Shape qui a des types dérivés pour cercle, carré, et ainsi de suite.

type Shape =
  // The value here is the radius.
| Circle of float
  // The value here is the side length.
| EquilateralTriangle of double
  // The value here is the side length.
| Square of double
  // The values here are the height and width.
| Rectangle of double * double

Au lieu d'une méthode virtuelle pour calculer une zone ou un périmètre, que vous utiliseriez dans une implémentation orientée objet, vous pouvez utiliser les critères spéciaux pour créer une branche vers les formules appropriées pour calculer ces quantités. Dans l'exemple suivant, différentes formules sont utilisées pour calculer la zone, selon la forme.

let pi = 3.141592654

let area myShape =
    match myShape with
    | Circle radius -> pi * radius * radius
    | EquilateralTriangle s -> (sqrt 3.0) / 4.0 * s * s
    | Square s -> s * s
    | Rectangle (h, w) -> h * w

let radius = 15.0
let myCircle = Circle(radius)
printfn "Area of circle that has radius %f: %f" radius (area myCircle)

let squareSide = 10.0
let mySquare = Square(squareSide)
printfn "Area of square that has side %f: %f" squareSide (area mySquare)

let height, width = 5.0, 10.0
let myRectangle = Rectangle(height, width)
printfn "Area of rectangle that has height %f and width %f is %f" height width (area myRectangle)

La sortie est la suivante :

Area of circle that has radius 15.000000: 706.858347
Area of square that has side 10.000000: 100.000000
Area of rectangle that has height 5.000000 and width 10.000000 is 50.000000

Utilisation d'unions discriminées pour les structures de données d'arborescence

Les unions discriminées peuvent être récursives, ce qui signifie que l'union elle-même peut être incluse dans le type d'un ou de plusieurs cas. Les unions discriminées récursives peuvent être utilisées pour créer des arborescences, utilisées pour modeler des expressions dans les langages de programmation. Dans le code suivant, une union discriminée récursive est utilisée pour créer une structure de données d'arborescence binaire. L'union se compose de deux cas, Node, qui est un nœud avec une valeur entière et des sous-arborescences gauche et droite, et Tip, qui termine l'arborescence.

type Tree =
    | Tip
    | Node of int * Tree * Tree

let rec sumTree tree =
    match tree with
    | Tip -> 0
    | Node(value, left, right) ->
        value + sumTree(left) + sumTree(right)
let myTree = Node(0, Node(1, Node(2, Tip, Tip), Node(3, Tip, Tip)), Node(4, Tip, Tip))
let resultSumTree = sumTree myTree

Dans le code précédent, resultSumTree a la valeur 10. L'illustration suivante montre l'arborescence pour myTree.

Arborescence pour myTree

Les unions discriminées fonctionnent bien si les nœuds de l'arborescence sont hétérogènes. Dans le code suivant, le type Expression représente l'arborescence de syntaxe abstraite d'une expression dans un langage de programmation simple qui prend en charge l'addition et la multiplication de nombres et de variables. Certains des cas d'union ne sont pas récursifs et représentent des nombres (Number) ou des variables (Variable). D'autres cas sont récursifs et représentent des opérations (Add et Multiply), où les opérandes sont également des expressions. La fonction Evaluate utilise une expression de correspondance pour traiter l'arborescence de syntaxe de manière récursive.

type Expression = 
    | Number of int
    | Add of Expression * Expression
    | Multiply of Expression * Expression
    | Variable of string

let rec Evaluate (env:Map<string,int>) exp = 
    match exp with
    | Number n -> n
    | Add (x, y) -> Evaluate env x + Evaluate env y
    | Multiply (x, y) -> Evaluate env x * Evaluate env y
    | Variable id    -> env.[id]

let environment = Map.ofList [ "a", 1 ;
                               "b", 2 ;
                               "c", 3 ]

// Create an expression tree that represents
// the expression: a + 2 * b.
let expressionTree1 = Add(Variable "a", Multiply(Number 2, Variable "b"))

// Evaluate the expression a + 2 * b, given the
// table of values for the variables.
let result = Evaluate environment expressionTree1

Lorsque ce code est exécuté, la valeur de result est 5.

Voir aussi

Autres ressources

Référence du langage F#

Historique des modifications