Initial commit

LICENSE

+Copyright (c) 1998-2004, Wolfgang Lux
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2.  Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+3. None of the names of the copyright holders and contributors may be
+used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

LIESMICH

+===============================================================================
+==
+==  Münster-Curry-Compiler
+==  Distribution zur Anwendung als Frontend in PAKCS
+==
+==  Letztes Update: 27.10.05
+
+Diese Distribution enthält die modifizierte Version des 
+Münster-Curry-Compilers (MCC) für die Verwendung als Frontend in PAKCS. Dieses 
+System ist u.a. in der Lage aus Curry-Programmen (entwickelt nach 
+PAKCS-Standard) Flat-Darstellungen (FlatCurry ".fcy", FlatInterface ".fint" 
+und FlatXML "_flat.xml"), sowie Abstract-Darstellungen (AbstractCurry ".acy" 
+und untyped AbstractCurry ".uacy") zu generieren.
+
+
+
+1. Installation
+---------------
+
+1.1 Installation der Binary-Distribution
+
+Die Binary-Distribution befindet sich in einem tar-Archiv und wird
+durch folgendes Kommando entpackt:
+
+	tar zxvf <Distribution>.tar.gz
+
+Danach steht der Compiler im Verzeichnis 'mcc' zur Verfügung.
+
+
+1.2 Installation der Source-Distribution
+
+Nach dem Entpacken des tar-Archivs mittels
+
+	tar zxvf <Distribution>.tar.gz
+
+kann der Compiler durch Aufruf von 'make' im Verzeichnis 'mcc' installiert
+werden. Bei Recompilierung (z.B. nach Änderungen in der Quelldateien)
+wird empfohlen vor einer erneuten Installation 'make clean' auszuführen.
+
+
+
+Nach erfolgreicher Installation befindet sich in beiden Fällen im Verzeichnis 
+'mcc/bin/' folgende ausführbare Datei:
+
+	cymake		- der Curry-Programm-Builder
+
+Dieses Tool übersetzt Curry-Programme unter Berücksichtigung der Import-
+abhängigkeiten.
+
+
+
+2. Kommandoübersicht
+--------------------
+
+In der folgenden Tabelle sind die Optionen zur Generierung der jeweiligen
+Darstellungen für das Kommando 'cymake' aufgelistet:
+
+	--flat		: Erzeugt FlatCurry- und FlatInterface-Datei
+	--xml		: Erzeugt FlatXML-Datei
+	--acy		: Erzeugt (typinferierte) AbstractCurry-Datei
+	--uacy		: Erzeugt ungetypte AbstractCurry-Datei
+
+
+
+3. Erzeugung von FlatCurry- und FlatXML-Programmen
+--------------------------------------------------
+
+Die Übersetzung eines Curry-Programms 'file.curry', sowie sämtlicher
+importierter Module nach FlatCurry bzw. FlatInterface, bewirkt folgendes
+Kommando:
+
+	cymake --flat <filename>
+
+Hierdurch werden die Dateien mit den entsprechenden Endungen ".fcy" und
+".fint" generiert. Der Dateiname <filename> kann hierbei mit oder ohne 
+Endung ".curry" bzw. ".lcurry" angegeben werden.
+
+Die analogen Übersetzungen in die FlatXML-Darstellung bewirkt folgendes
+Kommando:
+
+	cymake --xml <file name>
+
+Die hierdurch generierte Flat-XML-Datei hat die Endung '_flat.xml'.
+
+
+
+4. Erzeugung von AbstractCurry-Programmen
+-----------------------------------------
+
+Die Übersetzung eines Curry-Programms 'file.curry' nach (typgeprüftem)
+AbstractCurry bewirkt folgendes Kommando:
+
+	cymake --acy <filename>
+
+Hierdurch wird die entsprechende Datei (mit der Endung ".acy") generiert.
+Der Dateiname <filename> kann hierbei mit oder ohne Endung ".curry" bzw.
+".lcurry" angegeben werden.
+
+Ungetypte, bzw. typsignierte AbstractCurry-Programme werden mit folgendem
+Kommando generiert:
+
+	cymake --uacy <filename>
+
+Die hierdurch generierte Datei besitzt die Endung ".uacy".
+
+Die Generierung des ungetypten AbstractCurry-Programms findet ohne
+Typüberprüfung statt (d.h. auch Programme mit Typfehlern werden übersetzt).
+Alle Funktionen besitzen entweder die im Quellprogramm angegebenen Typsignatur,
+oder, sofern diese nicht vorhanden ist, den Dummy-Typ "prelude.untyped".
+
+In beiden Fällen werden für die Übersetzung FlatCurry-Dateien 
+für alle importierten Module erzeugt. Dies ist notwendig, da die 
+entsprechenden Interfaces für die Typinferenz (nur im Fall der getypten 
+AbstractCurry-Generierung) und die statisch-semantische Analyse benötigt 
+werden.
+
+
+
+5. Anmerkungen
+--------------
+
+- Um die PAKCS-Bibliotheken (insbesondere die Prelude) für Übersetzungen 
+  nutzen zu können muß die Umgebungsvariable 'PAKCS_LIB' auf die
+  entsprechenden Pfade verweisen, z.B. mittels
+
+	export PAKCS_LIB=<pakcs path>/pacs/lib:<pakcs path>/pacs/lib/meta:...
+
+  wobei <pakcs path> das Verzeichnis ist, das die PAKCS-Distribution
+  enthält.
+
+- Im Gegensatz zu PAKCS erlaubt das Frontend die Verwendung anonymer
+  Variablen (dargestellt durch dem Unterstrich '_') in Typdeklarationen,
+  z.B.
+
+	data T _ = C
+
+
+
+Bekannte Probleme
+------------------
+
+- Lambda-, do-, if-, case-, oder let-Ausdrücke, die in Argumenten von
+  Funktionsaufrufen verwendet werden, müssen immer geklammert werden.
+
+- 'let'-Anweisungen dürfen nicht folgendes Layout besitzen:
+
+           let x = <expr>
+               in ...
+
+- Die Regeln einer Funktionsdeklaration müssen immer zusammenstehen, d.h.
+  nicht durch andere Deklarationen unterbrochen werden.
+
+- Es ist bislang nicht möglich, den Konstruktor für leere Listen [], sowie 
+  den Unit-Konstruktor () zu qualifizieren (z.B. führt 'prelude.[]' zu 
+  einem Fehler). Der Listenkonstruktor (:), sowie Tupel-Konstruktoren
+  dagegen sind qualifizierbar.
+
+- FlatXML-Übersetzungen können derzeit mittels der Funktionen aus dem
+  PAKCS-Modul "FlatXML" noch nicht eingelesen werden, da es Unstimmigkeiten
+  zwischen dem generierten und den erforderlichen Formaten gibt.
+
+- Bei der Erzeugung von typgeprüftem AbstractCurry können die im Quelltext
+  verwendeten Bezeichner für Typvariablen nicht ins AbstractCurry-Programm
+  übernommen werden. Stattdessen generiert der Übersetzer neue
+  Bezeichner.
+
+- Bei der Erzeugung von ungetyptem AbstractCurry werden Typsynonyme in
+  Typsignaturen von Funktionen nicht dereferenziert.
+
+- Das Frontend gibt derzeit noch keinerlei Warnungen aus.
+
+

Makefile

+#------------------------------------------------------------------------------
+#--
+#-- Generate a simple version of the Muenster Curry Compiler for
+#-- running with PAKCS
+#--
+
+
+# Path of the MCC
+MCC	 = $(CURDIR)
+
+MCC_SRC  = $(MCC)/src
+MCC_BIN  = $(MCC)/bin
+MCC_DIST = $(MCC)/distribution
+
+MCC_DIST_BIN = $(MCC_DIST)/binary
+MCC_DIST_SRC = $(MCC_DIST)/source
+
+# distributions
+MCC_SRC_NAME = mcc_for_pakcs_src
+MCC_BIN_NAME = mcc_for_pakcs_`uname -s`
+
+
+#------------------------------------------------------------------------------
+# Let's start...
+
+# Generate the MCC
+.PHONY: all
+
+all: compile
+
+# Compile all necessary MCC components
+.PHONY: compile
+
+compile:
+	@cd $(MCC_SRC) && make
+
+# Clean generated files
+.PHONY: clean
+
+clean: clean_src clean_dist
+
+clean_src:
+	@cd $(MCC_SRC) && rm -f *.hi *.o
+
+clean_dist:
+	@cd $(MCC_DIST) && rm -rf *
+
+
+# Generate distribution
+
+# name of the root directory of the distribution:
+DISTROOT=mccparser
+
+.PHONY: dist
+
+dist: compile dist_src dist_bin
+
+dist_src:
+	@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/src
+	@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/bin
+	@mkdir -p $(MCC_DIST_SRC)/$(DISTROOT)/dist
+	@cp $(MCC_SRC)/*.lhs $(MCC_DIST_SRC)/$(DISTROOT)/src
+	@cp $(MCC_SRC)/*.hs $(MCC_DIST_SRC)/$(DISTROOT)/src
+	@cp $(MCC_SRC)/Makefile $(MCC_DIST_SRC)/$(DISTROOT)/src
+	@cp $(MCC)/LICENSE $(MCC_DIST_SRC)/$(DISTROOT)
+	@cp $(MCC)/Makefile $(MCC_DIST_SRC)/$(DISTROOT)
+
+	@cd $(MCC_DIST_SRC)                               \
+		&& tar cvf $(MCC_SRC_NAME).tar $(DISTROOT)/*      \
+		&& gzip -f9 -S .gz $(MCC_SRC_NAME).tar    \
+		&& mv $(MCC_SRC_NAME).tar.gz $(MCC_DIST)
+	@rm -rf $(MCC_DIST_SRC)
+
+dist_bin:
+	@mkdir -p $(MCC_DIST_BIN)/$(DISTROOT)/bin
+	@cp $(MCC_BIN)/cymake $(MCC_DIST_BIN)/$(DISTROOT)/bin
+	@cp $(MCC)/LICENSE $(MCC_DIST_BIN)/$(DISTROOT)
+
+	@cd $(MCC_DIST_BIN)                               \
+		&& tar cvf $(MCC_BIN_NAME).tar $(DISTROOT)/*      \
+		&& gzip -f9 -S .gz $(MCC_BIN_NAME).tar    \
+		&& mv $(MCC_BIN_NAME).tar.gz $(MCC_DIST)
+	@rm -rf $(MCC_DIST_BIN)

Setup.hs

+import Distribution.Simple
+main = defaultMain

TODO

+Records: Es ist kein qualifizierter Import von Records möglich, da die
+  Feldbezeichnungen nicht mit importiert werden können.
+  Beispiel:
+  import CompilerOpts -- okay
+  import CompilerOpts (Options) -- okay, aber Feldbezeichner nicht importiert
+  import CompilerOpts (Options (..)) Fehler: Options is not a data type
+
+NoImplicitPrelude
+Typklassen
+Hierarchische Module
+Nondeterminism by overlapping abschaltbar?
+QName wird als Typvariable angesehen
+DHO als Variable
\ No newline at end of file

curry-frontend.cabal

+Name:          curry-frontend
+Version:       0.3.0
+Cabal-Version: >= 1.6
+Synopsis:      Compile the functional logic language Curry to several
+               intermediate formats
+Description:   The Curry Frontend consists of the executable program "cymake".
+               It is used by various backends to compile Curry programs to
+               an internal representation.
+               The code is a stripped-down version of an early version of
+               the Muenster Curry Compiler
+               (<http://danae.uni-muenster.de/~lux/curry/>)
+Category:      Language
+License:       OtherLicense
+License-File:  LICENSE
+Author:        Wolfgang Lux, Martin Engelke, Bernd Brassel, Holger Siegel
+Maintainer:    Holger Siegel
+Bug-Reports:   mailto:hsi@informatik.uni-kiel.de
+Homepage:      http://curry-language.org
+Build-Type:    Simple
+Stability:     experimental
+
+Extra-Source-Files: LIESMICH
+Data-Files:         src/Html/currydoc.css
+
+Flag split-syb
+  Description: Has the syb functionality been split into the package syb?
+  Default:     True
+
+Executable cymake
+  hs-source-dirs: src
+  Main-is:        cymake.hs
+  if flag(split-syb)
+    Build-Depends: base == 4.*, syb
+  else
+    Build-Depends: base == 3.*
+  Build-Depends:
+    curry-base >= 0.3.0
+    , mtl, old-time, containers, pretty
+  ghc-options: -Wall
+  Other-Modules:
+      Base
+    , Base.Arity
+    , Base.Import
+    , Base.Module
+    , Base.OpPrec
+    , Base.TypeConstructors
+    , Base.Types
+    , Base.Value
+    , Check.InterfaceCheck
+    , Check.KindCheck
+    , Check.PrecCheck
+    , Check.SyntaxCheck
+    , Check.TypeCheck
+    , Check.WarnCheck
+    , Curry.IL
+    , Curry.IL.Pretty
+    , Curry.IL.Type
+    , Curry.IL.XML
+    , Curry.Syntax
+    , Curry.Syntax.Lexer
+    , Curry.Syntax.Parser
+    , Curry.Syntax.Pretty
+    , Curry.Syntax.ShowModule
+    , Curry.Syntax.Type
+    , Curry.Syntax.Utils
+    , Env.CurryEnv
+    , Env.NestEnv
+    , Env.OldScopeEnv
+    , Env.ScopeEnv
+    , Env.TopEnv
+    , Gen.GenAbstractCurry
+    , Gen.GenFlatCurry
+    , Html.CurryHtml
+    , Html.SyntaxColoring
+    , CurryBuilder
+    , CurryCompilerOpts
+    , CurryDeps
+    , CurryToIL
+    , Eval
+    , Exports
+    , Frontend
+    , Imports
+    , Messages
+    , Modules
+    , SCC
+    , Subst
+    , Transform.CaseCompletion
+    , Transform.Desugar
+    , Transform.Lift
+    , Transform.Qual
+    , Transform.Simplify
+    , Types
+    , TypeSubst
+    , Typing
+    , Utils
+Library
+  hs-source-dirs:  src
+  Build-Depends:   filepath
+  Exposed-Modules:
+    Files.CymakePath
+  Other-Modules:
+    Paths_curry_frontend

doc/document.tex

+
+\documentclass[11pt,fleqn]{article}
+
+\usepackage{latexsym}
+\usepackage{makeidx}
+\usepackage{amssymb}
+\usepackage{url}
+
+%%% ------------------------------------------------------------------
+
+\usepackage[colorlinks,linkcolor=blue]{hyperref}
+%\usepackage[]{hyperref}
+\hypersetup{bookmarksopen=true}
+\hypersetup{bookmarksopenlevel=0}
+\hypersetup{pdftitle={Curry: An Integrated Functional Logic Language}}
+\hypersetup{pdfauthor={Michael Hanus}}
+%\hypersetup{pdfstartview=Title}
+\hypersetup{pdfstartview=FitH}
+\usepackage{thumbpdf}
+
+%%% ------------------------------------------------------------------
+
+\setlength{\textwidth}{16.5cm}
+\setlength{\textheight}{23cm}
+\renewcommand{\baselinestretch}{1.1}
+\setlength{\topmargin}{-1cm}
+\setlength{\oddsidemargin}{0cm}
+\setlength{\evensidemargin}{0cm}
+\setlength{\marginparwidth}{0.0cm}
+\setlength{\marginparsep}{0.0cm}
+
+\newlength{\figurewidth}
+\setlength{\figurewidth}{\textwidth}
+\addtolength{\figurewidth}{-0.4cm}
+
+% environment for typing program texts:
+\makeatletter
+\newenvironment{prog}{\par\vspace{1.5ex}
+\setlength{\parindent}{1.0cm}
+\setlength{\parskip}{-0.1ex}
+\obeylines\@vobeyspaces\tt}{\vspace{1.5ex}\noindent
+}
+\makeatother
+\newcommand{\startprog}{\begin{prog}}
+\newcommand{\stopprog}{\end{prog}\noindent}
+\newcommand{\pr}[1]{\mbox{\tt #1}}   % program text in normal text
+
+\newcommand{\Ac}{{\cal{A}}}
+\newcommand{\Cc}{{\cal{C}}}
+\newcommand{\Dc}{{\cal{D}}}
+\newcommand{\Fc}{{\cal{F}}}
+\newcommand{\Tc}{{\cal{T}}}
+\newcommand{\Xc}{{\cal{X}}}
+\newcommand{\var}{{\cal V}ar}
+\newcommand{\Dom}{{\cal D}om}
+\newcommand{\VRan}{{\cal VR}an}
+\renewcommand{\emptyset}{\varnothing}
+
+\newcommand{\ans}{\mathbin{\framebox[1mm]{\rule{0cm}{1.2mm}}}}
+%\newcommand{\ans}{\;}
+\newcommand{\todo}[1]{\fbox{\sc To do: #1}}
+\newcommand{\dexp}{D}  % a disjunctive expression
+\newcommand{\cconj}{\ensuremath \mathop{\pr{\&}}} % concurrent conj. in math
+\newcommand{\ttbs}{\mbox{\tt\char92}} % backslash in tt font
+\newcommand{\ttus}{\mbox{\tt\char95}} % underscore in tt font
+\newcommand{\sem}[1]{\ensuremath [\![#1]\!]} % double square brackets
+\newcommand{\eval}[1]{{\cal E}\!val\sem{#1}}
+\newcommand{\To}{\Rightarrow}
+\newcommand{\infrule}[2]{\begin{array}{@{}c@{}} #1 \\ \hline #2 \end{array}}
+
+\newcommand{\pindex}[1]{\index{#1@{\tt #1}}}  % program elements in index
+\newcommand{\comment}[1]{} % ignore the argument
+\catcode`\_=\active
+\let_=\sb
+\catcode`\_=12
+
+% commands for the syntax:
+\newcommand{\term}[1]{{\tt #1}}
+\newcommand{\opt}[1]{\rm [\it #1{\rm ]}}
+\newcommand{\offside}[3]{\term{\{}\seq{#1}{#2}{#3} \term{\}}}
+\newcommand{\seq}[3]{{\it #1$_1$ \term{#2} $\ldots$ \term{#2} #1$_#3$}}
+\newcommand{\head}[1]{\makebox[1.3in][r]{\it #1}}
+\newcommand{\por}{\\\head{}\makebox[3em][c]{$|$}}
+\newcommand{\nextline}{\\\head{}\makebox[3em]{}}
+\newcommand{\marg}[1]{\hspace{\fill}$(#1)$}
+\newcommand{\lexicon}[1]{\production #1 {\rm see lexicon} end}
+\def\production #1 #2 end {\head{#1}\makebox[3em]{\rm ::=}\it #2}
+
+\newcommand{\translation}[1]{\bigskip\fbox{\begin{minipage}{15cm}\textbf{Translation: }{#1}\end{minipage}}\bigskip}
+    
+
+\makeindex
+
+
+
+\begin{document}
+
+%%------------------------------------------------------------------------------
+%%------------------------------------------------------------------------------
+
+\section {Records}
+\label{records}
+
+A record is a data structure for bundling several data of various types.
+It consits of typed data fields where each field is associated with
+a unique label. These labels can be used to construct, select or update
+fields in a record.
+
+
+Unlike labeled data fields in Haskell, records are 
+no syntactic sugar but a real extension of the
+language\footnote{
+  The current version allows to transform records
+  into abstract data types. Future extensions may not have
+  this facility.}.
+The basic concept is described in \cite{Leijen05} but the current
+version doesn't yet provide all features mentioned there. 
+The restrictions are explained in section \ref{sec-restrinrecs}.
+
+ 
+\subsection{Record Type Declaration}
+\label{sec-recordtypedecl}
+
+It is necessary to define a record type before a record
+can be constructed or used. The declaration has the following form:
+\startprog
+type $R$ $\alpha_1$ \ldots $\alpha_n$ = \{ $l_1$ :: $\tau_1$, \ldots, $l_m$ :: $\tau_m$ \}
+\stopprog
+It introduces a new $n$-ary record type $R$ which represents a
+record consisting of $m$ fields. Each field has a unique label $l_i$ 
+representing a value of the type $\tau_i$. Labels
+are identifiers which refer to the corresponding
+fields. The following examples define some records types:
+\startprog
+type Person = \{name :: String, age :: Int\}
+type Address = \{person :: Person, street :: String, city :: String\}
+type Branch a b = \{left :: a, right :: b\}
+\stopprog
+It is possible to summarize different labels which have the same
+type. E.g. the record \pr{Address} can also be declared as follows:
+\startprog
+type Address = \{person :: Person, street,city :: String\}
+\stopprog
+The fields can occur in an arbitrary order. The example above
+can also be written as
+\startprog
+type Address = \{street,city :: String, person :: Person\}
+\stopprog
+The record type can be used in every type expression to represent
+the corresponding record, e.g.
+\startprog
+data BiTree = Node (Branch BiTree BiTree) | Leaf Int
+\stopprog
+\startprog
+getName :: Person -> String
+getName \ldots
+\stopprog
+
+
+Labels can only be used in the context of
+records. They do not share the name space with 
+functions/constructors/variables or type constructors/type variables. 
+For instance it is possible to use 
+the same identifier for a label and a function at the same time. Label
+identifiers cannot be shadowed by other identifiers.
+
+
+Like in type synonym declarations, recursive or mutually 
+dependent record declarations are not allowed. Records can only
+be declared at top level. Further restrictions are described in
+section \ref{sec-restrinrecs}.
+
+
+\subsection{Record Construction}
+\label{sec-recordconstr}
+
+The record construction generates a record with initial values for
+each data field. It has the following form:
+\startprog
+\{ $l_1$ = $v_1$, \ldots, $l_m$ = $v_m$ \}
+\stopprog
+It generates a record where each label $l_i$ refers to the
+value $v_i$. The type of the record results from the record type
+declaration where the labels $l_i$ are defined.
+A mix of labels from different
+record types is not allowed. All labels must be specified with 
+exactly one assignment. Examples for record constructions are
+\startprog
+\{name = "Johnson", age = 30\}     -- generates a record of type 'Person'
+\{left = True, right = 20\}        -- generates a record of type 'Branch'
+\stopprog
+Assignments to labels can occur in an arbitrary order. For instance a
+record of type \pr{Person} can also be generated as follows:
+\startprog
+\{age = 30, name = "Johnson"\}     -- generates a record of type 'Person'
+\stopprog
+Unlike labeled fields in record type declarations, 
+record constructions can be used in expressions without any restrictions
+(as well as all kinds of record expressions). For instance the following
+expression is valid:
+\startprog
+\{person = \{name = "Smith", age = 20\},   -- generates a record of
+ street = "Main Street",                -- type 'Address'
+ city   = "Springfield"\}
+\stopprog
+
+
+\subsection{Field Selection}
+\label{sec-fieldsel}
+
+The field selection is used to extract data from records. 
+It has the following form:
+\startprog
+$r$ -> $l$
+\stopprog
+It returns the value to which the label $l$ refers to from the
+record expression $r$. The label must occur in the declaration of
+the record type of $r$.
+An example for a field selection is:
+\startprog
+pers -> name
+\stopprog
+This returns the value of the label \pr{name} from the record \pr{pers}
+(which has the type \pr{Person}).
+Sequential application of field selections are also possible:
+\startprog
+(addr -> person) -> age
+\stopprog
+The value of the label \pr{age} is extracted from a record which itself
+is the value of the label \pr{person} in the record \pr{addr}
+(which has the type \pr{Address}). When a field selection is used in
+expressions, it has to be parenthesized.
+
+
+\subsection{Field Update}
+\label{sec-fieldupd}
+
+Records can be updated by reassigning a new value to a label:
+\startprog
+\{$l_1$ := $v_1$, \ldots, $l_k$ := $v_k$ | $r$\}
+\stopprog
+The label $l_i$ is associated with the new value $v_i$ which
+replaces the current value in the record $r$.
+The labels must occur in the declaration