---

jupyter: jupytext: text_representation: extension: .md format_name: markdown format_version: '1.3' jupytext_version: 1.16.7 kernelspec: display_name: Logtalk language: logtalk name: logtalk_kernel ---

<!--

This file is part of Logtalk https://logtalk.org/ SPDX-FileCopyrightText: 1998-2025 Paulo Moura <pmoura@logtalk.org> SPDX-License-Identifier: Apache-2.0

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. -->

dcgs

This folder contains the following examples of using DCGs in objects and categories:

[99, 97, 108, 99, 117, 108, 97, 116, 111, 114]

canonical DCG example of parsing arithmetic expressions

[101, 110, 105, 103, 109, 97]

solve a cellphone enigma against a dictionary of words

[98, 111, 109]

bill of materials DCG example (see below for original source)

[115, 101, 110, 116, 101, 110, 99, 101, 115]

simple parsing of natural language sentences

[112, 97, 114, 115, 101, 116, 114, 101, 101]

same as above but building and returning the parse tree

[120, 109, 108]

conversion between XML and Prolog terms

[117, 114, 108]

parsing of URLs, decomposing them in components

[115, 104, 101, 108, 108]

parsing of command-line shell commands

[102, 97, 97]

command language DCG example (see below for original source)

[119, 97, 108, 107, 101, 114]

parsing of walker movements and calculation of distance travelled

[98, 121, 112, 97, 115, 115]

using the {}/1 DCG construct together with the {}/1 Logtalk control construct

[116, 111, 107, 101, 110, 105, 122, 101, 114]

natural language tokenizer example

[109, 97, 99, 97, 100, 100, 114]

validator for MAC hardware addresses

[109, 111, 114, 115, 101]

decoder for Morse code messages; illustrate how to use scope directives to declare grammar rule non-terminals

[105, 98, 97, 110]

IBAN validation; this example can generate very large integers during validation and thus may not work with all backend Prolog compilers

[108, 97, 109, 98, 100, 97, 115]

example of using lambda expressions in grammar rules

This folder includes an example, tokenizer, adapted with permission from a Michael A. Covington example:

http://www.ai.uga.edu/~mc/

See the file tokenizer.lgt for more details.

This folder also includes two examples of DCGs, bom and faa, adapted with permission from the Amzi! Prolog documentation. The documentation is available on-line in HTML format at the URL:

http://www.amzi.com/

Please refer to the Amzi! Prolog documentation for more information on the original examples.

Print Logtalk, Prolog backend, and kernel versions (if running as a notebook):

%versions

Start by loading the example:

logtalk_load(dcgs(loader)).

DCG rules implementing a simple calculator:

calculator::parse("1+2-3*4", Result).

<!-- Result = -9. -->

Recognize MAC addresses:

macaddr::valid("00:1e:4a:ef:72:8b").

<!-- true. -->

Decode Morse code messages (as phrase/2-3 are private methods, we use the logtalk built-in object and the (<<)/2 control construct to invoke the foo//0 public grammar rule non-terminal as the backend Prolog system implementation of the phrase/2-3 predicates is not Logtalk aware and would mishandle the (::)/2 message-sending operator):

logtalk << phrase(morse::morse(Message), "... --- ...").

<!-- Message = [sos]. -->

Solve a cellphone keypad encoded enigma:

enigma::solve("4 96853 5683 86 4283 346637 9484 968 8664448", Message).

<!-- Message = [i, would, love, to, have, dinner, with, you, tonight]. -->

Recognizing grammatically correct sentences:

sentence::parse([the, girl, likes, the, boy], Result).

<!-- Result = true. -->

sentence::parse([the, girl, scares, the, boy], Result).

<!-- Result = false. -->

Generating parse trees for sentences:

parsetree::parse([the, girl, likes, the, boy], Tree).

<!-- Tree = s(np(d(the), n(girl)), vp(v(likes), np(d(the), n(boy)))). -->

Bill of materials example:

bom::parts(bike, L).

<!-- L = [frame, crank, pedal, pedal, chain, spokes, rim, hub, spokes, rim, hub]. -->

bom::parts(wheel, L).

<!-- L = [spokes, rim, hub]. -->

Parsing command-line shell input:

shell::parse("pwd; cd ..; ls -a", L).

<!-- L = [pwd,'cd ..','ls -a']. -->

Convert a string to a list of tokens (words, numbers, punctuation):

tokenizer::tokens(" We owe $1,048,576.24 to Agent 007 for Version 3.14159! ", Tokens).

<!-- Tokens = [we,owe,$,1048576.24,to,agent,7,for,version,3.14159,!]. -->

Walker movements:

walker::walk([n(5), e(4), s(2), nw(8), s(5), se(1), n(4)], Ending).

<!-- Ending = -0.94974746830583223,6.9497474683058318. -->

Conversion between compound terms and XML:

xml::convert(word(child, children), word(singular, plural), XML).

<!-- XML = '<word><singular>child</singular><plural>children</plural></word>'. -->

xml::convert(Term, Interpretation, '<word><singular>child</singular><plural>children</plural></word>').

<!-- Term = word(child, children), Interpretation = word(singular, plural). -->

Parsing URLs:

url::parse("https://logtalk.org", Components).

<!-- Components = [protocol(http), address([logtalk, org]), path([]), file('')]. -->

url::parse("https://logtalk.org/", Components).

<!-- Components = [protocol(http), address([logtalk, org]), path(['']), file('')]. -->

url::parse("https://logtalk.org/cvs", Components).

<!-- Components = [protocol(http), address([logtalk, org]), path([cvs]), file('')]. -->

url::parse("https://logtalk.org/cvs.html", Components).

<!-- Components = [protocol(http), address([logtalk, org]), path([]), file('cvs.html')]. -->

url::parse("http://193.136.64.5/files/update", Components).

<!-- Components = [protocol(http), address([193, 136, 64, 5]), path([files, update]), file('')]. -->

Command language example (skip if running as a notebook):

(current_object(jupyter) -> true; faa::main).

<!-- Fly Amzi! Air enter command> list flights aa101 aa102 aa103 enter command> book elana aa102 enter command> book tom aa102 enter command> list passengers aa102 elana tom enter command> exit

true. -->

IBAN validation:

iban::valid("GB82 WEST 1234 5698 7654 32").

<!-- true. -->

Double bypass using the {}/1 control constructs of grammar rules and Logtalk (as phrase/2-3 are private methods, we use the logtalk built-in object and the (<<)/2 control construct to invoke the foo//0 public grammar rule non-terminal):

logtalk << phrase(bypass::foo, _, _).

<!-- bar predicate called. -->

Run the Logtalk DCG translator on the test cases:

dcgtest::run.

Try the meta_non_terminal/1 + call//N examples:

client::print.

<!-- 1-one 2-two 3-three a-one b-two c-three

true. -->

client::successors([1,2,3], Successors).

<!-- Successors = [2, 3, 4]. -->

Use lambda expressions in grammar rules:

logtalk << phrase(lambdas::aa(Duplicates), [a,b,c]).

<!-- Duplicates = [a,a,b,b,c,c]. -->

logtalk << phrase(lambdas::aa([a,a,b,b,c,c]), Singletons).

<!-- Singletons = [a,b,c]. -->

Use call//1 and a lambda expressions to access the grammar rule input list for debugging:

debug::copy([1,2,3,4,5], Copy).

<!-- [1,2,3,4,5] [2,3,4,5] [3,4,5] [4,5] [5] [] Copy = [1, 2, 3, 4, 5]. -->

Use a meta-non-terminal:

logtalk << phrase(meta_nt::repeat(bases::octal, 2, 4, Digits), [3,7,4,1,0,3,6], Rest).

<!-- Digits = [3,7,4,1], Rest = [0,3,6]. -->