🗊Презентация Вывод строки символов на экран монитора. Ввод строки символов с клавиатуры. Создание и удаление файлов

Ввод / вывод

Задачи Вывод строки символов на экран монитора Ввод строки символов с клавиатуры Создание и удаление файлов Чтение данных из файла Запись данных в файл Работа с командной строкой

монады Монада ввода - вывода используется в Haskell как связующее звено между значениями, присущими функциональному языку, и действиями, характеризующими операции ввода - вывода и императивное программирование в общем. Порядок вычисления выражений в Haskell ограничен только зависимостями данных; реализация обладает значительной свободой в выборе этого порядка. Действия, тем не менее, должны быть упорядочены определенным образом для выполнения программы и, в частности, ввода - вывода, для того чтобы быть правильно интерпретированы. В Haskell монада ввода - вывода предоставляет пользователю способ указать последовательное связывание действий, и реализация обязана соблюдать этот порядок.

монады Термин монада происходит из отрасли математики, известной как теория категорий. Однако, с точки зрения программиста Haskell , лучше думать о монаде как об абстрактном типе данных. В случае монады ввода - вывода абстрактными значениями являются упомянутые выше действия. Некоторые операции являются примитивными действиями, соответствующими обычным операциям ввода - вывода. Специальные операции последовательно связывают действия, соответствующие последовательным операторам (таким как точка с запятой) в императивных языках.

Все монады представлены в лице класса типов Monad - IO class  Monad m  where     (>>=)   :: m a -> (a -> m b) -> m b     (>>)    :: m a -> m b -> m b     return  :: a -> m a     fail    :: String -> m a   

Компоновка >>= Метод (>>=) - это оператор последовательной компоновки (sequentially composition). Иногда его ещё называют оператором связывания (bind): он связывает два IO-действия воедино, извлекая результат, возвращённый левым действием, и передавая его в качестве аргумента правому действию (>>=)  :: IO a -> (a -> IO b) -> IO b Первый аргумент - это IO-действие, которое, выполнив свою работу, вернёт значение некоторого типа a. Второй аргумент - это функция, принимающая значение типа a в качестве аргумента и возвращающая IO-действие, которое, выполнив свою работу, вернёт значение некоторого типа b.

пример main :: IO () main = do text <- getLine putStrLn $ "You said ‘ " ++ text ++ " ‘ "

Затем >> Монадический оператор >> - это оператор “затем” (then). Это простейший случай связывания: действия связываются без извлечения значений.

return obtainTextFromUser :: IO String obtainTextFromUser = do putStrLn "Enter your text, please: " firstText <- getLine return $ "'" ++ firstText ++ "' Функция getLine вернёт нам монаду, из которой оператор компоновки вытащит введённую пользователем строку. Эта строка поступит на вход λ-функции, которая в свою очередь создаст новую строку на основе строки, введённой пользователем, после чего - !!! - функция return вернёт эту новоиспечённую строку обратно в IO-монаду. Вытащили значение из монады, что-то с ним сделали, а потом вернули в монаду.

Пример IO в do нотации: Пример IO в do нотации: main = do putStrLn "Hello, what is your name?" name <- getLine putStrLn ("Hello " ++ name ++ "!") или, в терминах bind, использование специальной формы: main = putStrLn "Hello, what is your name?" >> getLine >>= \name -> putStrLn ("Hello " ++ name ++ "!") или, очень примитивно, без специальной формы для bind: main = putStrLn "Hello, what is your name?" >>= \x -> getLine >>= \name -> putStrLn ("Hello " ++ name ++ "!")

Функции вывода  putChar  :: Char -> IO ()   putStr   :: String -> IO ()   putStrLn :: String -> IO () --добавляет символ новой строки print    :: Show a => a -> IO ()

Исполняемый файл main = putStrLn "hello, world"   Сохраняем в файле Helloword.hs и компилируем В текущей директории ghc --make helloworld.hs   Появились объектный и интерфейсный файлы Запускаем Exe

Функции ввода getChar     :: IO Char -- читаем символ   getLine     :: IO String -- читаем строку   getContents :: IO String -- Считывание всего ввода   interact    :: (String -> String) -> IO ()   readIO      :: Read a => String -> IO a   readLn      :: Read a => IO a

getLine main = do       putStrLn "Hello, what's your name?"       name <- getLine       putStrLn ("Hello" ++ name ++  ": ) ! ")  

getLine import Data.Char      main = do       putStrLn "What's your first name?"       firstName <- getLine       putStrLn "What's your last name?"       lastName <- getLine       let bigFirstName = map toUpper firstName           bigLastName = map toUpper lastName       putStrLn $ "hey " ++ bigFirstName ++ " " ++ bigLastName ++ ", how are you?"  

программа считывает и суммирует два числа типа Integer import System.IO main = do hSetBuffering stdout NoBuffering putStr "Введите новое целое число: " x1 <- readNum putStr "Введите другое целое число: " x2 <- readNum putStr ("Их сумма равна " ++ show (x1+x2) ++ "\n") where readNum :: IO Integer -- Указание сигнатуры типа позволяет избежать -- исправления типов x1,x2 правилом по умолчанию readNum = readLn

getChar Программа принимает три символа с клавиатуры и выводит их в обратном порядке: import Control.Applicative f :: Char -> Char -> Char -> String f a b c = reverse $ [a,b,c] main :: IO () main = print =<< f <$> getChar <*> getChar <*> getChar

Файлы   type FilePath =  String      writeFile  :: FilePath -> String -> IO ()   appendFile :: FilePath -> String -> IO ()   readFile   :: FilePath    -> IO String

readFile readFile readFile :: FilePath -> IO String import System.IO      main = do       contents <- readFile “test.txt"       putStr contents  

writeFile writeFile :: FilePath -> String -> IO () import System.IO      import Data.Char        main = do          contents <- readFile “file.in"          writeFile “file.out" (map toUpper contents)

Добавление данных в файл appendFile import System.IO           main = do          todoItem <- getLine       appendFile "todo.txt" (todoItem ++ "\n") 

openFile import System.IO      main = do       handle <- openFile  "test.txt" ReadMode       contents <- hGetContents handle       putStr contents       hClose handle  

   data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode   withFile :: FilePath -> IOMode -> (Handle -> IO a) -> IO a. import System.IO           main = do          withFile “test.txt" ReadMode (\handle -> do           contents <- hGetContents handle              putStr contents)  

withFile' :: FilePath -> IOMode -> (Handle -> IO a) -> IO a   withFile' path mode f = do       handle <- openFile path mode        result <- f handle       hClose handle       return result

Аргументы командной строки getArgs :: IO [String] import System.Environment    import Data.List      main = do      args <- getArgs      progName <- getProgName      putStrLn "The arguments are:"      mapM putStrLn args      putStrLn "The program name is:"      putStrLn progName  

Основные подходы

Простой ввод-вывод import System.IO      import Data.Char main :: IO () main = do contents <- readFile "file.in" writeFile "file.out" (operate contents) operate :: String -> String operate = ... -- ваша функция

Список действий Если шаблон, описанный в предыдущем разделе, недостаточен для ваших задач, то следующим шагом будет использование списка действий. Функцию main можно написать так: main :: IO () main = do x1 <- expr1 x2 <- expr2 ... xN <- exprN return ()

Копирование файлов import System.IO import Data.Char ( toUpper ) import System.Environment main = do [f1,f2] <- getArgs h1 <- openFile f1 ReadMode h2 <- openFile f2 WriteMode copyFile h1 h2 hClose h1 hClose h2 copyFile h1 h2 = do eof <- hIsEOF h1 if eof then return () else do c <- hGetChar h1 hPutChar h2 (toUpper c) copyFile h1 h2

import System.IO   import System.IO   import System.Directory   import Data.List      main = do             handle <- openFile "todo.txt" ReadMode       (tempName, tempHandle) <- openTempFile "." "temp"       contents <- hGetContents handle       let todoTasks = lines contents              numberedTasks = zipWith (\n line -> show n ++ " - " ++ line) [0..] todoTasks          putStrLn "These are your TO-DO items:"       putStr $ unlines numberedTasks       putStrLn "Which one do you want to delete?"          numberString <- getLine          let number = read numberString              newTodoItems = delete (todoTasks !! number) todoTasks          hPutStr tempHandle $ unlines newTodoItems       hClose handle       hClose tempHandle       removeFile "todo.txt"       renameFile tempName "todo.txt" 

View , Add , Remove import System.Environment    import System.Directory   import System.IO   import Data.List      dispatch :: [(String, [String] -> IO ())]   dispatch =  [ ("add", add)               , ("view", view)               , ("remove", remove)               ]   main = do      (command:args) <  getArgs      let (Just action) = lookup command dispatch       action args 

View , Add , Remove add :: [String] -> IO ()   add [fileName, todoItem] = appendFile fileName (todoItem ++ "\n") view :: [String] -> IO ()   view [fileName] = do       contents <- readFile fileName       let todoTasks = lines contents           numberedTasks = zipWith (\n line -> show n ++ " - " ++ line) [0..] todoTasks       putStr $ unlines numberedTasks  

View , Add , Remove remove :: [String] -> IO ()   remove [fileName, numberString] = do       handle <- openFile fileName ReadMode       (tempName, tempHandle) <- openTempFile "." "temp"       contents <- hGetContents handle       let number = read numberString           todoTasks = lines contents           newTodoItems = delete (todoTasks !! number) todoTasks       hPutStr tempHandle $ unlines newTodoItems       hClose handle       hClose tempHandle       removeFile fileName       renameFile tempName fileName  

import System.Environment    import System.Environment    import System.Directory   import System.IO   import Data.List      dispatch :: [(String, [String] -> IO ())]   dispatch =  [ ("add", add)               , ("view", view)               , ("remove", remove)               ]       main = do       (command:args) <- getArgs       let (Just action) = lookup command dispatch       action args      add :: [String] -> IO ()   add [fileName, todoItem] = appendFile fileName (todoItem ++ "\n")     

$ ./todo view todo.txt   $ ./todo view todo.txt   0 - Iron the dishes   1 - Dust the dog   2 - Take salad out of the oven      $ ./todo add todo.txt "Pick up children from drycleaners"      $ ./todo view todo.txt   0 - Iron the dishes   1 - Dust the dog   2 - Take salad out of the oven   3 - Pick up children from drycleaners      $ ./todo remove todo.txt 2      $ ./todo view todo.txt   0 - Iron the dishes   1 - Dust the dog   2 - Pick up children from drycleaners  

 Обработка исключений в монаде ввода - вывода Монада ввода - вывода включает простую систему обработки исключений. Любая операция ввода - вывода может вызвать исключение вместо возвращения результата. Исключения в монаде ввода - вывода представлены значениями типа IOError. Это абстрактный тип: его конструкторы скрыты от пользователя. Библиотека IO определяет функции, которые конструируют и изучают значения IOError . Единственной функцией Prelude, которая создает значение IOError, является userError. Пользовательские значения ошибок включают строку с описанием ошибки. userError :: String -> IOError Исключения вызываются и отлавливаются с помощью следующих функций: ioError :: IOError -> IO a catch :: IO a -> (IOError -> IO a) -> IO a Функция ioError вызывает исключение; функция catch устанавливает обработчик, который получает любое исключение, вызванное действием, защищенным catch. Исключение отлавливается самым последним обработчиком, установленным catch. Эти обработчики не действуют выборочно: они отлавливают все исключения. Распространение исключения нужно явно обеспечить в обработчике путем повторного вызова любого нежелательного исключения. Например, в f = catch g (\e -> if IO.isEOFError e then return [] else ioError e) функция f возвращает [], когда в g возникает исключение конца файла, иначе исключение передается следующему внешнему обработчику. Функция isEOFError является частью библиотеки IO. Когда исключение передается за пределы главной программы, система Haskell выводит связанное с ним значение IOError и выходит из программы. Метод fail экземпляра IO класса Monad вызывает userError так: instance Monad IO where ...bindings for return, (>>=), (>>) fail s = ioError (userError s)

Ошибки ввода - вывода Ошибки типа IOError используются монадой ввода - вывода. Это абстрактный тип; библиотека обеспечивает функции для опроса и конструирования значений в IOError: isAlreadyExistsError --- операция завершилась неуспешно, потому что один из ее аргументов уже существует. isDoesNotExistError --- операция завершилась неуспешно, потому что один из ее аргументов не существует. isAlreadyInUseError --- операция завершилась неуспешно, потому что один из ее аргументов является однопользовательским ресурсом, который уже используется (например, открытие одного и того же файла дважды для записи может вызвать эту ошибку). isFullError --- операция завершилась неуспешно, потому что устройство заполнено. isEOFError --- операция завершилась неуспешно, потому что был достигнут конец файла. isIllegalOperation --- операция невозможна. isPermissionError --- операция завершилась неуспешно, потому что пользователь не имеет достаточно привилегий операционной системы на выполнение этой операции. isUserError --- определенное программистом значение ошибки вызвано использованием fail.

Ошибки ввода - вывода Все эти функции возвращают значение типа Bool, которое равно True, если ее аргументом является соответствующий вид ошибки, и False иначе. Любая функция, которая возвращает результат IO, может завершиться с ошибкой isIllegalOperation. Дополнительные ошибки, которые могут быть вызваны реализацией, перечислены после соответствующей операции. В некоторых случаях реализация не способна различить возможные причины ошибки. В этом случае она должна вернуть isIllegalOperation. Имеются три дополнительные функции для того, чтобы получить информацию о значении ошибки, --- это ioeGetHandle, которая возвращает Just hdl, если значение ошибки относится к дескриптору hdl, и Nothing иначе; ioeGetFileName, которая возвращает Just имя, если значение ошибки относится к файлу имя, и Nothing иначе; и ioeGetErrorString, которая возвращает строку. Для "пользовательских" ошибок (которые вызваны использованием fail), строка, возвращенная ioeGetErrorString, является аргументом, который был передан в fail; для всех остальных ошибок строка зависит от реализации. Функция try возвращает ошибку в вычислении, явно использующем тип Either . Функция bracket охватывает обычный способ выделения памяти, вычисления и освобождения памяти, в котором шаг освобождения должен произойти даже в случае ошибки во время вычисления. Это аналогично try-catch-finally в Java.

Обработка ошибок import System.Environment import System.IO import System.Directory main = do (fileName:_) <- getArgs fileExists <- doesFileExist fileName if fileExists then do contents <- readFile fileName putStrLn $ "The file has " ++ show (length (lines contents)) ++ " lines!" else do putStrLn "The file doesn't exist!"

import System.Random import System.Random import Control.Monad(when) main = do gen <- getStdGen askForNumber gen askForNumber :: StdGen -> IO () askForNumber gen = do let (randNumber, newGen) = randomR (1,10) gen :: (Int, StdGen) putStr "Which number in the range from 1 to 10 am I thinking of? " numberString <- getLine when (not $ null numberString) $ do let number = read numberString if randNumber == number then putStrLn "You are correct!" else putStrLn $ "Sorry, it was " ++ show randNumber askForNumber newGen

Дополнительная литература http://eax.me/monads/ О монадах http://habrahabr.ru/post/80396/ Объяснение ввода-вывода в Haskell без монад http://ru-lambda.livejournal.com/12467.html http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-Programming-Fundamentals/C9-Lectures-Dr-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-7-of-13 http://haskell.ru/io.html https://wiki.haskell.org/Ru/IO_Inside Система ввода/вывода