Creating new files

Operating systems generally provide a number of ways of opening files. In the default method, you normally open the file and overwrite the existing content with anything new that you write. When the file doesn’t exist, the operating system automatically creates it for you. The following code shows an example of opening a file for writing and automatically creating that file when it doesn’t exist:

import System.IO as IO

main = do
handle <- openFile "MyData.txt" WriteMode
hPutStrLn handle "This is some test data."
hClose handle

The defining factor here is the WriteMode argument. When you use the WriteMode argument, you tell the operating system to create a new file when one doesn't exist or to overwrite any existing content. The Python equivalent to this code is

handle = open("MyData2.txt", "w")
print(handle.write("This is some test data. "))
handle.close()

Notice that when using Python, you use the "w" argument to access the write mode. In addition, Python has no method of writing a line with a carriage return; you add it manually by using the escape. Adding the print function lets you see how many characters Python writes to the file.

As an alternative to using the WriteMode argument, you can use the ReadWriteMode argument when you want to both read from and write to the file. Writing to the file works as before: You either create a new file or overwrite the content of an existing file. To read from the file, of course, the file must contain something to read. The “Reading data” section of the chapter discusses this issue in more detail.

Opening existing files

When you have an existing file, you can read, append, update, and delete the data it contains. Even though you will create new files when writing an application, most applications spend more time opening existing files in order to manage content in some way. For the application to perform data-management tasks, the file must exist. Even if you think that the file exists, you must verify its presence because the user or another application may have deleted it, or the user may not have followed protocol and created it, or sunspot could have damaged the file directory entry on disk, or …. The list can become quite long as to why the file you thought was there really isn’t. The process of data management can become complex because you often perform searches for specific content as well. However, the initial task focuses on simply opening the file.

The “Reading data” section of the chapter discusses the task of opening a file to read it, especially when you need to search for specific data. Likewise, writing, updating, and deleting data appears in the “Updating data” section of the chapter. However, the task of appending — adding content to the end of the file — is somewhat different. The following code shows how to append data to a file that already exists:

import System.IO as IO

main = do
handle <- openFile "MyData.txt" AppendMode
hPutStrLn handle "This is some test data too."
hClose handle

Except for the AppendMode argument, this code looks much like the code in the previous section. However, no matter how often you run the code in the previous section, the resulting file always contains just one line of text. When you run this example, you see multiple lines, as shown in Figure 13-1.

Python provides the same functionality. The following code shows the Python version, which relies on the "a" (append) mode:

handle = open("MyData2.txt", "a")
print(handle.write("This is some test data too. "))
handle.close()

Some languages treat appending differently from standard writing. If the file doesn't exist, the language will raise an exception to tell you that you can't append to a file that doesn’t exist. To append to a file, you must create it first. Both Haskell and Python take a better route — appending also covers creating a new file when one doesn’t exist.

Considering CRUD

People create acronyms to make remember something easier. Sometimes those acronyms are unfortunate, as in calling operations on data CRUD. However, the people who work with databases wanted something easy to remember, so data-related tasks became CRUD. Another school of thought called the list of tasks Browse, Read, Edit, Add, and Delete (BREAD), but that particular acronym didn’t seem to stick, even though your daily BREAD might rely on your ability to employ CRUD. This chapter uses CRUD because that seems to be the most popular acronym. You can view CRUD as comprising the following tasks:

• Create: Adding new data to storage. Anytime you create new storage, such as a file, you generally create new data as well. Empty storage isn’t useful. The examples in the “Interacting with Files” section, earlier in this chapter, demonstrate creating data in both a new and an existing file. In both cases, the functional programming paradigm uses the IO monad operation on the combination of a handle and the associated data to place data in the file. This takes place after creating the file using another monad consisting of the IO operating on a combination of the filename and opening mode.
• Read: Reading data within a storage container means to do something with the content that doesn't change it in any way. You can see at least two kinds of read tasks in most applications:
  1. Employ an IO monad operation on the combination of a handle and data location to retrieve specific data. In this case, the data output is the target of the task. When you don’t supply a specific location, the operation assumes either the start of the storage or the current storage location pointer value. (The location pointer is an internally maintained value that indicates the end of the last read location within the storage.)
  2. Employ an IO monad operating on the combination of a handle and search criteria. In this case, the goal is to search for specific data and retrieve a data location based on that search. Some developers view this task as a browse, rather than as a read.
• Update: When data within the storage container still has value but contains mistakes, it requires an update, which the application performs using the following steps. In this case, you're really looking at a series of IO monads:
  1. Locate the existing data using the combination of a handle and the search expression.
  2. Copy the existing data using the combination of a handle and the data location.
  3. Write the new data using a combination of a handle and the data.
• Delete: When the data within storage no longer has value, the application deletes the entry. In this case, you rely on the following IO monads to perform the task:
  1. Locate the data to remove using a combination of a handle and a search expression.
  2. Delete the data using a combination of a handle and a data location.

Reading data

The concept of reading data isn't merely about obtaining information from a storage container, such as a file. When a person reads a book, a lot more goes on than simple information acquisition, in many cases. Often, the person must search for the appropriate information (unless the intent is to read the entire book) and then track progress during each reading session (unless there is just one session). A computer must do the same. The following example shows how the computer tracks its current position within the file during the read:

import System.IO as IO

main = do
handle <- openFile "MyData.txt" ReadMode
myData <- hGetLine handle
position <- hGetPosn handle
hClose handle
putStrLn myData
putStrLn (show position)

Here, the application performs a read using hGetLine, which obtains an entire line of text (ending with a carriage return). However, the test file contains more than one line of text if you worked through the examples in the previous sections. This means that the file pointer isn’t at the end of the file.

The call to hGetPosn obtains the actual position of the file pointer. The example outputs both the first line of text and the file position, which is reported as {handle: MyData.txt} at position 25 if you used the file from the previous examples. A second call to hGetLine will actually retrieve the next line of text from the file, at which point the file pointer will be at the end of the file.

The example shows hGetLine, but Haskell and Python both provide an extensive array of calls to obtain data from a file. For example, you can get a single character by calling hGetChar. You can also peek at the next character in line without moving the file pointer by calling hLookAhead.

Updating data

Of the tasks you can perform with a data container, such as a file, updating is often the hardest because it involves finding the data first and then writing new data to the same location without overwriting any data that isn't part of the update. The combination of the language you use and the operating system do reduce the work you perform immensely, but the process is still error prone. The following code demonstrates one of a number of ways to change the contents of a file. (Note that the two lines beginning with let writeData must appear on a single line in your code file.)

import System.IO as IO
import Data.Text as DT

displayData (filePath) = do
handle <- openFile filePath ReadMode
myData <- hGetContents handle
putStrLn myData
hClose handle

main = do
displayData "MyData3.txt"

contents <- readFile "MyData3.txt"
let writeData = unpack(replace
(pack "Edit") (pack "Update") (pack contents))
writeFile "MyData4.txt" writeData

displayData "MyData4.txt"

This example shows two methods for opening a file for reading. The first (as defined by the displayData function) relies on a modified form of the code shown in the “Reading data” section, earlier in this chapter. In this case, the example gets the entire contents of the file in a single read using hGetContents. The second version (starting with the second line of the main function) uses readFile, which also obtains the entire content of the file in a single read. This second form is easier to use but provides less flexibility.

The code uses the functions found in Data.Text to manipulate the file content. These functions rely on the Text data type, not the String data type. To convert a String to Text, you must call the pack function, as shown in the code. The reverse operation relies on the unpack function. The replace function provides just one method of modifying the content of a string. You can also rely on mapping to perform certain kinds of replacement, such as this single-character replacement:

let transform = pack contents
DT.map (c -> if c == '.' then '!' else c) transform

This method relies on a lambda function and provides considerable flexibility for a single-character replacement. The output replaces the periods in the text with exclamation marks by mapping the lambda function to the packed String (which is a Text object) found in transform. Notice how the lambda function examines characters separately, as opposed to the word-level search used in the example.

Observe how the example uses one file for input and an entirely different file for output. Haskell relies on lazy reads and writes. If you were to attempt to use readFile on a file and then writeFile on the same file a few lines down, the resulting application would display a “resource busy” type of error message.