4 make link work edit approved Feb 10 '15 at 15:37 3 added 13 characters in body edited Feb 8 '15 at 19:36 Andrej Bauer 22.3k11 gold badge5151 silver badges9191 bronze badges -- Simulated IO in a purely functional way in Haskell -- Simulated IO in a purely functional way in Haskell -- A dataype of programs which perform simulated IO and return -- results of type a data SimulatedIO a = Result a | Output String (SimulatedIO a) | Input (String -> SimulatedIO a) -- Run a simulated IO calculation on the given input stream. -- Return the result, the remaining (unused) input, and output. run :: [String] -> SimulatedIO a -> (a, [String], [String]) run input (Result a) = (a, input, []) run input (Output s c) = let (x, input', output) = run input c in (x, input', s : output) run (s:input') (Input c) = run input' (c s) -- Example greeter :: SimulatedIO Int greeter = Output "What is your name?" -- ask the user for his name (Input (\name -> -- read the name Output ("Hello " ++ name) -- greet the user (Result (length name)))) -- return the length of user's name -- Execute the example: user types inwith threesimulated stringsinput "John"["John", "Banana", "Orange""Orange"] example = run ["John", "Banana", "Orange"] greeter -- Thisthe computes:result is -- -- (4, ["Banana","Orange"], ["What is your name?","Hello John"]) -- -- 4 because "John" has four characters -- ["Banana","Orange"] is the unused input -- ["What is your name?","Hello John"] is the output  -- Simulated IO in a purely functional way in Haskell -- A dataype of programs which perform simulated IO and return -- results of type a data SimulatedIO a = Result a | Output String (SimulatedIO a) | Input (String -> SimulatedIO a) -- Run a simulated IO calculation on the given input stream. -- Return the result, the remaining (unused) input, and output. run :: [String] -> SimulatedIO a -> (a, [String], [String]) run input (Result a) = (a, input, []) run input (Output s c) = let (x, input', output) = run input c in (x, input', s : output) run (s:input') (Input c) = run input' (c s) -- Example greeter :: SimulatedIO Int greeter = Output "What is your name?" -- ask the user for his name (Input (\name -> -- read the name Output ("Hello " ++ name) -- greet the user (Result (length name)))) -- return the length of user's name -- Execute the example: user types in three strings "John", "Banana", "Orange" example = run ["John", "Banana", "Orange"] greeter -- This computes: -- (4, ["Banana","Orange"], ["What is your name?","Hello John"]) -- -- 4 because "John" has four characters -- ["Banana","Orange"] is the unused input -- ["What is your name?","Hello John"] is the output   -- Simulated IO in a purely functional way in Haskell -- A dataype of programs which perform simulated IO and return -- results of type a data SimulatedIO a = Result a | Output String (SimulatedIO a) | Input (String -> SimulatedIO a) -- Run a simulated IO calculation on the given input stream. -- Return the result, the remaining (unused) input, and output. run :: [String] -> SimulatedIO a -> (a, [String], [String]) run input (Result a) = (a, input, []) run input (Output s c) = let (x, input', output) = run input c in (x, input', s : output) run (s:input') (Input c) = run input' (c s) -- Example greeter :: SimulatedIO Int greeter = Output "What is your name?" -- ask the user for his name (Input (\name -> -- read the name Output ("Hello " ++ name) -- greet the user (Result (length name)))) -- return the length of user's name -- Execute the example with simulated input ["John", "Banana", "Orange"] example = run ["John", "Banana", "Orange"] greeter -- the result is -- -- (4, ["Banana","Orange"], ["What is your name?","Hello John"]) -- -- 4 because "John" has four characters -- ["Banana","Orange"] is the unused input -- ["What is your name?","Hello John"] is the output  2 added 1489 characters in body edited Feb 8 '15 at 18:33 Andrej Bauer 22.3k11 gold badge5151 silver badges9191 bronze badges The $$\lambda$$-calculus is a bit different because it does not have a direct notion of I/O. However, in any programming language we may simulate an input or an output stream by passing around extra lists of chacarters (or bits) which represent input and output streams. If you look up "IO monad"Here is an example in Haskell (but not of the Haskell kind – which is difficult as Google offersusing only thosepurely functional part if Haskell without any real I/O) you can see how it goes.:-- Simulated IO in a purely functional way in Haskell -- A dataype of programs which perform simulated IO and return -- results of type a data SimulatedIO a = Result a | Output String (SimulatedIO a) | Input (String -> SimulatedIO a) -- Run a simulated IO calculation on the given input stream. -- Return the result, the remaining (unused) input, and output. run :: [String] -> SimulatedIO a -> (a, [String], [String]) run input (Result a) = (a, input, []) run input (Output s c) = let (x, input', output) = run input c in (x, input', s : output) run (s:input') (Input c) = run input' (c s) -- Example greeter :: SimulatedIO Int greeter = Output "What is your name?" -- ask the user for his name (Input (\name -> -- read the name Output ("Hello " ++ name) -- greet the user (Result (length name)))) -- return the length of user's name -- Execute the example: user types in three strings "John", "Banana", "Orange" example = run ["John", "Banana", "Orange"] greeter -- This computes: -- (4, ["Banana","Orange"], ["What is your name?","Hello John"]) -- -- 4 because "John" has four characters -- ["Banana","Orange"] is the unused input -- ["What is your name?","Hello John"] is the output  The $$\lambda$$-calculus is a bit different because it does not have a direct notion of I/O. However, in any programming language we may simulate an input or an output stream by passing around extra lists of chacarters (or bits) which represent input and output streams. If you look up "IO monad" (but not of the Haskell kind – which is difficult as Google offers only those) you can see how it goes. The $$\lambda$$-calculus is a bit different because it does not have a direct notion of I/O. However, in any programming language we may simulate an input or an output stream by passing around extra lists of chacarters (or bits) which represent input and output streams. Here is an example in Haskell (but using only purely functional part if Haskell without any real I/O):-- Simulated IO in a purely functional way in Haskell -- A dataype of programs which perform simulated IO and return -- results of type a data SimulatedIO a = Result a | Output String (SimulatedIO a) | Input (String -> SimulatedIO a) -- Run a simulated IO calculation on the given input stream. -- Return the result, the remaining (unused) input, and output. run :: [String] -> SimulatedIO a -> (a, [String], [String]) run input (Result a) = (a, input, []) run input (Output s c) = let (x, input', output) = run input c in (x, input', s : output) run (s:input') (Input c) = run input' (c s) -- Example greeter :: SimulatedIO Int greeter = Output "What is your name?" -- ask the user for his name (Input (\name -> -- read the name Output ("Hello " ++ name) -- greet the user (Result (length name)))) -- return the length of user's name -- Execute the example: user types in three strings "John", "Banana", "Orange" example = run ["John", "Banana", "Orange"] greeter -- This computes: -- (4, ["Banana","Orange"], ["What is your name?","Hello John"]) -- -- 4 because "John" has four characters -- ["Banana","Orange"] is the unused input -- ["What is your name?","Hello John"] is the output  1 answered Feb 8 '15 at 18:23 Andrej Bauer 22.3k11 gold badge5151 silver badges9191 bronze badges