Haskell: Comment analyser un IO chaîne d'entrée dans un Flotteur (ou Int ou autre)?

Je suis en train de faire un programme qui prend un nombre à virgule entrés par l'utilisateur via le clavier et fait des trucs avec elle.

Cependant chaque fois que j'essaie d'analyser la saisie de Chaîne en Float je continue à faire des erreurs. Chaque méthode que j'ai essayé n'a pas me permettre de prendre de l'utilisateur saisie de données et le transformer en un Flotteur, qui est ce dont j'ai besoin.

Mon programme de pratique (pas de problème, je suis en train d'essayer de résoudre) est:

main = do
    putStrLn "Please input a number."
    inputjar <- getLine
    read :: read a => String -> a
    putStrLn( read inputjar :: Int)

Modifier

Une autre question.

Comment dois-je prendre en entrée de chaîne et de le transformer en quelque chose que je peux utiliser dans un calcul?

Par exemple, comment dois-je prendre en entrée de la chaîne de sorte que je puisse faire quelque chose comme:

(var + var) / 2

Pourriez-vous expliquer pourquoi vous avez la read :: read a => String -> a expression? (C'est une grave question: expliquant votre propre code en détail c'est vraiment une bonne façon de comprendre et de débogage.)
Un ami qui m'aidait m'a dit de mettre que en ou lire ne fonctionnerait pas. J'ai été assez tenter quoi que ce soit à ce point et a estimé qu'il était nécessaire.
Je pense que l'ami signifie que vous pouvez envelopper votre utilisation de read avec une spécialisation de sa signature, par exemple print ((read :: String -> Int) inputjar) (Nous utilisons l'impression ici, car c'est le nombre, pas une chaîne de caractères qui travaillent avec nous.) Le compilateur connaît déjà le type de read c'est à dire Read a => String -> a et cela ne va pas l'aider à comprendre ce que l'entrée de l'utilisateur moyen. Dans ce cas, vous pouvez également faire print (read inputjar ::Int) -- votre principale erreur ci-dessus a été à l'aide de putStrLn, qui agit uniquement sur les cordes, plutôt que de les imprimer.
Depuis "Quelqu'un a répondu sur cette page" veuillez accepter la réponse pertinente. Si quelqu'un d'autre a demandé fondamentalement la même question et la réponse est dans la question, s'il vous plaît lien dans un commentaire afin que nous puissions fermer celui-ci comme une double liaison à l'autre question.

OriginalL'auteur Philip Eloy | 2012-07-14

8
```
main = do
   putStrLn "Please input a number."
   inputjar <- readLn
   print (inputjar :: Int)
```
C'est d'une manière plus agréable car il immédiatement les correctifs de ce que nous sommes à la lecture de la chaîne:
```
main = do
   putStrLn "Please input a number."
   inputjar :: Int  <- readLn
   print inputjar
```
mais il nécessite { -#LANGUAGE ScopedTypeVariables#- }

inputjar <- readLN :: IO Int, pas d'extensions. Ma méthode de prédilection.
Même ici, j'ai pu résister à taper avec IO dans ce contexte.
Est-ce mauvais pour transtypage IO comme ça? Semble la solution la plus simple mais qui sonne comme vous avez vos réserves.

OriginalL'auteur
5

Vous dire (read inputjar :: Int) dans votre code, mais vous nous avez dit que vous voulez lire un Float. Vous n'êtes pas définir read, prendre cette ligne. Vous utilisez putStrLn de sorte que vous pouvez imprimer le flotteur, mais putStrLn prend un String, si vous avez besoin de show la valeur.
```
main = do
    putStrLn "Please input a number."
    inputjar <- getLine
    putStrLn $ show (read inputjar :: Float)
```
OriginalL'auteur
5

putStrLn imprime Strings, pas Ints, il y a donc deux solutions:

Utilisation print, qui imprime tout ce qui implémente Show:
```
main = do
    putStrLn "Please input a number."
    inputjar <- getLine
    let n = read inputjar :: Int
    print n
```
.. ou appelez putStrLn sur l'original String que vous lisez dans
```
main = do
    putStrLn "Please input a number."
    inputjar <- getLine
    let n = read inputjar :: Int
    putStrLn inputjar
```
Dans ce dernier exemple, n est jamais utilisé, mais sans doute vous écrire un peu de code après ce qui serait réellement l'utiliser.

OriginalL'auteur
3

Bien, je suppose que le
```
read :: read a => String -> a
```
est juste là par erreur?

De toute façon, en vertu de ghci, :t putStrLn montre:
```
putStrLn :: String -> IO ()
```
Donc putStrLn accepte uniquement Chaîne comme premier paramètre, donc si vous voulez vraiment:
```
putStrLn( show (read inputjar :: Int))
```
BTW, read inputjar :: int est correct, que votre sortie est mauvais.

ok, cela a fonctionné. C'est fantastique. Je vous remercie. Si je veux utiliser le contenu de inputjar pour autre chose (disons un calcul réel) qu'est-ce que je dois faire?

OriginalL'auteur

-2

Cela a fonctionné pour moi

import System.IO

getNum :: IO Integer 
getNum = readLn 

--call function like this
something <- getNum
--something is type Integer

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.