With univ, it makes sense to raise an error because its first argument becomes the predicate symbol of an atom and you can't have an atom with a free variable as a predicate symbol in a first order language (because it wouldn't be a first-order variable anymore).
What I mean is, if:
A =.. [P,X,Y]
Did not raise an error, it would produce an atom:
A = P(X,Y)
Which is not a first order atom. So that would violate core assumptions of the language and the syntax of first-order logic to boot.
(I use "atom" in the non-Prolog sense, to mean a predicate symbol followed by terms in parentheses).
Edit: that said, Win-LPA Prolog allows P(X,Y), but that is a quirk of the interpreter and not standard at all.
(I do not agree, but let's rather take a sharper example) Consider atomic(T) and T =.. [_] or functor(T,_,0) which describe exactly the same except that atomic(T) similar to integer(T) silently fails and T =.. [_] and functor(T,_,0) produce an instantiation error.
There are two different notions of type here. One is determined by the abstract syntax, in this context a variable is a type, that's what you are referring to. With this type no desirable algebraic properties hold like commutativity, since atomic(T), T = a and T = a, atomic(T) differ: one says yes, the other no. As a consequence, the meaning of a program is fixed by the very precise control of Prolog, no way to change this in some context. Many consider this a central weakness of Prolog. Say, Peter Norvig: However, Prolog's depth-first control structure is just too inflexible for me.https://www.quora.com/What-do-Lisp-Haskell-programmers-think...
The other meaning of type is the pure, declarative one. Here, variables do not belong to the valid types. In that context, atomic_si/1 and the other predicates fit in. Here, commutativity (modulo errors) holds. And thus alternative search procedures may be used.
(There is a third meaning similar to the second, but it is only standard related.)
That's correct but both the things you bring up are a matter of taste. Regarding the ordering of goals, as far as I know there is no straightforward way to make it not matter, that is also efficient to run on a modern computer (but I might be wrong about this because I haven't looked recently). With all due respect to Peter Norvig who is one of my AI heroes, that bit about "not knowing whether a particular ordering of goals is essential or arbitrary" is just picking at nits.
Regarding pure, declarative types those again are extra-logical and so, in the context of a first-order logic language, they are arbitrary and conventional. You can say "it's better this way", someone else can say "no, it's better this other way" but in the end of the day there's nothing set in stone. Far as I can tell.
Anyway I really think all those little complaints about Prolog's lack of absolute, pure perfection are always bordering on nitpicky- and from the wrong side of the border, at that. Peter Norvig says Prolog is not a general purpose relational solver, but it's a general purpose programming language. Well, yes, because it was, from the start, designed to be a general purpose programming language! That is, a language that can be used for, you know, actual programming in first order logic. Of course it's not perfect. That has always created a rift in the community, with some people taking the issue more seriously than others. Some have always been happy that they (we) have a language that's 90% of the way to pure, declarative perfection and that lets you express yourself in code in ways that would be really painful in any other language (just think of DCGs vs. the pain that compiler writing is in anything else). Others are always unhappy because they're missing that idealistic 10% that remains on the road to clean and pure declarative perfection. Well, we're not in a pure world. We don't have perfect computers. In fact, our computers just suck. We have to accept compromises, if we want to get anything done. Prolog is almost perfectly balanced in between shitty languages that abuse imperfections in computer architectures and mathematical purity. Personally, I'm grateful to Colmerauer and Kowalski for creating it. I can only imagine the mess I'd make of it if I had to do it myself.
What I mean is, if:
Did not raise an error, it would produce an atom: Which is not a first order atom. So that would violate core assumptions of the language and the syntax of first-order logic to boot.(I use "atom" in the non-Prolog sense, to mean a predicate symbol followed by terms in parentheses).
Edit: that said, Win-LPA Prolog allows P(X,Y), but that is a quirk of the interpreter and not standard at all.