diff options
Diffstat (limited to 'sites/pprolog.org/documentation')
5 files changed, 0 insertions, 172 deletions
diff --git a/sites/pprolog.org/documentation/index.md b/sites/pprolog.org/documentation/index.md deleted file mode 100644 index 77da430..0000000 --- a/sites/pprolog.org/documentation/index.md +++ /dev/null @@ -1,28 +0,0 @@ -# Learning prolog - -If you are new to prolog the following resources helped me a lot in the -beginning and they still do: - -* [The Power of Prolog](https://www.metalevel.at/prolog) by Markus Triska is a great book about prolog and logic programming and is very up to date. -It even contains videos for some of its topics which can help a bit. The text is easy to read and -the chapters are short so it doesn't become overwhelming. -* [The Art of Prolog](https://mitpress.mit.edu/books/art-prolog) an older book by Leon S. Sterling and Ehud Y. Shapiro which goes much more into -the details and foundations of logic programming, but since it is older -it should not be your only learning source. This book is my recommendation for people who are not afraid to read a bit since it is very -interesting. - -Please be aware that some of the things taught in the books aren't supported by pprolog yet, such as constraint logic programming which is used a lot in Triskas book for doing integer arithmetic. - -# PProlog tutorial - -There exists a mini series to get you up and running with -the pprolog system: - -* [Installing](/documentation/tutorial/1.-install) covers the steps needed to install pprolog on you very own 9front machine. -* [Prolog primer](/documentation/tutorial/2.-prolog-primer) gives a short introduction to prolog. -* [Using the repl](/documentation/tutorial/3.-repl) explains how to ask queries to the system at the repl. -* [Writing and consulting code](/documentation/tutorial/4.-writing-and-consulting). While asking queries using only the standard library and the builtins is fun, it becomes even more fun when you can write your own fact and rules and load them. - -# Information about the standard library and the builtins - -At the moment [the source](https://git.sr.ht/~pmikkelsen/pprolog) is the documentation.
\ No newline at end of file diff --git a/sites/pprolog.org/documentation/tutorial/1.-install.md b/sites/pprolog.org/documentation/tutorial/1.-install.md deleted file mode 100644 index f6f4bb2..0000000 --- a/sites/pprolog.org/documentation/tutorial/1.-install.md +++ /dev/null @@ -1,17 +0,0 @@ -# Install - -Since pprolog has zero dependencies other than what is available by default on 9front -it is pretty easy to install. - -If you have [git9](https://orib.dev/git9.html) installed the steps are: - - git/clone https://git.sr.ht/~pmikkelsen/pprolog - cd pprolog - mk install - - -This will install the pprolog binary to `/$objtype/bin`, so you may want to modify -`BIN` in the `mkfile` to install to somewhere else like `$home/bin/$objtype/` - -It will also install the prolog libraries to `/sys/lib/prolog` and this is hardcoded -in the `mkfile` and in `dat.h` if you want to change that. diff --git a/sites/pprolog.org/documentation/tutorial/2.-prolog-primer.md b/sites/pprolog.org/documentation/tutorial/2.-prolog-primer.md deleted file mode 100644 index f26345e..0000000 --- a/sites/pprolog.org/documentation/tutorial/2.-prolog-primer.md +++ /dev/null @@ -1,127 +0,0 @@ -# Introduction - -This page provides a *very* brief overview of prolog. For more documentation look at -[the documentation page](https://pprolog.org/documentation/). Also be aware that this -introduction is only _my_ explanation, so don't take it as 100% truth. - -First of all, prolog is a programming language in the family of languages called -*logic programming languages*. This means that it is very different from imperative -or functional programming, so you should read this with an open mind and try to -forget some of the things you already know. - -# Logic - -What does it mean to be a logic programming language? Well, it means that the programs written in it -can be understood as logical rules and results can be inferred from those rules. This leads to a very -declarative way of writing code which is often much cleaner than what could be written in C for example. - -It also means that in prolog we don't write code to tell the computer what to do, we write code to -express the facts and relations about a problem, and the prolog system then uses those facts and rules -to infer the result. - -# Example - -To calculate the length of a list in an imperative language like C, the following code would work. - - typedef struct List List; - struct List - { - int element; - List *next; - }; - - int - length(List *list) - { - int len = 0; - for(; list != nil; list = list->next) - len++; - - return len; - } - -It is very clear that the `length` function takes a list as input -and then runs a loop which increments `len` until the end of the list is reached. - -Compare this to the prolog code below which is a prolog predicate with arity 2, also sometimes called -`length/2` to describe the name and the arity. - - length([], 0). - length([_|Tail], N) :- - length(Tail, TailLength), - N is TailLength + 1. - -This code is written in a declarative style and it doesn't express _how_ the length -of the list is found, it expresses _what_ the length of a list is. -The code consists of two *clauses*: a fact and a rule. - -The fact `length([], 0).` describes that the length of an empty list (`[]`) is zero. - -The rule - - length([_|Tail], N) :- - length(Tail, TailLength), - N is TailLength + 1. - -describes that the length of a non-empty list with head `_` (we don't care about the head), and tail `Tail` has -then length `N` *if*: - -1. The length of the tail is `TailLength` *and* -2. `N` is `TailLength` plus one. - -The rule consists of a *head* `length([_|Tail), N)` and two goals separated by a comma which means *and*. - -# Wait, is the output just the last parameter? - -No, in general much prolog code describes relations between the parameters. -The length predicate from before as an example of that, but it could just -as well be used to check if a list has a given length, by providing an input for -both arguments. - -# Queries - -When `pprolog` is run it presents a toplevel where queries can be entered. The queries are like questions that -the prolog system tries to answer. It does this by looking in the *prolog database* which initially consists of -the predicates which are part of the standard library. Since `length/2` is part of the standard library, we could ask - - ?- length([1,2,3,a,b,c], Len). - -And it would respond - - Len = 6. - -In general, if a word starts with an uppercase letter it is a variable like `Len`, `Hello`, `X` and `Y`, and otherwise it -is an *atom* which just represents itself. - -To show that `length/2` can be used in multiple ways, consider the query - - ?- length([1,2], 4). - -What do you think it will say? The result is - - false. - -because it is not possible for the system to infer the the length of the list `[1,2]` is `4` using any of the -rules in the prolog database. The steps the system takes in calculating this result are: - -1. The fact `length([],0)` is tried first but it fails to *unify* (more on that later) with the query since -the empty list does not unify with our non-empty list, and 0 does not unify with 4. -2. The rule with the head `length([_|Tail], N)` is chosen at it unifies with our query giving the variables -`Tail = [2]` and `N = 4`. -3. The first goal is `length(Tail, TailLength)` and with the value of `Tail` that becomes `length([2], TailLenght)`. -As in step 1, the first fact does not unify with this goal since `[]` does not unify with `[2]`. -4. The second rule unifies with our goal and the variables become `Tail = []` and `N = TailLength`. Note that it is perfectly valid -to assign two unassigned variables to each other in prolog, and this just means that they should now be considered the same, and when one -of them is unified with a concrete value, the other will get that value too. -5. The first subgoal is tried again and this time it matches the first rule since `[]` unifies with `[]`, and `0` unifies `TailLength` with -the side effect that both `TailLength` and `N` is now 0. -6. We go back to step 4 and continue with subgoal 2 which says that `N` is `TailLength + 1` and N is therefore 1. -7. We go back to step 3 and continue with subgoal 2 which says that `N` is `TailLength + 1` but this fails since `N` at this -point was 4 and `TailLength` is 1, but the fact `4 = 1 + 1` is false. Since there are no more rules or facts to try, the whole query fails. - -(_that explanation was a mess_) - -# Unification - -say wut, like pattern matching but works both ways. - diff --git a/sites/pprolog.org/documentation/tutorial/3.-repl.md b/sites/pprolog.org/documentation/tutorial/3.-repl.md deleted file mode 100644 index e69de29..0000000 --- a/sites/pprolog.org/documentation/tutorial/3.-repl.md +++ /dev/null diff --git a/sites/pprolog.org/documentation/tutorial/4.-writing-and-consulting.md b/sites/pprolog.org/documentation/tutorial/4.-writing-and-consulting.md deleted file mode 100644 index e69de29..0000000 --- a/sites/pprolog.org/documentation/tutorial/4.-writing-and-consulting.md +++ /dev/null |