# Literate programming

(Difference between revisions)
 Revision as of 23:12, 8 October 2006 (edit) (Hawiki conversion and update)← Previous diff Revision as of 17:26, 9 October 2006 (edit) (undo) (Adding links, beefing it up)Next diff → Line 1: Line 1: [[Category:Glossary]] [[Category:Tutorials]] [[Category:Glossary]] [[Category:Tutorials]] - Literate programming was invented / coined / started by Dr. Donald + Literate programming was invented / coined / started by [http://www-cs-faculty.stanford.edu/~knuth/ Dr. Donald Knuth]. In, fact if you asked Dr. Knuth what his favourite programming - Knuth. In, fact if you asked Dr. Knuth what his favourite programming + language was, (5th question of http://www-cs-faculty.stanford.edu/~knuth/faq.html) you would be told CWEB - which is a literate programming - language was, you would be told CWEB - which is a literate programming + tool combining C and tex. - tool combining C and tex. + + What is literate programming? To quote Dr. Knuth: +
"The main idea is to regard a program as a communication to human beings rather than as a set of instructions to a computer."
+ + ==Haskell and literate programming== + Haskell is one of the few languages that provides native features to support literate programming. In haskell, a literate program is one with the suffix .lhs rather than .hs. + + In a literate Haskell program, there are two ways to distinguish between code and non-code portions. You can either prepend all code with a > , (bird style) or surround lines of code with \begin{code} and \end{code} pairs (latex style). For those who know, use and love latex, the latter is the suggested way to go. + + Note that [[Happy]] supports literate programming as well, via bird style (the > marker) in .ly files. Sadly, [[Alex]] no longer does. You might consider using [http://www.eecs.harvard.edu/~nr/noweb/ noweb] with it. + ==Latex suggestions for literate programming == ==Latex suggestions for literate programming == + (See also [[#lhs2TeX]] below) In the majority of these suggestions, you can simply write: In the majority of these suggestions, you can simply write: Line 107: Line 117: == Transformation of .lhs-files == == Transformation of .lhs-files == - To convert a Haskell script file which uses bird style to + Sub-pages here have scripts to convert from the demarcation via > (called "bird style" after Dr. Richard Bird) to \begin{code} and \end{code} pairs - \begin{code}...\end{code} style use one of the following scripts: + - awk: + * [[Literate programming/Bird conversion via awk]] + * [[Literate programming/Bird conversion via sed]] -
-                                                                                          # bird2code.awk
-                                                                                          ^[^>] || ^${print; next} - - ^> { - print "\\begin{code}" - sub(/^> /,"") - print - rc = getline - while(($0 ~ ^>) && (rc > 0)) {
-                                                                                          sub(/^> /,"")
-                                                                                          print
-                                                                                          rc = getline
-                                                                                          }
-                                                                                          print "\\end{code}\n"
-                                                                                          }
-
- - Or in sed: - -
-                                                                                          # bird2code.sed
-                                                                                          ^> !p
-                                                                                          ^> {
-                                                                                          i\
-                                                                                          \\begin{code}
-
-                                                                                          :loop
-                                                                                          N
-                                                                                          /\n>[^\n]*$/{ - b loop - } - s/^> // - s/$$\n$$> /\1/g - s/\n$//
-                                                                                          a\
-                                                                                          \\end{code}\
-
-                                                                                          p
-                                                                                          }
-
- - Thanks to Peter Tillier from the comp.lang.awk newsgroup. == Editors == == Editors == Line 212: Line 179: Highly recommended is '''lhs2TeX''' at [http://www.cs.uu.nl/~andres/lhs2tex/], courtesy of Andres Löh. It is designed for typesetting papers ''about'' Haskell, but '''lhs2TeX''' is easily configured and can make for a powerful preprocessor and documentation generator. Highly recommended is '''lhs2TeX''' at [http://www.cs.uu.nl/~andres/lhs2tex/], courtesy of Andres Löh. It is designed for typesetting papers ''about'' Haskell, but '''lhs2TeX''' is easily configured and can make for a powerful preprocessor and documentation generator. + + Input to lhs2TeX is a slightly modified .lhs file. One would typically use the standard latex recommendations above, using a \begin{code} and \end{code} pair to demarcate code. Additionally, lhs2TeX provides specialized macros to control the preprocessing. + + Note that lhs2TeX and in-line commenting do not seem to mix well. + Since it is able to typeset Haskell formulas in mathematical notation Since it is able to typeset Haskell formulas in mathematical notation with LaTeX's math mode you can also use it to create ''testable'' with LaTeX's math mode you can also use it to create ''testable'' papers. That is the reader can play with the formulas presented in the papers. That is the reader can play with the formulas presented in the paper if he obtains the literate Haskell source code of the paper. paper if he obtains the literate Haskell source code of the paper. + + ==See also== + * [http://www.literateprogramming.com/ Daniel Mall's website for Literate Programming.] + * [http://en.wikipedia.org/wiki/Literate_programming Wikipedia]

## Revision as of 17:26, 9 October 2006

Literate programming was invented / coined / started by Dr. Donald Knuth. In, fact if you asked Dr. Knuth what his favourite programming language was, (5th question of http://www-cs-faculty.stanford.edu/~knuth/faq.html) you would be told CWEB - which is a literate programming tool combining C and tex.

What is literate programming? To quote Dr. Knuth:

"The main idea is to regard a program as a communication to human beings rather than as a set of instructions to a computer."

## 1 Haskell and literate programming

Haskell is one of the few languages that provides native features to support literate programming. In haskell, a literate program is one with the suffix .lhs rather than .hs.

In a literate Haskell program, there are two ways to distinguish between code and non-code portions. You can either prepend all code with a > , (bird style) or surround lines of code with \begin{code} and \end{code} pairs (latex style). For those who know, use and love latex, the latter is the suggested way to go.

Note that Happy supports literate programming as well, via bird style (the >  marker) in .ly files. Sadly, Alex no longer does. You might consider using noweb with it.

## 2 Latex suggestions for literate programming

(See also #lhs2TeX below) In the majority of these suggestions, you can simply write:

\begin{code}
qsort []     = []
qsort (x:xs) = qsort [y | y<-xs, y>x] ++ [x] ++ qsort [y | y<-xs, y<=x]
\end{code}

and the code will be formatted as you requested.

The advantage: Source code and documentation are consistent! The code environment is understood by Haskell compilers, so you can run your documentation files directly.

### 2.1 Verbatim package

One can always simply use verbatim mode which will format the code "as-is".

Use verbatim:

\usepackage{verbatim}
\newenvironment{code}{\footnotesize\verbatim}{\endverbatim\normalsize}


### 2.2 Listings package

Another alternatative is to use the latex-package listings, which allows you to do much more customization of the output:

\usepackage{listings}


You can configure the appearance of the listings quite a bit! Some people find these settings to be the most satisfying:

\usepackage{listings}
\lstnewenvironment{code}
{\lstset{}%
\csname lst@SetFirstLabel\endcsname}
{\csname lst@SaveFirstLabel\endcsname}
\lstset{
basicstyle=\small\ttfamily,
flexiblecolumns=false,
basewidth={0.5em,0.45em},
literate={+}{{$+$}}1 {/}{{$/$}}1 {*}{{$*$}}1 {=}{{$=$}}1
{>}{{$>$}}1 {<}{{$<$}}1 {\\}{{$\lambda$}}1
{->}{{$\rightarrow$}}2 {>=}{{$\geq$}}2 {<-}{{$\leftarrow$}}2
{<=}{{$\leq$}}2 {=>}{{$\Rightarrow$}}2
{\ .}{{$\circ$}}2 {\ .\ }{{$\circ$}}2
{>>}{{>>}}2 {>>=}{{>>=}}2
{|}{{$\mid$}}1
}


You might want to consult the documentation of the "listings" package, to find out whether there's more you can tune to your likings. (Like adding line numbers, etc.) Note that the suggested "literate" option above will replace the given symbols anywhere in the text, including inside strings, which is probably not what one wants.

### 2.3 Hiding code from Latex

If you want to hide some code, you can e.g. define:

\long\def\ignore#1{}


Auxiliary functions can be hidden as follows:

\ignore{
\begin{code}
help = putStr "Help me, what is this LiterateProgramming thing??"
\end{code}
}


Thanks to Wolfram Kahl, Oliver Braun and the people of the German TeX-newsgroup.

Ciao, Steffen Mazanek

### 2.4 Hiding code from Haskell

If you want to hide a \begin{code}...\end{code} block from the compiler, say, if you want to show an example in the text that is not actually part of the source code, you can just add a comment right after the "\begin{code}" statement. This will cause the Haskell parser to treat this block as text, not code:

And the definition of the following function
would totally screw up my program, so I'm not
definining it:

\begin{code}% this is not really code
main :: IO ()
main = print "just an example"
\end{code}

See?


## 3 Transformation of .lhs-files

Sub-pages here have scripts to convert from the demarcation via >  (called "bird style" after Dr. Richard Bird) to \begin{code} and \end{code} pairs

## 4 Editors

### 4.1 Multi-mode support in Emacs

Another useful tool for literate programmers is the mmm-mode for Emacs. mmm-mode switches the current major mode of the buffer between two alternatives, depending on the context the cursor is in. If you're in, say, a \begin{code}...\end{code} block, you'll be editing in haskell-mode, but once you leave that block, you'll be editing in latex-mode.

I have managed to cook up a configuration for both literate styles, but surely some Emacs guru can enhance these. To configure mmm-mode for Haskell, add these lines to your .emacs file:

(add-hook 'haskell-mode-hook 'my-mmm-mode)

:submode text-mode
:front "^[^>]"
:include-front true
:back "^>\\|\$"
)
:front "^\\\\begin{code}"
:front-offset (end-of-line 1)
:back "^\\\\end{code}"
:include-back nil
:back-offset (beginning-of-line -1)
)))

(defun my-mmm-mode ()
;; go into mmm minor mode when class is given
(make-local-variable 'mmm-global-mode)
(setq mmm-global-mode 'true))

(setq mmm-submode-decoration-level 0)


You can activate mmm-mode by running "M-x mmm-ify-by-class" in the buffer. Emacs will prompt you for the class to use, to which should answer literate-haskell-bird or literate-haskell-latex, respectively.

If you want Emacs to activate mmm-mode automatically for certain literate Haskell files, add these lines to it at the end:

% ----- Configure Emacs -----
%
% Local Variables: ***
% mode: latex ***
% End: ***


This is, what the my-mmm-mode hook does, by the way.

### 4.2 Vim

Take a look at http://urchin.earth.li/~ian/vim. This improves considerably vim's syntax highlighting. See also Vim for the bits of vim script needed to integrate with the ghc compiler.

## 5 lhs2TeX

Highly recommended is lhs2TeX at [1], courtesy of Andres Löh. It is designed for typesetting papers about Haskell, but lhs2TeX is easily configured and can make for a powerful preprocessor and documentation generator.

Input to lhs2TeX is a slightly modified .lhs file. One would typically use the standard latex recommendations above, using a \begin{code} and \end{code} pair to demarcate code. Additionally, lhs2TeX provides specialized macros to control the preprocessing.

Note that lhs2TeX and in-line commenting do not seem to mix well.

Since it is able to typeset Haskell formulas in mathematical notation with LaTeX's math mode you can also use it to create testable papers. That is the reader can play with the formulas presented in the paper if he obtains the literate Haskell source code of the paper.