Computer Science – chapter 1

FUNCTION
Choose the best answer:
1. The small sections of code that are used to perform a particular task is called
(A) Subroutines (B) Files (C) Pseudo code (D) Modules
2. Which of the following is a unit of code that is often defined within a greater code
structure?
(A) Subroutines (B) Function (C) Files (D) Modules
3. Which of the following is a distinct syntactic block?
(A) Subroutines (B) Function (C) Definition (D) Modules
4. The variables in a function definition are called as
(A) Subroutines (B) Function (C) Definition (D) Parameters
5. The values which are passed to a function definition are called
(A) Arguments (B) Subroutines (C) Function (D) Definition
6. Which of the following are mandatory to write the type annotations in the function
definition? (A) { } (B) ( ) (C) [ ] (D) < >
7. Which of the following defines what an object can do?
(A) Operating System (B) Compiler (C) Interface (D) Interpreter
8. Which of the following carries out the instructions defined in the interface?
(A) Operating System (B) Compiler (C) Implementation (D) Interpreter
9. The functions which will give exact result when same arguments are passed are called
(A) Impure functions (B) Partial Functions
(C) Dynamic Functions (D) Pure functions
10. The functions which cause side effects to the arguments passed are called
(A) impure function (B) Partial Functions
(C) Dynamic Functions (D) Pure functions

2 Marks:
1. What is a subroutine?
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.
2. Define Function with respect to Programming language.
A function is a unit of code that is often defined within a greater code
structure. Specifically, a function contains a set of code that works on many kinds
of inputs, like variants, expressions and produces a concrete output.
3. Write the inference you get from X:=(78).
X:= (78) has an expression in it but (78) is not itself an expression. Rather,
it is a function definition. Definitions bind values to names, in this case the value
78 being bound to the name ‘X’. Definitions are not expressions, at the same time
expressions are also not treated as definitions. Definitions are distinct syntactic
blocks. Definitions can have expressions nested inside them, and vice-versa.
4. Differentiate interface and implementation.
Interface Implementation
Interface just defines what an Implementation carries out the
object can do, but won’t actually instructions defined in the interface
do it
5. Which of the following is a normal function definition and which is recursive
function definition
i) let sum x y:
return x+y Ans: normal function
ii) let disp:
print ‘Welcome’ Ans: normal function
iii) let rec sum num:
if(num!=0) then return num + sum(num-1)
else
return num Ans: Recursive function
3 Marks:
1. Mention the characteristics of Interface.
 The class template specifies the interfaces to enable an object to be created
and operated properly.
 An object's attributes and behaviour is controlled by sending functions to
the object.
2. Why strlen is called pure function?
let i:=0;
if i<strlen(s) then
++i
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 loop, then it can remove the redundant extra calls to
strlen and make the loop to execute only one time. From these what we can
understand, strlen is a pure function because the function takes one variable as a
parameter, and accesses it to find its length. This function reads external memory
but does not change it, and the value returned derives from the external memory
accessed.
3. What is the side effect of impure function? Give example.
As you are aware function has side effects when it has observable
interaction with the outside world. There are situations our functions can become
impure though our goal is to make our functions pure. Just to clarify remember
that side effect is not a necessary bad thing. Sometimes they are useful (especially
outside functional programming paradigm).
One of the most popular groups of side effects is modifying the variable
outside of function.
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’. As you can see some side
effects are quite easy to spot and some of them may tricky. A good sign that our
function impure (has side effect) is that it doesn’t take any arguments and it doesn’t
return any value.
4. Differentiate pure and impure function.
Pure function Impure function
The return value of the pure functions The return value of the impure
solely depends on its arguments passed. functions does not solely depend on its
Hence, if you call the pure functions arguments passed. Hence, if you call the
with the same set of arguments, you impure functions with the same set of
will always get the same return values. arguments, you might get the different
They do not have any side effects. return values For example, random(),
Date().
They do not modify the arguments They may modify the arguments which
which are passed to them are passed to them

5 Marks:
1. What are called Parameters and write a note on
(i) Parameter without Type (ii) 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.
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, shows that as per the typing rule the entire if expression has type int. Since
the if expression is of type ‘int’, the function's return type also be ‘int’. ‘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.
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 a (b-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”.
2. Explain with example Pure and impure functions.
Pure functions:
Pure functions are functions which will give exact result when the same
arguments are passed. For example the mathematical function sin (0) always
results 0. This means that every time you call the function with the same
arguments, you will always get the same result. A function can be a pure function
provided it should not have any external variable which will alter the behaviour of
that variable.
let square x
return: x * x
The above function square is a pure function because it will not give
different results for same input.
There are various theoretical advantages of having pure functions. One
advantage is that if a function is pure, then if it is called several times with the
same arguments, the compiler only needs to actually call the function once. Lt’s
see an example
let i: = 0;
if i < strlen(s) then
++i
If it is compiled, 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 loop, then it can remove the
redundant extra calls to strlen and make the loop to execute only one time. From
these what we can understand, strlen is a pure function because the function takes
one variable as a parameter, and accesses it to find its length. This function reads
external memory but does not change it, and the value returned derives from the
external memory accessed.
Evaluation of pure functions does not cause any side effects to its output
Impure functions
The variables used inside the function may cause side effects though the
functions which are not passed with any arguments. In such cases the function is
called impure function. 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 the mathematical function random() will
give different outputs for the same function call.
let Random number
let a := random()
if a > 10 then
return: a
else
return: 10
Here the function Random is impure as it is not sure what will be the result
when we call the function.

Pure function Impure function

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

3. Explain with an example interface and implementation.

An interface is a set of action that an object can do. For example when you
press a light switch, the light goes on, you may not have cared how it splashed the
light. In Object Oriented Programming language, an Interface is a description of
all functions that a class must have in order to be a new interface. In our example,
anything that "ACTS LIKE" a light, should have function definitions like turn_on
() and a turn_off (). The purpose of interface is to allow the computer to enforce
the properties of the class of TYPE T (whatever the interface is) must have
functions called X, Y, Z, etc.
A class declaration combines the external interface (its local state) with an
implementation of that interface (the code that carries out the behaviour). An
object is an instance created from the class.
The interface defines an object’s visibility to the outside world. The
difference between interface and implementation is
Interface Implementation
Interface just defines what an object can do, Implementation carries out the
but won’t actually do it instructions defined in the interface
In object oriented programs classes are the interface and how the object is
processed and executed is the implementation.
Characteristics of Interface:
  The class template specifies the interfaces to enable an object to be created
and operated properly.
 An object's attributes and behaviour is controlled by sending functions to
the object.
For example, let's take the example of increasing a car’s speed.
The person who drives the car doesn't care about the internal working. To
increase the speed of the car he just presses the accelerator to get the desired
behaviour. Here the accelerator is the interface between the driver (the calling /
invoking object) and the engine (the called object).
In this case, the function call would be Speed (70): This is the interface.
Internally, the engine of the car is doing all the things. It's where fuel, air,
pressure, and electricity come together to create the power to move the vehicle.
All of these actions are separated from the driver, who just wants to go faster.
Thus we separate interface from implementation.
Let us see a simple example, consider the following implementation of a
function that finds the minimum of its three arguments:
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