Explore topic-wise InterviewSolutions in .

An Objects attributes and behaviour is controlled by sending functions to the object.

Pure Function:

1. The return value of the pure functions solely depends on its arguments passed.

2. If you call the pure functions with the same set of arguments, you will always get the same return values.

3. They do not have any side effects.

4. They do not modify the arguments which are passed to them.

Impure Function:

1. The return value of the impure functions does not solely depend on its arguments passed.

2. If you call the impure functions with the same set of arguments, you might get the different return values. For example, random( ), Date( ).

3. They have side effects.

4. They may modify the arguments which are passed to them.

strlen (s) is called each time and strlen needs to iterate over the whole of ‘s’. If the compiler is smart enough to work out that strlen is a pure function and that ‘s’ is not updated in the lbop, then it can remove the redundant extra calls to strlen and make the loop to execute only one time. This function reads external memory but does not change it, and the value returned derives from the external memory accessed.

(d) Parameters

let min 3 x y z : =

if x < y then

if x < z then x else z

else

if y < z then y else z

The values which are passed to a function definition are called Arguments

sin (0) = 0 is an example for Pure function.

(a) Interface

Value 78 being bound to the name X

(d) Pure functions

(b) Parentheses

The function random ( ) is an example for Impure functions.

Interface:

Interface just defines what an object can do, but won’t actually do it.

Implementation:

Implementation carries out the instructions defined in the interface.

(c) Implementation

(c) Interface

Characteristics of interface:

1. The class template specifies the interfaces to enable an object to be created and operated properly. 

2. An object’s attributes and behaviour is controlled by sending functions to the object.

An Object is an instance created from the class.

(a) It gives different outputs for same function call

(a) Function name

class declaration

(c) In object oriented programs, objects are interfaces

The formula should be written after =

(b) All function definitions are dynamic

let rec even x : = Even

Answer is (c) 2

(d) None of these

When a function depends on variables or functions outside of its definition block, you can never be sure that the function will behave the same every time it’s called.

For example let y: = 0

(int) inc (int) x

y: = y + x;

return (y)

In the above example the value of y get changed inside the function definition due to which the result will change each time. The side effect of the inc ( ) function is it is changing the data ‘ of the external visible variable ‘y’.

To define a recursive function, Let rec is used.

let rec sum num:

if (num! = 0) then return num + sum (num – 1)

else

return num

If a function is not a recursive one, then let is used

1. Parameter without Type

2. Parameter with Type Parameters (and arguments)

Parameters are the variables in a function definition and arguments are the values which are passed to a function definition.

(I) Parameter without Type

Let us see an example of a function definition: (requires: b> = 0)

(returns: a to the power of b)

let rec pow a b: =

if b = 0 then 1

else a * pow a (b – 1)

In the above function definition variable ‘b’ is the parameter and the value which is passed to the variable ‘b’ is the argument. The precondition (requires) and postcondition (returns) of the function is given. Note we have not mentioned any types: (data types). Some language compiler solves this type (data type) inference problem algorithmically, but some require the type to be mentioned.

In the above function definition if expression can return 1 in the then branch, by the typing rule the entire if expression has type int. Since the if expression has type ‘int ’ , the function’s return type also be ‘inf. ‘b ’is compared to 0 with the equality operator, so ‘b ’is also a type of ‘int. Since a is multiplied with another expression using the * operator, ‘a’ must be an int.

(II) Parameter with Type

Now let us write the same function definition with types for some reason:

(requires: b > 0)

(returns: a to the power of b)

let rec pow (a: int) (b: int): int : =

if b = 0 then 1

else a * pow b (a – 1)

When we write the type annotations for ‘a ’ and ‘b ’ the parentheses are mandatory. Generally we can leave out these annotations, because it’s simpler to let the compiler infer them. There are times we may want to explicitly write down types. This is useful on times when you get a type error from the compiler that doesn’t make sense. Explicitly annotating the types can help with debugging such an error message.

The syntax to define functions is close to the mathematical usage: the definition is introduced by the keyword let, followed by the name of the function and its arguments; then the formula that computes the image of the argument is written after an = sign. If you want to define a recursive function: use “let rec ” instead of “let

Syntax: The syntax for function definitions:

let rec fnal a2 … an : = k

Here the fn is a variable indicating an identifier being used as a function name. The names ‘al ’ to ‘an ’ are variables indicating the identifiers used as parameters.

The keyword ‘rec ’ is required if fn ’ is to be a recursive function; otherwise it may be omitted.

For example: let us see an example to check whether the entered number is even or odd.

(requires: x> = 0)

let rec even x : = x = 0 || odd (x – 1)

return ‘even’

(requires: x> = 0)

let odd x : =

x< >0 && even (x – 1)

return ‘odd’

The syntax for function types:

x → y

x₁ → x₂ → y

x₁ → … → x_n → y

The ‘x’ and ‘y’ are variables indicating types. The type x → y is the type of a function that gets an input of type ‘x’ and returns an output of type ‘y’. Whereas x → x → y is a type of a function that takes two inputs, the first input is of type ‘x1 ’ and the second input of type ‘x2’ , and returns an output of type ‘y’. Likewise x1 → … → xn → y has type ‘x’ as input of n arguments and ‘y’ type as output.

(ii) Evaluation of Impure function causes side effects to its output.

1. Parameter without type

2. Parameter with type

(a) Subroutines

Definitions bind values to names, Definitions are not expressions, Definitions are distinct syntactic blocks. Definitions can have expressions nested inside them, and vice – versa.

let rec f_n a₁ a₂ … a_n : = k

f_n : Function name

a₁ … a_n – variable

rec: recursion

A function definition which calls itself is called recursive functions. It is given by let rec.

Function is a unit of code that is often defined within a greater code structure

Impure Function:

• The return value of the impure functions does not solely depend on its arguments passed. Hence, if you call the impure functions with the same set of arguments, you might get the different return values. For example, random( ), Date( ).
• They may modify the arguments which are passed to them.

(c) Definition

(a) Impure functions

Subroutines are the basic building blocks of computer programs. Subroutines are small sections of code that are used to perform a particular task that can be used repeatedly. In Programming languages these subroutines are called as Functions.

(b) data type of the parameters are not mentioned

In function definition pre condition is given by Requires

In function definition post condition is given by Returns

Correct option is (c) (a) and (b)