__GUILE_LOG__
What it is:
Guile log is a logic programming framework that has strong
continuation support meaning that stalling of algorithm is well
supported. It also sports most of the logic programming features you
see in common prolog softwares like swi-prolog and guile-log comes
with a prolog engine as well as a minikanren engine as well as an
internal scheme interface to logic programming which is the guile-log
interface.

What It can do:
It can do whatever an iso-prolog or swi-prolog can do and contains
most prolog constructs from them. If you want to program guile and
perhaps guile-emacs in prolog this is the main source to go to.

It is a good design to base a proof solver on due to the fact that it
can save the state of the program and return to the base interpreter
and you can control your environment as any scheme or prolog
environment without making a special interpreter.

To generate cases for e.g. optimisation or constraint satisfaction. The power 
of guile-log comes from the seamless intergration of continuations. You can 
postpone a calculation and evaluate all postponed calculations for making a 
set of prommissing continuations and take those one step further. It really is 
a great tool for all kinds of local searches.

And it can do much much more.

Prerequisites

A 64 bit system
This is a draft for guile-2.0.6 and later and works for linux.

You need the dev package for bdw-gc and e.g. libgc-dev and all guile's dependencies
for compilation.

You need to install guile fibers package see https://github.com/wingo/fibers

You need to have guile-syntax-parse installed into the system
    https://gitlab.com/guile-syntax-parse/guile-syntax-parse.git
    
For fibers you need to have Wingo's fibers library
    https://github.com/wingo/fibers/wiki/Manual

For correct garbage collection, engines and fibers you need
    https://gitlab.com/bdw-gc-logical-mod/bdw-gc-logical-mod
    use the latest version which can found in the head directory.
    furthermore check out 'configure --help' to find out how
    to configure in this feature (Experimental)

You need install guile-persist
    https://gitlab.com/tampe/guile-persist
    
You need autotools, texinfo, gcc, make, guile >= 2.0

Either do a system install:
============
autoreconfig
configure
make
make install

Or do a local install by:
============
autoreconfig
configure
make
add the repo directory to guile's load path

You may need to patch guile-3.0 sources and re-compile guile in order for autocompilation to work. In this case make sure to add the line

   #:declarative? #f

In the module definition of (system base compile) and (system base message)
   

------------------------------------------------
Now you are ready to use it from guile through,

> (use-modules (logic guile-log))

Or using the kanren interface

> (use-modules (logic guile-log kanren))

Or iso-prolog,

> (use-modules (logic guile-log iso-prolog))

For documentation, 
info guile-log at a system install.

For an Interactive prolog shell use
,L prolog

Else in doc/guile-log the documentation in html is available or at
     http://c-lambda.se/guile-log/

Also check out the blog at
     http://c-lambda.se/


There is a prolog script also in the top directory that you can run
and get a pythin interpreter setuped so that you can use prolog
libraries as well as scheme libraries. It's a bit involved to get
them to work.

There are a lot of material not included in the docs there

To enable proper gc and engine support see the installation
instructions in the manual. That is difficult though, you need to
compile the repository referenced above and make sure that guile is
using it. I ended up replacing the original so library with the new
one (saving the old one in case there is bugs) Use this only if you
know what you are doing.

Have fun!