Introduction to Programming: Lecture 19
|
|
|
- Lindsey McGee
- 5 years ago
- Views:
Transcription
1 Introduction to Programming: Lecture 19 K Narayan Kumar Chennai Mathematical Institute 6 November 2012
2 Actions: More details Actions are terms of type IO a for some a.
3 Actions: More details Actions are terms of type IO a for some a. Two basic functions used to construct and combine actions are: return :: a -> IO a >>= :: IO a -> (a -> IO b) -> IO b
4 Actions: More details Actions are terms of type IO a for some a. Two basic functions used to construct and combine actions are: return :: a -> IO a >>= :: IO a -> (a -> IO b) -> IO b Executing the action (ac1 >>= ac2) executes ac1 unboxes the resulting value, applies ac2 to get an action and executes that action.
5 Actions: More details Actions are terms of type IO a for some a. Two basic functions used to construct and combine actions are: return :: a -> IO a >>= :: IO a -> (a -> IO b) -> IO b Executing the action (ac1 >>= ac2) executes ac1 unboxes the resulting value, applies ac2 to get an action and executes that action. Actually, IO is an example of a Monad and these functions are available in any Monad.
6 Actions: More details Actions are terms of type IO a for some a. Two basic functions used to construct and combine actions are: return :: a -> IO a >>= :: IO a -> (a -> IO b) -> IO b Executing the action (ac1 >>= ac2) executes ac1 unboxes the resulting value, applies ac2 to get an action and executes that action. Actually, IO is an example of a Monad and these functions are available in any Monad. There are other functions such as readln, putstrln,... that are specfic to certain IO types.
7 Composing Actions Read a line and print it.
8 Composing Actions Read a line and print it. getline >>= putstrln
9 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string?
10 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String
11 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string.
12 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string. getline >>= \x -> (putstrln (show (length x)))
13 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string. getline >>= \x -> (putstrln (show (length x))) What if we wanted to print the length two times?
14 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string. getline >>= \x -> (putstrln (show (length x))) What if we wanted to print the length two times? getline >>= \x -> (putstrln (show (length x)) >>= putstrln (show (length x)))
15 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string. getline >>= \x -> (putstrln (show (length x))) What if we wanted to print the length two times? getline >>= \x -> (putstrln (show (length x)) >>= putstrln (show (length x))) Alas, that does not type check!
16 Composing Actions Read a line and print it. getline >>= putstrln What if we want to print the length of the string? getline :: IO String That should be coupled with a term of type String -> IO () which prints the length of a given string. getline >>= \x -> (putstrln (show (length x))) What if we wanted to print the length two times? getline >>= \x -> (putstrln (show (length x)) >>= putstrln (show (length x))) Alas, that does not type check! getline >>= \x -> (putstrln (show (length x)) >>= \y -> putstrln (show (length x)))
17 The operator >> p >> q = p >>= \n -> q
18 The operator >> p >> q = p >>= \n -> q Thus we may rewrite the previous program as
19 The operator >> p >> q = p >>= \n -> q Thus we may rewrite the previous program as getline >>= \x -> (putstrln (show (length x)) >> putstrln (show (length x)))
20 Translating do... using >>= A single actions needs no do do ---> exp exp
21 Translating do... using >>= A single actions needs no do do ---> exp exp No <- in the first action,
22 Translating do... using >>= A single actions needs no do do ---> exp exp No <- in the first action, any value it returns can be thrown away! do ---> exp >> do exp S S
23 Translating do... using >>= A single actions needs no do do ---> exp exp No <- in the first action, any value it returns can be thrown away! do ---> exp >> do exp S S name <- exp is the first action.
24 Translating do... using >>= A single actions needs no do do ---> exp exp No <- in the first action, any value it returns can be thrown away! do ---> exp >> do exp S S name <- exp is the first action. Bind the value returned by the first action to the name name and... do ---> exp >>= name <- exp \name -> do S S
25 Example main = do putstrln ("Please enter your name:") name <- getline putstrln ("Hello " ++ name)
26 Example main = do putstrln ("Please enter your name:") name <- getline putstrln ("Hello " ++ name) main = putstrln ("Please enter your name:") >> do name <- getline putstrln ("Hello " ++ name)
27 Example main = do putstrln ("Please enter your name:") name <- getline putstrln ("Hello " ++ name) main = putstrln ("Please enter your name:") >> do name <- getline putstrln ("Hello " ++ name) main = putstrln ("Please enter your name:") >> getline >>= \name -> do putstrln ("Hello " ++ name)
28 Example... main = putstrln ("Please enter your name:") >> getline >>= \name -> do putstrln ("Hello " ++ name)
29 Example... main = putstrln ("Please enter your name:") >> getline >>= \name -> do putstrln ("Hello " ++ name) main = putstrln ("Please enter your name:") >> getline >>= \name -> putstrln ("Hello " ++ name)
30 Reading and Writing into Files To supply input from a file to an executable we can use input redirection $./myprogram < inputfile
31 Reading and Writing into Files To supply input from a file to an executable we can use input redirection $./myprogram < inputfile The output of a program can be saved in a file we can use output redirection $./myprogram > outputfile
32 Reading and Writing into Files To supply input from a file to an executable we can use input redirection $./myprogram < inputfile The output of a program can be saved in a file we can use output redirection $./myprogram > outputfile We can redirect input and output together $./myprogram < inputfile > outputfile
33 Reading and Writing into Files To supply input from a file to an executable we can use input redirection $./myprogram < inputfile The output of a program can be saved in a file we can use output redirection $./myprogram > outputfile We can redirect input and output together $./myprogram < inputfile > outputfile File input output can also be done directly from within the program.
34 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode
35 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle
36 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle It takes the name of the file, the mode it which it is to be opened, and returns a handle.
37 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle It takes the name of the file, the mode it which it is to be opened, and returns a handle. The mode can be one of ReadMode, WriteMode, AppendMode and ReadWriteMode.
38 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle It takes the name of the file, the mode it which it is to be opened, and returns a handle. The mode can be one of ReadMode, WriteMode, AppendMode and ReadWriteMode. WriteMode begins by creating the file from scratch, deleting anything that is already there. AppendMode appends to the end of an existing file and creating the file if it does not exist. The handle is used in operations pertaining to the opened file.
39 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle It takes the name of the file, the mode it which it is to be opened, and returns a handle. The mode can be one of ReadMode, WriteMode, AppendMode and ReadWriteMode. WriteMode begins by creating the file from scratch, deleting anything that is already there. AppendMode appends to the end of an existing file and creating the file if it does not exist. The handle is used in operations pertaining to the opened file. The function hclose :: Handle -> IO () closes the file.
40 File I/O... To read or write from file, it has to be opened in the approriate mode. myhandle <- openfile "inputfile" ReadMode The type of openfile is FilePath -> IOMode -> IO Handle It takes the name of the file, the mode it which it is to be opened, and returns a handle. The mode can be one of ReadMode, WriteMode, AppendMode and ReadWriteMode. WriteMode begins by creating the file from scratch, deleting anything that is already there. AppendMode appends to the end of an existing file and creating the file if it does not exist. The handle is used in operations pertaining to the opened file. The function hclose :: Handle -> IO () closes the file. The module System.IO has to be imported.
41 File I/O Once a file is open we can perform I/O operations using a variety of functions.
42 File I/O Once a file is open we can perform I/O operations using a variety of functions. To read a line we can use hgetline :: Handle -> IO String
43 File I/O Once a file is open we can perform I/O operations using a variety of functions. To read a line we can use hgetline :: Handle -> IO String Starts from the first position. Each successive call continues reading from the position where the where the previous call ended.
44 File I/O Once a file is open we can perform I/O operations using a variety of functions. To read a line we can use hgetline :: Handle -> IO String Starts from the first position. Each successive call continues reading from the position where the where the previous call ended. and to write to a file we can use hputstrln :: Handle -> String -> IO ()
45 File I/O Once a file is open we can perform I/O operations using a variety of functions. To read a line we can use hgetline :: Handle -> IO String Starts from the first position. Each successive call continues reading from the position where the where the previous call ended. and to write to a file we can use hputstrln :: Handle -> String -> IO () To read other types combine hgetline with the function read :: Read a => String -> a that works like readln
46 File I/O Once a file is open we can perform I/O operations using a variety of functions. To read a line we can use hgetline :: Handle -> IO String Starts from the first position. Each successive call continues reading from the position where the where the previous call ended. and to write to a file we can use hputstrln :: Handle -> String -> IO () To read other types combine hgetline with the function read :: Read a => String -> a that works like readln Here is function to read in an Int from a line hreadint h = (hgetline h) >>= \x -> return ((read :: Int) x)
47 File I/O examples Copy two lines from the file FileA to the file FileB copyoneline :: Handle -> Handle -> IO () copyoneline hi ho = do inp <- hgetline hi hputstrln ho inp main = do hinp <- openfile "FileA" ReadMode hout <- openfile "FileB" WriteMode copyoneline hinp hout copyoneline hinp hout hclose hinp hclose hout
48 Copying Files To copy the entire file, we must know when to stop.
49 Copying Files To copy the entire file, we must know when to stop. The function hiseof :: Handle -> IO Bool returns True if the current position has reached the end of the file.
50 Copying Files To copy the entire file, we must know when to stop. The function hiseof :: Handle -> IO Bool returns True if the current position has reached the end of the file. We can copy a files using copyall :: Handle -> Handle -> IO () copyall hi ho = do over <- hiseof hi if over then return () else do copyoneline hi ho copyall hi ho
51 The stdin,stdout and stderr The Handle stdin is available to read from the standard input which is the keyboard unless the input has been redirected.
52 The stdin,stdout and stderr The Handle stdin is available to read from the standard input which is the keyboard unless the input has been redirected. The Handle stdout is available to write to the standard output which is the screen unless the output has been redirected.
53 The stdin,stdout and stderr The Handle stdin is available to read from the standard input which is the keyboard unless the input has been redirected. The Handle stdout is available to write to the standard output which is the screen unless the output has been redirected. The Handle stderr is available to write to the standard error, where error messages are printed, again set to the screen unless explicitely redirected.
54 The stdin,stdout and stderr The Handle stdin is available to read from the standard input which is the keyboard unless the input has been redirected. The Handle stdout is available to write to the standard output which is the screen unless the output has been redirected. The Handle stderr is available to write to the standard error, where error messages are printed, again set to the screen unless explicitely redirected. copyall stdin stdout will act like echo
55 The stdin,stdout and stderr The Handle stdin is available to read from the standard input which is the keyboard unless the input has been redirected. The Handle stdout is available to write to the standard output which is the screen unless the output has been redirected. The Handle stderr is available to write to the standard error, where error messages are printed, again set to the screen unless explicitely redirected. copyall stdin stdout will act like echo To generate EOF from the keyboard use ^D
56 Moving around a file A file is a sequence of characters. The positions are numbered starting at 0.
57 Moving around a file A file is a sequence of characters. The positions are numbered starting at 0. The Handle maintains our current position within the file.
58 Moving around a file A file is a sequence of characters. The positions are numbered starting at 0. The Handle maintains our current position within the file. Each time we read or write a character the position increases by 1.
59 Moving around a file A file is a sequence of characters. The positions are numbered starting at 0. The Handle maintains our current position within the file. Each time we read or write a character the position increases by 1. The function htell returns the current position.
60 Moving around a file A file is a sequence of characters. The positions are numbered starting at 0. The Handle maintains our current position within the file. Each time we read or write a character the position increases by 1. The function htell returns the current position. The function hseek can be used to move to a different position within the file. Relative to the current position (RelativeSeek) Relative to beginning of the file (AbsoluteSeek) Relative to the end of the file (SeekFromEnd)
61 Seek and Tell Write at the word The at the beginning of the file.
62 Seek and Tell Write at the word The at the beginning of the file. hseek h AbsoluteSeek 0 hputchar h T hputchar h h hputchar h e Assumes that h is a handle to a file opened in write or read-write mode.
63 Seek and Tell Write at the word The at the beginning of the file. hseek h AbsoluteSeek 0 hputchar h T hputchar h h hputchar h e Assumes that h is a handle to a file opened in write or read-write mode. Copy the current character to the next position.
64 Seek and Tell Write at the word The at the beginning of the file. hseek h AbsoluteSeek 0 hputchar h T hputchar h h hputchar h e Assumes that h is a handle to a file opened in write or read-write mode. Copy the current character to the next position. do c <- hgetchar h hputchar h c Assumes that h is a handle opened in read-write mode.
65 Seek and Tell Write at the word The at the beginning of the file. hseek h AbsoluteSeek 0 hputchar h T hputchar h h hputchar h e Assumes that h is a handle to a file opened in write or read-write mode. Copy the current character to the next position. do c <- hgetchar h hputchar h c Assumes that h is a handle opened in read-write mode. Copy the current character to the end of the file.
66 Seek and Tell Write at the word The at the beginning of the file. hseek h AbsoluteSeek 0 hputchar h T hputchar h h hputchar h e Assumes that h is a handle to a file opened in write or read-write mode. Copy the current character to the next position. do c <- hgetchar h hputchar h c Assumes that h is a handle opened in read-write mode. Copy the current character to the end of the file. do c <- hgetchar h hseek h SeekFromEnd 0 hputchar h c
67 Files and File I/O Files exist across different runs of a program. Any data that needs to be stored across runs has to be in files.
68 Files and File I/O Files exist across different runs of a program. Any data that needs to be stored across runs has to be in files. Files allow different programs to exchange information. One program may write its output to a file from which another reads.
69 Files and File I/O Files exist across different runs of a program. Any data that needs to be stored across runs has to be in files. Files allow different programs to exchange information. One program may write its output to a file from which another reads. Files reside on the disk and can typically store much more data than in memory. Large databases are manipulated by programs by loading just parts into the memory.
70 Files and File I/O Files exist across different runs of a program. Any data that needs to be stored across runs has to be in files. Files allow different programs to exchange information. One program may write its output to a file from which another reads. Files reside on the disk and can typically store much more data than in memory. Large databases are manipulated by programs by loading just parts into the memory. Files can also be used to exchange data between programs running in different machines.
71 Files: Examples A simple Music Library. Song Artist Album the number of times listed to.
72 Files: Examples A simple Music Library. Song Artist Album the number of times listed to. Each item occupies four lines.
73 Files: Examples A simple Music Library. Song Artist Album the number of times listed to. Each item occupies four lines. Entries are separated by a blank line.
74 Files: Examples A simple Music Library. Song Artist Album the number of times listed to. Each item occupies four lines. Entries are separated by a blank line. Find the song that I have listened to most?
75 Files: Examples A simple Music Library. Song Artist Album the number of times listed to. Each item occupies four lines. Entries are separated by a blank line. Find the song that I have listened to most? List the songs in the order of the number of times listened to?
76 Music Library... Body and Soul Django Reinhardt Djangology Vol 5 4 Entertainer Scott Joplin A-Z Encyclopedia of Jazz 10 Romanian Folk Dances for the Piano Bela Bartok Concertos for the piano and orchestra Vol 2/3 4 Raag Ek Nishad Ka Behagda Mallikarjun Mansur 12...
77 Load and process Each entry is a four tuple type Entry = (String,String,String,Int) deriving (Eq,Ord,Show) main = do hd <- openfile "MusicData" ReadMode el <- fillelist hd [] --- Process the list el using pure functions --- Write down el at the end.
78 Load and process Each entry is a four tuple type Entry = (String,String,String,Int) deriving (Eq,Ord,Show) main = do hd <- openfile "MusicData" ReadMode el <- fillelist hd [] --- Process the list el using pure functions --- Write down el at the end. Construct a list of entries from the file. fillelist :: Find the song most listened to. most :: Handle -> [Entry] -> IO [Entry] [Entry] -> Entry Increment its count by 1 (listen to it). inccount ::... Entry -> Entry
79 fillelist... fillelist h l = do over <- hiseof h if (over) then return l else do song <- hgetline h artist <- hgetline h album <- hgetline h times <- (hgetline h >>= (read::int)) hgetline h nl <- fillelist h l return ((song,artist,album,times):nl) Populates a list with the contents of the file.
80 Records in Haskell : An aside Tuples allow grouping if values. type Entry = (String,String,String,Int)
81 Records in Haskell : An aside Tuples allow grouping if values. type Entry = (String,String,String,Int) We may also use user defined datatypes. data Entry = Entry String String String Int
82 Records in Haskell : An aside Tuples allow grouping if values. type Entry = (String,String,String,Int) We may also use user defined datatypes. data Entry = Entry String String String Int In both cases we will need extractor functions to access the components: song :: Entry -> String artist :: Entry -> String album :: Entry -> String times :: Entry -> Int
83 Records in Haskell : An aside Tuples allow grouping if values. type Entry = (String,String,String,Int) We may also use user defined datatypes. data Entry = Entry String String String Int In both cases we will need extractor functions to access the components: song :: Entry -> String artist :: Entry -> String album :: Entry -> String times :: Entry -> Int Haskell allows you define extractor functions simultaneously with the definition of the data type.
84 Record Syntax We can define Entry as follows: data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int } deriving (Ord, Eq, Show)
85 Record Syntax We can define Entry as follows: data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int } deriving (Ord, Eq, Show) This has the effect of
86 Record Syntax We can define Entry as follows: data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int } deriving (Ord, Eq, Show) This has the effect of Defining a datatype data Entry = Entry String String String Int
87 Record Syntax We can define Entry as follows: data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int } deriving (Ord, Eq, Show) This has the effect of Defining a datatype data Entry = Entry String String String Int providing accessor functions song, artist, album andtimes
88 Record Syntax We can define Entry as follows: data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int } deriving (Ord, Eq, Show) This has the effect of Defining a datatype data Entry = Entry String String String Int providing accessor functions song, artist, album andtimes Values can be created as entry = Entry { song = "Tunji", artist = "John Coltrane album = "In a Soulful Mood", times = 3 }
89 Record... data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int entry = Entry { song = "Tunji", artist = "John Coltrane album = "In a Soulful Mood", times = 3 }
90 Record... data Entry = Entry { song :: String, artist :: String, album :: String, times :: Int entry = Entry { song = "Tunji", artist = "John Coltrane album = "In a Soulful Mood", times = 3 } As expected we have song entry = "Tunji" times entry = 3...
91 Record... The order of entries is unimportant if we use the record notation.
92 Record... The order of entries is unimportant if we use the record notation. entry = Entry { song = "Tunji", album = "In a Soulful Mood", artist = "John Coltrane", times = 3 } has the same effect.
93 Record... The order of entries is unimportant if we use the record notation. entry = Entry { song = "Tunji", album = "In a Soulful Mood", artist = "John Coltrane", times = 3 } has the same effect. We are also free to the datatype version. entry = Entry "Tunji" "In a Soulful Mood" "John Coltrane" 3
94 Back to the Music Album Our current scheme of
95 Back to the Music Album Our current scheme of Load the data from the file to a list
96 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list
97 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list Write the list to the file
98 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list Write the list to the file has some flaws.
99 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list Write the list to the file has some flaws. What if we change only one or two entries?
100 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list Write the list to the file has some flaws. What if we change only one or two entries? We still have to write the entire file.
101 Back to the Music Album Our current scheme of Load the data from the file to a list work with the list Write the list to the file has some flaws. What if we change only one or two entries? We still have to write the entire file. Can we selectively write only the changed entries?
102 Selective Writing
103 Selective Writing Seek to the correct position in the file and write.
104 Selective Writing Seek to the correct position in the file and write. How do we know the correct position in the file?
105 Selective Writing Seek to the correct position in the file and write. How do we know the correct position in the file? Modify fillellist to also record for each entry the position where it begins in the file. type Entry = (String,String,String,Int,Int)... fillellist... do pos = htell h song = hgetline h...
106 Selective Writing Seek to the correct position in the file and write. How do we know the correct position in the file? Modify fillellist to also record for each entry the position where it begins in the file. type Entry = (String,String,String,Int,Int)... fillellist... do pos = htell h song = hgetline h... To write an entry, seek to its position and then write.
107 A Flaw in our idea What happens when the count goes from 9 to 10.
108 A Flaw in our idea What happens when the count goes from 9 to 10. We overwrite the first character in the next entry!
109 A Flaw in our idea What happens when the count goes from 9 to 10. We overwrite the first character in the next entry! Either write everything from there on.
110 A Flaw in our idea What happens when the count goes from 9 to 10. We overwrite the first character in the next entry! Either write everything from there on. or assuming fixed length changable fields.
111 A Flaw in our idea What happens when the count goes from 9 to 10. We overwrite the first character in the next entry! Either write everything from there on. or assuming fixed length changable fields. Allocate 4 characters for times always.
IO Monad (3C) Young Won Lim 8/23/17
Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
IO Monad (3C) Young Won Lim 1/6/18
Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
HASKELL I/O. Curt Clifton Rose-Hulman Institute of Technology. Please SVN Update your HaskellInClass folder, then open eieio.hs
HASKELL I/O Curt Clifton Rose-Hulman Institute of Technology Please SVN Update your HaskellInClass folder, then open eieio.hs SEPARATION OF CONCERNS Haskell separates pure code from side-effecting code
Using Monads for Input and Output
L13-1 Using Monads for Input and Output Jan-Willem Laboratory for Computer Science M.I.T. November 4, 2002 Functional Languages and I/O L13-2 z := f(x) + g(y); In a functional language f and g can be evaluated
Programming in Haskell Aug Nov 2015
Programming in Haskell Aug Nov 2015 LECTURE 23 NOVEMBER 12, 2015 S P SURESH CHENNAI MATHEMATICAL INSTITUTE Summary of IO Actions of type IO t1, t1 -> IO t2, t1 -> t2 -> IO t3 etc. As opposed to pure functions
IO Monad (3D) Young Won Lim 1/18/18
Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
How to reify fresh type variables?
How to reify fresh type variables? Oleg Kiselyov Chung-chieh Shan 15 September 2011 1/17 Waiter, there s a term in my type! Rank-2 polymorphism (ab)used, for safety: mutable state array index bounds environment
The SimpleLit System for Literate Programming
The SimpleLit System for Literate Programming Andrew Rock School of Information and Communication Technology Griffith University Nathan, Queensland, 4111, Australia a.rock@griffith.edu.au June 15, 2017
Monad Background (3A) Young Won Lim 10/5/17
Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
I/O in Haskell. To output a character: putchar :: Char -> IO () e.g., putchar c. To output a string: putstr :: String -> IO () e.g.
I/O in Haskell Generally, I/O functions in Haskell have type IO a, where a could be any type. The purpose and use of a will be explained later. We call these commands or actions, for we think of them as
PROGRAMMING IN HASKELL. Chapter 10 - Interactive Programming
PROGRAMMING IN HASKELL Chapter 10 - Interactive Programming 0 Introduction To date, we have seen how Haskell can be used to write batch programs that take all their inputs at the start and give all their
References. Monadic I/O in Haskell. Digression, continued. Digression: Creating stand-alone Haskell Programs
References Monadic I/O in Haskell Jim Royer CIS 352 March 6, 2018 Chapter 18 of Haskell: the Craft of Functional Programming by Simon Thompson, Addison-Wesley, 2011. Chapter 9 of Learn you a Haskell for
INTERACTION FUNCTIONS
INTERACTION FUNCTIONS Definition of interaction function Function main is executed when we run a Haskell pro ask ask question :: String -> IO String = do putstrln question getline main :: IO () main =
Monad Background (3A) Young Won Lim 11/18/17
Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Haskell Revision and Exercises
and Exercises April 10, 2017 Martin Perešíni Haskell Revision and Exercises April 10, 2017 1 / 53 Content Content Content Haskell Revision Types and Typeclasses Types of Functions List of types Syntax
Introduction to Haskell
Introduction to Haskell Matt Mullins Texas A&M Computing Society October 6, 2009 Matt Mullins (TACS) Introduction to Haskell October 6, 2009 1 / 39 Outline Introduction to Haskell Functional Programming
More on functional programming
More on functional programming Emphasis on Haskell (as a pure functional language) Input and output in Haskell Wrappers / contexts Monads chaining wrapped computations Maybe and lists as monads Return
Monad Background (3A) Young Won Lim 11/8/17
Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Box-and-arrow Diagrams
Box-and-arrow Diagrams 1. Draw box-and-arrow diagrams for each of the following statements. What needs to be copied, and what can be referenced with a pointer? (define a ((squid octopus) jelly sandwich))
CSCE 314 Programming Languages. Interactive Programming: I/O
CSCE 314 Programming Languages Interactive Programming: I/O Dr. Hyunyoung Lee 1 Introduction To date, we have seen how Haskell can be used to write batch programs that take all their inputs at the start
Overview. Declarative Languages. General monads. The old IO monad. Sequencing operator example. Sequencing operator
Overview Declarative Languages D7012E: General monads in haskell Fredrik Bengtsson IO-monad sequencing operator monad class requirements on monad Monadic computation trivial example useful example The
Haskell: From Basic to Advanced. Part 2 Type Classes, Laziness, IO, Modules
Haskell: From Basic to Advanced Part 2 Type Classes, Laziness, IO, Modules Qualified types In the types schemes we have seen, the type variables were universally quantified, e.g. ++ :: [a] -> [a] -> [a]
CS The IO Monad. Slides from John Mitchell, K Fisher, and S. Peyton Jones
CS 242 2012 The IO Monad Slides from John Mitchell, K Fisher, and S. Peyton Jones Reading: Tackling the Awkward Squad, Sections 1-2 Real World Haskell, Chapter 7: I/O Beauty... Functional programming is
M-Structures (Continued)
M-Structures (Continued) plus Introduction to the I/O Monad Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. October 24, 2006 October 24, 2006 http://www.csg.csail.mit.edu/6.827 L12-1
Standard prelude. Appendix A. A.1 Classes
Appendix A Standard prelude In this appendix we present some of the most commonly used definitions from the standard prelude. For clarity, a number of the definitions have been simplified or modified from
Reading and manipulating files
Reading and manipulating files Goals By the end of this lesson you will be able to Read files without using text editors Access specific parts of files Count the number of words and lines in a file Sort
GHCi: Getting started (1A) Young Won Lim 5/31/17
GHCi: Getting started (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
The List Datatype. CSc 372. Comparative Programming Languages. 6 : Haskell Lists. Department of Computer Science University of Arizona
The List Datatype CSc 372 Comparative Programming Languages 6 : Haskell Lists Department of Computer Science University of Arizona collberg@gmail.com All functional programming languages have the ConsList
Iteratee IO safe, practical, declarative input processing
Iteratee IO safe, practical, declarative input processing http://okmij.org/ftp/streams.html Utrecht, NL December 17, 2009 Updated for the November 2010 version 1 Outline Introduction Non-solutions: Handle-based
Monad Background (3A) Young Won Lim 11/20/17
Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Input / Output Functions
CSE 2421: Systems I Low-Level Programming and Computer Organization Input / Output Functions Presentation G Read/Study: Reek Chapter 15 Gojko Babić 10-03-2018 Input and Output Functions The stdio.h contain
CSE 12 Spring 2018 Week One, Lecture Two
CSE 12 Spring 2018 Week One, Lecture Two Homework One and Two: - Introduction to C - Review of basic programming principles - Building from fgetc and fputc - Input and output strings and numbers - Introduction
Background Operators (1E) Young Won Lim 7/7/18
Background Operators (1E) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Programming Paradigms
PP 2017/18 Unit 11 Functional Programming with Haskell 1/37 Programming Paradigms Unit 11 Functional Programming with Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE
Programming Paradigms Functional languages
Programming Paradigms Functional languages Ing. Marek Běhálek Ph.D. FEI VŠB-TUO EA404 / 597 32 5879 http://www.cs.vsb.cz/behalek marek.behalek@vsb.cz Presentation is based on original course materials
GHCi: Getting started (1A) Young Won Lim 6/3/17
GHCi: Getting started (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Introduction to Programming: Lecture 3
Introduction to Programming: Lecture 3 K Narayan Kumar Chennai Mathematical Institute http://www.cmi.ac.in/~kumar 14 Aug 2012 Polymorphism in Haskell mylength [] = 0 mylength (x:xs) = 1 + mylength xs Polymorphism
Haskell Monads CSC 131. Kim Bruce
Haskell Monads CSC 131 Kim Bruce Monads The ontological essence of a monad is its irreducible simplicity. Unlike atoms, monads possess no material or spatial character. They also differ from atoms by their
John McCarthy IBM 704
How this course works SI 334: Principles of Programming Languages Lecture 2: Lisp Instructor: an arowy Lots of new languages Not enough class time to cover all features (e.g., Java over the course of 34-36:
Functional Programming in Haskell Part I : Basics
Functional Programming in Haskell Part I : Basics Madhavan Mukund Chennai Mathematical Institute 92 G N Chetty Rd, Chennai 600 017, India madhavan@cmi.ac.in http://www.cmi.ac.in/ madhavan Madras Christian
Programming Languages
Programming Languages Andrea Flexeder Chair for Theoretical Computer Science Prof. Seidl TU München winter term 2010/2011 Lecture 10 Side-Effects Main Points you should get: Why monads? What is a monad?
CSE 12 Spring 2016 Week One, Lecture Two
CSE 12 Spring 2016 Week One, Lecture Two Homework One and Two: hw2: Discuss in section today - Introduction to C - Review of basic programming principles - Building from fgetc and fputc - Input and output
Software Design & Programming I
Software Design & Programming I Starting Out with C++ (From Control Structures through Objects) 7th Edition Written by: Tony Gaddis Pearson - Addison Wesley ISBN: 13-978-0-132-57625-3 Chapter 3 Introduction
Informatics 1 Functional Programming Lectures 15 and 16. IO and Monads. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lectures 15 and 16 IO and Monads Don Sannella University of Edinburgh Part I The Mind-Body Problem The Mind-Body Problem Part II Commands Print a character putchar
Goals of this Lecture
I/O Management 1 Goals of this Lecture Help you to learn about: The Unix stream concept Standard C I/O functions Unix system-level functions for I/O How the standard C I/O functions use the Unix system-level
Software System Design and Implementation
Software System Design and Implementation Controlling Effects Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 18s1 Examples of effects
Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors
Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source
I/O Management! Goals of this Lecture!
I/O Management! 1 Goals of this Lecture! Help you to learn about:" The Unix stream concept" Standard C I/O functions" Unix system-level functions for I/O" How the standard C I/O functions use the Unix
I/O Management! Goals of this Lecture!
I/O Management! 1 Goals of this Lecture! Help you to learn about:" The Unix stream concept" Standard C I/O functions" Unix system-level functions for I/O" How the standard C I/O functions use the Unix
2.3 Unix Streaming and Piping
2.3 Unix Streaming and Piping In addition to streams explicitly opened by applications, the Unix system provides you with 3 special streams: stdin (standard input): This stream is usually connected to
CS#457/557:#Functional# Languages#
CS#457/557:#Functional# Languages# Lecture(8:(I/O(Actions(in(Haskell Mark(P(Jones(and(Andrew(Tolmach Portland(State(University 1 Side&effects+considered+harmful We+define++fst+(x,y)+=+x But+is+fst+(print+1,+print+2)
I/O in Purely Functional Languages. Stream-Based I/O. Continuation-Based I/O. Monads
I/O in Purely Functional Languages Stream-Based I/O Four centuries ago, Descartes pondered the mind-body problem: how can incorporeal minds interact with physical bodies? Designers of purely declarative
Introduction to Programming: Lecture 10
Introduction to Programming: Lecture 10 K Narayan Kumar Chennai Mathematical Institute http://www.cmi.ac.in/~kumar 10 Sep 2012 Organizing functions as Modules Organize functions into modules. Organizing
GHCi: Getting started (1A) Young Won Lim 5/26/17
GHCi: Getting started (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
(Refer Slide Time: 01:12)
Internet Technology Prof. Indranil Sengupta Department of Computer Science and Engineering Indian Institute of Technology, Kharagpur Lecture No #22 PERL Part II We continue with our discussion on the Perl
Fundamentals of Programming
Fundamentals of Programming Lecture 3 - Constants, Variables, Data Types, And Operations Lecturer : Ebrahim Jahandar Borrowed from lecturer notes by Omid Jafarinezhad Outline C Program Data types Variables
Welcome! COMP s1. Programming Fundamentals
Welcome! COMP1511 18s1 Programming Fundamentals COMP1511 18s1 Lecture 11 1 Files, Memory Andrew Bennett Overview 2 after this lecture, you should be able to have a basic understanding
Informatics 1 Functional Programming Lecture 7. Map, filter, fold. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 7 Map, filter, fold Don Sannella University of Edinburgh Part I Map Squares *Main> squares [1,-2,3] [1,4,9] squares :: [Int] -> [Int] squares xs [ x*x x
Fundamental of Programming (C)
Borrowed from lecturer notes by Omid Jafarinezhad Fundamental of Programming (C) Lecturer: Vahid Khodabakhshi Lecture 3 Constants, Variables, Data Types, And Operations Department of Computer Engineering
File Access. FILE * fopen(const char *name, const char * mode);
File Access, K&R 7.5 Dealing with named files is surprisingly similar to dealing with stdin and stdout. Start by declaring a "file pointer": FILE *fp; /* See Appendix B1.1, pg. 242 */ header
Principles of Programming Languages
Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 15/ Prof. Andrea Corradini Department of Computer Science, Pisa Monads in Haskell The IO Monad Lesson 27! 1 Pros of FuncConal
Lecture #23: Conversion and Type Inference
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). Last modified: Fri Oct 20 10:46:40 2006 CS164:
The Classical OS Model in Unix
The Classical OS Model in Unix Nachos Exec/Exit/Join Example Exec parent Join Exec child Exit SpaceID pid = Exec( myprogram, 0); Create a new process running the program myprogram. int status = Join(pid);
Functional Programming
Functional Programming Monadic Prelude Jevgeni Kabanov Department of Computer Science University of Tartu Introduction Previously on Functional Programming Monadic laws Monad class (>>= and return) MonadPlus
The nox Source Manual
The nox Source Manual Linus Arver ver. 0.1.0-4-gf123c9e 2014-01-07 16:34:14-0800 Contents 1 Introduction 1 1.1 How to Read This Manual............................ 1 2 nox.lhs 2 3 NOX/Option.lhs 2 4 NOX/Language.lhs
C++ basics Getting started with, and Data Types.
C++ basics Getting started with, and Data Types pm_jat@daiict.ac.in Recap Last Lecture We talked about Variables - Variables, their binding to type, storage etc., Categorization based on storage binding
Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";
CS 440: Programming Languages and Translators, Spring 2019 Mon 2/4
Haskell, Part 5 CS 440: Programming Languages and Translators, Spring 2019 Mon 2/4 More Haskell Miscellaneous topics Simple I/O, do blocks, actions Modules data vs type declaration Instances of classtypes
Reserved Words and Identifiers
1 Programming in C Reserved Words and Identifiers Reserved word Word that has a specific meaning in C Ex: int, return Identifier Word used to name and refer to a data element or object manipulated by the
Lecture 8: Structs & File I/O
....... \ \ \ / / / / \ \ \ \ / \ / \ \ \ V /,----' / ^ \ \.--..--. / ^ \ `--- ----` / ^ \. ` > < / /_\ \. ` / /_\ \ / /_\ \ `--' \ /. \ `----. / \ \ '--' '--' / \ / \ \ / \ / / \ \ (_ ) \ (_ ) / / \ \
Advanced training. Linux components Command shell. LiLux a.s.b.l.
Advanced training Linux components Command shell LiLux a.s.b.l. alexw@linux.lu Kernel Interface between devices and hardware Monolithic kernel Micro kernel Supports dynamics loading of modules Support
CS Final Exam Review Suggestions - Spring 2014
CS 111 - Final Exam Review Suggestions p. 1 CS 111 - Final Exam Review Suggestions - Spring 2014 last modified: 2014-05-09 before lab You are responsible for material covered in class sessions, lab exercises,
Scheme as implemented by Racket
Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the
Process Management! Goals of this Lecture!
Process Management! 1 Goals of this Lecture! Help you learn about:" Creating new processes" Programmatically redirecting stdin, stdout, and stderr" Unix system-level functions for I/O" The Unix stream
Unix Processes. What is a Process?
Unix Processes Process -- program in execution shell spawns a process for each command and terminates it when the command completes Many processes all multiplexed to a single processor (or a small number
Assignment 3. Timothy H. Kaiser, PH.D.
Assignment 3 Timothy H. Kaiser, PH.D. tkaiser@mines.edu 1 N-body - Bag of tasks Goal: Pull together a number of concepts we have discussed Basic MPI Bag of tasks OpenMPI Scripting Get you to think about
String Computation Program
String Computation Program Reference Manual Scott Pender scp2135@columbia.edu COMS4115 Fall 2012 10/31/2012 1 Lexical Conventions There are four kinds of tokens: identifiers, keywords, expression operators,
CSCI-243 Exam 2 Review February 22, 2015 Presented by the RIT Computer Science Community
CSCI-43 Exam Review February, 01 Presented by the RIT Computer Science Community http://csc.cs.rit.edu C Preprocessor 1. Consider the following program: 1 # include 3 # ifdef WINDOWS 4 # include
CS246 Spring14 Programming Paradigm Files, Pipes and Redirection
1 Files 1.1 File functions Opening Files : The function fopen opens a file and returns a FILE pointer. FILE *fopen( const char * filename, const char * mode ); The allowed modes for fopen are as follows
Background Type Classes (1B) Young Won Lim 6/14/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
CIS 194: Homework 3. Due Wednesday, February 11, Interpreters. Meet SImPL
CIS 194: Homework 3 Due Wednesday, February 11, 2015 Interpreters An interpreter is a program that takes another program as an input and evaluates it. Many modern languages such as Java 1, Javascript,
Streams. Rupesh Nasre.
Streams Rupesh Nasre. OOAIA January 2018 I/O Input stream istream cin Defaults to keyboard / stdin Output stream ostream cout std::string name; std::cout > name; std::cout
Monads seen so far: IO vs Gen
Monads David Sands Monads seen so far: IO vs Gen IO A Gen A Instructions to build a value of type A by interacting with the operating system Instructions to create a random value of type A Run by the ghc
Parsing. Zhenjiang Hu. May 31, June 7, June 14, All Right Reserved. National Institute of Informatics
National Institute of Informatics May 31, June 7, June 14, 2010 All Right Reserved. Outline I 1 Parser Type 2 Monad Parser Monad 3 Derived Primitives 4 5 6 Outline Parser Type 1 Parser Type 2 3 4 5 6 What
f() ! " Run a higher-priority task? ! " Yield the processor to another task because our ! " Use the processor for some other activity while
CS 410/510: Advanced Programming Continuing a Computation: Continuations Mark P Jones Portland State University 1 Standard nested function call pattern 2 Continuing a Computation: What might we want to
CS 410/510: Advanced Programming
CS 410/510: Advanced Programming Continuations Mark P Jones Portland State University 1 Continuing a Computation: f() g() h() Standard nested function call pattern 2 Continuing a Computation: f() g() h()
Monad P1 : Several Monad Types (4A) Young Won Lim 2/13/19
Monad P1 : Several Copyright (c) 2016-2019 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any
EECS 700 Functional Programming
EECS 700 Functional Programming Dr. Andy Gill University of Kansas February 16, 2010 1 / 41 Parsing A parser is a program that analyses a piece of text to determine its syntactic structure. The expression
stdin, stdout, stderr
stdin, stdout, stderr stdout and stderr Many programs make output to "standard out" and "standard error" (e.g. the print command goes to standard out, error messages go to standard error). By default,
Monads. Lecture 12. Prof. Aiken CS 264 Lecture 12 1
Monads Lecture 12 Prof. Aiken CS 264 Lecture 12 1 Monads A language without side effects can t do I/O Side effects are critical in some applications For expressiveness and/or efficiency Haskell has a general
CS102: Standard I/O. %<flag(s)><width><precision><size>conversion-code
CS102: Standard I/O Our next topic is standard input and standard output in C. The adjective "standard" when applied to "input" or "output" could be interpreted to mean "default". Typically, standard output
8. Characters, Strings and Files
REGZ9280: Global Education Short Course - Engineering 8. Characters, Strings and Files Reading: Moffat, Chapter 7, 11 REGZ9280 14s2 8. Characters and Arrays 1 ASCII The ASCII table gives a correspondence
Informatics 1 Functional Programming 19 Tuesday 23 November IO and Monads. Philip Wadler University of Edinburgh
Informatics 1 Functional Programming 19 Tuesday 23 November 2010 IO and Monads Philip Wadler University of Edinburgh The 2010 Informatics 1 Competition Sponsored by Galois (galois.com) List everyone who
LECTURE 16. Functional Programming
LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative
Functional Programming for Logicians - Lecture 1
Functional Programming for Logicians - Lecture 1 Functions, Lists, Types Malvin Gattinger 4 June 2018 module L1 where Introduction Who is who Course website: https://malv.in/2018/funcproglog/ Malvin Gattinger
Background Type Classes (1B) Young Won Lim 6/28/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Functional Programming in Haskell Prof. Madhavan Mukund and S. P. Suresh Chennai Mathematical Institute
Functional Programming in Haskell Prof. Madhavan Mukund and S. P. Suresh Chennai Mathematical Institute Module # 02 Lecture - 03 Characters and Strings So, let us turn our attention to a data type we have
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of
Monads. Bonus lecture 2017 David Sands
Monads Bonus lecture 2017 David Sands Our version of the story, so far. Monad is the class of instructions. Instructions can be built using do notation. We have seen two kinds of instructions i.e. two
CS 11 Haskell track: lecture 4. n This week: Monads!
CS 11 Haskell track: lecture 4 This week: Monads! Monads Have already seen an example of a monad IO monad But similar concepts can be used for a lot of completely unrelated tasks Monads are useful "general