Amis, nous continuons à comprendre la programmation fonctionnelle. Dans la deuxième partie de cette série d'articles, vous vous familiariserez avec les principes de base de ce paradigme de développement et comprendrez comment cette approche diffère de la programmation orientée objet ou impérative.
Valeurs et fonctions
Encore une fois, considérez cette fonction simple.
let add1 x = x + 1
Que signifie x ici:
- Prenez une certaine valeur du domaine (portée).
- Utilisez le nom «
x » pour fournir cette valeur afin qu'elle soit accessible ultérieurement.
L'utilisation d'un nom pour représenter une valeur est appelée liaison. Le nom « x » est «lié» à la valeur d'entrée.
Ainsi, si vous calculez une fonction avec une valeur d'entrée de, disons, 5, les événements suivants se produiront: où que « x » se trouve dans la définition d'origine, la valeur 5 est définie, similaire à la fonction «rechercher et remplacer» dans un éditeur de texte.
let add1 x = x + 1 add1 5 // «x» with «5» // add1 5 = 5 + 1 = 6 // 6
Il est important de comprendre qu'il ne s'agit pas d'une mission. « x » n'est pas un «slot» et n'est pas une variable avec une valeur assignée qui peut être modifiée ultérieurement. Il s'agit d'une association unique du nom " x " avec une certaine valeur. Cette valeur est l'un des entiers prédéfinis; elle ne peut pas être modifiée. C'est-à-dire une fois lié x ne peut pas être changé . L'étiquette une fois associée à la valeur est toujours associée à cette valeur.
Ce principe est un élément essentiel de la pensée fonctionnelle: il n'y a pas de "variables", seulement des valeurs .
Fonctions comme valeurs
Si vous y réfléchissez un peu plus longtemps, vous pouvez voir que le nom « add1 » en lui-même n'est qu'une liaison à «une fonction qui augmente l'entrée d'une add1 ». La fonction elle-même est indépendante du nom qui lui est attaché.
En introduisant let add1 x = x + 1 , nous disons au compilateur F # "chaque fois que vous voyez le nom" add1 ", remplacez-le par une fonction qui ajoute 1 à l'entrée." « add1 » est appelé une valeur de fonction .
Pour voir que la fonction ne dépend pas de son nom, il suffit d'exécuter le code suivant:
let add1 x = x + 1 let plus1 = add1 add1 5 plus1 5
Comme vous pouvez le voir, « add » et « plus » sont deux noms liés à la même fonction.
Vous pouvez toujours identifier une fonction de valeur par sa signature, qui a le domain -> range formulaire standard domain -> range . La signature généralisée de la fonction valeur:
val functionName : domain -> range
Valeurs simples
Imaginez une opération qui ne prend rien et renvoie toujours 5.
Ce serait une opération «constante».
Comment cela pourrait-il être décrit en F #? Nous voulons dire au compilateur: "chaque fois que vous voyez le nom c , remplacez-le par 5". Comme ça:
let c = 5
Lors du calcul reviendra:
val c : int = 5
Cette fois, il n'y a pas de flèche correspondante, juste un int. Du nouveau - un signe égal avec la valeur réelle déduite après cela. Le compilateur F # sait que cette liaison a une valeur connue, qui sera toujours renvoyée, à savoir le nombre 5.
En d'autres termes, nous venons de définir une constante, ou, en termes de F #, une valeur simple.
Vous pouvez toujours distinguer une valeur simple d'une fonction de valeur, car toutes les valeurs simples ont une signature similaire:
val aName: type = constant // -
Valeurs simples vs valeurs de fonction | Signification simple vs fonctions de valeur
Il est important de comprendre qu'en F #, contrairement à d'autres langages tels que C #, il y a très peu de différence entre les valeurs simples et les fonctions de valeur. Les deux types sont des valeurs qui peuvent être associées à des noms (à l'aide du mot clé let ), après quoi elles peuvent être transmises partout. En fait, nous verrons bientôt que l'idée que les fonctions sont des valeurs qui peuvent être transmises en entrée à d'autres fonctions est l'un des aspects clés de la pensée fonctionnelle.
Notez qu'il existe une légère différence entre une valeur simple et une fonction de valeur. Une fonction a toujours un domaine et une plage et doit être "appliquée" à l'argument pour renvoyer le résultat. Une valeur simple n'a pas besoin d'être calculée après la liaison. En utilisant l'exemple ci-dessus, si nous voulons définir une «fonction constante» qui renvoie 5, nous pourrions utiliser:
let c = fun()->5 // or let c() = 5
La signature de ces fonctions ressemble à ceci:
val c : unit -> int
Pas comme ça:
val c : int = 5
Plus d'informations sur l' unit , la syntaxe des fonctions et les fonctions anonymes seront fournies ultérieurement.
«Valeurs» vs "Objets"
Dans les langages de programmation fonctionnels, tels que F #, la plupart des choses sont appelées «valeurs». Dans les langages orientés objet, tels que C #, la plupart des choses sont appelées «objets». Quelle est la différence entre «sens» et «objet»?
La valeur, comme nous l'avons vu ci-dessus, est membre du domaine. Le domaine des entiers, le domaine des chaînes, le domaine des fonctions qui mappent les entiers aux chaînes, etc. En principe, les valeurs sont immuables (non mutables). Et les significations n'ont pas le comportement qui leur est attaché.
Les objets de la définition canonique sont l'encapsulation de la structure de données avec le comportement associé (méthodes). En général, les objets doivent avoir un état (c'est-à-dire être mutables), et toutes les opérations qui changent l'état interne doivent être fournies par l'objet lui-même (via une notation "point").
En F #, même les valeurs primitives ont un certain comportement «objet». Par exemple, vous pouvez obtenir la longueur d'une chaîne via un point:
«abc».Length
Mais en général, nous éviterons le terme «objet» pour les valeurs standard en F #, en l'enregistrant pour faire référence à des classes à part entière ou à d'autres valeurs fournissant des méthodes.
Nommer des valeurs
Les conventions de dénomination standard utilisées pour les noms de valeur et de fonction sont essentiellement des caractères de soulignement alphanumériques +. Mais il y a quelques ajouts:
- Vous pouvez ajouter une apostrophe dans n'importe quelle partie du nom, à l'exception du premier caractère.
A'b'c begin' //
- Ce dernier cas est souvent utilisé comme étiquette pour les versions "différentes" d'une valeur:
let f = x let f' = derivative f let f'' = derivative f'
ou pour des variables du même nom avec des mots clés existants
let if' btf = if b then t else f
Vous pouvez également utiliser des doubles backticks pour n'importe quelle chaîne pour en faire un identifiant valide.
``this is a name`` ``123`` //
Cas où vous devrez peut-être utiliser une astuce de double backtick:
- Lorsque vous devez utiliser un identifiant correspondant au mot clé.
let ``begin`` = «begin»
- Lorsque vous devez utiliser des langages naturels pour les règles métier, les tests unitaires ou la documentation exécutable de style BBD telle que Cucumber.
let ``is first time customer?`` = true let ``add gift to order`` = () if ``is first time customer?`` then ``add gift to order`` // - let [<Test>] ``When input is 2 then expect square is 4``= // code here // BDD clause let [<Given>] ``I have (.*) N products in my cart`` (n:int) = // code here
Contrairement à C #, la convention de dénomination F # exige que les fonctions et les valeurs commencent par une lettre minuscule, et non par une lettre majuscule ( camelCase , pas PascalCase ), sauf si elles sont conçues pour interagir avec d'autres langages .NET. Cependant, les types et les modules utilisent des majuscules (au début).
Ressources supplémentaires
Il existe de nombreux didacticiels pour F #, y compris des documents pour ceux qui viennent avec une expérience C # ou Java. Les liens suivants peuvent être utiles pour approfondir F #:
Plusieurs autres façons de commencer à apprendre le F # sont également décrites.
Enfin, la communauté F # est très conviviale pour les débutants. Il y a un chat très actif chez Slack, soutenu par la F # Software Foundation, avec des salles pour débutants que vous pouvez rejoindre librement . Nous vous recommandons fortement de le faire!
N'oubliez pas de visiter le site de la communauté russophone F # ! Si vous avez des questions sur l'apprentissage d'une langue, nous serons heureux d'en discuter dans les salles de chat:
À propos des auteurs de traduction
Traduit par @kleidemos
La traduction et les modifications éditoriales ont été apportées par les efforts de la communauté russophone des développeurs F # . Nous remercions également @schvepsss et @shwars d' avoir préparé cet article pour publication.