Difference between revisions of "Ru/IO Inside"

**монадах.**

getchar :: Char

get2chars = [getchar,getchar]

getchar :: Int -> Char

get2chars = [getchar 1, getchar 2]

getchar   :: Int -> Char
get2chars :: Int -> String

get2chars _ = [getchar 1, getchar 2]

getchar :: Int -> (Char, Int)

get2chars _ = [a,b]  where (a,i) = getchar 1
                           (b,_) = getchar i

get2chars i0 = [a,b]  where (a,i1) = getchar i0
                            (b,i2) = getchar i1

get4chars = [get2chars 1, get2chars 2]  -- порядок вызовов 'get2chars' не определён.

get2chars :: Int -> (String, Int)

get4chars i0 = (a++b)  where (a,i1) = get2chars i0
                             (b,i2) = get2chars i1

get2chars :: Int -> (String, Int)
get2chars i0 = ([a,b], i2)  where (a,i1) = getchar i0
                                  (b,i2) = getchar i1

main :: RealWorld -> ((), RealWorld)

type IO a  =  RealWorld -> (a, RealWorld)

getChar :: RealWorld -> (Char, RealWorld)

main :: RealWorld -> ((), RealWorld)
main world0 = let (a, world1) = getChar world0
                  (b, world2) = getChar world1
              in ((), world2)

main = do a <- ask "What is your name?"
          b <- ask "How old are you?"
          return ()

ask s = do putStr s
           readLn

when :: Bool -> IO () -> IO ()
when condition action world =
    if condition
      then action world
      else ((), world)

  main = do putStr "Hello!"

  main = putStr "Hello!"

main = do putStr "What is your name?"
          putStr "How old are you?"
          putStr "Nice day!"

main = (putStr "What is your name?")
       >> ( (putStr "How old are you?")
            >> (putStr "Nice day!")
          )

(>>) :: IO a -> IO b -> IO b
(action1 >> action2) world0 =
   let (a, world1) = action1 world0
       (b, world2) = action2 world1
   in (b, world2)

action1 >> action2 = action
  where
    action world0 = let (a, world1) = action1 world0
                        (b, world2) = action2 world1
                    in (b, world2)

main = do a <- readLn
          print a

main = readLn
       >>= (\a -> print a)

(>>=) :: IO a -> (a -> IO b) -> IO b
(action1 >>= action2) world0 =
   let (a, world1) = action1 world0
       (b, world2) = action2 a world1
   in (b, world2)

main = readLn >>= print

 do x <- action1
    action2

 action1 >>= (\x -> action2)

main = do putStr "What is your name?"
          a <- readLn
          putStr "How old are you?"
          b <- readLn
          print (a,b)

main = putStr "What is your name?"
       >> readLn
       >>= \a -> putStr "How old are you?"
       >> readLn
       >>= \b -> print (a,b)

return :: a -> IO a
return a world0  =  (a, world0)

main = do a <- readLn
          return (a*2)

main = do a <- readLn
          when (a>=0) $ do
              return ()
          print "a is negative"

main = do a <- readLn
          if (a>=0)
            then return ()
            else print "a is negative"

main = do a <- readLn
          if (a>=0) then return ()
            else do
          print "a is negative"
          ...

liftM :: (a -> b) -> (IO a -> IO b)

liftM f action = do x <- action
                    return (f x)

action >>= \x -> return (x+1)

do x <- action
                    return (x+1)

fmap (+1) action

main = do let a0 = readVariable varA
              _  = writeVariable varA 1
              a1 = readVariable varA
          print (a0, a1)

main = do varA <- newIORef 0  -- Create and initialize a new variable
          a0 <- readIORef varA
          writeIORef varA 1
          a1 <- readIORef varA
          print (a0, a1)

 import Data.Array.IO
 main = do arr <- newArray (1,10) 37 :: IO (IOArray Int Int)
           a <- readArray arr 1
           writeArray arr 1 64
           b <- readArray arr 1
           print (a, b)

rand :: IO Int

foreign import ccall
   sin :: Double -> Double

foreign import ccall
   tell :: Int -> IO Int

main world0 = let get2chars = getChar >> getChar
                  ((), world1) = putStr "Press two keys" world0
                  (answer, world2) = get2chars world1
              in ((), world2)

main = do let get2chars = getChar >> getChar
          putStr "Press two keys"
          get2chars
          return ()

ioActions :: [IO ()]
ioActions = [(print "Hello!"),
             (putStr "just kidding"),
             (getChar >> return ())
            ]

ioActions :: [RealWorld -> ((), RealWorld)]

main = do head ioActions
          ioActions !! 1
          last ioActions

sequence_ :: [IO a] -> IO ()
sequence_ [] = return ()
sequence_ (x:xs) = do x
                      sequence_ xs

main = sequence_ ioActions

while :: IO Bool -> IO ()
while action = ???

main = do let a = sequence ioActions
              b = when True getChar
              c = getChar >> getChar
          putStr "These 'let' statements are not executed!"

readi h i = do hSeek h AbsoluteSeek i 
               hGetChar h

readfilei :: String -> IO (Integer -> IO Char)
readfilei name = do h <- openFile name ReadMode
                    return (readi h)

readfilei name = do h <- openFile name ReadMode
                    let readi h i = do hSeek h AbsoluteSeek i 
                                       hGetChar h
                    return (readi h)

readfilei name = do h <- openFile name ReadMode
                    let readi i = do hSeek h AbsoluteSeek i
                                     hGetChar h
                    return readi

main = do myfile <- readfilei "test"
          a <- myfile 0
          b <- myfile 1
          print (a,b)

memoryAllocator :: Ptr a -> Int -> IO (Int -> IO (Ptr b),
                                       Ptr c -> IO ())

memoryAllocator buf size = do ......
                              let alloc size = do ...
                                                  ...
                                  free ptr = do ...
                                                ...
                              return (alloc, free)

memoryAllocator buf size = do start <- newIORef buf
                              end <- newIORef (buf `plusPtr` size)
                              ...

      ...
      let alloc size = do addr <- readIORef start
                          writeIORef start (addr `plusPtr` size)
                          return addr
                          
      let free ptr = do writeIORef start ptr

main = do buf1 <- mallocBytes (2^16)
          buf2 <- mallocBytes (2^20)
          (alloc1, free1) <- memoryAllocator buf1 (2^16)
          (alloc2, free2) <- memoryAllocator buf2 (2^20)
          ptr11 <- alloc1 100
          ptr21 <- alloc2 1000
          free1 ptr11
          free2 ptr21
          ptr12 <- alloc1 100
          ptr22 <- alloc2 1000

data Figure = Figure { draw :: IO (),
                       move :: Displacement -> IO ()
                     }

type Displacement = (Int, Int)  -- horizontal and vertical displacement in points

circle    :: Point -> Radius -> IO Figure
rectangle :: Point -> Point -> IO Figure

type Point = (Int, Int)  -- point coordinates
type Radius = Int        -- circle radius in points

circle center radius = do
    let description = "  Circle at "++show center++" with radius "++show radius
    return $ Figure { draw = putStrLn description }

rectangle from to = do
    let description = "  Rectangle "++show from++"-"++show to)
    return $ Figure { draw = putStrLn description }

drawAll :: [Figure] -> IO ()
drawAll figures = do putStrLn "Drawing figures:"
                     mapM_ draw figures

main = do figures <- sequence [circle (10,10) 5,
                               circle (20,20) 3,
                               rectangle (10,10) (20,20),
                               rectangle (15,15) (40,40)]
          drawAll figures

circle center radius = do
    centerVar <- newIORef center
    
    let drawF = do center <- readIORef centerVar
                   putStrLn ("  Circle at "++show center
                             ++" with radius "++show radius)
                   
    let moveF (addX,addY) = do (x,y) <- readIORef centerVar
                               writeIORef centerVar (x+addX, y+addY)
                               
    return $ Figure { draw=drawF, move=moveF }

    
rectangle from to = do
    fromVar <- newIORef from
    toVar   <- newIORef to

    let drawF = do from <- readIORef fromVar
                   to   <- readIORef toVar
                   putStrLn ("  Rectangle "++show from++"-"++show to)
                   
    let moveF (addX,addY) = do (fromX,fromY) <- readIORef fromVar
                               (toX,toY)     <- readIORef toVar
                               writeIORef fromVar (fromX+addX, fromY+addY)
                               writeIORef toVar   (toX+addX, toY+addY)

    return $ Figure { draw=drawF, move=moveF }

main = do figures <- sequence [circle (10,10) 5,
                               rectangle (10,10) (20,20)]
          drawAll figures
          mapM_ (\fig -> move fig (10,10)) figures
          drawAll figures

data Figure = Figure { draw :: IO (),
                       move :: Displacement -> IO (),
                       area :: Double,
                       origin :: IORef Point
                     }

readContents :: Filename -> String

unsafePerformIO :: IO a -> a

unsafePerformIO :: (RealWorld -> (a, RealWorld)) -> a
unsafePerformIO action = let (a, world1) = action createNewWorld
                         in a

one :: Int
one = unsafePerformIO $ do var <- newIORef 0
                           modifyIORef var (+1)
                           readIORef var

unsafePerformIO action = let (a,world1) = action createNewWorld
                         in (world1 `seq` a)

-- | Just like unsafePerformIO, but we inline it. Big performance gains as
-- it exposes lots of things to further inlining
{-# INLINE inlinePerformIO #-}
inlinePerformIO action = let (a, world1) = action createNewWorld
                         in (world1 `seq` a)
#endif

write :: Int -> (Ptr Word8 -> IO ()) -> Put ()
write !n body = Put $ \c buf@(Buffer fp o u l) ->
  if n <= l
    then write' c fp o u l
    else write' (flushOld c n fp o u) (newBuffer c n) 0 0 0

  where {-# NOINLINE write' #-}
        write' c !fp !o !u !l =
          -- warning: this is a tad hardcore
          inlinePerformIO
            (withForeignPtr fp
              (\p -> body $! (p `plusPtr` (o+u))))
          `seq` c () (Buffer fp o (u+n) (l-n))

word8 w = write 1 (\p -> poke p w)

do let c = unsafePerformIO getChar
   do_proc c

do let s = [unsafePerformIO getChar, unsafePerformIO getChar, unsafePerformIO getChar]
   do_proc s

do str <- unsafeInterleaveIO myGetContents

myGetContents = do
   c <- getChar
   s <- unsafeInterleaveIO myGetContents
   return (c:s)

myGetContents = do
   c <- replicateM 512 getChar
   s <- unsafeInterleaveIO myGetContents
   return (c++s)

newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))

data World = World
newtype IO a = IO (World -> Either IOError a)

Difference between revisions of "Ru/IO Inside"

Revision as of 06:34, 10 August 2022

Contents

Haskell - чистый язык

Что такое монада?

Добро пожаловать в Реальный мир, детка :)

Нотация '>>=' и 'do'

Mutable data (references, arrays, hash tables...)

IO actions as values

Example: a list of IO actions

Example: returning an IO action as a result

Example: a memory allocator generator

Example: emulating OOP with record types

Dark side of IO monad

unsafePerformIO

inlinePerformIO

unsafeInterleaveIO

Welcome to the machine: the actual GHC implementation

The Yhc/nhc98 implementation

Further reading

To-do list

Navigation menu

Search

@@ Line 1: / Line 1: @@
-Система ввода/вывода Haskell (Haskell I/O) всегда была слишком сложной для новичков. И хотя простой IO код на Haskell выглядит очень похожим на подобный в императивных языках, попытки написать чуть более сложный код часто приводят к замешательству. Это всё от того, что внутреннее устройство Haskell I/O очень сильно отличается. Haskell - чистый язык, и даже I/O система не способна нарушить эту чистоту.
+Система ввода/вывода Haskell (Haskell I/O) всегда была слишком сложной для новичков. И хотя простой IO код на Haskell выглядит очень похожим на подобный в императивных языках, попытки написать чуть более сложный код часто приводят к замешательству. Это всё от того, что внутреннее устройство Haskell I/O очень сильно отличается. Haskell — чистый язык, и даже I/O система не способна нарушить эту чистоту.
-Цель данной работы - попытка объяснить детали реализации Haskell I/O и постепенно сделать из вас специалиста по работе с IO. Более того, я добавил детальное описание всех ловушек, с которыми вы можете столкнуться. После прочтения этого текста, вы получите звание "Повелитель Haskell I/O", а это тоже самое, что и Бакалавр Информатики и Математики :)
+Цель данной работы — попытка объяснить детали реализации Haskell I/O и постепенно сделать из вас специалиста по работе с IO. Более того, я добавил детальное описание всех ловушек, с которыми вы можете столкнуться. После прочтения этого текста, вы получите звание "Повелитель Haskell I/O", а это тоже самое, что и Бакалавр Информатики и Математики :)
 Если вы никогда не работали с Haskell I/O, лучше будет, если вы сначала прочтёте [[Ru/IO | Введение в Haskell IO]]
@@ Line 7: / Line 7: @@
 == Haskell - чистый язык ==
-Haskell - чистый язык. Это означает, что результат, возвращаемый любой функцией, полностью определён её аргументами. Псевдофункции, такие как rand() или getchar() в C, которые возвращают разные результаты при каждом вызове, невозможны в Haskell. Более того, функции в Haskell не могут иметь побочных эффектов. Это означает, что они не способны влиять на "внешний мир", т.е. не могут производить действия такие как: изменение файлов, вывод на экран, печать, отправка данных по сети и подобное.
+Haskell — чистый язык. Это означает, что результат, возвращаемый любой функцией, полностью определён её аргументами. Псевдофункции, такие как rand() или getchar() в C, которые возвращают разные результаты при каждом вызове, невозможны в Haskell. Более того, функции в Haskell не могут иметь побочных эффектов. Это означает, что они не способны влиять на "внешний мир", т.е. не могут производить действия такие как: изменение файлов, вывод на экран, печать, отправка данных по сети и подобное.
 Эти два ограничения означают, что любой вызов функции может быть заменён на результат работы предыдущего вызова этой же функции с теми же параметрами, и язык '''гарантирует''', что подобная замена не изменит результат всей программы в целом.
@@ Line 13: / Line 13: @@
 Давайте сравним с C: оптимизирующий компилятор C пытается определить, какая функция не имеет побочных эффектов и не обращается к глобальным переменным. Но если определение неверное, то оптимизация может поменять семантику программы! Во избежание подобных ситуаций C-оптимизаторы очень осторожны при определении или требуют от программистов подсказок о чистоте функций.
-В отличие от компилятора C, Haskell-компилятор - это набор чистых математических преобразований, что даёт возможность более высокоуровневой оптимизации. Более того, чистые математические вычисления проще разделить на несколько потоков, запущенных параллельно. В наши дни при наличии многоядерных процессоров это приобретает всё большее значение. И наконец, чистые вычисления больше защищены от ошибок и их легче проверять и доказывать, из-за чего Haskell более надёжен и скорость написания программ на нём выше.
+В отличие от компилятора C, Haskell-компилятор — это набор чистых математических преобразований, что даёт возможность более высокоуровневой оптимизации. Более того, чистые математические вычисления проще разделить на несколько потоков, запущенных параллельно. В наши дни при наличии многоядерных процессоров это приобретает всё большее значение. И наконец, чистые вычисления больше защищены от ошибок и их легче проверять и доказывать, из-за чего Haskell более надёжен и скорость написания программ на нём выше.
 Чистота Haskell позволяет вызывать только те функции, результат которых необходим для вычисления конечного результата функции более высокого уровня.
@@ Line 38: / Line 38: @@
 # Даже если вдруг будет произведено два вызова функции 'getchar', невозможно определить порядок этих вызовов. Кто из них будет произведён первым? Вы хотите получить два символа в том порядке, в котором ввели, или в обратном порядке? В определении 'get2chars' нет ответа на этот вопрос.
+Как эта проблема может быть решена с точки зрения программиста?
-How can these problems be solved, from the programmer's viewpoint?
+Можно ввести фиктивный параметр таким образом, что компилятор примет два вызова
-Let's introduce a fake parameter of 'getchar' to make each call
+'getchar' за "разные".
-"different" from the compiler's point of view:
 <haskell>
@@ Line 48: / Line 48: @@
 </haskell>
+Первая проблема, которую мы описали выше, решена. Теперь компилятор видит, что функции имеют разные параметры, и будет вызывать 'getchar' два раза,
-Right away, this solves the first problem mentioned above - now the
-compiler will make two calls because it sees them as having different
+Функции 'get2chars' тоже следует добавить фиктивный параметр:
-parameters. The whole 'get2chars' function should also have a
-fake parameter, otherwise we will have the same problem calling it:
 <haskell>
@@ Line 60: / Line 59: @@
 </haskell>
+Теперь нужно дать компилятору небольшую подсказку, чтобы он понял, какую функцию следует вычислять первой.
+В Haskell нет способа задать порядок вычисления... кроме зависимости между данными!
-Now we need to give the compiler some clue to determine which function it
+Как насчёт того, чтобы добавить искусственную зависимость, которая недопустит вычисление второго 'getchar' прежде первого?
-should call first. The Haskell language doesn't provide any way to express
+Сделаем мы это следующим образом: мы будем возвращать из 'getchar' ещё один фиктивный результат, а он, в свою очередь, будет
-order of evaluation... except for data dependencies! How about adding an
+использоваться в качестве параметра в следующем вызове 'getchar':
-artificial data dependency which prevents evaluation of the second
-'getchar' before the first one? In order to achieve this, we will
-return an additional fake result from 'getchar' that will be used as a
-parameter for the next 'getchar' call:
 <haskell>
@@ Line 76: / Line 72: @@
 </haskell>
+Пока всё отлично. Теперь мы можем гарантировать, что 'a' будет прочитано прежде чем 'b', потому как для чтения 'b' требуется значение
-So far so good - now we can guarantee that 'a' is read before 'b'
+'i', которое возвращается при чтении 'a'!
-because reading 'b' needs the value ('i') that is returned by reading 'a'!
+Мы добавили параметр в 'get2chars', но проблема в том, что комплятор Haskell слишком умён!
-We've added a fake parameter to 'get2chars' but the problem is that the
+Он ещё может поверить, что внешняя функция 'getchar' действительно зависит от своего параметра, но для 'get2char' всё выглядит
-Haskell compiler is too smart! It can believe that the external 'getchar'
+таким образом как-будто мы жульничаем, потому что отбрасываем параметр!
-function is really dependent on its parameter but for 'get2chars' it
-will see that we're just cheating because we throw it away! Therefore it won't feel obliged to execute the calls in the order we want.  How can we fix this? How about passing this fake parameter to the 'getchar' function?! In this case
+Поэтому компилятор не считает себя обязанным делать вызовы в том порядке, в котором мы хотим.
-the compiler can't guess that it is really unused :)
+Как же нам это исправить? А может передавать этот фиктивный параметр в 'getchar'?!
+Тогда компилятор не поймёт, что параметр на самом деле не используется :)
 <haskell>
@@ Line 91: / Line 89: @@
-And more - 'get2chars' has all the same purity problems as the 'getchar'
+Теперь у функции 'get2chars' те же самые проблемы, что были у 'getchar'.
+Если вы захотите вызвать её дважды, то должны найти способ описать порядок этих вызовов. Взгляните:
-function. If you need to call it two times, you need a way to describe
-the order of these calls. Look at:
 <haskell>
-get4chars = [get2chars 1, get2chars 2]  -- order of 'get2chars' calls isn't defined
+get4chars = [get2chars 1, get2chars 2]  -- порядок вызовов 'get2chars' не определён.
 </haskell>
+Но мы уже знаем, как решать такие проблемы. 'get2chars' тоже должен возвращать какое-нибудь фиктивное значение,
-We already know how to deal with these problems - 'get2chars' should
+которое будет использовано для задания порядка вычисления:
-also return some fake value that can be used to order calls:
 <haskell>
@@ Line 109: / Line 106: @@
 </haskell>
+Но какое значение должна возвращать функция 'get2chars'?
+Если мы будем использовать постоянное целое число, то слишком умный компилятор решит, что мы опять мухлюем :)
-But what's the fake value 'get2chars' should return? If we use some integer constant, the excessively-smart Haskell compiler will guess that we're cheating again :)  What about returning the value returned by 'getchar'? See:
+Давай будет возвращать значение, вычисленное 'getchar'. Смотрите:
 <haskell>
@@ Line 118: / Line 116: @@
 </haskell>
+Хотите верьте, хотите нет, но мы только что полностью воссоздали "монадическую" систему ввода/вывода языка Haskell.
-Believe it or not, but we've just constructed the whole "monadic"
-Haskell I/O system.
+== Добро пожаловать в Реальный мир, детка :) ==
+Почему бы нам не смотреть на '''''Реальный мир''''', как на ещё один тип данных? Назовём этот тип 'RealWorld'. Функция 'main' имеет следующий тип:
-== Welcome to the RealWorld, baby :) ==
-The 'main' Haskell function has the type:
 <haskell>
@@ Line 131: / Line 126: @@
 </haskell>
+вместо нашего Int используется фиктивный тип 'RealWorld'.
-where 'RealWorld' is a fake type used instead of our Int. It's something
+Реальный мир похож на эстафетную палочку: когда main вызывает другие функции, в результате которых присутствует IO, main передаёт полученный им '''''мир''''' этим функциям.
-like the baton passed in a relay race. When 'main' calls some IO function,
+Все функции, выполняющие ввод-вывод, имеют тип, схожий с типом 'main'. А конкретнее, сам класс типов "IO" определён как синоним типа:
-it passes the "RealWorld" it received as a parameter. All IO functions have
-similar types involving RealWorld as a parameter and result. To be
-exact, "IO" is a type synonym defined in the following way:
 <haskell>
@@ Line 141: / Line 134: @@
 </haskell>
-So, 'main' just has type "IO ()", 'getChar' has type "IO Char" and so
+Таким образом, 'main' имеет тип "IO ()", 'getChar' имеет тип "IO Char" и так далее.
+Например, "IO Char" можно понимать таким образом: получить мир, (может быть, изменить мир) и вернуть Char и изменённый мир.
-on.  You can think of the type "IO Char" as meaning "take the current RealWorld, do something to it, and return a Char and a (possibly changed) RealWorld".  Let's look at 'main' calling 'getChar' two times:
+Так выглядит 'main', вызывающий 'getChar' последовательно два раза:
 <haskell>
@@ Line 154: / Line 148: @@
-Look at this closely: 'main' passes to first 'getChar' the "world" it
+'main' отдаёт первому 'getChar' полученный мир.
+Возвращённый первым 'getChar' мир отдаётся второму 'getChar'.
-received. This 'getChar' returns some new value of type RealWorld
+'main' возвращает тот мир, который был возвращён вторым 'getChar'.
-that gets used in the next call. Finally, 'main' returns the "world" it got
+К чему привела такая схема вызова 'getChar'?
-from the second 'getChar'.
+# Можно ли опустить вызов 'getChar', если его результат не нужен? Нет, так как нам всё равно нужен новый 'RealWorld', возвращаемый  'getChar' помимо символа.
-# Is it possible here to omit any call of 'getChar' if the Char it read is not used? No, because we need to return the "world" that is the result of the second 'getChar' and this in turn requires the "world" returned from the first 'getChar'.
+# Можно ли переставить местами вызовы 'getChar'? Нет, так как второй 'getChar' использует 'RealWorld', возвращённый первым.
-# Is it possible to reorder the 'getChar' calls? No: the second 'getChar' can't be called before the first one because it uses the "world" returned from the first call.
-# Is it possible to duplicate calls? In Haskell semantics - yes, but real compilers never duplicate work in such simple cases (otherwise, the programs generated will not have any speed guarantees).
+# Is it possible to duplicate calls? In Haskell semantics - yes, but real compilers never duplicate work in such simple cases (otherwise, the programs generated will not have any speed guarantees). (Непонятно, что понимается под duplicate calls --[[User:Beroal|Beroal]] 00:48, 18 April 2008 (UTC))
+Повторим ещё раз, что 'RealWorld' похож на эстафетную палочку, которая передаётся между IO-процедурами.
-As we already said, RealWorld values are used like a baton which gets passed
+IO-процедуры, явно или неявно, вызываются из 'main' в строгом порядке.
-between all routines called by 'main' in strict order. Inside each
+Внутри IO-процедуры 'RealWorld' используется таким образом: чтобы «вычислить» новое значение 'RealWorld', мы выполняем императивные команды. Поэтому каждая IO-процедура выполняется именно в тот момент, который мы задали (момент относительно других IO-процедур). Пример:
-routine called, RealWorld values are used in the same way. Overall, in
-order to "compute" the world to be returned from 'main', we should perform
-each IO procedure that is called from 'main', directly or indirectly.
-This means that each procedure inserted in the chain will be performed
-just at the moment (relative to the other IO actions) when we intended it
-to be called. Let's consider the following program:
 <haskell>
@@ Line 182: / Line 171: @@
 </haskell>
+Теперь вы знаете, как транслировать императивные программы на Хаскелле в низкоуровневый код и можете проверить, что IO-процедуры выполняются именно в том порядке и с теми аргументами, которые вы запланировали.
-Now you have enough knowledge to rewrite it in a low-level way and
-check that each operation that should be performed will really be
-performed with the arguments it should have and in the order we expect.
+Пока мы рассматривали линейные алгоритмы. Можно ли задать ветвление? Конечно. Так задаётся управляющая структура 'when':
-But what about conditional execution? No problem. Let's define the
-well-known 'when' operation:
 <haskell>
@@ Line 198: / Line 184: @@
 </haskell>
+Мы можем выполнить некоторую IO-процедуру при некотором условии, наложенном на аргумент функции 'when'.
-As you can see, we can easily include or exclude from the execution chain
+Если аргумент 'condition' ложный, то 'action' не будет вызвана, так как реальный компилятор не вызывает функцию, если её результат не нужен для подсчёта окончательного результата (под окончательным подразумевается значение 'RealWorld', возвращаемое 'main').
-IO procedures (actions) depending on the data values. If 'condition'
-will be False on the call of 'when', 'action' will never be called because
-real Haskell compilers, again, never call functions whose results
-are not required to calculate the final result (''i.e.'', here, the final "world" value of 'main').
+(Чтобы обеспечить правильное выполнение императивных команд, недостаточно, чтобы 'RealWorld' был абстрактным типом. Значение типа 'RealWorld' (то есть, реальный мир) необходимо запретить копировать. Если компилятор нарушит вышеприведённое условие, то есть, вычислит 'action' при ложном 'condition', то одно и то же значение типа 'RealWorld' будет передано в 'action' возвращено функцией 'when'. То есть компилятор должен уметь копировать мир. Но скопировать мир нельзя, так как под миром подразумеваются не только внутренности компьютера, но и все его внешние устройства, то есть, потенциально, вся Вселенная. То есть, 'RealWorld' — это не обычный тип. Этот тип обозначает данные, которые нельзя копировать. Это свойство 'RealWorld' можно распространить на другие типы данных, например, можно задать монолитный массив, который запрещено копировать из соображений производительности. Подробнее с некопируемыми данными можно познакомиться в функциональном языке Clean, uniqueness type system.)
-Loops and more complex control structures can be implemented in
-the same way. Try it as an exercise!
+Аналогично можно задать циклы и другие управляющие конструкции. Это вам домашнее задание.
-Finally, you may want to know how much passing these RealWorld
-values around the program costs. It's free! These fake values exist solely for the compiler while it analyzes and optimizes the code, but when it gets to assembly code generation, it "suddenly" realize that this type is like "()", so
-all these parameters and result values can be omitted from the final generated code. Isn't it beautiful? :)
+Наконец возникает опасение, что протаскивание 'RealWorld' через все функции увеличит накладные расходы. На самом деле, компилятор, видя, что 'RealWorld' не содержит данных (так же, как и "()"), не включает 'RealWorld' в низкоуровневый императивный код. Круто? :)
-== '>>=' and 'do' notation ==
+== Нотация '>>=' и 'do' ==
-All beginners (including me :)) start by thinking that 'do' is some
-magic statement that executes IO actions. That's wrong - 'do' is just
+Все новички (включая меня :)) думают, что 'do' — это специальная конструкция для выполнения IO.
-syntactic sugar that simplifies the writing of procedures that use IO (and also other monads, but that's beyond the scope of this tutorial). 'do' notation eventually gets translated to statements passing "world" values around like we've manually written above and is used to simplify the gluing of several
+Это не так — 'do' просто синтаксический сахар, делающий использование IO (и других монад) более удобным.
-IO actions together. You don't need to use 'do' for just one statement; for instance,
+'do' в конечном счёте транслируется в код, передающий 'RealWorld', примерно так же, как мы это делали ранее вручную
+'do' склеивает несколько IO-процедур в цепочку.
+(Точнее, 'do' транслируется в функциональный код, состоящий из '>>=', '>>' и лямбда-абстракций, а 'RealWorld' подставляется на следующем этапе.
+Другие монады 'RealWorld' не используют.)
+Каждая строка под 'do' называется командой (statement). IO-процедура — частный случай команды.
+'do', применённое к только одной IO-процедуре, не делает ничего. Код:
 <haskell>
@@ Line 225: / Line 213: @@
 </haskell>
+транслируется в:
-is desugared to:
 <haskell>
@@ Line 231: / Line 219: @@
 </haskell>
+Но признаком хорошего стиля считается использовать 'do' даже для одной IO-процедуры, так как это облегчает добавление новых процедур к цепочке в будущем.
-But nevertheless it's considered Good Style to use 'do' even for one statement
-because it simplifies adding new statements in the future.
+Посмотрим, как можно транслировать 'do' с несколькими IO-процедурами:
-Let's examine how to desugar a 'do' with multiple statements in the
-following example:
 <haskell>
@@ Line 244: / Line 229: @@
 </haskell>
+Здесь 'do' просто выполняет несколько IO-процедур последовательно.
-The 'do' statement here just joins several IO actions that should be
+После трансляции мы увидим, что IO-процедуры объединены в цепочку с помощью операции '>>'.
-performed sequentially. It's translated to sequential applications
+Она и другая операция '>>=' относятся к «связывающим» операциям ('>>=' так и называется: 'bind'):
-of one of the so-called "binding operators", namely '>>':
 <haskell>
@@ Line 255: / Line 240: @@
 </haskell>
+'>>' просто передает мир от предыдущей IO-процедуры к последующей:
-This binding operator just combines two IO actions, executing them
-sequentially by passing the "world" between them:
 <haskell>
@@ Line 266: / Line 250: @@
 </haskell>
+Другой вариант того же определения:
-If defining operators this way looks strange to you, read this
-definition as follows:
 <haskell>
@@ Line 277: / Line 260: @@
 </haskell>
+Подставьте определение '>>' в код, получившийся после трансляции 'do', чтобы убедиться, что код точно так же манипулирует миром, как мы манипулировали вручную.
-Now you can substitute the definition of '>>' at the places of its usage
-and check that program constructed by the 'do' desugaring is actually the
-same as we could write by manually manipulating "world" values.
+Есть другая разновидность команд 'do'. Они могут связывать переменную с помощью "<-" (аналогично тому, как связываются переменные в лямбда-абстракции):
-A more complex example involves the binding of variables using "<-":
 <haskell>
@@ Line 289: / Line 269: @@
 </haskell>
+Этот код транслируется в:
-This code is desugared into:
 <haskell>
@@ Line 296: / Line 276: @@
 </haskell>
+В отличие от лямбда-абстракции, "<-" может связывать только одну переменную.
-As you should remember, the '>>' binding operator silently ignores
-the value of its first action and returns as an overall result
+Функция '>>' выбрасывает значение предыдущей IO-процедуры.
-the result of its second action only. On the other hand, the '>>=' binding operator (note the extra '=' at the end) allows us to use the result of its first action - it gets passed as an additional parameter to the second one! Look at the definition:
+'>>=', наоборот, позволяет использовать это значение в следующей IO-процедуре.
+Поэтому к её имени добавили знак равенства.
+Значение предыдущей IO-процедуры передаётся как аргумент последующей IO-процедуре:
 <haskell>
@@ Line 308: / Line 291: @@
 </haskell>
+Расшифруем тип 'action2': "a -> IO b" = "a -> RealWorld -> (b, RealWorld)".
-First, what does the type of the second "action" (more precisely, a function which returns an IO action), namely "a -> IO b", mean? By
+Это значит, что 'action2' имеет два аргумента: аргумент типа 'a', который она использует некоторым неизвестным для нас образом, и аргумент типа 'RealWorld' для передачи управления.
-substituting the "IO" definition, we get "a -> RealWorld -> (b, RealWorld)".
+Все IO-процедуры имеют на один параметр больше, чем указано в их типе.
-This means that second action actually has two parameters
+Этот параметр спрятан в конструкторе типов 'IO'.
-- the type 'a' actually used inside it, and the value of type RealWorld used for sequencing of IO actions. That's always the case - any IO procedure has one
-more parameter compared to what you see in its type signature. This
-parameter is hidden inside the definition of the type alias "IO".
+Вы можете использовать '>>' и '>>=' наряду с 'do'. Иногда это упрощает код.
-Second, you can use these '>>' and '>>=' operations to simplify your
+В этом примере нет необходимости вводить переменную — результат 'readLn' можно прямо передать в 'print':
-program. For example, in the code above we don't need to introduce the
-variable, because the result of 'readLn' can be send directly to 'print':
 <haskell>
@@ Line 324: / Line 304: @@
+Наконец, конструкция:
-And third - as you see, the notation:
 <haskell>
@@ Line 331: / Line 311: @@
 </haskell>
-where 'action1' has type "IO a" and 'action2' has type "IO b",
+где 'action1' имеет тип "IO a" и 'action2' имеет тип "IO b", транслируется в:
-translates into:
 <haskell>
@@ Line 338: / Line 317: @@
 </haskell>
-where the second argument of '>>=' has the type "a -> IO b". It's the way
+где второй аргумент функции '>>=' имеет тип "a -> IO b".
+Так транслируется '<-' — связанная им переменная может использоваться в дальнейших IO-процедурах, соединённых в одну большую IO-процедуру.
-the '<-' binding is processed - the name on the left-hand side of '<-' just becomes a parameter of subsequent operations represented as one large IO action.  Note also that if 'action1' has type "IO a" then 'x' will just have type "a"; you can think of the effect of '<-' as "unpacking" the IO value of 'action1' into 'x'.  Note also that '<-' is not a true operator; it's pure syntax, just like 'do' itself.  Its meaning results only from the way it gets desugared.
+Тип введённой переменной определяется типом 'action1': если 'action1' имеет тип "IO a", то 'x' имеет тип "a".
+Можно представить себе, что '<-' «раскрывает» IO-процедуру.
+'<-' не является функцией, это специальная синтаксическая конструкция, как и 'do'.
+Её смысл в том, как она транслируется.
+Следующий пример:
-Look at the next example:
 <haskell>
@@ Line 351: / Line 334: @@
 </haskell>
+Код транслируется в:
-This code is desugared into:
 <haskell>
@@ Line 361: / Line 344: @@
 </haskell>
+Скобки обущены; обе функции '>>' и '>>=' ассоциативны слева направо, но лямбда-абстракция всегда поглощает максимум кода справа от '->', насколько это возможно.
-I omitted the parentheses here; both the '>>' and the '>>=' operators are
+Поэтому переменные 'a' и 'b' видимы во всём коде правее места, где 'a' и 'b' связываются.
-left-associative, but lambda-bindings always stretches as far to the right as possible, which means that the 'a' and 'b' bindings introduced
+В качестве упражнения, расставьте скобки так, как их расставил бы парсер, и транслируйте код до 'RealWorld'.
-here are valid for all remaining actions. As an exercise, add the
+На этом можно закончить изучение 'do' и IO.
-parentheses yourself and translate this procedure into the low-level
-code that explicitly passes "world" values. I think it should be enough to help you finally realize how the 'do' translation and binding operators work.
+Постойте! Я забыл про третью монадную функцию: 'return'.
-Oh, no! I forgot the third monadic operator - 'return'. It just
+Она заключает два своих параметра в кортеж:
-combines its two parameters - the value passed and "world":
 <haskell>
@@ Line 376: / Line 358: @@
 </haskell>
+Попробуйте транслировать пример с 'return':
-How about translating a simple example of 'return' usage? Say,
 <haskell>
@@ Line 384: / Line 366: @@
+Программисты, раннее изучавшие императивные языки, ошибочно полагают, что 'return' в Хаскелле возвращает управление из IO-процедуры, опуская дальнейшие IO-процедуры.
-Programmers with an imperative language background often think that
+Но даже из её типа видно, что это не так.
-'return' in Haskell, as in other languages, immediately returns from
+'return' используется только для того, чтобы вернуть некоторое значение типа 'a' как результат IO-процедуры типа "IO a".
-the IO procedure. As you can see in its definition (and even just from its
+Как правило, 'return' стоит в конце списка команд 'do'.
-type!), such an assumption is totally wrong. The only purpose of using
+Попробуйте транслировать следующий пример:
-'return' is to "lift" some value (of type 'a') into the result of
-a whole action (of type "IO a") and therefore it should generally be used only as the last executed statement of some IO sequence. For example try to
-translate the following procedure into the corresponding low-level code:
 <haskell>
@@ Line 399: / Line 379: @@
 </haskell>
+чтобы убедиться, что 'print' будет выполнена при любых значениях 'a', а значение "()", которые вроде бы должен был вернуть 'main', просто потеряется.
-and you will realize that the 'print' statement is executed even for non-negative values of 'a'. If you need to escape from the middle of an IO procedure, you can use the 'if' statement:
+Потеряется потому, что код будет транслирован в функцию '>>', которая выбрасывает результат IO-процедуры.
+Для того, чтобы вернуть управление из середины IO-процедуры, используйте 'if':
 <haskell>
@@ Line 408: / Line 390: @@
 </haskell>
+Также Хаскелл позволяет вставить 'do' внутрь 'if':
-Moreover, Haskell layout rules allow us to use the following layout:
 <haskell>
@@ Line 418: / Line 400: @@
 </haskell>
+Так удобно выходить из середины длинного списка команд в 'do'.
-that may be useful for escaping from the middle of a longish 'do' statement.
+Последнее упражнение: напишите реализацию функции 'liftM', которая превращает обычную функцию в монадическую:
-Last exercise: implement a function 'liftM' that lifts operations on
-plain values to the operations on monadic ones. Its type signature:
 <haskell>
@@ Line 428: / Line 409: @@
 </haskell>
+Если это для вас трудно, воспользуйтесь следующим функциональным определением:
-If that's too hard for you, start with the following high-level
-definition and rewrite it in low-level fashion:
 <haskell>
@@ Line 435: / Line 415: @@
                     return (f x)
 </haskell>
+Не следует забывать, что всё, что является монадой, является и функтором.
+Поэтому на IO-процедурах можно использовать функцию 'fmap'.
+Вместо громоздкого
+<haskell>
+action >>= \x -> return (x+1)
+</haskell>
+или
+<haskell>
+do x <- action
+                    return (x+1)
+</haskell>
+можно написать:
+<haskell>
+fmap (+1) action
+</haskell>
+Также fmap = liftM, о которой мы говорили выше.
@@ Line 671: / Line 674: @@
 <haskell>
-readi h i = do hSeek h i AbsoluteSeek
+readi h i = do hSeek h AbsoluteSeek i
                hGetChar h
 </haskell>
@@ Line 690: / Line 693: @@
 <haskell>
 readfilei name = do h <- openFile name ReadMode
-                    let readi h i = do hSeek h i AbsoluteSeek
+                    let readi h i = do hSeek h AbsoluteSeek i
                                        hGetChar h
                     return (readi h)
@@ Line 699: / Line 702: @@
 <haskell>
 readfilei name = do h <- openFile name ReadMode
-                    let readi i = do hSeek h i AbsoluteSeek
+                    let readi i = do hSeek h AbsoluteSeek i
                                      hGetChar h
                     return readi
@@ Line 1,174: / Line 1,177: @@
 == Further reading ==
-This tutorial is largely based on the Simon Peyton Jones' paper [http://research.microsoft.com/%7Esimonpj/Papers/marktoberdorf Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell]. I hope that my tutorial improves his original explanation of the Haskell I/O system and brings it closer to the point of view of beginning Haskell programmers. But if you need to learn about concurrency, exceptions and FFI in Haskell/GHC, the original paper is the best source of information.
+This tutorial is largely based on the Simon Peyton Jones' paper [https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.13.9123&rep=rep1&type=pdf Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell]. I hope that my tutorial improves his original explanation of the Haskell I/O system and brings it closer to the point of view of beginning Haskell programmers. But if you need to learn about concurrency, exceptions and FFI in Haskell/GHC, the original paper is the best source of information.
 You can find more information about concurrency, FFI and STM at the [[GHC/Concurrency#Starting points]] page.
@@ Line 1,206: / Line 1,209: @@
 ----
+[[Category:Ru]]