c  go  java  js  lua  py  vbs  rkt  scm  pro  

In functional and logic languages, the concept of a machine state changed by a destructive update is not in the core language.

Most functional and logic languages provide some way to change state in a limited way but that is not the focus here.

Here is a function in JavaScript that prints numbers in a range from first parameter to (but not including) the second parameter. A while loop is used in the function.

Here is the JavaScript code.
function pRange1(i1, i2) { while (i1 < i2) { console.log(i1+"\n"); i1 += 1; } } pRange1(0,4);
Here is the output of the JavaScript code.
0 1 2 3

Here is a function in JavaScript that prints numbers in a range from first parameter to (but not including) the second parameter. A recursive function is used.

Here is the JavaScript code.
function pRange1(i1, i2) { if (i1 < i2) { console.log(i1+"\n"); pRange1(i1+1,i2); } } pRange1(0,4);
Here is the output of the JavaScript code.
0 1 2 3

In both of the above examples, a divide and conquer problem solving strategy is used whereby the problem of size n is divided into a problem of size 1 (one) and a problem of size n-1.

The loop version is not as obvious.

This becomes clearer from an expansion of the while loop.

Consider the following while loop (pseudo code) form.

The above form is equivalent to the following form.

This process is called loop unrolling as it can be continued until a fixed point is reached.

In imperative and functional languages a function takes parameters and returns a value.

In Prolog (and logic languages) there is not the same concept of a function.

The concept is more of a procedure but the procedures are called predicates.

In logic, there are the following areas.

• propositional calculus (propositions in truth table form) is decidable (though can be intractable)
• predicate calculus (predicated on everything, for all, or existence, there exists) is undecidable

In logic terms, Prolog is Turing Complete in that it can model both propositional and predicate calculus.

Here is the Prolog code.
prints([]):- nl. prints([X|Rest]):- print(X), prints(Rest). prange(I1,I1). prange(I1,I2):- prints([I1,'\n']), I3 is I1+1, prange(I3,I2). go:- prange(0,4). :- solve(go).
Here is the output of the Prolog code.
0\n 1\n 2\n 3\n

Most imperative programming languages have a parameter passing mechanism called "call by value" in which an actual parameter is evaluated (using eager evaluation) to a value and a copy of that value is passed.

The original actual parameter cannot be changed.

The "call by reference" mechanism passes a reference which allows the called routine to change the original actual parameter.

Logic languages such as Prolog (and lazy functional languages) have a parameter passing mechanism that can be described as "call by pattern".

That is, a pattern, or logical variable (placeholder to be filled in later, but only once) is passed and the called routine performs pattern matching on the called actual parameter (structure, etc.). The following rule succeeds only if I1 unifies with I2.

But this can be shortened using pattern matching to the following.