Expressions de calcul (F#)

En F#, les expressions de calcul fournissent une syntaxe pratique pour l'écriture de calculs qui peuvent être séquencés et combinés à l'aide de liaisons et de constructions de flux de contrôle. Elles peuvent être utilisées pour fournir une syntaxe pratique pour les monades, qui sont une fonctionnalité de programmation fonctionnelle pouvant être utilisée pour gérer des données, le contrôle et les effets secondaires dans les programmes fonctionnels.

Workflows intégrés

Les expressions de séquence sont un exemple d'expression de calcul, au même titre que les flux de travail asynchrones. Pour plus d'informations sur les expressions de séquence, consultez Séquences. Pour plus d'informations sur les flux de travail asynchrones, consultez Flux de travail asynchrones.

Certaines fonctionnalités sont communes aux expressions de séquence et aux flux de travail asynchrones, et illustrent la syntaxe de base d'une expression de calcul :

builder-name { expression }

La syntaxe précédente spécifie que l'expression donnée est une expression de calcul d'un type spécifié par builder-name. L'expression de calcul peut être un flux de travail intégré, tel que seq ou async, ou peut être quelque chose que vous définissez. builder-name est l'identificateur pour une instance d'un type spécial appelé type de générateur. Le type de générateur est un type de classe qui définit des méthodes spéciales qui régissent la façon dont les fragments de l'expression de calcul sont combinés (autrement dit, le code qui contrôle le mode d'exécution de l'expression). Une autre façon de décrire une classe de générateur consiste à dire qu'elle vous permet de personnaliser l'opération de nombreuses constructions F#, telles que les boucles et les liaisons.

Dans les expressions de calcul, deux formulaires sont disponibles pour quelques constructions de langage courantes. Vous pouvez appeler les constructions de type variant en utilisant un « ! » (bang) sur certains mots clés, tels que let!, do!, etc. Ces formulaires spéciaux forcent certaines fonctions définies dans la classe de générateur à remplacer le comportement intégré ordinaire de ces opérations. Ces formes ressemblent à la forme yield! du mot clé yield utilisé dans les expressions de séquence. Pour plus d'informations, consultez Séquences.

Création d'un type d'expression de calcul

Vous pouvez définir les caractéristiques de vos propres expressions de calcul en créant une classe de générateur et en définissant certaines méthodes spéciales sur la classe. La classe de générateur peut éventuellement définir les méthodes, comme indiqué dans le tableau suivant.

Le tableau suivant décrit les méthodes qui peuvent être utilisées dans une classe de générateur de workflow.

Beaucoup de méthodes d'une classe de générateur de flux de travail utilisent et retournent toutes une construction M<'T>, qui doit en général être un type défini séparément qui caractérise le genre des calculs combinés, par exemple, Async<'T> pour les flux de travail asynchrones et Seq<'T> pour les flux de travail de séquence. Les signatures de ces méthodes leur permettent d'être combinées et imbriquées les unes dans les autres, afin que l'objet de flux de travail retourné d'une construction puisse être passé à la suivante. Lorsque le compilateur analyse une expression de calcul, il convertit l'expression en une série d'appels de fonction imbriqués à l'aide des méthodes du tableau précédent et du code de l'expression de calcul.

L'expression imbriquée a la forme suivante :

builder.Run(builder.Delay(fun () -> {| cexpr |}))

Dans le code ci-dessus, les appels à Run et Delay sont omis s'ils ne sont pas définis dans la classe de générateur d'expressions de calcul. Le corps de l'expression de calcul, désigné ici par {| cexpr |}, est traduit en appels concernant les méthodes de la classe de générateur par les traductions décrites dans le tableau suivant. L'expression de calcul {| cexpr |} est définie de manière récursive selon ces traductions où expr est une expression F# et cexpr est une expression de calcul.

Dans le tableau précédent, other-expr décrit une expression qui n'est pas autrement répertoriée dans le tableau. Une classe de générateur n'a pas besoin d'implémenter toutes les méthodes et de prendre en charge toutes les traductions répertoriées dans le tableau précédent. Ces constructions qui ne sont pas implémentées ne sont pas disponibles dans les expressions de calcul de ce type. Par exemple, si vous ne souhaitez pas prendre en charge le mot clé use dans vos expressions de calcul, vous pouvez omettre la définition de Use dans votre classe de générateur.

L'exemple de code suivant illustre la création et l'utilisation d'un type d'expression de calcul simple qui génère une sortie de console qui suit la progression de l'exécution du code.

// Program.fs
open Module1

// Create the computation expression object.
let trace1 = trace {
   // A normal let expression (does not call Bind).
   let x = 1
   // A let expression that uses the Bind method.
   let! y = 2
   let sum = x + y
   // return executes the Return method.
   return sum  
   }

// Execute the code. Start with the Delay method.
let result = trace1()

Le code suivant implémente la classe de générateur pour l'expression de calcul de trace.

// Module1.fs
module Module1 =

 // Functions that implement the builder methods.
 let bind value1 function1 = 
     printfn "Binding %A." value1 
     function1 value1

 let result value1 =
     printfn "Returning result: %A" value1
     fun () -> value1

 let delay function1 =
     fun () -> function1()

 // The builder class for the "trace" workflow.
 type TraceBuilder() =
     member x.Bind(value1, function1) = 
         bind value1 function1
     member x.Return(value1)  = result value1
     member x.Delay(function1)   = 
         printfn "Starting traced execution."
         delay function1

 let trace = new TraceBuilder()

La sortie de cet exemple est la suivante.

Starting traced execution.
Binding 2.
Returning result: 3

Voir aussi

Autres ressources

Référence du langage F#

Historique des modifications