BRANCH: Parser.
UPGRADE: PrologAtom.

PrologAtom now can be namet as a single word string: "cat", or as a combination of words: "'dog eats cat.'".
EDIT: PrologAtom unifying method.

EDIT: PrologString output method.
ADD: PrologArguments.

A PrologArgument is a vector of PrologTerms. It has all functions necessary: generating, outputing, evaluating, creating.
EDIT: PrologStructure replaced with PrologFact.

PrologFact is basicly the same thing, but instead of a keyword as a name, it has a PrologAtom and instead of a vector with PrologTerms, it has a PrologArgumentss object.
EDIT: PrologFunctor replaced with PrologRule.
FIX: Get-term-variables function.

Due to the renaming and recreating some of the Prolog Objects, the function was not working properly.
FIX: More bugs from the renaming.
ADD: Prolog Terms functions with Protocol.

The PrologTerms interface functions are now combined in a Protocol. It's a way more cleaner Polymorphism imitation.
Yet another CHECKPOINT.
EDIT: PrologAtom refined again.

Because of the constantly changing TermInterface protocol, all Prolog Terms must be changed. The Prolog Atom is now in a stable condition.
EDIT: TermInterface protocol for PrologNumber.

ADD: Todo list on top of the terms.clj file.
NEW: TermInterface protocol for PrologString.
NEW: Term Interface protocol for PrologArguments.
FIX: Some bugs fixed.

PrologList unification partialy working.
NEW: TermInterface for PrologList.

TermInterface now has PrologList protocol. The PrologList interface functions are complitely rewritten and better-made.
CHECKPOINT: PrologVariables refactoring in process.
NEW: TermInterface protocol for PrologVariable.

The unification method is much more simple than before. Instead of producing sets of bound together Variables, it just makes the value of a Variable to be the other Variable.
	BEFORE: X ~> Y => {X = #{Y}, Y = #{X}}
	NOW:    X ~> Y => {Y = X}

If we now bind Y with Z:
	BEFORE Y ~> Z => {X = #{Y}, Y = #{X, Z}, Z = #{Y}}
	NOW:   Y ~> Z => {Y = X, Z = X}.

If we now evaluate Y with 42:
	BEFORE: Y ~> 42 => foreach var in #{X, Z} => {X = 42, Y = 42, Z = 42}
					      var ~> 42

	NOW: 	Y ~> 42 => X ~> 42 => {X = 42, Y = X, Z = X}

It's working directly. If we now want to get the value of Y:
	BEFORE: Y? => 42
	NOW:    Y? => X? => 42.
It makes one more action than before, but overall it's faster.

Let's have W now and W is to be unified with Y:
	BEFORE: W ~> Y => W ~> 42 => {X = 42, Y = 42, Z = 42, W = 42}
	NOW:    W ~> Y => W ~> X  => {X = 42, Y = X, Z = X, W = X}.

There are no sets, no unecessary evaluations - just a single additional operation.
ADD: Some documentation.
EDIT: Documentation.