views:

93

answers:

2

In my principles of programming class we are talking about different calling methods. Some we discussed were:

  • call by value
  • call by reference
  • call by value/result
  • and call by name

I can't find an example of how call by name works. Anyone care to give me an example? I think that when you take an xml file as input this is similar to call by name. Could someone give me a more traditional example?

+2  A: 

I'll work in a hypothetical programming language. Let's assume we have a function p(x) that prints out x and then returns it. Now let's define a function:

function foo(x, y) { return y+1; }

Now let's call it with some arguments:

foo(p(123),p(456))

x and y are going to be substituted for the parameters, so the call to foo above is going to result in:

return p(456)+1;

So we're going to print 456 to the screen and return 457. In another evaluation strategy, we would evaluate the function parameters first (printing 123 and 456 to the screen in the process) and then substitute 456 for y in the function body, eventually returning 457.

It's contrived, but I hope you get the idea. It's all about substitution.

Gian
so would call by name also call call by reference? value? Anything specific?
sixtyfootersdude
@sixtyfootersdude, that sentence made my brain hurt. Care to re-state it?
Gian
Sure. Lets say you have this (**Call by name**): `int x = 0; foo(t(x)); print(x);` if it was *also* "call by value" this would print 0. If it was *also* "call by reference" it *could* print something else.
sixtyfootersdude
A: 

http://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_name

In call by value, you evaluate arguments, retrieving values that are then passed to the function. foo(bar()) is evaluated as arg = bar();, then foo(arg) is called, and in the body of the function, this newly allocated arg variable is accessible, modifiable, ...

In call by name, you substitues in the body of the function any references to arguments by their code used during the call. Then, evaluating the body, you will evaluate the arguments. foo(bar()) with foo(arg) { return arg; } will be evaluated as foo(arg) { return bar(); }

Scharron