Égal (=) Vs flèche vers la gauche (<-) symboles en haskell

Code de travail:

import System
main = do
     [file1, file2] <- getArgs
     --copy file contents
     str <- readFile file1
     writeFile file2 str

S'écraser code:

import System
main = do
       [file1, file2] = getArgs
       str = readFile file1
       writeFile file2 str

Quand j'ai essayé, il a jeté une erreur comme:

un.hs:6:18: parse error sur l'entrée '='

Alors, combien est différent <- de =?

Vous avez besoin de comprendre Monade de-la cabane à sucre pour avoir une réelle idée de la façon dont cela s'inscrit.
c'est techniquement vrai, mais je pense qu'il devrait être possible de répondre à cette question, sans parler de la M-parole. Après tout, m***ds sont juste une façon de traiter avec les IO dans une langue pure. Haskell aurait encore une séparation entre le pur et l'impur code, même si elle n'a pas m****ds construit dans la langue, et ce problème (ou similaire), il existerait toujours.
Alors qu'il est possible de répondre à cette question sans expliquer la Monade, je doute vraiment si cela peut aider les OP à saisir le concept. Cela étant dit, il ya beaucoup de bonnes réponses ici-bas.

InformationsquelleAutor Madhavan | 2015-02-20

haskell

83

De comprendre la véritable différence, vous devez comprendre les monades, et la desugaring décrite par @rightfold dans leur réponse.

Pour le cas spécifique de l'IO monade, comme dans votre getArgs exemple, un brouillon mais utile intuition peut être effectué comme suit:
- x <- action s'exécute le IO action, obtient son résultat, et le lie à x
- let x = action définit x équivalent à action, mais ne pas exécuter quoi que ce soit. Plus tard, vous pouvez utiliser y <- x sens y <- action.
Programmeurs venant de langages qui permettent de fermetures, peuvent tirer de cette rude en parallèle avec Javascript:
```
var action = function() { print(3); return 5; }

//roughly equivalent to x <- action
print('test 1')
var x = action()  //output:3
//x is 5

//roughly equivalent to let y = action
print('test 2')
var y = action    //output: nothing
//y is a function

//roughly equivalent to z <- y
print('test 3')
var z = y()       //output:3
//z is 5
```
Encore: cette comparaison porte sur IO, seulement. Pour les autres monades, vous avez besoin de vérifier ce >>= est réellement, et de réfléchir à la desugaring de do.

InformationsquelleAutor chi
45
```
do
    x <- y
    f x
```
est équivalent à:
```
y >>= \x -> f x
```
```
do
    let x = y
    f x
```
est équivalent à
```
f y
```
c'est à dire let/= ne pas monadique lier alors que <- n'.
- En disant let x = y in f x (qui vraiment est équivalent à la 2ème expression do) est "équivalent" à f y est dangereux, principalement parce qu'il peut ne pas être évident pour le lecteur que "équivalent" signifie; les valeurs de ces deux expressions sont les mêmes, mais leur sémantique peut être différent.
- non, ils sont exactement la même chose. Il n'y a pas une seule différence.
InformationsquelleAutor rightfold
14

Le code ne se compile pas, parce que les types ne correspondent pas. Nous allons charger un GHCI session et de regarder les types de fonctions que vous utilisez
```
> :t writeFile
writeFile :: FilePath -> String -> IO ()
>
> :t readFile
readFile :: FilePath -> IO String
```
Donc writeFile veut un FilePath et un String. Vous voulez obtenir le String de readFile - mais readFile retourne IO String au lieu de String.

Haskell est un très raisonnée de la langue. Il a une distinction entre pur fonctions (ce qui donne les mêmes sorties à chaque fois qu'ils sont appelés avec les mêmes arguments) et impur code (qui peuvent donner des résultats différents, par exemple si la fonction dépend de certains saisie de l'utilisateur). Les fonctions qui traitent des entrées/sorties (IO) ont toujours un type de retour qui est marqué avec IO. Le type de système garantit que vous ne pouvez pas utiliser impur IO code à l'intérieur de pures fonctions - par exemple, au lieu de retourner un String la fonction readFile retourne un IO String.

C'est là que le <- notation est important. Il vous permet d'obtenir à la String à l'intérieur de la IO et il assure que tout ce que vous faites avec cette chaîne, la fonction de la définition va être marquée par la IO. Comparer les suivantes -
```
> let x = readFile "tmp.txt"
> :t x
x :: IO String
```
ce qui n'est pas ce que nous voulons, à ce
```
> y <- readFile "tmp.txt"
> :t y
y :: String
```
qui est ce que nous voulons. Si jamais vous avez une fonction qui renvoie un IO a et vous souhaitez accéder à la a , vous devez utiliser <- d'affecter le résultat d'un nom. Si votre fonction ne retourne pas IO a , ou si vous ne voulez pas d'obtenir à la a à l'intérieur de la IO vous pouvez simplement utiliser =.
- L'OP du code a un erreur de syntaxe. Il semble que devraient probablement être adressées avant le type d'erreur qui se cache derrière elle.
- A noté, merci 🙂
- il peut être souligné que le fait d'avoir à passer par la <- pour obtenir le résultat calculé force pour cela, à l'intérieur IO do bloc, pour être capable de faire cela. ainsi, l'application de la séparation de l'impur IO de code pur.
InformationsquelleAutor Chris Taylor
12
```
let x = readFile file1
```
Cela prend l'action "readFile file1" et les magasins l'action dans x.
```
x <- readFile file1
```
Ce exécute l'action "readFile file1" et les magasins le résultat de l'action dans x.

Dans le premier exemple, x est un non I/O action de l'objet. Dans le deuxième exemple, x est le contenu d'un fichier sur le disque.

InformationsquelleAutor MathematicalOrchid

Vous devez vous connecter pour publier un commentaire.