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. -->

metapredicates

This example shows the use of meta-predicates in Logtalk. Meta-predicates are predicates whose head includes arguments that will be called as goals in the body of the predicate definition.

This example defines the following objects:

company usage example of the map_reduce/5 meta-predicate
fibonacci example of calculating Fibonacci numbers using the fold_left/4 meta-predicate
sort(_) this is a parametric object containing a method that implements the quicksort sorting algorithm; the parameter is interpreted as the type of the elements being sorted
tracer this object implements a meta-predicate that is used by sort(_) to trace the sorting algorithm steps
metapreds, descendant, and test objects used for illustrating the use of closures as meta-arguments
predicates object defining some predicates for testing meta-predicates defined in the Logtalk library
grammar object illustrating using phrase/2 as a meta-predicate meta-argument
Print Logtalk, Prolog backend, and kernel versions (if running as a notebook):
```
%versions
```
Start by loading the example and the required library files:
```
logtalk_load(metapredicates(loader)).
```
Try the simple meta-predicate definitions from the "goals.lgt" file:
```
simple_client::test_whatever.
```

```
simple_client::test_whatever_all.
```


Alternatively:
```
simple_client_alt::test_whatever.
```

```
simple_client_alt::test_whatever_all.
```


Note that user is a pseudo-object representing the Prolog database; therefore, the integer comparisons are performed using the standard Prolog built-in predicates:
```
sort(user)::sort([3, 1, 4, 2, 9], Sorted).
```


Test the setof/3 wrapper:
```
wrappers_client::p(L).
```

```
wrappers_client::q(L).
```


Call the meta-predicate apply/2 directly:
```
metapreds::test_this.
```


Send an apply/2 message to self:
```
descendant::test_self.
```


Send an apply/2 message from another object:
```
test::test_obj.
```


Use the partition/4 meta-predicate with a predicate defined in the pseudo-object user:
```
meta::partition(even_integer, [1,2,3,4,5], Included, Excluded).
```


Get a visual illustration of the differences between left and right folds:
```
folds::left(Left).
```

```
folds::right(Right).
```


Walk a list using left and right folds (note the lambda parameters order):
```
meta::fold_left([Y, X, [X|Y]]>>true, [], [1,2,3,4,5,6,7,8,9], R).
```

```
meta::fold_right([X, Y, [X|Y]]>>true, [], [1,2,3,4,5,6,7,8,9], R).
```


We can compose left folds:
```
meta::fold_left([X,Y,Z]>>(Z is X + Y), 0, [1,2,3], Sum).
```

```
meta::fold_left(meta::fold_left([X,Y,Z]>>(Z is X + Y)), 0, [[1,2,3],[4,5,6]], Sum).
```


Use the fold_left/4 meta-predicate with a predicate defined in the pseudo-object user:
```
meta::fold_left(sum_squares, 0, [1,2,3], Result).
```


Use the fold_left/4 and fold_right/4 meta-predicates with the atom_concat/3 Prolog built-in predicate:
```
meta::fold_left(atom_concat, 'PREFIX', [abc,def,ghi], Result).
```

```
meta::fold_right(atom_concat, 'SUFIX', [abc,def,ghi], Result).
```


Use the fold_left/4 meta-predicate with predicates defined in the object predicates:
```
meta::fold_left(predicates::sum, 0, [1,2,3,4,5], Result).
```

```
meta::fold_left(predicates::product, 1, [1,2,3,4,5], Result).
```

```
meta::fold_left(predicates::tuple, (0,0), [(1,2), (3,4), (6,4)], Result).
```


Alternatives to fold_left/4 and fold_right/4 when there isn't an initial value:
```
meta::fold_left_1([X,Y,Z]>>(Z is X+Y), [1,2,3,4,5], R).
```

```
meta::fold_right_1([X,Y,Z]>>(Z is X-Y), [1,2,3,4,5], R).
```

```
meta::fold_right_1([X,Y,Z]>>(Z is X*Y), [1,2,3,4,5], R).
```


Use the scan_left/4 and scan_right/4 meta-predicates with predicates defined in the object predicates:
```
meta::scan_left(sum_squares, 0, [1,2,3], Result).
```

```
meta::scan_right(predicates::sum, 5, [1,2,3,4], Result).
```


Compute a sequence of factorial numbers using a scan of natural numbers using multiplication:
```
meta::scan_left([X,Y,Z]>>(Z is X*Y), 1, [1,2,3,4,5,6], Result).
```


Use the map/2-3 meta-predicates with some Prolog built-in predicates.

Check that all list elements are integers:
```
meta::map(integer, [1,2,3,4,5]).
```


Map characters to character codes:
```
meta::map(char_code, [a,b,c,d,e], Codes).
```


Use the fold_left/4 meta-predicate to calculate Fibonacci numbers:
```
fibonacci::nth(10, Fib).
```


The first six Fibonacci numbers:
```
%%table
integer::between(0, 5, Nth), fibonacci::nth(Nth, Fib).
```


Use the map_reduce/5 meta-predicate to give bad news to a company employees:
```
company::(company(C1), get_salary(company(C1),S1)).
```

```
company::(company(C1), cut_salary(company(C1), C2), get_salary(C2, S2)).
```