Parameters - Programming Languages - Computer Science & Engineering Video Lecture - Computer Science Engineering (CSE)

welcome to lecture 39 so today we will
discuss parameter passing so since most
of the issues are pragmatic though it is
really and it is also tremendously
complicated to give a semantics so what
we'll do is we'll discuss most of the
basic parameter passing mechanisms from
a purely pragmatic viewpoint and it's
possible to give a semantics but then
that's the semantics of often
afterthought and it's not a predefined
semantics in the sense that so as a
result especially for imperative
languages it becomes very messy and
rather complicated and actually does not
provide too much intuition at least in
my opinion so but what it can do of
course is to accurately pin down exactly
how it should be implemented what are
the considerations but however we will
look at it from a purely pragmatic point
of view it's most elegantly discussed
only in a functional setting or in a
lambda calculus setting with the toy
language so as I said most functional
languages U is called by value which is
which is that given an operator and an
operand you completely evaluate the
operand before you actually perform the
application right now the whole question
of and as I said in the in the
particular case of the applied lambda
calculi whether type in the case of
typed applied lambda calculi which is
what most function languages are
call-by-value and call-by-name give the
same results but call-by-value is likely
to give you a faster convergence to the
normal form in the untyped case
call-by-name is always guaranteed to
give you a normal form if it exists but
call-by-value might go off into an
infinite computation so so that's so
that's one important reason why you
should introduce typing
so that then you're guaranteed that
you'll always get normal forms secondly
from a purely pragmatic viewpoint you
can use call-by-value which is an easy
implementation compared to a
call-by-name implementation anyway
coming to procedural languages or
imperative languages the whole question
of parameter passing is closely is
closely related to what might be called
an attitudinal problem problem alright
so essentially given a function or a
procedure call the question is and this
in general could be an expression this e
which is where I put it in dark green
but now very often it is just a single
name of a variable or or a phonetic
component or a record field so very
often it is just a name of off some
object and in imperative languages if
you remember objects could have even
simple variables actually have different
interpretations for example depending on
whether they occur on the left hand side
of an assignment or all or on the right
hand side of an assignment
I mean assignment in some form over the
other is the most important construct in
an imperative language right and it and
a name has a different meaning depending
upon whether it has whether it occurs on
the left hand side or on the right hand
side of an assignment so when it occurs
on the left hand side you are
essentially referring to its location or
its address and a variable is really
like a container then a container which
can contain a value and if it occurs on
the right hand side you are really
looking at not the location but the
value contained in a particular location
so I mean so I made this distinction
between L values and our value as long
ago and
essentially that confusion resides here
okay so the attitude so all the
interpretation that you can give an
expression if it's a simple arithmetic
expression or some such thing there is
really nothing you can do I mean it's
actually there is still confusion there
too but as we will see but so the
attitude that you can take is if the
parameter e denotes an R value then what
you mean is that this e is really a
value and therefore the value is what
has to be passed as the actual parameter
of this procedure column okay and if you
regard this expression as denoting a
value then essentially you will be using
a call-by-value mechanism on the other
hand you could regard this expression as
an L value okay which means that it is
it should be an expression which for
which there is a possibility of that
confusion between an R value and an L
value and if it's just some arithmetic
expression of the form 2 plus 3 then
clearly it has no L value okay so but
there it could be a simple variable or
an array component or a record field in
such cases what happens is that that so
then that expression is open to two
different interpretations either as the
value of the value contained in a
location or the location itself okay so
then here what you are saying is should
I have passed the location itself as the
parameter after all that that expression
if it contains if it's an if it could be
interpreted as an L value then it is
just the name of a certain object right
and I am passing I am passing that which
object am i passing that object itself
or am i passing the value contained
inside that object
okay so if I'm passing that object
itself then it's really an end l value
that I am looking at and what you get if
you take that attitude is what is known
as the call-by-reference mechanism and
there is actually a third attitude if
there is if it's some expression then
whether it might have an if it's an
expression then it certainly has an
r-value let's say it may or may not have
an L value but then can I say that when
I'm calling this procedure I am NOT
passing either the l value of the R
value but I am passing the expression
itself as a parameter in large parts of
mathematics actually this confusion
never arose okay and that's because and
that's because whether you pass the
expression itself or you pass the value
of the expression as a parameter you are
always guaranteed the same results in
mathematics okay and that really has to
do with the fact that whether you
whether you do a call-by-value reduction
of a lambda term or a leftmost outermost
reduction of a lambda term in either
case the results if they are not an
infinite computation will yield the same
normal form and that is a call-by-value
that's the call-by-name implementation
you I can look upon the parameter itself
as just a plain piece of text which is
what I'm interested in passing I am NOT
interested in it passing its value I am
NOT passing interested in passing its
location I am really passing just a
plain piece of text and this is really
what happens in a beta reduction in the
lambda cap
and because the lambda calculus is such
that especially the type lambda calculus
regardless of whether you pass it as
value or you pass it as a piece of text
you get the same normal forms
therefore in mathematics in mathematics
there is no question of an L value
therefore so the only confusion there
could have been is whether you are
passing when when you when you do a
function application whether you are
passing a value or an expression as
regarded as a piece of text okay but
that confusion in the typed lambda
calculi since it's guaranteed that you
will always get normal forms and you'll
get the same normal form always it did
not matter a call by value or a call by
name implementation however in any
programming language in which locations
are also closely into interval one into
the language what happens is that this
call-by-value and call-by-name can
produce different results yeah okay so
so this is the call by name or what what
in the lambda calculus would be the
leftmost outermost beta reduction rule
that means you scan a lambda term the
moment you find a lambda application
take the left the take the take the
operator and the operand do not reduce
the operand apply the left starting from
the left the outermost application has
to be done first then in that case the
operand itself could be something that
my is capable of being reduced but you
do not reduce it and when you do the
beta reduction what you do what you are
doing is substituting the entire text of
the operand in place of a free variable
in the body of a lambda abstraction
right that's a call-by-name method of
parsing yeah okay so let's so let's look
at I mean these three are the most
important for these reasons actually
though call-by-name is really not being
used too much but you cannot really
justify a lot of things especially in
the in functional languages without
actually proving for example that they
will give you the same semantics as
called by name and so on so however
there are so the call-by-value is
something that's implemented in past C
and most languages most imperative
languages call by name the only
imperative language in which I know it
was implemented was Algol 60 and certain
derivatives of Algol 60 are which well
like the Stanford artificial
intelligence language sale I think used
call by name right but it's a very very
it's a very very dicey kind of thing to
implement so it's quite unpopular
call-by-reference of courses in is there
in Pascal and Fortran and then there is
also something called call-by-value
result and I say a dot question mark
because it's not clear what ADA wants
you to implement okay it's not
absolutely clear I will we will see the
reason for that okay so let's look at
this so when since called by values if
you remember the activation records and
stack and so on there was a place for
parameters so I won't go back to that
just keep that in mind
so in a call-by-value and i call by
value implementation what you do is you
evaluate the actual parameter to obtain
a value so the actual parameter actually
could be an expression including let's
say an arithmetic expression containing
just constants if you like whatever but
you actually
do all the possible reductions that are
possible till you get a value right and
having done that there is a formal
parameter right let's let's look at the
general structure of procedures you will
have let's say a procedure text which
has some formal parameters okay let's
let's call it X let's just assume one
one parameter and then you might have a
call to this procedure procedure has a
name let's say P and you might have a
call to this procedure this procedure
could also be a Pascal function and what
I mean is there's no fundamental
difference between functions in
procedures in Pascal or in Fortran
because all it means is having an extra
local variable to store the result
otherwise that they're both absolutely
the same right so we just look at them
as procedures and there is an actual
parameter okay and of course you have to
draw the formal to actual correspondence
and the whole question of interpretation
now reduces to in this call should X
denote the value the r-value of a should
X denote the L value of a or should X be
the name for this piece of text just a
name for this piece of text right that's
really all that you those are the three
mechanisms that we are real that we are
really interested in looking at right so
so then what do you do in a
call-by-value implementation you just
you evaluate the actual parameter down
to an R value okay and assign the formal
parameter this value that means you are
explicitly you're performing an implicit
assignment operation okay where the
formal parameter is initialized to this
value right
and then you execute the procedure or
function with this initialization of the
formal parameters right so now because
of this particular way of going about
things supposing the actual parameter
were an expression that could be an L
value either the actual parameter is
then a simple variable and had a
component or let's say a record field
then what happens is this this process
does not for example change the value of
values of the I mean the so within the
procedure or function if you change the
value of the formal parameter that is
not reflected in the value of the actual
problem so this call-by-value
implementation if you take a broad
pragmatic view is really for doing
things like well yeah I've got a value a
and I want to find sine E or cos say you
know elementary mathematical functions
where you are not really interested in
producing side effects of course what
happens with most of our programs is
that within the function there are side
effect due to various reasons many and
very often the reasons are lie in pascal
or the appropriate language for example
pascal has a restriction that a pascal
function can return only an scalar data
type value supposing i have a function
which actually want has to return two
different values what do i do so i might
do some some silly thing like making one
of the values global returning one value
and producing a side-effect within the
function it's that's one possible way of
doing it so we do such things but
whatever are the changes in the values
of the formal parameter in the execution
of the procedure will not be reflected
back unless you actually use that actual
parameter also as you modify that actual
parameter also in the procedure or
function you know so changes in the
formal will not be reflected back in the
action
in general in general but there are
specific instance is very good right so
so now so what so what kinds of
variations can you have for example you
could have so your actual parameter
could be as I said it's pasta the value
of a base type yeah so which means that
there will be no side effects possible
I'm talking of these side effects
whenever I talk of no side effects
possible I don't mean I mean side
effects through modification of the
formal parameter and not side effects
created by explicit assignments of
assignments to global variables within
the function or the procedure right
however the Alpha the R value of the
actual parameter could be a location
after all a location is also locations
the addresses are also our values so it
could be a location in which case what
happens is that you're essentially
dealing with pointers and then all
assignments to formal parameters are
immediately reflected in the actual I
mean in fact if I were to write various
list list based programs in Pascal for
example I want to take all these scheme
functions Elementary scheme functions
and program them in Pascal so what would
I do
well I would define a function called
cons which takes let's say a value and a
pointer to a list and I would actually
concept and do things so and and that
pointer to the list would could just be
a call-by-value parameter but since it's
a pointer and I'm going to go through
this process of first creating a new
location and then modifying the pointer
and so on and so forth I will actually
get side-effects the end result that I
get would actually be a new list with
that new element constant
it so under cases where the r-value is
actually an address you could act you
could actually so what it means is that
there is a global there's a heap based
data structure which you are modifying
somewhere you're not actually modifying
the value of the location in the formula
okay but you're modifying some some last
structure that is pointed to by this
r-value and once you modified that you
essentially got you essentially changed
your global environment so on your
return from the procedure you have got a
modified global environment right so for
example lopping off the head of the list
i could just pass the list as a pointer
okay
lop off the head by deallocating the
head putting the pointers in some
particular way and then just get back
Pistor ostensively there are no side
effects because of a call-by-value
implementation but the new list that i
get is really the tail of the original
list and in fact this is what is used
mostly in c to do to produce side
effects c uses only a single parameter
passing mechanism and that's called by
value and the way it uses call-by-value
even though it for normal variables
call-by-value produces no side effects
the way it produces call-by-value is
that it uses value parameters through
explicit referencing and dereferencing
operations so you can actually pass a
value which is a pointer to something
okay dereference that pointer change the
value through an explicit call-by-value
mechanism and get that and you would
have produced side-effects though the
actual parameter would not have changed
its value right it would still be a
pointer to the same location but you
change the contents of that location
and so you've produced a side effect yes
that's all see for example does not
allow for any other parameter passing
mechanism allows only for call-by-value
but since it has primitives for
referencing and dereferencing you can
produce side effects through the
call-by-value mechanism right so so
there is another variation of the call
by value parameter mechanism and that's
called the call by value result right
and that's very simple you just proceed
exactly as in call by value okay the
only extra constraint is that your
actual parameter should also have an L
value right so if you if your actual if
your actual parameter is some let's say
some arithmetic expression 2 plus 3 is
what comes to mind always then obviously
call by value result is I mean it's not
going to I mean it doesn't satisfy this
constraint but the actual parameter is
something which also has an L value then
what I can do is proceed exactly as in
call by value and after the and just as
there was a there's a copying in face in
a call-by-value mechanism you first find
the r-value of the expression and you
find the r-value of the expression and
then you actually do this assignment to
the formal parameter right so this is
the copying in face so just like you
have a copying in face after executing
the procedure you have a copy out face
ok so where you will actually copy back
values from the formals to the actions
right so a call-by-value result is just
called my value plus this extra step
which is firstly with this constraint
that the actual parameter should have
should be a should also be a look
and after executing I mean it's because
you have to copy back values from the
formal to the actual and you can't do
that in a memory based system without
the actual parameter hat actually also
denoting a location also having an L
value so then this copying back is done
and essentially you have created a
side-effect but in a clean fashion I
mean in the sense that there's no really
there's no great interference between
the Global's and the body of the
procedure I mean the the procedure still
remains us and abstract but you're
copying back the values at the end of
the execution of the procedure all
intermediate values of the that the
formal stake within the procedure will
not be reflected in the actual okay so
so that's that's a callback the the
call-by-value result is as I said it's
not actually used in any programming
language except that ADA has three kinds
of parameter mechanisms okay so and a
typical ada procedure could have what
are known as in parameters okay which
are quite faithfully reproduced by the
call-by-value mechanism okay then there
are in out parameters which means there
is a copying in face of these parameters
and at the execution of the at the end
of the execution of the procedure
there's a copying out face also okay and
then there are also plain-out parameters
okay so you can think of this plain-out
parameters as a form of what might be
called just call by result I mean there
is no copying in face for these out
parameters they stand let's say
essentially uninitialized when the
procedure begins execution but
the end of the execution there is a copy
out of values and you have essentially
war I mean so you don't have a copying
in phase but you have a copy obvious so
you can call that a call by result
mechanism if you like but the whole
point about the error language is it
does not specify how these things have
to be implemented it is just generally
accepted conjecture that this is what
the designer is meant okay so that's why
there's a question mark there now what
actually most most languages from
Fortran always tried to implement was
always provided was what is known as a
call by reference mechanism which is
what is which is the variable parameter
ISM in pascal right so what happens is
you actually assign to the formal the l
value of the actual parameter and then
you execute the procedure with this
proviso so that whenever the formal the
whenever the r-value of the formal
parameter is required
you take the r-value of the
corresponding actual parameter and
whenever you want to change the value of
the formal parameter you actually change
the value of the actual the
corresponding actual parameter so the
formal parameter or whatever is regarded
whatever is the space reserved for the
formal parameter in the activations
record is just an address to the actual
parameter and within the procedure
whenever it's a formal parameter that is
that is being assigned or being used
whose value is being used actually the
value is not taken from that formal
parameter but you could go down that
pointer to the to the location where the
actual parameter is and either use the
value inside
or modify that okay and this is a this
is so the call-by-reference mechanism
was what was used in Fortran a long time
ago it is used in Pascal through the VAR
declaration it's clear in Algol 68 there
is there in so many languages and it's
there in C by virtue of the fact that C
allows referencing and dereferencing and
but it is not explicitly provided by the
C language the only explicitly provided
mechanism is the call by value accounts
right so so let's look at a few examples
of these things so supposing you have so
I'll use a Pascal like syntax throughout
so let's let's consider just this
trivial example taken from an elementary
programming course on Pascal so I have
this procedure swap with two with two
formal parameters x and y declare
integer i have an integer an
intermediate variable t also declared to
be an integer and then i have the
standard swap procedure right and now i
call this procedure with two actual
parameters a and B okay and now by
default if it's if if this is a Pascal
program then this x and y are
implemented as value parameters so what
it means is that first there is a
copying in face so the values of a and B
the are values of a and B are stored in
the locations corresponding the
locations for x and y and then the
values of x and y are actually swapped
okay and when you get out the values of
a and B are still the same old values
right so that's okay so there are no
changes to the values of a and B so the
standard thing to do this so what you
could do is you could implement it by a
call-by-value result mechanism supposing
we extended this the Pascal parameter
passing mechanisms to two value result
then what it means is that I would
assume that the body of the swap
procedure is the same except that I have
made this change I've declared x and Y
to be value reserved then what happens
is that in the copying in face x and y
are assigned the values of a and b then
the values of x and y are swapped in the
procedure body and then there is a copy
out phase where the actual parameters
are assigned the values of the formals
so that's what I mean by a clean
interface I mean you can look upon this
I mean if you look at the procedure as a
single entry single exit black box okay
with the parameters forming the
interface then it's a clean interface in
the sense that there's a copying in
which corresponds so the power the
transmission of that parameters is
through the through the interface for
through the copying in portion and then
there is an output through the copy out
phase okay and the rest of the program
while this procedure is executing
essentially if there are if Global's are
not referenced Global's are not modified
and so on and so forth then what it
means is that this procedure stands
alone and can be used by others as a
purely as a distinct complete functional
unit in itself as an abstraction in the
true sense of the word right okay on the
other hand of course what we normally do
since the value result mechanism is not
available in Pascal what you do is you
usually implement this swap by reference
so you actually if
is these two formal parameters to be war
parameters or reference parameters and
then the mechanism goes something as
follows
so yeah so X is assigned the value of a
pointer to a which means address of a Y
is assigned address of B okay so this
type information here is only refers to
the type of the actual parameter and not
to the type of the formal really okay
all that you are saying is that it
should X can be a pointer to n to an
integer actual parameter right and then
after that what happens is that the body
of the procedure executes actually in
this fashion you dereference X and take
that value and put it in T and act of
dereferencing X means going to the
variable a taking its value and
assigning it to T then then the
dereference X that means go to a and to
it assign the value of the dereference
value contained in Y so dereference Y
which means go to the location B and
copy that value into the location
pointed to by x and then of course copy
the value of T into the location pointed
to by Y okay so the side-effects are
immediate right so the side-effects are
immediate unlike let's say the
call-by-value result mechanism so
so essentially if you look at these
three mechanisms then as long as you
have referencing dereferencing
primitives available what you could do
is you could all effects of
call-by-reference can be captured by
call-by-value and which is what she does
and which is what a lot of which is what
many people do in pascal because of
Pascal's peculiar constraints on what
functions can return okay either you
define it as a procedure or define it as
a function return a pointer parameter to
some structure right I mean that and
then you'll get the same result yeah so
so so essentially all the effects of
call-by-reference may be captured by
call-by-value but provided you have this
referencing and dereferencing primitives
already in the language otherwise of
course you can't right now in the
absence of referencing and dereferencing
primitives what we have is of course
that the call-by-value can produce no
side effects except explicit assignments
to Global's and so on and so forth and
but all call-by-reference side effects
can actually be captured by a
call-by-value result and the only
difference is that this effects are not
immediate in a call-by-value result
mechanism the effects are delayed I mean
they are delayed till you actually are
exiting the procedure right but however
there is there is a catch to this which
actually most books do not point out
okay and the catch is
and this you can capture all effects of
the call-by-reference
all side effects of call-by-reference by
call-by-value result only provided all
the actual parameters in your procedure
call are distinct if there is if you
have an aliasing problem okay you have
you have actually used okay let's look
at this so if you have an aliasing
problem then there is no guarantee that
the effects of call-by-reference will be
captured by call-by-value result and
vice versa there is absolutely no
guarantee that the effects of
call-by-value result will be captured by
call-by-reference
again so here's this here is a simple
example which actually does this the
important thing here I mean here look at
this
so this is this procedure presumably
takes values x and y which are let's say
integers and then it it gives the
quotient and remainder of the input
values x and y and stores them also in x
and y because assuming some of that you
don't interfere the original x and y and
you want only the quotient and remainder
then what this procedure does is it
somehow does this but then there is
nothing which prevents me from calling
this procedure with x and y being the
same being the same l value right then
actually what will happen is this order
of evaluation and the last statement
which modified a will is what is going
to take effect okay and since the
effects are immediate well in order to
buffer the effects being immediate I
have used this intermediate variable T
and used it throughout otherwise I might
I used Y here but so essentially what it
means is
the result of this procedure call is
going to be that a will have the
quotient which means one if a is not
zero okay at the end of this procedure
or it won't have that maybe it will have
a is equal to X multi that that's zero
oh yeah it have right really have one
I have luckily pro programmed it right
okay now on the under the value result
implementation what happens is that you
here at the end of this procedure X
actually contains the quotient of the
original a and a which is 1y actually
contains the value 0 but depending on in
what order you do the copy out face it
will be reflected in this actual
parameter so which means supposing you
assume that all sensible compilers and
runtime systems do the copy or phase in
the order because parameter orders are
important always so if they do it in
this order then essentially what it
means is that a will have the value of y
which means it will have 0 in this case
you will have a equals 0 and in this
case you never equals 1 right which is
an excellent reason for not doing this
kind of programming
once you use the actual parameter inside
the procedure then there's this
confusion confounded okay so and let's
not get into those complications this is
just to point out a difference between
these two in effects which is usually
not pointed out in most books on
programming languages most books
actually claim that the effects of
call-by-value result can be captured the
effects of call-by-reference can be
captured by call-by-value result and
it's not entirely true yeah okay however
so since but call-by-value result is a
very clean mechanism in the sense that
it doesn't give you unnecessary
headaches however the point is the
problem really is what happens when you
have to pass really large structures I
mean so whereas call-by-reference
actually can be can make things quite
complicated especially with array
referencing array index computations
array index modifications inside the
procedure and so on and so forth it can
it can make things quite complicated and
reasoning about in a call by reference
environment can be quite tricky
it means debugging also could be tricky
right so however it's called by
reference is actually the most
economical way of passing large
structures huge arrays a bitmap of
yourself for example to be transformed
somehow into maybe to make you look more
handsome or something but what I mean is
you want if you have if you're going to
pass large structures then you would
also like to be economical about your
usage of store of the store so what you
don't want is what you don't want is to
create an output which is another large
structure so very often you just want to
create the side effects on that
structure itself and have those side
effects available to you at the end of
the execution of the procedure
right so when you in the if you have
really large structures like a million
bits by a million bits passed as a
parameter then the copying phase and the
copy or phase are going to be extremely
expensive so even though you might get
to get your results through a call level
you might get correct results through a
call-by-value result mechanism it's
actually faster and more space efficient
to use a call by reference mechanism to
produce the required side effects right
so so that's what happens with call by
reference so this is one of the reasons
why I call by reference is most popular
because even for large structures all
you require is a single address that's
it as a parameter so your parameter will
just contain a single address to the
start of the structure and that's it so
whether it's large large list structures
or a large array structures or record
structures it does not matter one
address is all that you require a single
pointer okay so in so then let's look at
the call-by-name mechanism so in a
call-by-name mechanism essentially what
you are saying is that a formal
parameter is just a name for the piece
of text which comprises the actual path
which comprises the actual parameter
right so what you do is you go back to
the lambda calculus and try to model the
behavior of the beta reduction there
exactly in your programming language so
how would you do that
so that means before executing the
procedure
I replace all occurrences of the formal
parameter in the procedure body by the
text which is the actual parameter okay
so essentially the effect of a call by
name is to produce a macro expansion
okay
you have produce a macro expansion
except that just as in the case of a
beta reduction you have to be careful
there should be no free variable capture
okay so essentially if you look at the
so the in the in the event of course in
a compiled language this may not be such
a serious problem because weather
weather so essence every variable will
have an app we would have a would have
an address determined by its the base of
its activation record and the relative
address with respect to the base of its
activation record this problem may not
be so serious at runtime for a compiled
language but we looked at as a form of
beta reduction being modeled in an
imperative programming language what it
means is that so you have to replace all
occurrences and of the formal in the
procedure body by the text of the actual
and to avoid free variable capture what
you have to do is you have to rename all
local variables in the procedure by an
alpha conversion mechanism thank but in
a compiled language that part of it
could be automatically done but what
happens is that in the case of a process
so essentially the resulting procedure
when you replace all these formals by
the text of the actual expression the
resulting procedure should be executed
as an unnamed block in the calling
environment that means the procedure
call is just a number
for taking the entire body of the
procedure after replacing all the
occurrences of the formal parameter by
the text of the actual parameters so the
execution of the procedure the so a
procedure called just has the meaning
that it is an unnamed block a procedure
call is just an abbreviation a
parametrized abbreviation for an unnamed
block that has to be executed at that
point with a substitution of the
parameters by the text of the actual
parameter and of course ensuring that
there are no free variable captures so
so that the so so this so this aspect is
what is really a beta reduction in the
lambda calculus and that is what is
obtained by a call-by-name mechanism and
since all the execution is in the
calling environment in the environment
of the procedure call all side-effects
are immediate okay and you can actually
pass large structures because you'll
just be giving the large structure and
name and passing it that's it so
depending on how you're at runtime
environment deals with large structures
for example arrays regardless of what
language you're looking at arrays are
still just a pointer okay so your side
effects will be immediate and you don't
have this extra overhead of what happens
in I mean you don't have this copying
and copying out all that the effects on
large structures are also captured
immediately array dereferencing or array
indexing and so on the only problem with
this is that reasoning about the program
in about the program from the text can
be quite a problem right and but of
course so that is so this is
so and there is of course another
another effect which called my name and
and of course there is no guarantee that
called my name is equivalent to
call-by-reference or any other any other
mechanism for that matter all these
mechanisms are different because what
happens is that it's different from call
by value because in call by value the
parameter is evaluated once to a value
and that value U is used throughout all
references of the formal it is in the
procedure in the call by name because of
a textual replacement that actual
parameter is evaluated every time that
formal is referenced inside the
procedure so what it means is an
expression like a plus B passed as an
actual parameter to the procedure me so
that a plus B can mean different things
in four different references of X in the
procedure because you may have modified
a between Tuesday to successive
references to the formal parameter okay
so so in general for imperative
languages this is this is not the same
as using a call-by-value mechanism it
means it means repeatedly evaluating
that expression every time that formal
is encountered you execute the text
corresponding to the expression and
essentially reevaluate that expression
but you really ate that expression in
the calling environment further this
call-by-name mechanism can produce
different effects depending upon whether
your language is a statically scoped
language or a dynamically scoped
language because then you are not then
your references because your textual
yeah the text of your parameter really
is a consists of non-local references so
there depending upon where it is being
called those non-local references have
different bindings
okay if you call it if you have it in
the environment of the procedure call it
if you have it in the environment of the
call that in a statically scoped
language the parameter is referred to
the innermost enclosing text innermost
textually enclosing block whereas in a
dynamically scoped language they refer
to the binding in the innermost calling
block so the two so even call by name
depending upon whether you are talking
about a statically scoped language or a
dynamically scoped language can produce
different effects all right okay lastly
I'll just there's just one more thing
and that is that many languages like
Pascal have procedures as parameters
yeah and here there's no question of
whether it's called by a name or called
by a value or anything of the sort
so supposing you have this set of
procedures this this main body where of
course the main body has this call to
this procedure P which is blue the main
body has two procedures Q and P Q is
black and P is blue the blue procedure P
has a function inside it the black
procedure Q is a is a procedure which
calls a function as R as a parameter
okay and this R is also just a formal
name right and then let's say there's a
call to this RI here the RI is used here
and now what happens is if you look at
this call there's a call to P and then
within within P there's a call to Q with
the function f passed as a parameter so
that means this this formal parameter R
now refers to this function deeply
nested inside this P okay
so the question is what is the
environment of non-local references
inside the function okay the point is
that any act in a Pascal in a statically
scoped language X this X should refer to
the Spink X here in the main body any
reference to I here should be this blue
eye here Q itself has an X and an eye
this eye here this black eye here refers
to this black eye here but when you call
this function with this eye here then
you are actually using this blue eye
within Q so you have to somehow create
the static environment suitable for F in
order for F to be executed at this point
and that is very simple what you do is
at the point of this call for a function
or a procedure parameter you also send
along with the parameters and so on you
send the static chain pointer address
for the current base so that all
references to I and X within this
function would refer to the non-local
references in keeping with the
statically scoped structure of the
language okay I mean this is a separate
but this is a very weak parameter
passing mechanism and actually creates
more confusion than it solves
but it's an excellent way of for example
programming higher-order functions like
map at least first level higher-order
functions like map and whatever list
based functions which have to be applied
over the entire list or for example
solving you can have a newton-raphson
method in which the actual function is
called as a through a parameter the
actual function could be a trigonometric
function or a hyperbolic function or
could be a polynomial or mixtures of
these things you call that as a
parameter and that's that's the reason
it was introduced in Pascal for doing
such
of computations independent of actually
what the value of the function is so you
can call newton-raphson with this
function f and maybe find a fixed point
solution but what it means is along with
the function name and the type checking
becomes problematic pascal is the the
rules of pascal are inadequate to do to
adequately type-check this mechanism
because pascal tries to save on your
effort by saying that you don't need to
declare all the variables all the
parameters but then if you don't declare
all the parameters how are you going to
type-check
pascal thinks it's being more flexible
by not allowing parameters so that now
you can actually call it at different
places with a unary function or a binary
function or a ternary function but then
you can't type check those things and it
violates the static type checking rules
of pascal that that at compile time
everything should be type checkable it
violates that basic requirement so
anyway it's not a very popular thing but
it is a way of programming higher-order
functions in an imperative language