Une fonction est-elle immédiatement impure si elle prend une fonction en paramètre?

Étant donné que la pureté d'un paramètre d'entrée est inconnue jusqu'à l'exécution, une fonction est-elle immédiatement considérée comme impure si elle prend une fonction comme paramètre d'entrée?

Connexes: si une fonction applique une fonction pure qui est définie en dehors de la fonction, mais qui n'est pas transmise en tant que paramètre, est-elle toujours pure si elle remplit les critères de l'absence d'effets secondaires et la sortie dépend uniquement de l'entrée?

Pour le contexte, j'écris du code fonctionnel en JavaScript.

Tant que toutes les valeurs utilisées dans la fonction sont définies uniquement par ses paramètres, c'est une fonction pure.

La facette que la sortie est la même à chaque fois pour la même entrée est contrôlée par la pureté des paramètres. Si vous supposez que les paramètres (comme un argument de fonction) sont également purs, alors c'est pur.

Dans un langage comme Javascript où la pureté n'est pas appliquée, cela signifie qu'il est possible de faire en sorte qu'une fonction par ailleurs pure ait un comportement impur en invoquant une fonction impure passée en paramètre.

Cela signifie effectivement que pour les langages qui n'imposent pas la pureté (c'est-à-dire presque tous), il est impossible de définir une fonction pure qui invoque des fonctions passées en arguments. Il est toujours utile de les écrire aussi pur que possible et de les raisonner en tant que fonctions pures, mais vous devez faire preuve de prudence car l'hypothèse selon laquelle elle est pure sera brisée si vous passez les mauvais arguments.

D'après mon expérience dans la pratique, ce n'est généralement pas un gros problème - je trouve rare que des fonctions impures soient utilisées comme arguments de fonction pour des fonctions pures.

Étant donné que la pureté d'un paramètre d'entrée est inconnue jusqu'à l'exécution, une fonction est-elle immédiatement considérée comme impure si elle prend une fonction comme paramètre d'entrée?

Non. Contre-exemple:

function pure(other_function) {
    return 1;
}

Peu importe qu'il s'agisse d' other_functionune fonction pure, d'une fonction impure ou pas du tout. La purefonction est pure.

Autre contre-exemple:

function identity(x) {
    return x;
}

Cette fonction est pure, même si elle xest impure. identity(impure_function)sera toujours de retour impure_function, peu importe combien de fois vous répétez l'appel. Peu importe que cela identity(impure_function)()renvoie toujours la même chose; La valeur de retour d'une valeur de retour d' une fonction n'affecte pas sa pureté.

En général, si une fonction peut appeler une fonction, elle a été passée en argument, elle n'est pas pure. Par exemple, une fonction function call(f) {f();}n'est pas pure, car même si elle ne fait mention d'aucun état global ou mutable, cela fpourrait alertprovoquer des effets secondaires visibles.

Si une fonction prend des fonctions comme arguments, mais qu'elle ne les appelle pas ou ne les fait pas appeler, elle peut être pure. Il pourrait encore être impur s'il fait une autre chose impure. Par exemple, function f(ignored_function) {alert('This isn't pure.');}est impur, même s'il n'appelle jamais ignored_function.

Étant donné que la pureté d'un paramètre d'entrée est inconnue jusqu'à l'exécution, une fonction est-elle immédiatement considérée comme impure si elle prend une fonction comme paramètre d'entrée?

Techniquement, oui, sauf s'il existe un moyen dans votre langue de garantir que la fonction d'entrée est également pure.

si une fonction applique une fonction pure qui est définie en dehors de la fonction, mais qui n'est pas transmise en tant que paramètre, est-elle toujours pure si elle remplit les critères de l'absence d'effets secondaires et la sortie dépend uniquement de l'entrée?

Oui. Concentrons-nous donc sur ce qui compte ici. Appeler une fonction pure ou non n'est pas en soi utile. Les fonctions pures sont utiles car produire la même sortie pour n'importe quelle entrée et ne pas dépendre de l'état ou avoir des effets secondaires est un ensemble de propriétés très utile. Cela signifie qu'une fois que votre fonction a été exécutée, vous pouvez vous «souvenir» de la réponse pour cette entrée et ce sera toujours vrai. Vous n'avez pas non plus besoin d'exécuter à nouveau la fonction pour générer des effets secondaires. Et vous pouvez exécuter cette fonction en parallèle (ou dans le désordre) avec d'autres fonctions et savoir qu'elles n'auront pas d'interactions cachées qui se comportent mal.

Ces propriétés utiles restent valables si la fonction utilise d'autres fonctions en lecture seule pour effectuer son travail, quelle que soit la façon dont elle les référence.

Comme Telastyn l'a dit: Techniquement, oui, à moins qu'il n'y ait un moyen dans votre langue de garantir que la fonction d'entrée est également pure.

Ce n'est pas hypothétique, il existe en effet de bons moyens de garantir cela. Au moins dans une langue fortement typée.

Une telle fonction ~ pure que vous écririez en JavaScript

function foo(f) {
   return f(1) + 2;
}

peut être traduit directement en Haskell:

foo :: (Int -> Int) -> Int
foo f = f 1 + 2

Maintenant, en JavaScript, vous pouvez faire des trucs diaboliques comme

js> foo (function(x) {console.log("muharhar"); return 0})
muharhar
2

Ce n'est pas possible à Haskell . La raison en est que quelque chose d'effet secondaire console.log()doit toujours avoir un type de résultat IO something, pas seulement somethingseul.

GHCi> foo (\x -> print "muarhar" >> return 0)

<interactive>:7:12:
    Couldn't match expected type ‘Int’ with actual type ‘IO b0’
    In the expression: print "muarhar" >> return 0
    In the first argument of ‘foo’, namely
      ‘(\ x -> print "muarhar" >> return 0)’
    In the expression: foo (\ x -> print "muarhar" >> return 0)

Pour que cette expression soit vérifiée, nous aurions besoin de donner foola signature de type

foo :: (Int -> IO Int) -> Int

Mais il s'avère que je ne peux plus l'implémenter alors: parce que la fonction d'argument a IOdans son résultat, je ne peux pas l'utiliser à l'intérieur foo.

<interactive>:8:44:
    Couldn't match expected type ‘Int’ with actual type ‘IO Int’
    In the first argument of ‘(+)’, namely ‘f 1’
    In the expression: f 1 + 2

La seule façon dont je pourrais utiliser une IOaction fooest si le résultat de fooa IO Intlui-même le type :

foo :: (Int -> IO Int) -> IO Int
foo f = do
   f1 <- f 1
   return (f1 + 2)

Mais à ce stade, il ressort clairement de la signature fooque ce n'est pas une fonction pure non plus.

Non ça ne l'est pas.

Si la fonction passée est impure ET que votre fonction appelle la fonction passée, alors votre fonction sera considérée comme impure.

La relation pure / impure est un peu comme sync / async dans JS. Vous pouvez librement utiliser du code pur impur, mais pas l'inverse.