@*Small scripts with Haskell.
@qNormally@> I give blog posts detailing the fun, interesting or advanced
stuff I do with Haskell. But that isn't a real representation of my
programming life! Most of the time I am doing small scripts that do
little tasks, so I thought I'd describe one of those. This post is 
a literate program, which means you save the contents as a
.hweb file  from which you generate .shtml and .hs files.
@h

@*.
The task I had to complete was to take a directory of files, and, for
each file <code>foo.txt</code>, generate the files <code>foo_m1.txt
</code> to <code>foo_m3.txt</code>, where each one file is a block 
of lines from the original delimited by a blank line i.e. given the
file with lines <code>["", "1", "1", "", "2", "", "3"]</code>, the
numbers "1" would go in <code>foo_m1.txt.txt</code> etc.
@h

@*.
This blog post isn't how I actually wrote the original script - I 
didn't use literate Haskell (since I find it ugly), I didn't give 
explicit import lists (since they are needlessly verbose), I didn't
give type signatures (but I should have) and I didn't split the IO
and non-IO as well as (but again, I should have). It is intended as
a guide to the simple things you can easily do with Haskell. Now on
to the code...
@h

@*.
Every Haskell program starts with <code>main</code>, which is an IO 
action. For this program, we are going to keep all the IO in <code>main
</code>, and otherwise only use functions. With most file processing
applications it's best to read files from one directory, and write 
them to another. That way, if anything goes wrong, it is usually easy
to recover. In this case we read from "data" and write to "res".
@h
@<Needed libraries@>
main :: IO ()
main = do
    @<Set <code>files</code> to be list of files in the directory "data"@>
    @<Process each file in <code>files</code> which has the extension ".txt"@>

@*.
@<Needed libraries@>=
import System.Directory(getDirectoryContents)

@*.
@<Set <code>files</code> to be list of files in the directory "data"@>=
    files <- getDirectoryContents "data"
    
@*.
@<Needed libraries@>=
import Control.Monad
import System.FilePath(takeExtension, dropExtension, (<.>), (</>))
    
@*.
@<Process each file in <code>files</code> which has the extension ".txt"@>=
    forM_ files $ \file -> when (takeExtension file == ".txt") $ do
        @<Set <code>src</code> to be the result of reading the file@>
        @<Process each numbered result of reading the file@>
        
@*.
@<Set <code>src</code> to be the result of reading the file@>=
        src <- readFile $ "data" </> file
      
@*.
@<Process each numbered result of reading the file@>=
        forM_ (zip [1..] (split_file src)) $ \(i, x) ->
            @<Write out the value to "res/file_m#.txt" where # is the 1-based index into the results list@>

@*.
@<Write out the value to "res/file_m#.txt" where # is the 1-based index into the results list@>=
            writeFile ("res" </> dropExtension file ++ "_m" ++ show i <.> "txt") x
            
@*. We can now move on to the functional bits left over. We want a
function <code>split_file</code> that that takes a string and splits
it in three chunks for each of the blocks in the string. When
processing text, often there will be stray blank lines, and the term
"blank lines" will also apply to lines consisting only spaces. The 
code is:
@h
split_file :: String -> [String]
split_file xs = 
    let 
        @<Split the text into lines@>
        @<Drop all leading spaces from each line@>
        @<Drop all leading blank lines@>
        @<Break on the first empty line, the bits before are chunk 1@>
        @<Drop all leading blank lines for the rest@>
        @<Break on the first empty line in the rest, before is chunk 2, after is chunk 3@>
    in
        @<Put the lines of each chunk back together, and tabify them@>
      
@*.
@<Split the text into lines@>=
        as = lines xs
        
@*.
@<Needed libraries@>=
import Data.Char(isSpace)

@*.
@<Drop all leading spaces from each line@>=
        bs = map (dropWhile isSpace) as
        
@*.
@<Drop all leading blank lines@>=
        cs = dropWhile null bs
        
@*.
@<Break on the first empty line, the bits before are chunk 1@>=
        (s1, _:rest) = break null cs
        
@*.
@<Drop all leading blank lines for the rest@>=
        ds = dropWhile null rest
        
@*.
@<Break on the first empty line in the rest, before is chunk 2, after is chunk 3@>=
        (s2,_:s3) = break null ds
        
@*.
@<Put the lines of each chunk back together, and tabify them@>=
        map (tabify . unlines) [s1,s2,s3]
        
@*.
The tabify requirement was added after. The person decided that all
continuous runs of spaces should be converted to tabs, so the file
could better be loaded into a spreadsheet. Easy enough to add, just
a simple bit of recursive programming:
@h
tabify xs = 
    case xs of
        @<If the list is empty, then we're done@>
        @<If you encounter a space, drop it and all successive spaces, and write out a tab@>
        @<Otherwise just continue onwards@>
        
@*.
@<If the list is empty, then we're done@>=
        [] -> []
        
@*.
@<If you encounter a space, drop it and all successive spaces, and write out a tab@>=
        (' ':ys) -> '\t' : tabify (dropWhile (== ' ') ys) 
        
@*.
@<Otherwise just continue onwards@>=
        (y:ys) -> y : tabify ys
        
@*.
Haskell is a great language for writing shorts, and as the libraries
improve it just keeps getting better.
@h