comment pourrais-je retourner plusieurs valeurs à partir d'une fonction en haskell?

Hifriends
est-il possible que cette fonction renvoie plusieurs valeurs(e.g string et boolean)?
si oui, alors j'ai un appel de fonction concat qui retourne un Booléen et un string, mais je ne sais pas comment appeler les fonctions parce que je veux les stocker. J'ai écrit un très bigcode. Je ne suis donc pas en mesure de le poster.enter code here

concat::(String->Int)->(IO Bool->IO String)
concat line i=do
       return True line

Pouvez-vous m'aider à écrire la signature de la fonction, et comment appeler les fonctions?

juste j'ai besoin d'un prototype

Grâce

OriginalL'auteur rahul | 2014-07-30

haskell

11

Au moment de retourner plusieurs valeurs, vous devrez retourner un type de données algébrique. Beaucoup peut être dit à propos de cela, je vais vous donner quelques suggestions.
1. Si votre Bool et String sont en quelque sorte plus liés et ils seront souvent ensemble dans votre code, définir un nouveau type de données algébrique:
```
data Question = Question Bool String
```
  Vous pouvez définir également avec les fonctions d'accesseur, qui documentent les données ainsi:
```
data Question = Question{ answered :: Bool
                        , text     :: String }
```
  et vous pouvez définir une fonction électronique. g. pour l'initialisation de la question:
```
question :: String -> Question
question str = Question False (str ++ "?")
```
  ou (pour l'amélioration de la documentation):
```
question :: String -> Question
question str = Question{ answered = False
                       , text     = str ++ "?"}
```
  ensuite, vous pouvez travailler avec vos données en utilisant les données constructeur:
```
answer :: String -> Question -> Question
answer answ (Question False str) =
  Question True (str ++ " " ++ answ ++ ".")
answer _ old = old
```
  ou en utilisant les fonctions d'accesseur (beaucoup de combinaisons des deux approches sont possibles):
```
answer :: String -> Question -> Question
answer answ qstn
  | answered qstn = qstn
  | otherwise     = qstn{ answered = True
                        , text     = text qstn ++ " " ++ answ ++ "."}
```
  exemple de l'appel de fonctions:
```
answer "Yes it is" (question "Is this answer already too long")
```
2. Si vous ne voulez pas définir un nouveau type de données utiliser un prédéfini d'un tuple. Il existe de nombreuses fonctions définies dans la norme des bibliothèques, qui rendent votre travail avec les tuples plus facile. Cependant, n'utilisez pas les tuples partout - plus code pourrait devenir un gâchis (manque de documentation - il n'est pas clair quelles sont les données que le tuple représente), les erreurs de type n'est pas si facile à suivre en raison de polymorphisme.
  
  Un exemple d'un type de pratique de l'utilisation de n-uplets:
```
squareAndCube :: Int -> (Int, Int)
squareAndCube x = (square, square*x)
  where square = x*x

sumOfSquareAndCube :: Int -> Int
sumOfSquareAndCube x = square + cube
  where (square, cube) = squareAndCube x
```
  Trop dit à propos de cette question simple, mais puisque j'ai parlé de la bibliothèque standard de soutien comme le principal avantage de tuples, je vais donner le dernier exemple qui utilise uncurry fonction de Prélude:
```
sumOfSquareAndCube :: Int -> Int
sumOfSquareAndCube x = uncurry (+) (squareAndCube x)
```
OriginalL'auteur pallly
10

Oui, vous pouvez retourner plusieurs valeurs avec une haskell construire appelé un n-uplet.

Voici un exemple simple
```
addAndSub :: Int -> Int -> (Int, Int)
addAndSub a b = (a + b, a - b)
```
Vous pouvez alors accéder à la première partie de la n-uplet avec fst et la seconde avec snd. Cependant, il est préférable de mise en correspondance du modèle
```
use = case addAndSub 2 3 of
  (i, j) -> i + j
```
ou
```
let (i,j) = addAndSub 2 3 
in i + j
```
Maintenant, imaginons que votre fonction ne certains IO et obtient un String et un Bool, votre fonction serait vaguement comme
```
magic :: IO (String, Bool)
magic = do
  string <- getString
  bool   <- getBool
  return (string, bool)
```
Si vous travaillez dans une monade et avec l'aide d'un do bloc, vous pouvez également en correspondance du modèle à l'aide d'une jolie forme.
```
foo = do
 (i, j) <- magic
```
Avis que cette doit être en bloc. Vous ne pouvez utiliser qu'un faire bloc si vous êtes de retour d'une valeur du type m a où m est une monade, comme IO.

je ne veux pas utiliser le cas, puis-je écrire de cette façon
Écrire de quelle manière?
je l'ai,j<-addAndSub 2 3
J'ai mis à jour. Ne pas que vous ne pouvez pas utiliser ne bloque partout, seulement lorsque vous faites quelque chose comme IO. Pourquoi vous n'aimez pas le case forme?
La deuxième forme que j'ai posté est vraiment juste une affaire avec du sucre, de sorte que vous pouvez utiliser.

OriginalL'auteur jozefg

Vous devez vous connecter pour publier un commentaire.