Yet Another Haskell Tutorial (original) (raw)

Report on the programming language Haskell, a non-strict, purely functional …

Sigplan …, 1992

Wise, and Jonathan Young-for the major contributions they have made to previous versions of this report. We also thank those who have participated in the lively discussions about Haskell on the FP and Haskell mailing lists. x PREFACE 1. At the topmost level a Haskell program is a set of modules, described in Section 5. Modules provide a way to control namespaces and to re-use software in large programs. 2. The top level of a module consists of a collection of declarations, of which there are several kinds, all described in Section 4. Declarations define things such as ordinary values, datatypes, type classes, and fixity information. 3. At the next lower level are expressions, described in Section 3. An expression denotes a value and has a static type; expressions are at the heart of Haskell programming "in the small." 4. At the bottom level is Haskell's lexical structure, defined in Section 2. The lexical structure captures the concrete representation of Haskell programs in text files. This report proceeds bottom-up with respect to Haskell's syntactic structure. The sections not mentioned above are Section 6, which describes the standard built-in datatypes and classes in Haskell, and Section 7, which discusses the I/O facility in Haskell (i.e. how Haskell programs communicate with the outside world). Also, there are several appendices describing the Prelude, the concrete syntax, literate programming, the specification of derived instances, and pragmas supported by most Haskell compilers. Examples of Haskell program fragments in running text are given in typewriter font:

Formulating haskell

1992

The functional programming language Haskell is examined from the point of view of proving programs correct. Particular features explored include the data type definition facilities, classes, the behaviour of patterns and guards and the monad approach to IO in the Glasgow Haskell compiler.

An implementation of the Haskell language

1990

Abstract This report describes the design and implementation of HASKELL system. The areas implemented are the lexical analysis, parsing, intepretation of the lambda tree, and machine code generation. Because of the size, complexity and novelty of the language many of these areas present particular difficulty. A considarable amount of meta-programming was used in order to tackle the size of the project.

Notes on Functional Programming with Haskell

2007

Permission to copy and use this document for educational or research purposes of a non-commercial nature is hereby granted provided that this copyright notice is retained on all copies. All other rights are reserved by the author. I wrote this set of lecture notes for use in the course Functional Programming (CSCI 555) that I teach in the Department of Computer and Information Science at the University of Mississippi. The course is open to advanced undergraduates and beginning graduate students. The first version of these notes were written as a part of my preparation for the fall semester 1993 offering of the course. This version reflects some restructuring and revision done for the fall 1994 offering of the course—or after completion of the class. For these classes, I used the following resources: These notes more or less cover the material from chapters 1 through 6 plus selected material from chapters 7 through 9. Gofer is an interpreter for a dialect of the " lazy " fu...

Functional programming, and where you can put it

ACM SIGPLAN Notices, 2001

Poor performance-Haskell and ML programs are big and slow. Rudimentary tools-Programming environments for Haskell and ML lag. Limited resource control-Haskell and ML inhibit direct control of computing resources. Restricted side effects-Tweaking system state is not a strong point of Haskell or ML.

Implementing Haskell: Language implementation as a tool building exercise

1993

Abstract Although a number of tool boxes for compiler construction exist, the language implementation task can often be made easier by building specialised tools. A prototype Haskell system was implemented within a four month period using such an approach. The system is currently used as a front end for a transputer array, Haskell implementation. In this article we describe the tool building aspect of the implementation process.