Context Navigation

-                      r75d789c
+                      r9a32903
 \section{OCaml}
+\lstnewenvironment{ocaml}[1][]{\lstset{language=ML,escapechar=\$,moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
+An enumerated data types is a list of named values.
+\lstnewenvironment{ocaml}[1][]{\lstset{language=ML,escapechar=\$,morekeywords={match},moredelim=**[is][\color{red}]{@}{@},}\lstset{#1}}{}
+OCaml~\cite{Ocaml} provides a tagged variant (union) type, where multiple heterogeneously-typed objects share the same storage.
+The simplest form of the variant type is a list of untyped tags, which is like an unscoped, pure enumeration.
 \begin{ocaml}
 type weekday = Mon | Tue | Wed | Thu | Fri | Sat | Sun
+let day : weekday = Mon                                 $\C{(* bind *)}$
+let take_class( d : weekday ) =
+        match d with                                            $\C{(* matching *)}$
+                Mon | Wed -> Printf.printf "CS442\n" |
+                Tue | Thu -> Printf.printf "CS343\n" |
+                Fri -> Printf.printf "Tutorial\n" |
+                _ -> Printf.printf "Take a break\n"
+let _ = take_class( Mon );
+@CS442@
 \end{ocaml}
+Enumerated data types are the simplest subset of variants types.
+Because @weekday@ is a summantion of values @Mon@ to @Sun@, enumerated data types are often call a sum type in turns of functional programming paradigm.
+The values defined in an enumerated type are called data constructors.
+The data constructors of an enumerated data type takes no value as parameter.
+They are known as 0-arity constructor.
+A more generic variant type has n-ary constructors.
+The only operations are binding a tag and pattern matching (equality).
+Here, function @take_class@ has a @weekday@ parameter, and returns @"CS442"@, if the weekday value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
+The ``@_@'' is a wildcard matching any @weekday@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
+Since the tag has no type, it has a \Newterm{0-arity constructor}, \ie no parameters.
+Because @weekday@ is a summation of values @Mon@ to @Sun@, it is a \Newterm{sum type} in turns of the functional-programming paradigm.
+Each tag can have an associated heterogeneous type, with an n-ary constructor for creating a corresponding value.
 \begin{ocaml}
 type colour = Red | Green of string | Blue of int * float
 \end{ocaml}
+The @colour@ type can be constructed as a combination of a value from an @int@ and a @blue@, using the @Blue@ data constructor.
+Mathematically, a @Blue@ value is a Cartesian product of the @int@ type and the @bool@.
+@Colour@ type is a summation of a nullary type, a unary product type, and a cross product of @int@ and @bool@.
+The OCaml variant type can be create as a sum of product of different types.
+@colour@ is a summation of a nullary type, a unary product type of @string@, and a cross product of @int@ and @bool@.
+(Mathematically, a @Blue@ value is a Cartesian product of the @int@ type and the @bool@.)
+Hence, a variant type creates a sum of product of different types.
+\begin{ocaml}
+let c : colour = Red                                    $\C{(* 0-ary constructor *)}$
+let _ = match c with Red -> Printf.printf "Red, "
+let c : colour = Green( "abc" )                 $\C{(* 1-ary constructor *)}$
+let _ = match c with Green g -> Printf.printf "%s, " g
+let c : colour = Blue( 1, 1.5 )                 $\C{(* 2-ary constructor *)}$
+let _ = match c with Blue( i, f ) -> Printf.printf "%d %g\n" i f
+@Red, abc, 1 1.5@
+\end{ocaml}
 A variant type can have a recursively definition.
 …
 type stringList = Empty | Pair of string * stringList
 \end{ocaml}
+OCaml's variant types are recusrive sum of product of types, which are known as Algebraic Data Types.
+Programming languages follows the functional programming paradigm often supports algebraic data types, and supports pattern matching against algebraic data type.
+\begin{ocaml}
+let take_class = function
+        Mon | Wed -> "CS442" |
+        Tue | Thu -> "CS343" |
+        Fri -> "Tutorial" |
+        _ -> "Take a break"
+\end{ocaml}
+The function has a @weekday@ as parameter, and returns @"CS442"@, if the weekday value is @Mon@ or @Wed@, @"CS343"@, if the value is @Tue@ or @Thu@, and @"Tutorial"@ for @Fri@.
+The @_@ is a wildcard matching any @weekday@ value, so the function returns @"Take a break"@ for values @Sat@ or @Sun@, which are not matched by the previous cases.
+Values of a product type can be named.
+\begin{ocaml}
+let check_colour (c: colour): string =
+         match c with
+                Red -> "Red" |
+                Green g -> g |
+                Blue(i, f) -> string_of_int i ^ string_of_float f
+\end{ocaml}
+A recurisve function is often used to pattern match against a recurisve variant type.
+which is a recursive sum of product of types, called an \Newterm{algebraic data-type}.
+A recursive function is often used to pattern match against a recursive variant type.
 \begin{ocaml}
 let rec len_of_string_list(l: stringList): int =
 …
                 Pair(_ , r) -> 1 + len_of_string_list r
 \end{ocaml}
+Note, matching is logically a dynamic type-check.
+Hence, a tagged variant has no notion of enumerabilty, and therefore is not an enumeration, except for the simple pure (untyped) case.

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 9a32903 for doc/theses/jiada_liang_MMath

Legend:

doc/theses/jiada_liang_MMath/relatedwork.tex

Download in other formats: