Sweep: SWI-Prolog Embedded in Emacs ¶

1.1 Main Features ¶

Some of the main benefits that Sweep brings to working with Prolog code in Emacs are:

• Semantic highlighting, see Semantic Highlighting.
• Automatic indentation, Indentation
• Structural editing and navigation, see Term-based editing and motion commands
• Jumping to predicate definitions and references, see Definitions and References
• On-the-fly diagnostics, see Examining Diagnostics
• Intelligent code completion, see Code Completion
• Refactoring, see Renaming Variables and Extracting Goals to Separate Predicates
• Integrated SWI-Prolog top-level, see The Prolog Top-level
• Ability to run Prolog queries directly from Emacs Lisp, Querying Prolog

These features and others are documented in the rest of this manual, along with many options that Sweep provides for you to customize its behavior.

1.2 High-level Architecture ¶

• sweep.c defines a dynamic Emacs module which is referred to from Elisp as sweep-module. This module is linked against the SWI-Prolog runtime library (libswipl) and exposes a subset of the SWI-Prolog C interface to Emacs in the form of Elisp functions (see Querying Prolog). Notably, sweep-module is responsible for translating Elisp objects to Prolog terms and vice versa.

1.3 Comparison with Emacs’s built-in Prolog mode ¶

Emacs has a built-in mode for Prolog code, defined in the library prolog.el that comes bundled with Emacs. prolog.el aims to work with a wide variety of Prolog systems and dialects, unlike Sweep that is very tightly integrated with SWI-Prolog specifically.

If you are working with SWI-Prolog, you’ll find Sweep to be far more powerful than the built-in prolog.el. This is because Sweep leverages the Prolog parser and other analysis tools that SWI-Prolog itself uses, which give it access to highly accurate and rich information about SWI-Prolog code. If you’re using another Prolog implementation, you should stick to prolog.el as Sweep only supports SWI-Prolog.

6.1 Conversion of Elisp objects to Prolog terms ¶

Sweep converts Elisp objects into Prolog terms to allow the Elisp programmers to specify arguments for Prolog predicates invocations (see Definition of sweeprolog-open-query). Seeing as some Elisp objects, like Elisp compiled functions, wouldn’t be as useful for passing to Prolog as others, Sweep only converts Elisp objects of certain types to Prolog, namely Sweep currently converts trees of strings and numbers:

• Elisp strings are converted to equivalent Prolog strings.
• Elisp integers are converted to equivalent Prolog integers.
• Elisp floats are converted to equivalent Prolog floats.
• The Elisp nil object is converted to the Prolog empty list [].
• Elisp cons cells are converted to Prolog lists whose head and tail are the Prolog representations of the car and the cdr of the cons.

6.2 Conversion of Prolog terms to Elisp objects ¶

Sweep converts Prolog terms into Elisp object to allow efficient processing of Prolog query results in Elisp (see Definition of sweeprolog-next-solution).

• Prolog strings are converted to equivalent Elisp strings.
• Prolog integers are converted to equivalent Elisp integers.
• Prolog floats are converted to equivalent Elisp floats.
• A Prolog atom foo is converted to a cons cell (atom . "foo").
• The Prolog empty list [] is converted to the Elisp nil object.
• Prolog lists are converted to Elisp cons cells whose car and cdr are the representations of the head and the tail of the list.
• Prolog compounds are converted to list whose first element is the symbol compound. The second element is a string denoting the functor name of the compound, and the rest of the elements are the arguments of the compound in their Elisp representation.
• All other Prolog terms (variables, blobs and dicts) are currently represented in Elisp only by their type:
  • Prolog variables are converted to the symbol variable,
  • Prolog blobs are converted to the symbol blob, and
  • Prolog dicts are converted to the symbol dict.

6.3 Counting solutions for a Prolog predicate in Elisp ¶

Below is an example usage of the Sweep interface for calling Prolog. It shows an invocation of the non-deterministic predicate lists:permutation/2 directly from an function Elisp that counts the number of different permutations of the list (1 2 3 4 5):

(sweeprolog-open-query "user" "lists" "permutation" '(1 2 3 4 5))
(let ((num 0)
      (sol (sweeprolog-next-solution)))
  (while sol
    (setq num (1+ num))
    (setq sol (sweeprolog-next-solution)))
  (sweeprolog-close-query)
  num)

6.4 Calling Elisp function inside Prolog queries ¶

Sweep defines the foreign Prolog predicates sweep_funcall/2 and sweep_funcall/3, that you can use for calling Elisp functions from Prolog code. You can only call these predicates in the context of a Prolog query initiated by sweeprolog-open-query, meaning that they only work in the main Prolog thread (which is also Emacs’s main thread). The first argument to these predicates is a Prolog string holding the name of the Elisp function to call. The last argument to these predicates is unified with the return value of the Elisp function, represented as a Prolog term (see Conversion of Elisp objects to Prolog terms). sweep_funcall/3 converts its second argument to an Elisp object (see Conversion of Prolog terms to Elisp objects) and passes it as a sole argument to the Elisp function it invokes. The sweep_funcall/2 variant invokes the Elisp function without any arguments.

7.1 Indentation ¶

TAB ¶

C-i

Indent the current line. If the region is active, indent all the lines within it (indent-for-tab-command).

Function: sweeprolog-indent-line ¶

Indent the current line according to SWI-Prolog conventions. This function is used as the value of indent-line-function in Sweep Prolog mode buffers.

Command: sweeprolog-infer-indent-style ¶

Infer the indentation style of the current buffer from its contents.

User Option: sweeprolog-indent-offset ¶

Number of columns to indent nested code to in Sweep Prolog mode buffers.

The entry point of the indentation engine is the function sweeprolog-indent-line which takes no arguments and indents the line at point. Sweep Prolog mode cooperates with the standard Emacs interface for indentation by arranging for sweeprolog-indent-line to be called whenever a line should be indented, notably when you press TAB. For a full description of the available commands and options that pertain to indentation, See (emacs)Indentation.

(add-hook 'sweeprolog-mode-hook #'sweeprolog-infer-indent-style)

• Indentation rules

7.2 Semantic Highlighting ¶

Sweep Prolog mode highlights Prolog code through the standard Emacs font-lock system (see (emacs)Font Lock). Sweep Prolog mode highlights different tokens in Prolog code according to their semantics, determined through static analysis that Sweep performs on demand. When you first open a buffer in Sweep Prolog mode, its entire contents are analyzed to collect and cache cross reference data, and Sweep highlight all of the code in the buffer accordingly. In contrast, while you edit and move around the buffer, Sweep uses a faster, local analysis for updating the semantic highlighting in response to changes in the buffer.

C-c C-c ¶

Analyze the current buffer and update cross-references (sweeprolog-analyze-buffer).

User Option: sweeprolog-analyze-buffer-on-idle ¶

Whether to analyze sweeprolog-mode buffers on idle. Defaults to t.

User Option: sweeprolog-analyze-buffer-max-size ¶

Maximum number of characters in a Sweep Prolog mode buffer to analyze on idle. Larger buffers are not analyzed on idle. Defaults to 100,000 characters.

User Option: sweeprolog-analyze-buffer-min-interval ¶

Minimum number of idle seconds to wait before analyzing a sweeprolog-mode buffer. Defaults to 1.5.

At any point in a sweeprolog-mode buffer, you can use the command C-c C-c (M-x sweeprolog-analyze-buffer) to update the cross reference cache and highlight the buffer accordingly. When Sweep’s Flymake integration is enabled, this command also updates the diagnostics for the current buffer (see Examining Diagnostics). This may be useful, for example, after defining a new predicate.

If the user option sweeprolog-analyze-buffer-on-idle is set to non-nil (as it is by default), Sweep also updates semantic highlighting in the buffer whenever Emacs is idle for a reasonable amount of time, unless the buffer is larger than the value of the sweeprolog-analyze-buffer-max-size user option. You can specify a minimum idle time for Sweep to wait before updating reanalyzing the buffer highlighting is controlled by customizing the user option sweeprolog-analyze-buffer-min-interval.

To view and customize the various faces that Sweep defines and uses for semantic highlighting, type M-x customize-group RET sweeprolog-faces RET. See (emacs)Faces, for more information about text faces in Emacs.

• PceEmacs Highlighting Emulation
• Highlighting occurrences of a variable
• Quasi-quotation highlighting

(load-theme 'sweeprolog-pce t)

7.3 Hover for Help ¶

In See Semantic Highlighting, we talked about how Sweep performs semantic analysis to determine the meaning of different terms in different contexts and highlight them accordingly. Beyond highlighting, Sweep can also tell you exactly what different tokens in Prolog code mean by annotating them with a textual description that’s displayed when you hover over them with the mouse.

User Option: sweeprolog-enable-help-echo ¶

Whether to annotate Prolog tokens with help text via the help-echo text property. Defaults to t.

C-h . ¶

Display the help-echo text of the token at point in the echo area (display-local-help).

If the user option sweeprolog-enable-help-echo is non-nil, as it is by default, Sweep annotates Prolog tokens with a short description of their meaning in that specific context. This is done by adding the help-echo text property to different parts of the buffer based on semantic analysis. The help-echo text is automatically displayed at the mouse tooltip when you hover over different tokens in the buffer.

Alternatively, you can display the help-echo text for the token at point in the echo area by typing C-h . (C-h followed by a dot).

The help-echo description of file specification in import directives is especially useful as it tells you which predicates that the current buffer uses actually come from the imported file. For example, if we have a Prolog file with the following contents:

:- use_module(library(lists)).

foo(Foo, Bar) :- flatten(Bar, Baz), member(Foo, Baz).

Then hovering over library(lists) shows:

Dependency on /usr/local/lib/swipl/library/lists.pl, resolves calls to flatten/2, member/2

7.4 Maintaining Code Layout ¶

(   if
->  then
;   else
*-> elif
;   true
)

To help you in maintaining the desired layout without having to manually count spaces, Sweep provides the command sweeprolog-align-spaces that updates the whitespace around point such that the next token is aligned to a (multiple of) four columns from the start of the previous token. Sweep also provides a dedicated minor mode sweeprolog-electric-layout-mode that adjusts whitespace around point automatically as you type (Electric Layout mode).

• Inserting the Right Number of Spaces
• Electric Layout mode

foo :-
    (   if
    ;∗

foo :-
    (   if
    ;   ∗

(eval-after-load 'sweeprolog
  '(define-key sweeprolog-mode-map (kbd "M-SPC") #'sweeprolog-align-spaces))

(add-hook 'sweeprolog-mode-hook #'sweeprolog-electric-layout-mode)

7.5 Term-based editing and motion commands ¶

The Emacs manual covers the most important commands that operate on S-expressions, and by extension on Prolog terms. See (emacs)Expressions. Another useful command for Prolog programmers is M-x kill-backward-up-list, bound by default to C-M-^ in Sweep Prolog mode buffers.

C-M-^ ¶

Kill the Prolog term containing the current term, leaving the current term itself (kill-backward-up-list).

This command replaces the parent term containing the term at point with the term itself. To illustrate the utility of this command, consider the following clause:

head :-
    goal1,
    setup_call_cleanup(setup,
                       goal2,
                       cleanup).

Now with point anywhere inside goal2, calling kill-backward-up-list removes the setup_call_cleanup/3 term leaving goal2 to be called directly:

head :-
    goal1,
    goal2.

7.6 Holes ¶

See Inserting Terms with Holes, for a command that uses holes to let you write syntactically correct Prolog terms incrementally. Several other Sweep commands insert holes in place of unknown terms, including C-M-i (see Code Completion), C-M-m (see Context-Based Term Insertion) and M-x sweeprolog-plunit-testset-skeleton (see Writing Tests).

• Inserting Terms with Holes
• Jumping to Holes
• Filling Holes
• Highlighting Holes

(add-hook 'sweeprolog-mode-hook #'sweeprolog-forward-hole-on-tab-mode)

7.7 Definitions and References ¶

Sweep Prolog mode integrates with the Emacs xref API to facilitate quick access to predicate definitions and references in Prolog code buffers. This enables the many commands that the xref interface provides, like M-. (xref-find-definitions) for jumping to the definition of the predicate at point. See (emacs)Find Identifiers, for an overview of the available commands.

Sweep Prolog mode also integrates with Emacs’s imenu, which provides a simple facility for looking up and jumping to definitions in the current buffer. To jump to a definition in the current buffer, type M-x imenu RET (bound by default to M-g i in Emacs version 29 or later). For information about customizing imenu, (emacs)Imenu.

You can use the command sweeprolog-xref-project-source-files to update Sweep’s cross reference data for all Prolog source files in the current project. To determine the set of source files in the current project, Sweep consults the functions project-current and project-files (see (emacs)Projects). When you search for references to Prolog predicates with M-? (xref-find-references), Sweep implicitly invokes sweeprolog-xref-project-source-files to bring you up-to-date references from across the current project.

7.8 Predicate Definition Boundaries ¶

M-n ¶

Move forward from point to the next predicate definition in the current buffer (sweeprolog-forward-predicate).

M-p ¶

Move backward from point to the previous predicate definition (sweeprolog-backward-predicate).

M-h ¶

Select the current predicate as the active region, put point at the its beginning, and the mark at the end (sweeprolog-mark-predicate).

In Sweep Prolog mode, the commands M-n (sweeprolog-forward-predicate) and M-p (sweeprolog-backward-predicate) are available for quickly jumping to the first line of the next or previous predicate definition in the current buffer.

The command M-h (sweeprolog-mark-predicate) marks the entire predicate definition at point, along with its ‘PlDoc’ comments if there are any. As an example, you can use this command to move an entire predicate definition typing M-h C-w and then yanking it elsewhere with C-y.

7.9 Following File Specifications ¶

In SWI-Prolog, one often refers to source file paths using file specifications, special Prolog terms that act as path aliases, such as library(lists) which refers to a file lists.pl in any of the Prolog library directories.

C-c C-o ¶

Resolve file specification at point and visit the specified file (sweeprolog-find-file-at-point).

Function: sweeprolog-file-at-point &optional point ¶

Return the file name specified by the Prolog file specification at point.

You can follow file specifications that occur in Sweep Prolog mode buffers with C-c C-o (or M-x sweeprolog-find-file-at-point RET) whenever point is over a valid file specification. For example, consider a Prolog file buffer with the common directive use_module/1:

:- use_module(library(lists)).

With point anywhere inside library(lists), type C-c C-o to open the lists.pl file in the Prolog library.

Sweep also extends Emacs’s file-name-at-point-functions hook with the function sweeprolog-file-at-point that returns the resolved Prolog file specification at point, if any. Emacs uses this hook to populate the “future history” of minibuffer prompts that read file names, such as the one you get when you type C-x C-f (find-file). In particular this means that if point is in a Prolog file specification, you can type M-n after C-x C-f to populate the minibuffer with the corresponding file name. You can then go ahead and visit the file by typing RET, or you can edit the minibuffer contents and visit a nearby file instead.

For more information about file specifications in SWI-Prolog, see absolute_file_name/3 in the SWI-Prolog manual.

7.10 Loading Buffers ¶

C-c C-l ¶

Load the current buffer into the embedded SWI-Prolog runtime (sweeprolog-load-buffer).

Use the command sweeprolog-load-buffer to load the contents of a Sweep Prolog mode buffer into the embedded SWI-Prolog runtime. After a buffer is loaded, you can query the predicates it defines from Elisp (see Querying Prolog) and from the Sweep top-level (see The Prolog Top-level). In Sweep Prolog mode buffers, sweeprolog-load-buffer is bound to C-c C-l. By default this command loads the current buffer if its major mode is sweeprolog-mode, and prompts for an appropriate buffer otherwise. To choose a different buffer to load while visiting a sweeprolog-mode buffer, invoke sweeprolog-load-buffer with a prefix argument (C-u C-c C-l).

The mode line displays the word ‘Loaded’ next to the ‘Sweep’ major mode indicator if the current buffer has been loaded and hasn’t been modified since. See (emacs)Mode Line, for more information about the mode line.

More relevant information about loading code in SWI-Prolog can be found in Loading Prolog source files in the SWI-Prolog manual.

7.11 Setting Breakpoints ¶

You can set breakpoints in Sweep Prolog mode buffers to have SWI-Prolog break before specific goals in the code (see Breakpoints in the SWI-Prolog manual).

C-c C-b ¶

Set a breakpoint (sweeprolog-set-breakpoint).

User Option: sweeprolog-highlight-breakpoints ¶

Whether to highlight breakpoints in Sweep Prolog mode buffers. Defaults to t.

The command sweeprolog-set-breakpoint, bound to C-c C-b, sets a breakpoint at the position of the cursor. If you call it with a positive prefix argument (for example, C-u C-c C-b), it creates a conditional breakpoint with a condition goal that you insert in the minibuffer. If you call it with a non-positive prefix argument (for example, C-0 C-c C-b), it deletes the breakpoint at point instead.

When Context Menu mode is enabled, you can also create and delete breakpoints in sweeprolog-mode buffers through right-click context menus (see Context Menu).

By default, Sweep highlights terms with active breakpoints in Sweep Prolog mode buffers. To inhibit breakpoint highlighting, customize the user option sweeprolog-highlight-breakpoints to nil.

• Breakpoint Menu

7.12 Creating New Modules ¶

User Option: sweeprolog-module-header-comment-skeleton ¶

Additional content to put in the topmost comment in Prolog module headers.

The command auto-insert in Sweep Prolog mode inserts a Prolog module skeleton that begins with a module header multi-line comment. By default, this header includes your name and email address (user-full-name and user-mail-address respectively). If you want the header to contain more information, you can extend it to suite yours needs by customizing sweeprolog-module-header-comment-skeleton. This can be useful, for example, for including copyright text in the header.

After the header, the module skeleton inserts a module/2 directive with the module name set to the base name of the file.

Lastly the skeleton includes a ‘PlDoc’ module comment for you to fill with the module’s documentation (see File comments in the SWI-Prolog manual).

As an example, open a new Prolog file and call it foo.pl by typing C-x C-f foo.pl RET, and insert the module skeleton with M-x auto-insert RET. The buffer contents should now be as follows:

/*
    Author:        John Doe
    Email:         [email protected]

*/

:- module(foo, []).

/** <module>

*/

To automatically insert the module skeleton whenever you open a new Prolog file, enable the minor mode auto-insert-mode. See Autoinserting in the Autotyping manual, for detailed information about auto-insert and its customization options.

7.13 Documenting Predicates ¶

SWI-Prolog predicates can be documented with specially structured comments placed above the predicate definition, which are processed by the ‘PlDoc’ source documentation system. Emacs comes with many useful commands specifically intended for working with comments in programming languages, which apply also to writing ‘PlDoc’ comments for Prolog predicates. For an overview of the relevant standard Emacs commands, see (emacs)Comment Commands.

C-c C-d ¶

Insert ‘PlDoc’ documentation comment for the predicate at or above point (sweeprolog-document-predicate-at-point).

User Option: sweeprolog-read-predicate-documentation-function ¶

Function to use for determining the initial contents of documentation comments that you insert with sweeprolog-document-predicate-at-point.

Function: sweeprolog-read-predicate-documentation-default-function ¶

Prompt and read from the minibuffer the argument modes, determinism specification and initial summary of the given predicate.

Function: sweeprolog-read-predicate-documentation-with-holes ¶

Use holes for the initial documentation of the given predicate.

Sweep also includes a dedicated command called sweeprolog-document-predicate-at-point for interactively creating ‘PlDoc’ comments for predicates in sweeprolog-mode buffers. This command, bound by default to C-c C-d, finds the beginning of the predicate definition under or right above the current cursor location, and inserts a formatted ‘PlDoc’ comment. This command fills in initial argument modes, determinism specification, and optionally a summary line for the documented predicate. There are different ways in which sweeprolog-document-predicate-at-point can obtain the needed initial documentation information, depending on the value of the user option sweeprolog-read-predicate-documentation-function which specifies a function to retrieve this information. The default function prompts you to insert the parameters one by one via the minibuffer. Alternatively, you can use holes (see Holes) for the predicate’s argument modes and determinism specifiers by setting this option to sweeprolog-read-predicate-documentation-with-holes, as follows:

(setq sweeprolog-read-predicate-documentation-function
      #'sweeprolog-read-predicate-documentation-with-holes)

sweeprolog-document-predicate-at-point leaves the cursor at the end of the newly inserted documentation comment for you to extend or edit it as you see fit. To add another comment line, use M-j (default-indent-new-line) which starts a new line with the comment prefix filled in. Emacs has other powerful built-in features for working with comments in code buffers that you can leverage to edit ‘PlDoc’ comments—See (emacs)Comments, for the full details. Furthermore you can make use of the rich support Emacs provides for editing natural language text when working on ‘PlDoc’ comments. For example, to nicely format a paragraph of text, use M-q (fill-paragraph). Many useful commands for editing text are documented in (emacs)Text, which see.

For more information about ‘PlDoc’ and source documentation in SWI-Prolog, see the PlDoc manual.

7.14 Example Usage Comments ¶

Beyond documenting your code with ‘PlDoc’ comments as described in Documenting Predicates, you may want to have comments in your source code that demonstrate example usage of some predicate or another. Creating such comments usually involves posting queries in a Prolog top-level, copying the queries and their results into the relevant source code buffer, and formatting them as comments. Sweep provides the following command to streamline this process:

C-c C-% ¶

Start a new top-level for recording example usage. When you finish interacting with the top-level its contents are formatted as a comment in the buffer and position where you invoked this command (sweeprolog-make-example-usage-comment).

The command sweeprolog-make-example-usage-comment, bound to C-c C-% in Sweep Prolog mode buffers, creates and switches to a new top-level buffer for recording example usage that you want to demonstrate. The example usage top-level is a regular top-level buffer (see The Prolog Top-level), except that it’s tied to the specific position in the source buffer where you invoke this command. You can post queries in the example usage top-level and edit it freely, then type C-c C-q in to quit the top-level buffer and format its contents as a comment in the source buffer.

You can have multiple example usage top-levels for different parts of your code at the same time. To display the source position where you created a certain usage example top-level buffer by, type C-c C-b in that buffer.

7.15 Displaying Predicate Documentation ¶

Sweep integrates with the Emacs minor mode ElDoc, which automatically displays documentation for the predicate at point. Whenever you move the cursor into a predicate definition or invocation, ElDoc displays the signature and summary of that predicate in the echo area at the bottom of the frame.

User Option: sweeprolog-enable-eldoc ¶

Whether to enable ElDoc support in sweeprolog-mode buffers. Defaults to t.

To disable the ElDoc integration in Sweep Prolog mode buffers, customize the user option sweeprolog-enable-eldoc to nil.

See (emacs)Programming Language Doc, for more information about ElDoc and its customization options.

7.16 Examining Diagnostics ¶

User Option: sweeprolog-enable-flymake ¶

Whether to enable Flymake support in Sweep Prolog mode buffers. Defaults to t.

C-c C-` ¶

List diagnostics for the current buffer or project in a dedicated buffer (sweeprolog-show-diagnostics).

Flymake integration is enabled by default, to disable it customize the user option sweeprolog-enable-flymake to nil.

When this integration is enabled, several Flymake commands are available for listing and jumping between found errors. see Finding diagnostics, for a full description of these commands. Additionally, Sweep Prolog mode configures the standard command M-x next-error to operate on Flymake diagnostics. This allows for moving to the next (or previous) error location with the common M-g n (or M-g p) keybinding. See (emacs)Compilation Mode, for more information about these commands.

The command sweeprolog-show-diagnostics shows a list of Flymake diagnostics for the current buffer. It is bound by default to C-c C-` in Sweep Prolog mode buffers with Flymake integration enabled. When you call it with a prefix argument (C-u C-c C-`), it shows a list of diagnostics for all buffers in the current project.

7.17 Exporting Predicates ¶

C-c C-e ¶

Add the predicate predicate at point to the export list of the current Prolog module (sweeprolog-export-predicate).

Sweep provides a convenient command for exporting predicates that you define in Sweep Prolog mode buffers. To add the predicate near point to the export list of the current module, use the command C-c C-e (sweeprolog-export-predicate). If the current predicate is documented with a ‘PlDoc’ comment, this command adds a comment with the predicate’s mode after its name in the export list. If point is not near a predicate definition, calling sweeprolog-export-predicate prompts for a predicate to export with completion for non-exported predicates in the current buffer. To force sweeprolog-export-predicate to prompt even when point is on a predicate definition, invoke it with a prefix argument (C-u C-c C-e).

7.18 Code Completion ¶

In Emacs, major modes for different programming languages provide in-buffer code completion via a standard generic command called completion-at-point (see (emacs)Symbol Completion). This command is normally bound to C-M-i and M-TAB. Sweep extends completion-at-point with context-aware completion for Prolog code in Prolog buffers.

When providing candidates for in-buffer completion, Sweep takes into account the code surrounding the cursor to determine what kind of completion makes most sense:

Variable name completion

If the text before point can be completed to one or more variable names that appear elsewhere in the current clause, completion-at-point suggests matching variable names as completion candidates.

Predicate completion

If point is at a callable position, completion-at-point suggests matching predicate calls. If the predicate you choose takes arguments, Sweep inserts holes in their places, and moves point to the first argument (see Holes).

Predicate option completion

If point is inside a predicate options list, completion-at-point suggests matching options or option values for the appropriate predicate.

Source file completion

If point is at a position where a source file specification should appear (such as the argument of use_module/1), completion-at-point suggests matching source file specifications.

Arithmetic function completion

If point is inside an arithmetic expression, completion-at-point suggests matching arithmetic functions.

Flag completion

If point is at a position where a Prolog flag should appear (such as the first argument of set_prolog_flag/2), completion-at-point suggests matching flags.

Atom completion

If point is at a non-callable position, completion-at-point suggests matching atoms and functors.

7.19 Context-Based Term Insertion ¶

M-RET ¶

C-M-m

Insert an appropriate Prolog term in the current buffer, based on the current context (sweeprolog-insert-term-dwim).

Variable: sweeprolog-insert-term-functions ¶

List of functions for sweeprolog-insert-term-dwim to try for inserting a Prolog term based on the current context.

To determine which term to insert and exactly where, the command sweeprolog-insert-term-dwim calls the functions in the list sweeprolog-insert-term-functions one after the other until one of them succeeds. The functions on this list are called term insertion functions, each insertion function takes two arguments—the position where you invoke sweeprolog-insert-term-dwim and the prefix argument you give it, if any—and returns non-nil after performing its specific insertion if it is applicable in the current context.

By default, sweeprolog-insert-term-functions contains the following insertion functions:

Function: sweeprolog-maybe-extract-region-to-predicate ¶

If the region is active and selects a goal, extract the selected goal into a separate predicate. With a prefix argument, also suggest replacing other goals in the buffer that the selected goal subsumes with invocations of the new predicate that this function creates. See Extracting Goals to Separate Predicates.

Function: sweeprolog-maybe-insert-next-clause ¶

If the last token before point is a fullstop ending a predicate clause, insert a new clause below it.

Function: sweeprolog-maybe-define-predicate ¶

If point is over a call to an undefined predicate, insert a definition for that predicate. By default, the new predicate definition is inserted right below the last clause of the current predicate definition. You can customize the user option sweeprolog-new-predicate-location-function to control where in the buffer this function inserts new predicate definitions.

This command inserts holes as placeholders for the body term and the head’s arguments, if any. See Holes.

7.20 Writing Tests ¶

SWI-Prolog includes the ‘PlUnit’ unit testing framework¹, in which you write unit tests in special blocks of Prolog code enclosed within the directives begin_tests/1 and end_tests/1. To insert a new block of unit tests (also known as a test-set) in a Prolog buffer, use the command M-x sweeprolog-plunit-testset-skeleton RET.

Command: sweeprolog-plunit-testset-skeleton ¶

Insert a ‘PlUnit’ test-set skeleton at point.

This command prompts for a name to give the new test-set and inserts a template such as the following:

:- begin_tests(foo_regression_tests).

test() :- TestBody.

:- end_tests(foo_regression_tests).

The cursor is left between the parentheses of the test() head term, and the TestBody variable is marked as a hole (see Holes). To insert another unit test, place point after a complete test case and type C-M-m (or M-RET) to invoke sweeprolog-insert-term-dwim (see Context-Based Term Insertion).

7.21 Managing Dependencies ¶

C-c C-u ¶

Add explicit dependencies for implicitly autoloaded predicates in the current buffer (sweeprolog-update-dependencies).

User Option: sweeprolog-dependency-directive ¶

Determines which Prolog directive to use in sweeprolog-update-dependencies when adding new directives. The value of this user option is one of the symbols use-module, autoload or infer. If it is use-module, sweeprolog-update-dependencies adds use_module/2 directives, a value of autoload means to add autoload/2 directives, and infer says to infer which directive to use based on the existing dependency directives in the buffer, if any. Defaults to infer.

User Option: sweeprolog-note-implicit-autoloads ¶

Whether Flymake should complain about implicitly autoloaded predicates in Sweep Prolog mode buffers.

The command sweeprolog-update-dependencies, bound to C-c C-u, analyzes the current buffer and adds or updates autoload/2 and use_module/2 directives as needed.

When this command adds a new directive, rather than updating an existing one, it can use either autoload/2 or use_module/2 to declare the new dependency based on the value of the user option sweeprolog-dependency-directive. If you set this option is to use-module, new dependencies use the use_module/2 directive. If it’s autoload, new dependencies use autoload/2. If it’s infer, as it is by default, new dependencies use autoload/2 unless the buffer already contains dependency directives and they are all use_module/2 directives, in which case they also use use_module/2.

By default, when Flymake integration is enabled (see Examining Diagnostics), Sweep highlights calls to implicitly autoloaded predicates and reports them as Flymake diagnostics. To inhibit Flymake from diagnosing implicit autoloads, customize the user option sweeprolog-note-implicit-autoloads to nil.

7.22 Term Search ¶

C-c C-s ¶

Search for Prolog terms matching a given search term in the current buffer (sweeprolog-term-search).

The command sweeprolog-term-search, bound by default to C-c C-s in Sweep Prolog mode buffers, prompts for a Prolog term to search for and finds terms in the current buffer that the search term subsumes. It highlights all matching terms in the buffer and moves the cursor to the end of the next match after point. For example, to find if-then-else constructs in the current buffer do C-c C-s _ -> _ ; _ RET.

This command highlights the current match with the sweeprolog-term-search-current face, and all other matches with the sweeprolog-term-search-match face. See (emacs)Face Customization for information about customizing faces.

While prompting for a search term in the minibuffer, this command populates the “future history” with the Prolog terms at point, with the most nested term at point on top. Typing M-n once in the minibuffer fills in the innermost term at point, typing M-n again cycles up the syntax tree at point filling the minibuffer with larger terms, up until the top-term at point. See (emacs)Minibuffer History, for more information about minibuffer history commands.

If you invoke sweeprolog-term-search with a prefix argument (C-u C-c C-s), you can further refine the search with an arbitrary Prolog goal. The given goal runs for each matching term, and if the goal fails sweeprolog-term-search disregards the corresponding match. You can use variables from the search term in the goal to refer to the corresponding subterms of the matching term—for example, you can find all places in your code where you have a call to sub_string/5 with either the first or the last argument being a literal atom by typing C-u C-c C-s sub_string(Str, _, _, _, Sub) RET atom(Str) ; atom(Sub) RET.

If you call this command with a double prefix argument (C-u C-u C-c C-s), it also prompts you to specify the class of term to search for. This can be one of the following symbols:

clause

Matches whole clauses.

head

Matches head terms.

goal

Matches goal terms.

data

Matches data terms.

_

Matches any term.

You can specify multiple classes in the minibuffer by delimiting them with ‘,’, in which case sweeprolog-term-search matches terms that match any of the these classes.

If you call sweeprolog-term-search with a negative prefix argument (C-- C-c C-s), it searches backward and moves to beginning of the first match that starts before point.

After invoking sweeprolog-term-search, use C-s to move to the next matching term and C-r to move backward to the previous match. To exit term search, type C-m (or RET). Similarly to Isearch, sweeprolog-term-search sets the mark to the original point so you can easily return to where you were before beginning the search. See (emacs)Basic Isearch.

7.23 Query Replace Term ¶

Sweep includes a powerful search and replace mechanism called Term Replace, that allows you to quickly and consistently transform some terms across a Prolog buffer. Term Replace searches for terms with the same flexibility and precision of Term Search (see Term Search), while letting you interactively transform and replace matching terms in place. You can use Term Replace to refactor your code in many ways, such as extending a predicate with another argument, or replacing all calls to a predicate with another one while transposing some of the arguments. If you’re familiar with Emacs’s Query Replace commands, you can think of Term Replace as a Prolog-specific superpowered version of query-replace-regexp (see (emacs)Query Replace). To initiate Term Replace, use the following command:

C-c C-S ¶

Replace some terms after point matching a given template with a given replacement (sweeprolog-query-replace-term).

The command sweeprolog-query-replace-term (bound to C-c C-S) prompts for two Prolog terms, the template term and the replacement term, and then asks for each term in the buffer that matches the template if you want to replace it. You can use variables in the template term to capture sub-terms of the matching term, and use them in the replacement term. For example, if you want to transpose the two arguments in a bunch of calls to =/2, you can specify R=L as the template term and L=R as the replacement.

This command uses the same underlying term search as C-c C-s (sweeprolog-term-search) does for finding matches, expect that sweeprolog-query-replace-term only searches from point to the end of buffer. If you invoke sweeprolog-query-replace-term with an active region, it limits the operation to matching terms in the region. sweeprolog-query-replace-term highlights the current match with the sweeprolog-query-replace-term-current face, and all other matches with the sweeprolog-query-replace-term-match face. By default, these faces inherit from sweeprolog-term-search-current and sweeprolog-term-search-match, respectively. Furthermore, similarly to C-c C-s, you can invoke sweeprolog-query-replace-term with a prefix argument to refine the search with an arbitrary Prolog goal that matching terms must satisfy, or with two prefix arguments to target only terms in certain contexts. See Term Search for full details about prefix arguments and search refinement.

sweeprolog-query-replace-term goes over the matching terms in turn and asks you what to do with each. The available answers are:

y

Replace the current match and move to the next one.

n

Skip the current match without replacing it.

t

Replace the current match, show the result, and suggest reverting back before moving to the next match.

q

Quit without replacing the current match.

.

Replace the current match, and exit right away asking about further matches.

!

Replace the current match and all remaining matches without asking.

e

Edit the replacement term for the current match in the minibuffer, and then perform the replacement.

C-r

Enter recursive edit. This allows you to pause the current Term Replace session, perform some edits, or otherwise use Emacs however you please, an then resume Term Replace from the same point by typing C-M-c. See (emacs)Recursive Edit.

If you include a new variable in the replacement term that does not appear in the template term, sweeprolog-query-replace-term uses that variable as-is in each replacement, expect if the matching term happens to contain a variable with that name already, in which case this command adds the suffix ‘Fresh’ to the name of the new variable from the replacement. Including a new variable in the replacement term is useful, for example, for introducing a new argument to a predicate.

7.24 Context Menu ¶

Command: context-menu-mode ¶

Toggle Context Menu mode. When enabled, clicking the mouse button down-mouse-3 (meaning “right-click”) activates a menu whose contents depend on its surrounding context.

Variable: sweeprolog-context-menu-functions ¶

List of functions that create Context Menu entries for Prolog tokens. Each function should receive as its arguments the menu that is being created, the Prolog token’s description, its start position, its end position, and the position of the mouse click. It should alter the menu according to that context.

To enable Context Menu mode, type M-x context-menu-mode RET. To have Context Menu mode enabled automatically when Emacs starts, place a call to (context-menu-mode) in your Emacs initialization file. You can access the context menu by right-clicking anywhere in Emacs. If you do it in a Sweep Prolog mode buffer, you can invoke several Prolog-specific commands based on where you click in the buffer.

If you right-click on a Prolog file specification or module name, Sweep suggests visiting it either in the current window or in another. If you right-click on a predicate, it lets you view its documentation in a dedicated buffer (see Prolog Help). For variables, it enables the ‘Rename Variable’ menu entry that you can use to rename the variable you click on across its containing clause (see Renaming Variables).

You can further extend and customize the context menu that Sweep Prolog mode provides by adding functions to the variable sweeprolog-context-menu-functions. Each function on this list receives the menu that is being created and a description of the clicked Prolog token, and it can extend the menu with entries before Emacs displays the menu.

7.25 Renaming Variables ¶

You can rename a Prolog variable across the current top-term with the following command:

C-c C-r ¶

Rename a variable across the topmost Prolog term at point (sweeprolog-rename-variable).

User Option: sweeprolog-rename-variable-allow-existing ¶

If non-nil, allow selecting an existing variable name as the new name of a variable being renamed with sweeprolog-rename-variable. If it is the symbol confirm, allow but ask for confirmation first. Defaults to confirm.

The command sweeprolog-rename-variable, bound to C-c C-r, prompts for two variable names and replaces all occurrences of the first variable in the term at point with the second. The prompt for the first (old) variable name provides completion based on the existing variable names in the current term, and it uses the variable at point as its default.

The user option sweeprolog-rename-variable-allow-existing controls what happens if the second (new) variable name that you insert in the minibuffer already occurs in the current clause. By default it is set to confirm, which says to ask for confirmation before selecting an existing variable name as the new name. This is because renaming a variable to another existing variable name potentially alters the semantics of the term by merging the two variables. Other alternatives for this user option are t for allowing such merges without confirmation, and nil for refusing them altogether.

If Context Menu mode is enabled, you can also rename variables by right-clicking on them with the mouse and selecting ‘Rename Variable’ from the top of the context menu. See Context Menu, for more information about context menus in Sweep.

7.26 Numbered Variables ¶

A widespread convention in Prolog is using a common prefix with a numeric suffix to name related variables, such as Foo0, Foo1, etc. Sweep provides convenient commands for managing such numbered variable sequences consistently:

C-c C-+ ¶

Prompt for a numbered variable and increment it and all numbered variables with the same base name and a greater number in the current clause (sweeprolog-increment-numbered-variables).

C-c C-- ¶

Prompt for a numbered variable and decrement it and all numbered variables with the same base name and a greater number in the current clause (sweeprolog-decrement-numbered-variables).

Numbering variables is often used to convey the order in which they are bound. For example:

%!  process(+State0, -State) is det.

process(State0, State) :-
    foo(State0, State1),
    bar(State2, State1),
    baz(State2, State).

Here State0 and State are respectively the input and output arguments of process/2, and State1 and State2 represent intermediary stages between them.

The command C-c C-+ (sweeprolog-increment-numbered-variables) prompts you for a numbered variable in the current clause, and increments the number of that variable along with all other numbered variables with the same base name and a greater number. You can use it to “make room” for another intermediary variable between two sequentially numbered variables. If you call this command with point on a numeric variable, it suggests that variable as the default choice. If you call this command with a prefix argument, it increments by the numeric value of the prefix argument, otherwise it increments by one.

For instance, typing C-c C-+ State1 RET with point anywhere in the definition of process/2 from the above example results in the following code:

process(State0, State) :-
    foo(State0, State2),
    bar(State3, State2),
    baz(State3, State).

Note how sweeprolog-increment-numbered-variables replaced all occurrences of State1 with State2, while the original occurrences of State2 are replaced with State3. The overall semantics of the clause doesn’t change, but you can now replace the call to foo/2 with two goals and reintroduce State1 as an intermediary result between them while keeping your numbering consistent, e.g.:

process(State0, State) :-
    one(State0, State1), two(State1, State2),
    bar(State3, State2),
    baz(State3, State).

If Context Menu mode is enabled, you can also invoke sweeprolog-increment-numbered-variables by right-clicking on a numbered variables and selecting ‘Increment Variable Numbers’ from the context menu. See Context Menu.

The command C-c C-- (sweeprolog-decrement-numbered-variables) is similar to C-c C-+ except it decrements all numbered variables starting with a given numbered variable rather than incrementing them. When you delete an intermediary numbered variable and end with a gap in the variable numbering sequence, you can use this command to close the gap by decrementing the following numbered variables.

After invoking either C-c C-- or C-c C-+, you can continue to decrement or increment the same set of numbered variables by repeating with - and +.

7.27 Macro Expansion ¶

Recent versions of SWI-Prolog include a pre-processing mechanism called Prolog macros, implemented in library(macros). It provides a convenient way for computing terms at compile time and using them in code.

Macros are defined using special rules with #define(Macro, Replacement) head terms. Then, when SWI-Prolog reads a term of the form #(Macro) during compilation, it invokes the macro replacement rule and uses the expanded term instead.

Sweep can replace macro invocations with their expansions. To expand a macro in your source code, use the following command:

Command: sweeprolog-expand-macro-at-point ¶

Replace the Prolog macro invocation starting at point with its expansion.

You can call this command with point on the # macro indicator to expand the macro inline. To undo the expansion, use C-/ (undo).

With Context Menu mode enabled, you can also expand macros by right-clicking on the # and selecting ‘Expand Macro’ from the context menu. See Context Menu.

7.28 Extracting Goals to Separate Predicates ¶

Command: sweeprolog-extract-region-to-predicate ¶

Extract the goal between point and mark into a new predicate.

This command extracts the selected goal into a separate predicate. It prompts you for the name of the new predicate and inserts a definition for that predicate in the current buffer, while replacing the current region with a call to this new predicate. The body of the new predicate is the goal in the current region, and this command determines the arguments of the new predicate based on the variables that the goal to extract shares with the containing clause.

If the selected goal contains a cut whose scope would change as a result of being extracted from the current clause, sweeprolog-extract-region-to-predicate warns you about it and asks you to confirm before continuing. If your code already includes a definition for the predicate that sweeprolog-extract-region-to-predicate would define, this command similarly warns you and asks for confirmation.

If you call sweeprolog-extract-region-to-predicate when the region does not contain a valid Prolog term, this command complains and refuses to extract the invalid term.

By default, sweeprolog-extract-region-to-predicate is not bound directly to any key in Sweep Prolog mode; instead, you can invoke it by typing M-RET (sweeprolog-insert-term-dwim) when the region is active. See Context-Based Term Insertion.

If you invoke sweeprolog-extract-region-to-predicate with a prefix argument—either directly or via sweeprolog-insert-term-dwim by typing C-u M-RET with an active region—then after extracting the selected goal to a new predicate, this command searches the current buffer for other goals that the selected goal subsumes, and suggests replacing them with invocations of the newly defined predicate. See Query Replace Term.

With Context Menu mode enabled, you can also invoke this command by right-clicking on an active region and selecting ‘Extract to New Predicate’.

9.1 Interacting with the Top-level ¶

When you start a new top-level, it prompts you to enter a Prolog query by displaying the query prompt, which is usually ‘?- ’. You post your query by typing it at the prompt, and pressing RET (comint-send-input) to send it. If the query succeeds with a choicepoint, the top-level lets you to perform one of several actions by typing a single character, such as ; to get the next answer. Sweep Top-level mode detects that the top-level expects a single character input, and sends the character you type to the top-level immediately. After the top-level is done with answering your query, it prompts you again to post a new one.

The Sweep top-level provides input completion at the query prompt, which works similarly to the in-buffer completion you get in Sweep Prolog mode buffers (see Code Completion). Namely, to complete a partial predicate name or other input in the top-level prompt, type C-M-i (or M-TAB).

9.2 Multiple Top-levels ¶

You can create and use any number of top-levels at the same time, each top-level with its own buffer. If a top-level buffer already exists, sweeprolog-top-level simply opens it by default. To create another one or more top-level buffers, run sweeprolog-top-level with a prefix argument (C-u M-x sweeprolog-top-level RET) to choose a different buffer name. Alternatively, run the command C-x x u (rename-uniquely) in the buffer called *sweeprolog-top-level* and then do M-x sweeprolog-top-level RET again. This changes the name of the original top-level buffer to something like *sweeprolog-top-level*<2> and allows the new top-level to claim the buffer name *sweeprolog-top-level*.

9.3 The Top-level Menu buffer ¶

Command: sweeprolog-list-top-levels ¶

Display a list of running Prolog top-levels.

To open the Top-level Menu buffer, use the command M-x sweeprolog-list-top-levels RET. By default, the buffer is called *Sweep Top-levels*.

The Top-level Menu buffer uses a special major mode named sweeprolog-top-level-menu-mode. This mode provides several commands that operate on the top-level corresponding to the table row at point. The available commands are:

RET (Sweep Top-level Menu mode) ¶

Open the specified top-level buffer (sweeprolog-top-level-menu-go-to).

k (Sweep Top-level Menu mode) ¶

Kill the specified top-level buffer (sweeprolog-top-level-menu-kill).

s (Sweep Top-level Menu mode) ¶

Signal the specified top-level buffer (sweeprolog-top-level-menu-signal). See Sending signals to running top-levels.

t (Sweep Top-level Menu mode) ¶

Create a new top-level buffer (sweeprolog-top-level-menu-new).

g (Sweep Top-level Menu mode)

Update the Top-level Menu contents (revert-buffer).

9.4 Sending signals to running top-levels ¶

Command: sweeprolog-top-level-signal ¶

Prompt for a Prolog goal and signal a top-level buffer to execute it.

This command prompts for an active Sweep top-level buffer followed by a Prolog goal, and interrupts the top-level causing it to run the specified goal.

C-c C-c ¶

C-u C-c C-c

Interrupt the current Prolog top-level.

You can also signal top-levels from the Sweep Top-level Menu buffer with the command sweeprolog-top-level-menu-signal with point at the entry corresponding to the wanted top-level (see The Top-level Menu buffer).

For more information about interrupting threads in SWI-Prolog, see Signaling threads in the SWI-Prolog manual.

9.5 Top-level History ¶

Sweep top-level buffers provide a history of previous user inputs, similarly to other comint-mode derivatives such as shell-mode. To insert the last input from the history at the prompt, use M-p (comint-previous-input). See (emacs)Shell History, for a full description of history related commands.

User Option: sweeprolog-top-level-min-history-length ¶

Minimum input length to record in the history of Sweep top-levels.

User Option: sweeprolog-top-level-persistent-history ¶

How to persist input history for top-levels across Emacs sessions.

The Sweep top-level history only records inputs whose length is at least sweeprolog-top-level-min-history-length characters. This user option is set to 3 by default, and should generally be set to at least 2 to keep the history from being clobbered with single-character inputs, which are common in the top-level interaction, for example ; as used to invoke backtracking.

Sweep can optionally persist top-level input history. The user option sweeprolog-top-level-persistent-history controls if and where top-levels store their persistent history: when this option is non-nil, Sweep top-level buffers that you create read their input history from a persistent history file, and write their history back to it when you delete them. If this option is a string, it is treated as a file name, and top-level buffers use that file to persistent their input history. If it’s a function, it is called with no arguments and should return either a file name for the persistent history, or nil to disable persistent history for that top-level buffer. The file name that this user option specifies can be either absolute or relative, in which case it is expanded relative to the default directory of the top-level buffer (see (emacs)File Names). This option can also be a list of the form (project rel def), in which case the persistent history file that a top-level buffer uses depends on the current project of the of that buffer (see (emacs)Projects). If there is no current project, the top-level persistent history file is def. Otherwise, the history file is rel relative to the project’s root directory. You can leave def nil or omit it entirely to disable persistent history for top-levels that are not associated with any project. By default, this option is set to nil which says not to keep persistent top-level history.

9.6 Following Error Messages ¶

Many standard SWI-Prolog facilities generate messages that refer to specific source code locations. For example, loading a Prolog file that contains singleton variables into the top-level produces warning messages pointing to the starting line of the clauses where the singleton variables occur. If you enable compilation-shell-minor-mode in the top-level buffer, Emacs recognizes the Prolog messages that refer to source locations and provides convenient commands for visiting such source locations from the top-level buffer. See (emacs)Compilation Mode, For more information about compilation-shell-minor-mode.

To use compilation-shell-minor-mode automatically in all top-level buffers, you can arrange for the sweeprolog-top-level-mode hook to enable it as follows:

(add-hook 'sweeprolog-top-level-mode-hook
          #'compilation-shell-minor-mode)

9.7 Sending Goals to the Top-level ¶

You can send a goal to execute in a Prolog top-level from any buffer with the command M-x sweeprolog-top-level-send-goal RET.

C-c C-q ¶

Execute a Prolog goal in a top-level buffer and display that buffer (sweeprolog-top-level-send-goal).

This command prompts for a Prolog goal in the minibuffer, executes it in a top-level buffer and displays that buffer if it’s not already visible. While inserting the goal in the minibuffer, you can use TAB (or C-i) to get completion suggestions.

In Sweep Prolog mode buffers, you can invoke sweeprolog-top-level-send-goal by typing C-c C-q. It also uses the goal at point (if any) as the “future history” for the goal prompt, which you can access with M-n in the minibuffer.

11.1 Prolog file specification expansion ¶

Sweep defines a handler for the Emacs function expand-file-name that recognizes Prolog file specifications, such as library(lists), and expands them to their corresponding absolute paths. This means that you can use Prolog file specifications with Emacs’s standard find-file (C-x C-f) to locate Prolog resources directly.

For example, typing C-x C-f library(pldoc/doc_man) RET opens the source of the pldoc_man module from the Prolog library, and C-x C-f pack(.) RET opens the Prolog packages directory.

11.2 Built-in Native Predicates ¶

User Option: sweeprolog-swipl-sources ¶

Location of the SWI-Prolog source code root directory.

The way Sweep locates the SWI-Prolog sources depends on the user option sweeprolog-swipl-sources. Setting it to nil disables searching for definitions of native built-ins altogether. To point Sweep to the root directory of the SWI-Prolog source code, set sweeprolog-swipl-sources to the name of that directory. Any non-nil non-string value says to try and locate a checkout of the SWI-Prolog sources among known project root directories (Sweep consults Emacs’s built-in project-known-project-roots to find your project roots, see (emacs)Projects).

With sweeprolog-swipl-sources set, the provided commands for finding predicate definitions operate seamlessly on native built-ins to display their C definitions. These commands include:

• M-x sweeprolog-find-predicate,
• M-. (xref-find-definitions) in Sweep Prolog mode buffers (see Definitions and References), and
• s (help-view-source) in the *Help* buffer produced by M-x sweeprolog-describe-predicate (see Prolog Help).

16.1 Setting up Sweep for local development ¶

Since the Prolog and C parts of Sweep are distributed and installed along with SWI-Prolog (see Installation), the easiest way to set up Sweep for development is to start with a SWI-Prolog development setup. Clone the swipl-devel Git repository, go the subdirectory packages/sweep that contains Sweep as a Git submodule, and update it to the latest development version:

git clone --recursive https://github.com/SWI-Prolog/swipl-devel.git
cd swipl-devel/packages/sweep
git checkout master
git pull

The directory packages/sweep in the swipl-devel repository now contains the development version of Sweep. You can hack on Sweep’s source files and then (re)build SWI-Prolog to test your changes. See Building SWI-Prolog using cmake for more information about building SWI-Prolog from source.

If you only modify the Elisp library sweeprolog.el, you do not need to rebuild SWI-Prolog. You can simply evaluate and test your changes directly inside Emacs (see (emacs)Lisp Eval).

If you change sweep.c or otherwise want to rebuild SWI-Prolog, you can do that from the packages/sweep subdirectory by running the following command:

ninja -C ../../build

16.2 Submitting patches and bug reports ¶

The best way to get in touch with the Sweep maintainers is via the Sweep mailing list.

Command: sweeprolog-submit-bug-report ¶

Report a bug in Sweep to the maintainers via mail.

You can use the command M-x sweeprolog-submit-bug-report to easily contact the Sweep maintainers from within Emacs. This command opens a new buffer with a message template ready to be sent to the Sweep mailing list.

17.1 Improvements around editing Prolog ¶

Respect font-lock-maximum-decoration

We should take into account the value of font-lock-maximum-decoration while highlighting sweeprolog-mode buffers. This variable conveys the user’s preferred degree of highlighting. A possible approach would be changing sweeprolog-analyze-fragment-to-faces such that each color fragment in the returned list states the minimum decoration level (1, 2 or 3) for which it should apply. sweeprolog-analyze-fragment-font-lock would then compare this target to the value of (font-lock-value-in-major-mode font-lock-maximum-decoration) and decide whether or not to apply the fragment.

Support M-x align

Sweep Prolog mode should integrate with align.el such that M-x align aligns arguments of consecutive predicate calls. Concretely, we need to locally set align-mode-rules-list to a suitable value in sweeprolog-mode.

Support code filling/formatting

Sweep Prolog mode should define a fill-paragraph-function, and perhaps also a normal-auto-fill-function, for code filling that takes into account Prolog-specific conventions.

17.2 General improvements ¶

Facilitate interactive debugging

Sweep should facilitate interactive debugging of SWI-Prolog code. This is a big topic that we don’t clearly address. Perhaps this should be handled through a Debug Adapter Protocol integration similar to dap-swi-prolog (Debug Adapter Protocol for SWI-Prolog).

Integrate with project.el adding support for SWI-Prolog packs

It would be nice if Sweep would “teach” project.el to detect directories containing SWI-Prolog pack.pl package definitions as root project directories.

Extend the provided Elisp-Prolog interface

Currently, the Elisp interface that Sweep provides for querying Prolog only allows calling directly to predicates of arity 2 (see Querying Prolog), ideally we should provide a (backward-compatible) way for executing arbitrary Prolog queries.