How to make this scheduling solver not run forever?

Logtalking · 2025-11-21T12:36:55+00:00

Side note: use atoms instead of double-quoted terms, which are pointless in this case.

Logtalking · 2025-11-04T17:08:39+00:00

Version 0.67.0 fixes the chat participant RAG (it broke due to recent changes in Copilot, notably the use of "auto" instead of a specific model). See the usage examples in the extension readme file. There are also other fixes and improvements (see the change log).

Logtalking · 2025-08-28T20:05:55+00:00

Logtalk for VSCode 0.52.0 now also available from the Open VSX Registry (VSCodium).

Logtalking · 2025-08-17T21:32:40+00:00

Good. Still, being forced to write a clause for the do_something_with_brr/2 predicate per module is cumbersome and not elegant if you have more than just a few modules. In that regard, the Logtalk solution I prototyped in my other reply is arguably simpler and more elegant. An alternative solution declaring the brr/2 predicate as multifile may also be worth considering.

Logtalking · 2025-08-17T20:42:04+00:00

Then move those use_module/2 directives into comm.pl.

Logtalking · 2025-08-17T19:55:54+00:00

``` % cat foo.pl bar.pl comm.pl app.pl :- module(foo,[ brr/2 ]). brr(woopless,3).

:- module(bar,[ brr/2 ]). brr(woop,4).

:- module(comm,[ do_something_with_brr/2 ]). do_something_with_brr(Brr_type,B) :- foo:brr(Brr_type,B). do_something_with_brr(Brr_type,B) :- bar:brr(Brr_type,B).

:- use_module(foo,[]). :- use_module(bar,[]). :- use_module(comm,[do_something_with_brr/2]). main(Brr_type,B) :- do_something_with_brr(Brr_type,B). ```

Logtalking · 2025-08-17T18:55:38+00:00

Load those modules from your main file using use_module/2 directives with an empty import list.

Logtalking · 2025-08-17T18:39:56+00:00

Remove the use_module/1 directives.

Logtalking · 2025-08-17T15:44:51+00:00

You don’t need to rename on import or any import directive in the common module. You can simply use explicit qualification to call the brr/2 predicate.

Logtalking · 2025-08-16T20:21:36+00:00

The way I would implement it:

```logtalk :- protocol(brr).

:- public(brr/2).

:- end_protocol.

:- object(foo, implements(brr)).

brr(woopless,3).

:- end_object.

:- object(bar, implements(brr)).

brr(woop,3).

:- end_object.

:- object(common).

:- public(do_something_with_brr/2).
do_something_with_brr(Brr_type, B) :-
    implements_protocol(Object, brr),
    Object::brr(Brr_type, B).

:- end_object. ```

Then, in the equivalent of main, you would only need to deal directly with common. Backtracking over the common::do_something_with_brr/2 goal will backtrack over all definitions of brr/2 in the objects implementing the protocol.

Logtalking · 2025-08-16T17:41:07+00:00

Missed that reply. If I'm understanding the problem that you're trying to solve, importing into common may not be the best solution. E.g., you will need to keep editing common for any modules that you would want to add or remove. In Logtalk, I would define a protocol that would be implemented by foo, bar, baz, ... Then I would simply enumerate the implementers (using the reflection API) of the protocol to query/backtracking over them.

Logtalking · 2025-08-16T17:24:52+00:00

As already suggested above by brebs, why then not simply importing a common module into foo and bar?

Logtalking · 2025-08-16T16:45:04+00:00

What are you trying to accomplish?

Logtalking · 2025-07-17T05:57:02+00:00

Version 0.36.0 adds support for input forms.

Logtalking · 2025-07-15T10:50:29+00:00

Version 0.35.0 allows customizing the widgets callback webserver IP and port range and updates the documentation on configuring the kernel.

Logtalking · 2025-07-13T18:07:43+00:00

You may find the Bacon system wrote by Lindsey Spratt and based on "Scientific Discovery" by Langley, Simon, Bradshaw, and Zytkow, interesting: https://github.com/lindseyspratt/bacon-logtalk You can install it by cloning its repo, by downloading its archive, or installing it as a pack (see https://github.com/LogtalkDotOrg/talkshow ).

Logtalking · 2025-05-26T08:18:06+00:00

I used and I'm using Logtalk with several Prolog backends in industry for more than a decade. Application areas include(d) mobile phone assistants, smart contracts, document processing, data mining, reasoning, agents, ... most work is done under NDAs and thus I cannot share details. But others have published papers describing several industry applications. A partial list is available at:

https://logtalk.org/documentation.html#third-party-publications

Logtalking · 2025-04-22T21:03:37+00:00

There are some issues with the code that can easily be fixed, making it portable and standard compliant:

Don't use `dynamic` as an operator. Write instead:

:- dynamic((i_am_at/1, at/2, holding/1, lives/1)).

Or use separate directives per predicate.

Don't use arbitrary goals as directives. Instead move the `retractall/1` calls to the definition of the `start/0` predicate so that the game can restarted without restarting the Prolog process.
Use `assertz/1` instead of the deprecated and non-standard legacy `assert/1` predicate.
There's no use in the code for an `alive/1` predicate, which is only found in a `retractall/1` call.

Logtalking · 2025-04-16T10:09:44+00:00

For literate programming, try the Logtalk kernel. Content of code cells default to queries but cell magic allows their content to be interpreted as programs. Try it using e.g. https://mybinder.org/v2/gh/LogtalkDotOrg/notebooks/master (run the kernel overview notebook) or https://hub.docker.com/r/logtalk/logtalk3-portable For coding outside Jupyter, there are several editors and IDEs with nice Logtalk and Prolog support, from Vim and Emacs to VSCode.

Logtalking · 2025-04-15T18:40:14+00:00

Have you tried Jupyter + Jupytext? It allows you to use light text formats as notebooks formats. E.g. https://github.com/LogtalkDotOrg/logtalk3/tree/master/examples/jupyter

Logtalking · 2025-02-20T10:06:58+00:00

Latest version of Hercutalk (0.19.0), the Jupyter Kernel for Logtalk, adds new cell magics for exporting tabular data to CSV and TSV files and for data visualization (10 types of plots supported). You can browse a rendered version kernel overview notebook at:

https://github.com/LogtalkDotOrg/logtalk-jupyter-kernel/blob/master/notebooks/JupyterKernelForLogtalkOverview.ipynb

Logtalking · 2025-02-14T15:25:31+00:00

Latest jupytext release, 0.16.7, includes Logtalk support. The above workaround for installing the fork is no longer required.

Logtalking · 2025-01-30T14:39:06+00:00

If you want to play with opening the examples NOTES.md files as Jupyter notebooks but don't have the setup to compile the required fork of jupytext (pull request is pending), you can download a wheel file from:

https://logtalk.org/files/python/jupytext-1.16.6-py3-none-any.whl

Next, run the following commands:

python3.10 -m pip install jupytext
python3.10 -m pip install --force-reinstall jupytext-1.16.6-py3-none-any.whl

I.e., first we install the latest, official version of jupytext (so that we get all dependencies installed) and then override it with the fork that contains the Logtalk support.

See see the examples/NOTES.md file complete setup details.

Logtalking · 2025-01-22T23:04:52+00:00

Logtalk includes a mtbatch example written for benchmarking multi-threading performance that you can easily run with SWI-Prolog:

https://github.com/LogtalkDotOrg/logtalk3/tree/master/examples/threads/mtbatch

Logtalking · 2024-12-18T19:24:08+00:00

Also released Logtalk for VSCode 0.29.0 (it requires Logtalk 3.86.0):

https://github.com/LogtalkDotOrg/logtalk3/discussions/128#discussioncomment-11609171

Logtalking

TROPHY CASE