Pourquoi println est-il considéré comme une fonction impure?

Je lis la programmation du livre en scala, et il est dit:

... dans ce cas, son effet secondaire est l'impression sur le flux de sortie standard.

et je ne vois pas où est l'effet secondaire, car, pour la même entrée, println imprimera la même sortie (je pense)
UPDATE
par exemple chaque fois que nous appelons:

println(5)

il affichera 5 , je ne vois pas de cas où appeler println(5)affichera une valeur autre que 5 !!

Vous pouvez savoir si une expression a un effet secondaire en remplaçant l'expression par son résultat. Si le programme change de sens , il y a un effet secondaire. Par exemple,

println(5)

est un programme différent de

()

Autrement dit, un effet secondaire est tout effet observable qui n'est pas codé dans le résultat de l'évaluation d'une expression. Voici le résultat (), mais il n'y a rien dans cette valeur qui code le fait que 5 est maintenant apparu quelque part sur votre écran.

Considérez l'analogie suivante

var out: String = ""
def myprintln(s: String) = {
  out += s // this non-local mutation makes me impure
  ()
}

Voici myprintlnimpur car en plus de renvoyer une valeur, ()il mute également une variable non locale outcomme effet secondaire. Imaginez maintenant que outle flux de vanille printlnmute.

L'effet secondaire est dans l'état de l'ordinateur. Chaque fois que vous appelez, println()l'état de la mémoire change afin d'afficher la valeur donnée au terminal. Ou plus généralement, l'état du flux de sortie standard est modifié.

De bonnes réponses ont déjà été données à cette question, mais permettez-moi d'ajouter mes deux cents.

Si vous regardez à l'intérieur de la printlnfonction, c'est essentiellement la même chose java.lang.System.out.println()- donc lorsque vous appelez la printlnméthode de bibliothèque standard de Scala sous le capot, elle appelle la méthode printlnsur l' PrintStreaminstance d'objet qui est déclarée comme champ outdans la Systemclasse (ou plus précisément outVardans Consoleobjet), ce qui change son état interne . Cela peut être considéré comme une autre explication de la printlnfonction impure.

J'espère que cela t'aides!

Il s'agit du concept de transparence référentielle . Une expression est référentiellement transparente si vous pouvez la remplacer par son résultat évalué sans changer le programme .

Lorsqu'une expression n'est pas référentiellement transparente, nous disons qu'elle a des effets secondaires .

f(println("effect"), println("effect"))
// isn't really equivalent to!
val x = println("effect")
f(x, x)

tandis que

import cats.effect.IO

def printlnIO(line: String): IO[Unit] = IO(println(line))

f(printlnIO("effect"), printlnIO("effect"))
// is equivalent to
val x = printlnIO("effect")
f(x, x)

Vous pouvez trouver une explication plus détaillée ici: https://typelevel.org/blog/2017/05/02/io-monad-for-cats.html