Difference between logic programming and functional programming

Question

I have been reading many articles trying to understand the difference between functional and logic programming, but the only deduction I have been able to make so far is that lo

Answer 1

First, there are a lot of commonalities between functional and logic programming. That is, a lot of notions developed in one community can also be used in the other. Both paradigms started with rather crude implementations and strive towards purity.

But you want to know the differences.

So I will take Haskell on the one side and Prolog with constraints on the other. Practically all current Prolog systems offer constraints of some sort, like B, Ciao, ECLiPSe, GNU, IF, SICStus, SWI, YAP, XSB. For the sake of the argument, I will use a very simple constraint dif/2 meaning inequality, which was present even in the very first Prolog implementation - so I will not use anything more advanced than that.

What functional programming is lacking

The most fundamental difference revolves around the notion of a variable. In functional programming a variable denotes a concrete value. This value must not be entirely defined, but only those parts that are defined can be used in computations. Consider in Haskell:

> let v = iterate (tail) [1..3] 
> v
[[1,2,3],[2,3],[3],[],*** Exception: Prelude.tail: empty list

After the 4th element, the value is undefined. Nevertheless, you can use the first 4 elements safely:

> take 4 v
[[1,2,3],[2,3],[3],[]]

Note that the syntax in functional programs is cleverly restricted to avoid that a variable is left undefined.

In logic programming, a variable does not need to refer to a concrete value. So, if we want a list of 3 elements, we might say:

?- length(Xs,3).
Xs = [_G323, _G326, _G329].

In this answer, the elements of the list are variables. All possible instances of these variables are valid solutions. Like Xs = [1,2,3]. Now, lets say that the first element should be different to the remaining elements:

?- length(Xs,3), Xs = [X|Ys], maplist(dif(X), Ys).
Xs = [X, _G639, _G642],
Ys = [_G639, _G642],
dif(X, _G642),
dif(X, _G639).

Later on, we might demand that the elements in Xs are all equal. Before I write it out, I will try it alone:

?- maplist(=(_),Xs).
Xs = [] ;
Xs = [_G231] ;
Xs = [_G231, _G231] ;
Xs = [_G231, _G231, _G231]  ;
Xs = [_G231, _G231, _G231, _G231] .

See that the answers contain always the same variable? Now, I can combine both queries:

?- length(Xs,3), Xs = [X|Ys], maplist(dif(X), Ys), maplist(=(_),Xs).
false.

So what we have shown here is that there is no 3 element list where the first element is different to the other elements and all elements are equal.

This generality has permitted to develop several constraint languages which are offered as libraries to Prolog systems, the most prominent are CLPFD and CHR.

There is no straight forward way to get similar functionality in functional programming. You can emulate things, but the emulation isn't quite the same.

What logic programming is lacking

But there are many things that are lacking in logic programming that make functional programming so interesting. In particular:

Higher-order programming: Functional programming has here a very long tradition and has developed a rich set of idioms. For Prolog, the first proposals date back to the early 1980s, but it is still not very common. At least ISO Prolog has now the homologue to apply called call/2, call/3 ....

Lambdas: Again, it is possible to extend logic programming in that direction, the most prominent system is Lambda Prolog. More recently, lambdas have been developed also for ISO Prolog.

Type systems: There have been attempts, like Mercury, but it has not caught on that much. And there is no system with functionality comparable to type classes.

Purity: Haskell is entirely pure, a function Integer -> Integer is a function. No fine print lurking around. And still you can perform side effects. Comparable approaches are very slowly evolving.

There are many areas where functional and logic programming more or less overlap. For example backtracking and lazyness and list comprehensions, lazy evaluation and freeze/2, when/2, block. DCGs and monads. I will leave discussing these issues to others...

Answer 2

functional programming: when 6PM, light on. logic programming: when dark, light on.

Answer 3

I wouldn't say that logic programming defines programs through mathematical expressions; that sounds more like functional programming. Logic programming uses logic expressions (well, eventually logic is math).

In my opinion, the major difference between functional and logic programming is the "building blocks": functional programming uses functions while logic programming uses predicates. A predicate is not a function; it does not have a return value. Depending on the value of it's arguments it may be true or false; if some values are undefined it will try to find the values that would make the predicate true.

Prolog in particular uses a special form of logic clauses named Horn clauses that belong to first order logic; Hilog uses clauses of higher order logic.

When you write a prolog predicate you are defining a horn clause: foo :- bar1, bar2, bar3. means that foo is true if bar1, bar2 and bar3 is true. note that I did not say if and only if; you can have multiple clauses for one predicate:

foo:-
   bar1.
foo:-
  bar2.

means that foo is true if bar1 is true or if bar2 is true

Some say that logic programming is a superset of functional programming since each function could be expressed as a predicate:

foo(x,y) -> x+y.

could be written as

foo(X, Y, ReturnValue):-
   ReturnValue is X+Y.

but I think that such statements are a bit misleading

Another difference between logic and functional is backtracking. In functional programming once you enter the body of the function you cannot fail and move to the next definition. For example you can write

abs(x) -> 
   if x>0 x else -x

or even use guards:

abs(x) x>0 -> x;
abs(x) x=<0 -> -x.

but you cannot write

abs(x) ->
   x>0,
   x;
abs(x) ->
   -x.

on the other hand, in Prolog you could write

abs(X, R):-
   X>0,
   R is X.
abs(X, R):-
   R is -X.

if then you call abs(-3, R), Prolog would try the first clause, and fail when the execution reaches the -3 > 0 point but you wont get an error; Prolog will try the second clause and return R = 3.

I do not think that it is impossible for a functional language to implement something similar (but I haven't used such a language).

All in all, although both paradigms are considered declarative, they are quite different; so different that comparing them feels like comparing functional and imperative styles. I would suggest to try a bit of logic programming; it should be a mind-boggling experience. However, you should try to understand the philosophy and not simply write programs; Prolog allows you to write in functional or even imperative style (with monstrous results).

Answer 4

Prolog, being a logical language, gives you free backtracking, it's pretty noticeable.

To elaborate, and I precise that I'm in no way expert in any of the paradigms, it looks to me like logical programming is way better when it comes to solving things. Because that's precisely what the language does (that appears clearly when backtracking is needed for example).

Answer 5

Difference between functional programming and imperative programming is based on two concepts :-

a:- What to do ? b:- How to do ?

Think a computer like newly born baby now you want that baby to complete a task (What to do?). Now that baby can either know by itself how to achieve that task if he knows than its functional programming. Now if that bay doesn't know how to achieve that task and it needs the programmers help to make a logic for that concept than this is imperitive programming.

Answer 6

In a nutshell:

In functional programming, your program is a set of function definitions. The return value for each function is evaluated as a mathematical expression, possibly making use of passed arguments and other defined functions. For example, you can define a factorial function, which returns a factorial of a given number:

factorial 0 = 1                       // a factorial of 0 is 1
factorial n = n * factorial (n - 1)   // a factorial of n is n times factorial of n - 1 

In logic programming, your program is a set of predicates. Predicates are usually defined as sets of clauses, where each clause can be defined using mathematical expressions, other defined predicates, and propositional calculus. For example, you can define a 'factorial' predicate, which holds whenever second argument is a factorial of first:

factorial(0, 1).               // it is true that a factorial of 0 is 1
factorial(X, Y) :-             // it is true that a factorial of X is Y, when all following are true:
    X1 is X - 1,                   // there is a X1, equal to X - 1,
    factorial(X1, Z),              // and it is true that factorial of X1 is Z, 
    Y is Z * X.                    // and Y is Z * X

Both styles allow using mathematical expressions in the programs.