Qu'est ce qu'un remplacement fonctionnel pour if-then?

Un point important qui n'a pas été mentionné jusqu'à présent est la différence entre if .. then .. else et if .. then sans else branche.

If dans les langages fonctionnels

L'interprétation fonctionnelle de if est que c'est une expression qui renvoie une valeur. Pour évaluer la valeur de if c then e1 else e2 vous d'évaluer l'état de c et ensuite évaluer e1 ou e2, en fonction de l'état. Cela vous donne le résultat de la if .. then .. else.

Si vous avez juste if c then e, alors vous ne savez pas quel sera le résultat de l'évaluation doit être si c est false, car il n'est pas else branche! La suite n'a clairement aucun sens:

let num = if input > 0 then 10

En F#, des expressions qui ont des effets secondaires comme printf "hi" retourner une valeur spéciale de type unit. Le type n'a qu'une seule valeur (écrit que ()) et vous pouvez donc écrire if qui fait un effet dans un seul cas:

let u = if input > 0 then printf "hi" else ()

Cette évalue toujours à unit, mais dans le true branche, il exerce également des effets secondaires. Dans le false branche, elle retourne un unit valeur. En F#, vous n'avez pas à écrire le else () peu par la main, mais sur le plan conceptuel, il est toujours là. Vous pouvez écrire:

let u = if input > 0 then printfn "hi"

Concernant votre exemple supplémentaire

Le code ressemble parfaitement bien pour moi. Lorsque vous avez à traiter avec l'API qui est impératif (comme beaucoup de la .Bibliothèques NET), alors la meilleure option est d'utiliser l'impératif fonctionnalités comme if avec un unit-le retour de la branche.

Vous pouvez utiliser différents réglages, à l'instar de représenter vos données à l'aide de option<string> (au lieu de simplement string avec null ou une chaîne vide). De cette façon, vous pouvez utiliser None pour représenter des données manquantes et de toute autre chose serait d'entrée valide. Ensuite, vous pouvez utiliser certaines fonctions d'ordre supérieur pour le travail avec des options, telles que Option.iter, qui appelle une fonction donnée s'il existe une valeur:

maybeData |> Option.iter (fun data ->
    let byteData = System.Text.Encoding.Unicode.GetBytes(data)  
    req.ContentLength <- int64 byteData.Length  
    use postStream = req.GetRequestStream()  
    postStream.Write(byteData, 0, byteData.Length) )

Ce n'est pas vraiment moins impératif, mais il est plus déclaratif, parce que vous n'avez pas à écrire le if vous-même. BTW: je recommande également à l'aide de use si vous voulez Dispose objet auotmatically.

Ce n'est pas le cas-expression qui est impératif, c'est ce qui se passe dans le si-expression. Par exemple, let abs num = if num < 0 then -num else num est totalement fonctionnelle à écrire la fonction abs. Elle prend un argument et retourne une transformation de cet argument, sans effets secondaires. Mais quand vous avez de code", qui ne fait qu'une chose, de ne pas renvoyer une valeur," puis vous écrivez quelque chose qui n'est pas purement fonctionnelle. L'objectif de la programmation fonctionnelle est de réduire la part du programme qui peut être décrit de cette façon. La façon dont vous écrivez votre conditionnelles est tangentielle.

Il est considéré comme fonctionnel si votre if déclaration a une valeur de retour et n'a pas d'effets secondaires.

Supposons que vous vouliez écrire l'équivalent de:

if(x > 3) n = 3; else n = x;

Au lieu de cela, vous utilisez l'instruction de retour de la commande if:

let n = (if x > 3 then 3 else x)

Cette hypothétique if est soudainement fonctionnel car il n'a pas d'effets secondaires; il ne renvoie une valeur. Pensez à elle comme si c'était la opérateur ternaire dans certaines langues: int n = x>3?3:x;

Mes excuses pour ne pas connaître de F#, mais ici, c'est une solution possible en javascript:

function $if(param) {
return new Condition(param)
}
function Condition(IF, THEN, ELSE) {
this.call = function(seq) {
if(this.lastCond != undefined) 
return this.lastCond.call(
sequence(
this.if, 
this.then, 
this.else, 
(this.elsif ? this.elsif.if : undefined),
seq || undefined
)
);
else 
return sequence(
this.if, 
this.then, 
this.else, 
(this.elsif ? this.elsif.if : undefined),
seq || undefined
)
}
this.if   = IF ? IF : f => { this.if = f; return this };
this.then = THEN ? THEN : f => { this.then = f; return this };
this.else = ELSE ? ELSE : f => { this.else = f; return this };
this.elsif = f => {this.elsif = $if(f); this.elsif.lastCond = this; return this.elsif};
}
function sequence(IF, THEN, ELSE, ELSIF, FINALLY) {
return function(val) {
if( IF(val) ) 
return THEN();
else if( ELSIF && ELSIF(val) ) 
return FINALLY(val);
else if( ELSE ) 
return ELSE();
else 
return undefined
}
}}

L' $si la fonction retourne un objet avec le if..then..else..elsif construire, à l'aide de la Condition constructeur.
Une fois que vous appelez Condition.elsif() vous allez créer un autre État de l'objet - essentiellement la création d'une liste, qui peut être parcouru de manière récursive à l'aide de séquences()

Vous pouvez l'utiliser comme:

var eq = val => x => x == val ? true : false;
$if( eq(128) ).then( doStuff ).else( doStuff )
.elsif( eq(255) ).then( doStuff ).else( doStuff ).call();

Cependant, je me rends compte que l'utilisation d'un objet n'est pas une approche purement fonctionnelle. Alors, dans ce cas, vous pouvez renoncer à l'objet, tous ensemble:

sequence(f, f, f, f,
sequence(f, f, f, f
sequence(f, f, f)
)
);

Vous pouvez voir que la magie est vraiment dans la séquence() fonction.
Je ne vais pas essayer de répondre à votre question spécifique en javascript. Mais je pense que le point principal est que vous devriez faire une fonction qui va exécuter des fonctions en vertu d'un si..alors l'instruction, puis nid multiples de cette fonction en utilisant la récursivité pour créer un complexe de chaîne logique. Au moins de cette façon vous n'aurez pas à répéter vous-même 😉

Ce code est juste un prototype, donc prenez-le comme une preuve de concept et laissez-moi savoir si vous trouvez des bugs.