From 09e62111fd29ec376e3e13ca80cb8e88a47bdea7 Mon Sep 17 00:00:00 2001 From: bringert Date: Wed, 7 Dec 2005 10:03:18 +0000 Subject: [PATCH] Transfer reference: added list patterns, do notation. --- doc/transfer-reference.html | 128 +++++++++++++++++++++++++----------- doc/transfer-reference.txt | 72 +++++++++++++++++--- 2 files changed, 153 insertions(+), 47 deletions(-) diff --git a/doc/transfer-reference.html b/doc/transfer-reference.html index 820f0f152..7670da8b8 100644 --- a/doc/transfer-reference.html +++ b/doc/transfer-reference.html @@ -7,7 +7,7 @@

Transfer language reference

Author: Björn Bringert <bringert@cs.chalmers.se>
-Last update: Wed Dec 7 10:45:42 2005 +Last update: Wed Dec 7 11:02:54 2005

@@ -29,23 +29,24 @@ Last update: Wed Dec 7 10:45:42 2005
  • Tuples
  • Lists -
  • Pattern matching +
  • Case expressions +
  • Patterns -
  • Metavariables -
  • Overloaded functions / Type classes -
  • Operators -
  • Compositional functions -
  • do notation +
  • Metavariables +
  • Overloaded functions / Type classes +
  • Operators +
  • Compositional functions +
  • do notation

    @@ -140,11 +141,14 @@ equations. The first equation whose patterns match the function arguments is used when the function is called. Pattern equations are on the form: 

    -  f p1 ... p1n = exp
+  f p11 ... p1m = exp
   ...
-  f qn1 ... qnm = exp
+  f pn1 ... pnm = exp

    +

    +where p11 to pnm are patterns, see Patterns. +

    Data type declarations

    @@ -238,7 +242,7 @@ in the type. Such dependent function types are written:

    Here, x1 can be used in T2 to Tn, x1 can be used -in T2 to Tn +in T2 to Tn.

    Basic types

    @@ -355,7 +359,7 @@ be used instead of Cons. These are just syntactic sugar for express using Nil and Cons, with the type arguments hidden.

    -

    Pattern matching

    +

    Case expressions

    Pattern matching is done in pattern equations and by using the case construct: @@ -368,6 +372,7 @@ Pattern matching is done in pattern equations and by using the

    +where p1 to pn are patterns, see Patterns. guard1 to guardn are boolean expressions. Case arms can also be written without guards, such as:

    @@ -382,10 +387,9 @@ This is the same as writing: pk | True -> rhsk

    -

    -The syntax of patterns are decribed below. -

    - + +

    Patterns

    +

    Constructor patterns

    Constructor patterns are written as: @@ -400,7 +404,7 @@ If the value to be matched is the constructor C applied to arguments v1 to vn, then v1 to vn will be matched against p1 to pn.

    - +

    Variable patterns

    A variable pattern is a single identifier: @@ -413,7 +417,7 @@ A variable pattern is a single identifier: A variable pattern matches any value, and binds the variable name to the value. A variable may not occur more than once in a pattern.

    - +

    Wildcard patterns

    Wildcard patterns are written as with a single underscore: @@ -425,7 +429,7 @@ Wildcard patterns are written as with a single underscore:

    Wildcard patterns match all values and bind no variables.

    - +

    Record patterns

    Record patterns match record values: @@ -442,7 +446,7 @@ fields l1 to ln, and their values match p1 - +

    Disjunctive patterns

    It is possible to write a pattern on the form: @@ -455,9 +459,39 @@ It is possible to write a pattern on the form: A value will match this pattern if it matches any of the patterns p1 to pn. FIXME: talk about how this is expanded

    - -

    List patterns

    +

    List patterns

    +

    +When pattern matching in lists, there are two special constructs. +A whole list can be matched be a list of patterns: +

    +
    +  [p1, ... , pn]
+
    +

    +

    +This pattern will match lists of length n, such that each element +in the list matches the corresponding pattern. The empty list pattern: +

    +
    +  []
+
    +

    +

    +is a special case of this. It matches the empty list, oddly enough. +

    +

    +Non-empty lists can also be matched with ::-patterns: +

    +
    +  p1::p2
+
    +

    +

    +This pattern matches a non-empty lists such that the first element of +the list matches p1 and the rest of the list matches p2. +

    +

    Tuple patterns

    Tuples patterns on the form: @@ -469,17 +503,17 @@ Tuples patterns on the form:

    are syntactic sugar for record patterns, in the same way as tuple expressions.

    - +

    String literal patterns

    String literals can be used as patterns.

    - +

    Integer literal patterns

    Integer literals can be used as patterns.

    - +

    Metavariables

    Metavariable are written as questions marks: @@ -494,17 +528,33 @@ A metavariable is a way to the the Transfer type checker that: I can't be bothered to tell you".

    -Metavariables can be used to avoid having to give type variables -and dictionaries explicitly. +Metavariables can be used to avoid having to give type +and dictionary arguments explicitly.

    - -

    Overloaded functions / Type classes

    -

    Operators

    +

    Overloaded functions / Type classes

    -

    Compositional functions

    +

    Operators

    +

    Compositional functions

    +

    do notation

    +

    +Sequences of operations in the Monad type class can be written +using do-notation, like in Haskell: +

    +
    +  do x <- f
+     y <- g x
+     h y
+
    +

    +

    +is equivalent to: +

    +
    +  f >>= \x -> g x >>= \y -> h y
+
    diff --git a/doc/transfer-reference.txt b/doc/transfer-reference.txt index a7d534363..5ebff583a 100644 --- a/doc/transfer-reference.txt +++ b/doc/transfer-reference.txt @@ -61,6 +61,7 @@ braces and semicolons. Thus the above is equivalent to: case x of { p1 -> e1 ; p2 -> e2 } ``` + == Imports == A Transfer module start with some imports. Most modules will have to @@ -89,11 +90,13 @@ equations. The first equation whose patterns match the function arguments is used when the function is called. Pattern equations are on the form: ``` -f p1 ... p1n = exp +f p11 ... p1m = exp ... -f qn1 ... qnm = exp +f pn1 ... pnm = exp ``` +where ``p11`` to ``pnm`` are patterns, see [Patterns #patterns]. + == Data type declarations == @@ -137,7 +140,6 @@ let x1 : T1 = exp1 ``` - == Types == === Function types ===[function_types] @@ -182,7 +184,8 @@ in the type. Such dependent function types are written: ``` Here, ``x1`` can be used in ``T2`` to ``Tn``, ``x1`` can be used -in ``T2`` to ``Tn`` +in ``T2`` to ``Tn``. + === Basic types === @@ -191,12 +194,14 @@ in ``T2`` to ``Tn`` The type of integers is called ``Integer``. standard decmial integer literals are used to represent values of this type. + ==== Floating-point numbers ==== The only currently supported floating-point type is ``Double``, which supports IEEE-754 double-precision floating-point numbers. Double literals are written in decimal notation, e.g. ``123.456``. + ==== Strings ==== There is a primitive ``String`` type. This might be replaced by a list of @@ -255,12 +260,14 @@ rec p1 = exp1 pn = expn ``` + ==== Record subtyping ==== A record of some type R1 can be used as a record of any type R2 such that for every field ``p1 : T1`` in R2, ``p1 : T1`` is also a field of T1. + === Tuples === Tuples on the form: @@ -293,7 +300,7 @@ be used instead of ``Cons``. These are just syntactic sugar for expressions using ``Nil`` and ``Cons``, with the type arguments hidden. -== Pattern matching == +== Case expressions == Pattern matching is done in pattern equations and by using the ``case`` construct: @@ -305,6 +312,7 @@ case exp of pn | guardn -> rhsn ``` +where ``p1`` to ``pn`` are patterns, see [Patterns #patterns]. ``guard1`` to ``guardn`` are boolean expressions. Case arms can also be written without guards, such as: @@ -318,7 +326,8 @@ This is the same as writing: pk | True -> rhsk ``` -The syntax of patterns are decribed below. + +== Patterns ==[patterns] === Constructor patterns === @@ -386,6 +395,32 @@ FIXME: talk about how this is expanded === List patterns === +When pattern matching in lists, there are two special constructs. +A whole list can be matched be a list of patterns: + +``` +[p1, ... , pn] +``` + +This pattern will match lists of length n, such that each element +in the list matches the corresponding pattern. The empty list pattern: + +``` +[] +``` + +is a special case of this. It matches the empty list, oddly enough. + +Non-empty lists can also be matched with ``::``-patterns: + +``` +p1::p2 +``` + +This pattern matches a non-empty lists such that the first element of +the list matches ``p1`` and the rest of the list matches ``p2``. + + === Tuple patterns === Tuples patterns on the form: @@ -418,14 +453,35 @@ A metavariable is a way to the the Transfer type checker that: "you should be able to figure out what this should be, I can't be bothered to tell you". -Metavariables can be used to avoid having to give type variables -and dictionaries explicitly. +Metavariables can be used to avoid having to give type +and dictionary arguments explicitly. + == Overloaded functions / Type classes == + + == Operators == + + == Compositional functions == + + == do notation == +Sequences of operations in the Monad type class can be written +using do-notation, like in Haskell: + +``` +do x <- f + y <- g x + h y +``` + +is equivalent to: + +``` +f >>= \x -> g x >>= \y -> h y +```