Quick impression - Revision history

ErikZuurbier at 11:21, 12 December 2011

2011-12-12T11:21:40Z

ErikZuurbier at 16:09, 9 December 2011

2011-12-09T16:09:49Z

← Older revision		Revision as of 16:09, 9 December 2011
Line 38:		Line 38:
	power x n = x * power x (n-1)		power x n = x * power x (n-1)

	This function is usually indicated by the infix operator ^ in programming languages. An infix operator is in fact just an ordinary function of two arguments that is written between its arguments: x^n. In Clean you can define your own infix operators. An infix operator is defined just like ~~every~~ other function. There are two slight differences: in the type of the function we indicate that it is an infix operator and the operator is written as an ordinary function between ~~parenthesis~~ in the left-hand side of the definition.		This function is usually indicated by the infix operator ^ in programming languages. An infix operator is in fact just an ordinary function of two arguments that is written between its arguments: x^n. In Clean you can define your own infix operators. An infix operator is defined just like any other function. There are two slight differences: in the type of the function we indicate that it is an infix operator and the operator is written as an ordinary function between parentheses in the left-hand side of the definition.

	(^) infixr 8 :: Int Int -> Int		(^) infixr 8 :: Int Int -> Int
Line 44:		Line 44:
	(^) x n = x * x ^ (n-1)		(^) x n = x * x ^ (n-1)

	The keyword infixr in the type of declaration indicates that this function is a right associative infix operator. The number 8 indicates the binding ~~power~~. This binding ~~power~~ is chosen in accordance to the mathematical habits. This implies that there are no ~~parenthesis~~ needed in the body of the second alternative of the operator to distinguish (xx)^(n-1) and x(x^(n-1)). In fact this operator is defined as a type class in the standard environment of Clean.		The keyword infixr in the type of declaration indicates that this function is a right associative infix operator. The number 8 indicates the binding level. This binding level is chosen in accordance to the mathematical habits. This implies that there are no parentheses needed in the body of the second alternative of the operator to distinguish (xx)^(n-1) and x(x^(n-1)). In fact this operator is defined as a type class in the standard environment of Clean.

	== Guards ==		== Guards ==
	Although distinguishing various cases in the definition of a function by patterns is very powerful, it is not enough. For instance, using patterns it is impossible to check whether an integer argument is positive, or larger than another argument. This can be solved using guards. A guard is a boolean expression that can be inserted between the patterns of a function alternative and the symbol =. The symbol \| separates the patterns and the guard. The alternative is only applied when the ~~guards~~ yields True. Each function alternative can have a sequence of guarded right-hand sides. Consider the function maximum as example, this function yields the largest of its two arguments.		Although distinguishing various cases in the definition of a function by patterns is very powerful, it is not enough. For instance, using patterns it is impossible to check whether an integer argument is positive, or larger than another argument. This can be solved using guards. A guard is a boolean expression that can be inserted between the patterns of a function alternative and the symbol =. The symbol \| separates the patterns and the guard. The alternative is only applied when the guard yields True. Each function alternative can have a sequence of guarded right-hand sides. Consider the function maximum as example, this function yields the largest of its two arguments.

	maximum :: Int Int -> Int		maximum :: Int Int -> Int
Line 57:		Line 57:

	== Higher order functions ==		== Higher order functions ==
	Functions can be the arguments and results of other functions. As a somewhat extreme example we consider the function twice. The ~~functions~~ twice takes ~~an other~~ function, f, and an argument, x, for f as arguments. The function f is applied twice to the arguments x:		Functions can be the arguments and results of other functions. As a somewhat extreme example we consider the function twice. The function twice takes another function, f, and an argument, x, for f as arguments. The function f is applied twice to the arguments x:

	twice f x = f (f x)		twice f x = f (f x)
Line 74:		Line 74:

	== Polymorphism ==		== Polymorphism ==
	For many functions the type of the argument is irrelevant. The simplest example is the identity function I. The argument of this function is its result. The type of this argument is irrelevant. To indicate this we use a type variable in the type definition of the type of such a polymorphic (having many forms) function.		For many functions the type of the argument is irrelevant. The simplest example is the identity function I. The argument of this function is its result. The type of this argument is irrelevant. To indicate this we use a type variable in the type definition of the type of such a polymorphic ('having many forms') function.

	I :: t -> t // Type: from type t to type t.		I :: t -> t // Type: from type t to type t.
	I x = x		I x = x

	Also the function twice defined above is polymorphic. In our examples we used it with an x of type Int as well as an x of type Int -> Int. In effect the type of the function square defined above is more restrictive than necessary. This function can be used for any type t, provided that the multiplication is defined for that type t. This is indicated by a type restriction of the form \| * t. The more general type is used in the ~~next~~ definition for the function square:		Also the function twice defined above is polymorphic. In our examples we used it with an x of type Int as well as an x of type Int -> Int. In effect the type of the function square defined above is more restrictive than necessary. This function can be used for any type t, provided that the multiplication is defined for that type t. This is indicated by a type restriction of the form \| * t. The more general type is used in the following definition for the function square:

	square :: t -> t \| * t // Type: from t to t provided that there is a * for t.		square :: t -> t \| * t // Type: from t to t provided that there is a * for t.
Line 91:		Line 91:
	\| n >= m = n		\| n >= m = n

	The Clean System knows how to compute greater or equal, >=, when less than, <, is defined. Functions that can process arguments of various types are called polymorphic. When there is a type restriction, like * t, on one or more of the type variables involved we have an implicit type class rather than a polymorphic function.		The Clean System knows how to compute greater or equal, >=, when less than, <, is defined. Functions that can process arguments of various types are called polymorphic. When there is a type restriction, like \| * t, on one or more of the type variables involved, we have an implicit type class rather than a polymorphic function.

	== Lists ==		== Lists ==
	Lists are one of the basic compound data structures of Clean. A list can have any number of elements. All elements of a list should have the same type. Since lists are so commonly used in functional programming, there is some special syntax for lists. A list of integers can be written as an enumeration: [7,12] or [1,2,3,4,5]. It is also possible to use the list generator like [1..5] in expressions. Such a phrase is called a dot dot expression The empty list is written as []. Finally, a list with head element x and tail xs is written as [x:xs] (note the difference between [x,xs] (a list of two elements) and [x:xs]).		Lists are one of the basic compound data structures of Clean. A list can have any number of elements. All elements of a list should have the same type. Since lists are so commonly used in functional programming, there is some special syntax for lists. A list of integers can be written as an enumeration: [7,12] or [1,2,3,4,5]. It is also possible to use the list generator like [1..5] in expressions. Such a phrase is called a dot dot expression The empty list is written as []. Finally, a list with head element x and tail xs is written as [x:xs] (note the difference between [x,xs] (a list of two elements) and [x:xs]).

	This list notation can be used in the patterns of a function. For instance, the function product that computes the product of the elements of a list. The type declaration states that this function takes a list of an arbitrary type t as argument and produces an value of type t, provided that type t is member of type class one and type class *. This just implies that multiplication and its unit element, one, should be defined for type t.		This list notation can be used in the patterns of a function. For instance, the function product that computes the product of the elements of a list. The type declaration states that this function takes a list of an arbitrary type t as an argument and produces a value of type t, provided that type t is member of type class 'one' and type class *. This just implies that multiplication and its unit element, 'one', should be defined for type t.

	product :: [t] -> t \| one, * t		product :: [t] -> t \| one, * t
Line 102:		Line 102:
	product [x:r] = x * product r		product [x:r] = x * product r

	The first alternative of this function states that the product of a empty list is one. The second alternative states that the product of a list consisting of element x and tail r is equal to the multiplication of the first element and the product of the tail of the list. The compiler selects the appropriate instances of the classes one and * for each application.		The first alternative of this function states that the product of an empty list is one. The second alternative states that the product of a list consisting of element x and tail r is equal to the multiplication of the first element and the product of the tail of the list. The compiler selects the appropriate instances of the classes one and * for each application.

	This can be used to give an alternative definition of the factorial function. The factorial of some number n is equal to the product of the list of numbers from 1 to n.		This can be used to give an alternative definition of the factorial function. The factorial of some number n is equal to the product of the list of numbers from 1 to n.
Line 112:		Line 112:

	== List comprehensions ==		== List comprehensions ==
	~~The list~~ comprehensions in the functional programming language Clean are a very compact and powerful way to express list manipulation. For example the ~~square~~ of all integers from 1 to 10 that are not dividable by three are computed by the program:		List comprehensions in the functional programming language Clean are a very compact and powerful way to express list manipulation. For example, the squares of all integers from 1 to 10 that are not dividable by three are computed by the program:

	Start = [n*n \\ n <- [1..10] \| n rem 3 <> 0]		Start = [n*n \\ n <- [1..10] \| n rem 3 <> 0]

	As desired this program yields [1,4,16,25,49,64,100]. In general a list comprehension yields the list of values indicated between [ and \\. These values are computed for each element of the generators (between // and \|), that obeys the condition between \| and ]. For more realistic program we define a distance table as a list of tuples:		As desired, this program yields [1,4,16,25,49,64,100]. In general, a list comprehension yields the list of values indicated between [ and \\. These values are computed for each element of the generators (between // and \|), that obeys the condition between \| and ]. For a more realistic program, we define a distance table as a list of tuples:

	:: From :== String		:: From :== String
Line 132:		Line 132:
	]		]

	Using a list comprehension we can select all towns closer than 1000 km to Amsterdam, with the distance, by the program:		Using a list comprehension, we can select all towns closer than 1000 km to Amsterdam, with the distance, by the program:

	Start =		Start =

Thomas: moved Quick Impression to Quick impression

2010-07-27T12:22:24Z

moved Quick Impression to Quick impression

← Older revision		Revision as of 12:22, 27 July 2010
(No difference)

ErikZuurbier: /* List comprehensions */

2010-07-21T06:48:59Z

List comprehensions

← Older revision		Revision as of 06:48, 21 July 2010
Line 163:		Line 163:
	Here we have used a local definition to share the definition of the connections to be considered. The scope of local definitions is the function alternative where they are defined. Local definitions are used to limit the scope of definitions, to share a value or to name an expression. The local definitions used in this text are preceded by the keyword where. The language Clean has a rich palette of local definitions.		Here we have used a local definition to share the definition of the connections to be considered. The scope of local definitions is the function alternative where they are defined. Local definitions are used to limit the scope of definitions, to share a value or to name an expression. The local definitions used in this text are preceded by the keyword where. The language Clean has a rich palette of local definitions.

	The last condition in the list comprehension excludes routes that ~~ends~~ in Amsterdam. In this example the generators are separated by a semicolon, this implies that all possible combinations of elements from the generators are considered. It is also possible to separate the generators by a &-symbol. This implies that the generators are used synchronously. This is for instance useful to label the towns reachable from Amsterdam with consecutive numbers.		The last condition in the list comprehension excludes routes that end in Amsterdam. In this example the generators are separated by a semicolon, this implies that all possible combinations of elements from the generators are considered. It is also possible to separate the generators by a &-symbol. This implies that the generators are used synchronously. This is for instance useful to label the towns reachable from Amsterdam with consecutive numbers.

	Start =		Start =

ErikZuurbier: /* List comprehensions */

2010-07-21T06:46:43Z

List comprehensions

← Older revision		Revision as of 06:46, 21 July 2010
Line 142:		Line 142:
	Note that we have used the pattern ("Amsterdam",to,dist) in the generator of this list expression. Only elements of the list that match this pattern contribute to the result of this list comprehension.		Note that we have used the pattern ("Amsterdam",to,dist) in the generator of this list expression. Only elements of the list that match this pattern contribute to the result of this list comprehension.

	As a matter of fact you might not be satisfied with this program. You will usually read a distance table like in two directions. The fact that the distance form Paris to Amsterdam is 490 Km usually implies that the distance between Amsterdam and Paris is also 490 Km. Nevertheless the tuple ("Paris","Amsterdam",490) does not match the pattern. We can solve this by considering also the tuples from the table where the towns from and to are flipped:		As a matter of fact you might not be satisfied with this program. You will usually read a distance table like in two directions. The fact that the distance form Paris to Amsterdam is 490 km usually implies that the distance between Amsterdam and Paris is also 490 km. Nevertheless the tuple ("Paris","Amsterdam",490) does not match the pattern. We can solve this by considering also the tuples from the table where the towns from and to are flipped:

	Start =		Start =
Line 175:		Line 175:
	]		]

	Since we have no idea what the upper bound of the number of towns reachable from Amsterdam is, we have omitted the upper bound of the dot dot expression [1..]. This dot dot expression denotes an infinite list of integers. Thanks to the lazy evaluation strategy of Clean we can handle such ~~potential~~ infinite datastructures. Lazy evaluation implies that an expression is only evaluated as far as needed to produce the result of the program.		Since we have no idea what the upper bound of the number of towns reachable from Amsterdam is, we have omitted the upper bound of the dot dot expression [1..]. This dot dot expression denotes an infinite list of integers. Thanks to the lazy evaluation strategy of Clean we can handle such potentially infinite datastructures. Lazy evaluation implies that an expression is only evaluated as far as needed to produce the result of the program.

	We will illustrate the use of list comprehensions by a number of additional examples below.		We will illustrate the use of list comprehensions by a number of additional examples below.

ErikZuurbier: /* List comprehensions */

2010-07-21T06:43:54Z

List comprehensions

← Older revision		Revision as of 06:43, 21 July 2010
Line 132:		Line 132:
	]		]

	Using a list comprehension we can select all ~~town that are less then~~ 1000 ~~Km from~~ Amsterdam with the distance ~~involved~~ by the program:		Using a list comprehension we can select all towns closer than 1000 km to Amsterdam, with the distance, by the program:

	Start =		Start =

ErikZuurbier: /* Lists */

2010-07-21T06:40:14Z

Lists

← Older revision		Revision as of 06:40, 21 July 2010
Line 102:		Line 102:
	product [x:r] = x * product r		product [x:r] = x * product r

	The first alternative of this function states that the product of a empty list is one. The second alternative states that the product of a list consisting of element x and tail r is equal to the multiplication of the first element and the product of the tail of the list. The compiler selects the appropriate instances of the classes ~~zero~~ and * for each application.		The first alternative of this function states that the product of a empty list is one. The second alternative states that the product of a list consisting of element x and tail r is equal to the multiplication of the first element and the product of the tail of the list. The compiler selects the appropriate instances of the classes one and * for each application.

	This can be used to give an alternative definition of the factorial function. The factorial of some number n is equal to the product of the list of numbers from 1 to n.		This can be used to give an alternative definition of the factorial function. The factorial of some number n is equal to the product of the list of numbers from 1 to n.

ErikZuurbier: /* Polymorphism */

2010-07-21T06:39:27Z

Polymorphism

← Older revision		Revision as of 06:39, 21 July 2010
Line 91:		Line 91:
	\| n >= m = n		\| n >= m = n

	The Clean System knows how to compute greater or equal, >=, when less than, <, is defined. Functions that can process arguments of various types are called ~~polymorph~~. When there is a type restriction, like * t, on one or more of the type variables involved we have an implicit type class rather than a polymorphic function.		The Clean System knows how to compute greater or equal, >=, when less than, <, is defined. Functions that can process arguments of various types are called polymorphic. When there is a type restriction, like * t, on one or more of the type variables involved we have an implicit type class rather than a polymorphic function.

	== Lists ==		== Lists ==

Thomas at 11:15, 20 July 2010

2010-07-20T11:15:12Z

← Older revision		Revision as of 11:15, 20 July 2010
Line 1:		Line 1:
	We show here some very elementary examples of Clean for those people who have never seen a functional programming language before or for those of you who just want to have an impression how Clean code looks like in order to compare it with other functional languages.		We show here some very elementary examples of Clean for those people who have never seen a functional programming language before or for those of you who just want to have an impression how Clean code looks like in order to compare it with other functional languages.

	Although the real power of the language only pops up in serious applications, these tiny examples do give an impression of the compact and elegant language constructs. For a complete language description we refer to the Clean [[Documentation~~#Clean_Language_Report\|language report~~]]. A thorough introduction to functional programming in Clean can be found in the [[Documentation~~#Clean_Book\|Clean book~~]].		Although the real power of the language only pops up in serious applications, these tiny examples do give an impression of the compact and elegant language constructs. For a complete language description we refer to the Clean [[Documentation]]. A thorough introduction to functional programming in Clean can be found in the [[Documentation]].

	The text of this overview is copied from the Hilt web pages. The following language constructs are briefly discussed:		The text of this overview is copied from the Hilt web pages. The following language constructs are briefly discussed:

Thomas at 11:14, 20 July 2010

2010-07-20T11:14:52Z

← Older revision		Revision as of 11:14, 20 July 2010
Line 1:		Line 1:
	We show here some very elementary examples of Clean for those people who have never seen a functional programming language before or for those of you who just want to have an impression how Clean code looks like in order to compare it with other functional languages.		We show here some very elementary examples of Clean for those people who have never seen a functional programming language before or for those of you who just want to have an impression how Clean code looks like in order to compare it with other functional languages.

	Although the real power of the language only pops up in serious applications, these tiny examples do give an impression of the compact and elegant language constructs. For a complete language description we refer to the Clean [[Documentation#Clean_Language_Report\|language report]]. A thorough introduction to functional programming in Clean can be found in the [[Clean book]].		Although the real power of the language only pops up in serious applications, these tiny examples do give an impression of the compact and elegant language constructs. For a complete language description we refer to the Clean [[Documentation#Clean_Language_Report\|language report]]. A thorough introduction to functional programming in Clean can be found in the [[Documentation#Clean_Book\|Clean book]].

	The text of this overview is copied from the Hilt web pages. The following language constructs are briefly discussed:		The text of this overview is copied from the Hilt web pages. The following language constructs are briefly discussed: