January 12 2007 金曜日

  I am going to learn Haskell functional programming language in that I are aware
that it is nessary to do it.  The Haskell language has evolved signicantly since
its birth in 1987.  The scheme and Haskell are two polars respectively of the family
of functional programming language.

  data Tree a = Leaf a | Branch (Tree a) (Tree a)

  The above the definition of a binary tree enchanted me.  It is so simple, so intuitive.
Let's look at a function in Haskell.

  length :: [a]->Integer
  length [] = 0
  length (x:xs) = 1 + length xs

  It is different for those definitions form C, scheme, Java, and so on.  It is
intuitive, and more close to mathematical expression.  Here, -> says there is a
map from a type to another type.

  Integer -> Integer -> Integer

  We can look it like that.

  Integer -> (Integer -> Integer)

  In Haskell, the -> is actual a type constructor.  If you learned discrete mathematics,
it is easy to understand.  It make a map type.  What is map?  It usually is the synonyms
of function.  All right, if a symbol is defined by a map type, it is a function.  The function
in Haskell adapted pattern matching.  It is also easy to understand because of we are
familiar to pattern matching languages, from the macrox of scheme, or awk language, and
so forth.

  add :: Integer -> Integer -> Integer
  add x y = x + y

  This is an example of a curried function. An application of add has the form add e1 e2,
and is equivalent to (add e1 ) e2, since function application associates to the left.  In
other words, applying add to one argument yields a new function which is then applied to
the second argument.  This is consistent with the type of add, Integer->Integer->Integer,
which is equivalent to Integer->(Integer->Integer); i.e. -> associatestothe right.

  At this point we should note carefully the dierences between tuples and lists. In
particular, note the recursive nature of the list type whose elements are homogeneous
and of arbitrary length, and the non-recursive nature of a (particular) tuple type whose
elements are heterogeneous and of fixed length.  The typing rules for tuples and lists
should now also be clear:

For (e1 ,e2 , ... ,en ); n >= 2,if ti is the type of ei, then the type of the tuple is (t1,t2,...,tn).
For [e1 ,e2 , ... ,en ]; n >= 0,each e must have the same type t, and the type of the list is [t].

  In fact, a list like [1,2,3] is a tuple like (1:[2,3]), 1:(2:3:[]), in Haskell, not
in scheme.  But it is also a pair.

  Non-strict functions are also called "lazy functions", and are said to evaluate their
arguments "lazily", or "byneed".  Non-strict functions are extremely useful in a variety
of contexts.  The main advantage is that they free the programmer from many concerns about
evaluation order.

  Another way of explaining non-strict functions is that Haskell computes using definitions
rather than the assignments found in traditional languages.  Read a declaration such as:

  v = 1/0

as 'define v as 1/0' instead of 'compute 1/0 and store the result in v'.  Only if the value
(definition) of v is needed will the division by zero error occur.  By itself, this declaration
does not imply any computation.  Programming using assignments requires careful attention
to the ordering of the assignments: the meaning of the program dependson the order in which
the assignments are executed.  Definitions, in contrast, are much simpler: they can be presented
in any order without affecting the meaning of the program.

  Technically speaking, formal parameters are also patterns -- it's just that they never fail to
match a value.  As a "side eect" of the successful match, the formal parameter is bound to the
value it is being matched against.  For this reason patterns in any one equation are not allowed
to have more than one occurrence of the same formal parameter.