rational(n, d):
return [n, d]
numer(x):
return x[0]
denom(x):
return x[1]

The pseudo code for the representation of the rational number using the above constructor and selector is component
x,y:=8,3
rational(n,d)
numer(x)/numer(y)
- - output: 2.6666666666666665

(i) A tuple is a comma-separated sequence of values surrounded with parentheses. Tuple is similar to a list.
(ii) The difference between the two is that you cannot change the elements of a tuple once it is assigned whereas in a list, elements can be changed
(iii) Example : colour = ('red', 'blue, 'Green')

List is constructed by placing expressions within square brackets separated by commas. List can store multiple values.
Example:
1st := [10, 20]
x, y:= 1st
In the above example x will become 10 and y will become 20.

(i) Abstract Data type (ADT) is a type (or class) for objects whose behavior is defined by a set of value and a set of operations. 
(ii) The definition of ADT only mentions what operations are to be performed but not how these operations will be implemented.

An ADT for rational numbers:
- - constructor
- - constructs a rational number with numerator n, denominator d
rational(n, d)
- - selector
number(x) \(\rightarrow \) returns the numerator of rational number x
denom(y) \(\rightarrow \) returns the denominator of rational number y

(i) Data abstraction is supported by defining an abstract data type (ADT) which is a collection of constructors and selectors.
(ii) Constructors create an object, bundling together different pieces of information, while selectors extract individual pieces of information from the object.

(i) Constructor
(ii) Selector
(iii) Constructor
(iv) Selector
(v) Selector

(i) The elements of a list can be accessed in two ways. The first way is via our familiar method of multiple assignment, which unpacks a list into its elements and binds each element to a different name.
lst := [10, 20]
x, y := lst
(ii) In the above example x will become l0 andy will become 20.
(iii) A second method for accessing the elements in a list is by the element selection operator. Unlike a list literal, a square brackets  expression directly following another expression does not evaluate to a list value, but instead selects an element from the value of the preceding expression.
Ist [0]
10
lst [1]
20

 

A powerful strategy for designing programs, 'wishful thinking'. Wishful Thinking is the formation of beliefs and making decisions according to what might be pleasing to imagine instead of by appealing to reality.

(i) The basic idea of data abstraction is to structure programs so that they operate on abstract data. That is, our programs should use data in such a way, as to make as few assumptions about the data as possible.
(li) At the same time, a concrete data representation is defined as an independent part of the program.
(iii) Any program consist of two parts. The two parts of a program are, the part that operates on abstract data and the part that defines a concrete representation, is connected by a small set of functions that implement abstract data in terms of the concrete representation.
(iv) To illustrate this technique, let us consider an example to design a set of functions for manipulating rational numbers.
(v) Example: A rational number is a ratio of integers, and rational numbers constitute an important sub-class of real numbers. A rational number such as 8/3 or 19/23 is typically written as : < numerator > /< denominator >
(vi) where both the < numerator > and <denominator> are placeholders for integer values. Both parts are needed to exactly characterize the value of the rational number. Actually dividing integers produces a float approximation, losing the exact precision of integers.
(vii) However, you can create an exact representation for rational numbers by combining together the numerator and denominator.
(viii) As we know from using functional abstractions, we can start programming productively before you have an implementation of some parts of our program.
(ix) Let us begin by assuming that you already have a way of constructing a rational number from a numerator and a denominator. You also assume that, given a rational number, you have a way of selecting its numerator and its denominator component.

List : 
(i) List is constructed by placing expressions within square brackets separated by commas. Such an expression is called a list literal. List can store  multiple values. Each value can be of any type and can even be another list.
Example for List [10, 20].
(ii) The elenments of a list can be accessed in two ways. The first way is via our familiar method of multiple assignment, which unpacks a list into its elements and binds each elenment to a different name.
Ist := [10, 20]
x, y = lst
(iii) In the above example x will become l0 and y will become 20. A second method for accessing the elements in a list is by the element  selection operator.
(iv) Unlike a list literal, a square-brackets expression directly following another expression does not evaluate to a list value, but instead selects an element from the value of the preceding expression.
lst [0]
10
Ist [1]
20
(v) In both the example mentioned above mathematically we can represent list similar to a set.

Pair :
Any way of bundling two values together into one can be considered as a pair. Lists are a common methodto do so. Therefore List can be called as Pairs.