Logic, control and exceptions

### 6.18 Logic, control and exceptions

#### 6.18.1 `abort/0`, `stop/0`, `top_level/0`, `break/0`, `halt/1`, `halt/0`

Templates

  `abort
  stop
  top_level
  break
  halt(+integer)
  halt`

Description
`abort` aborts the current execution. If this execution was initiated under a top-level the control is given back to the top-level and the message `{``execution aborted``}` is displayed. Otherwise, e.g. execution started by a `initialization/1` directive (section 5.1.13), `abort/0` is equivalent to `halt(1)` (see below).
`stop` stops the current execution. If this execution was initiated under a top-level the control is given back to the top-level. Otherwise, `stop/0` is equivalent to `halt(0)` (see below).
`top_level` starts a new recursive top-level (including the banner display). To end this new top-level simply type the end-of-file key sequence (`Ctl-D`) or its term representation: `end_of_file.`
`break` invokes a recursive top-level (no banner is displayed). To end this new level simply type the end-of-file key sequence (`Ctl-D`) or its term representation: `end_of_file.`
`halt(Status)` causes the GNU Prolog process to immediately exit back to the shell with the return code `Status`.
`halt` is equivalent to `halt(0)`.
Errors

`Status` is a variable |  | `instantiation_error`
`Status` is neither a variable nor an integer |  | `type_error(integer, Status)`

Portability
`halt/1` and `halt/0` are ISO predicates. `abort/0`, `stop/0`, `top_level/0` and `break/0` are GNU Prolog predicates.

#### 6.18.2 `once/1`, `(``\``+)/1` - not provable, `call_with_args/1-11`, `call/2`

Templates

  `once(+callable_term)
  ``\``+(+callable_term)
  call_with_args(+atom, +term,..., +term)
  call(+callable_term, ?boolean)`

Description
`once(Goal)` succeeds if `call(Goal)` succeeds. However `once/1` is not re-executable on backtracking since all alternatives of `Goal` are cut. `once(Goal)` is equivalent to `call(Goal), !`.
`\``+ Goal` succeeds if `call(Goal)` fails and fails otherwise. This built-in predicate gives negation by failure.
`call_with_args(Functor, Arg1,..., ArgN)` calls the goal whose functor is `Functor` and whose arguments are `Arg1`,..., `ArgN` (0 £ `N` £ 10).
`call(Goal, Deterministic)` succeeds if `call(Goal)` succeeds and unifies `Deterministic` with `true` if `Goal` has not created any choice-points, with `false` otherwise.
`\``+` is a predefined prefix operator (section 6.14.10).
Errors

`Goal` is a variable |  | `instantiation_error`
`Goal` is neither a variable nor a callable term |  | `type_error(callable, Goal)`
The predicate indicator `Pred` of `Goal` does not correspond to an existing procedure and the value of the `unknown` Prolog flag is `error` (section 6.22.1) |  | `existence_error(procedure, Pred)`
`Functor` is a variable |  | `instantiation_error`
`Functor` is neither a variable nor an atom |  | `type_error(atom, Functor)`
`Deterministic` is neither a variable nor a boolean |  | `type_error(boolean, Deterministic)`

Portability
`once/1` and `(``\``+)/1` are ISO predicates, `call_with_args/1-11` and `call/2` are GNU Prolog predicates.

#### 6.18.3 `repeat/0`

Templates

  `repeat`

Description
`repeat` generates an infinite sequence of backtracking choices. The purpose is to repeatedly perform some action on elements which are somehow generated, e.g. by reading them from a stream, until some test becomes true. Repeat loops cannot contribute to the logic of the program. They are only meaningful if the action involves side-effects. The only reason for using repeat loops instead of a more natural tail-recursive formulation is efficiency: when the test fails back, the Prolog engine immediately reclaims any working storage consumed since the call to `repeat/0`.
Errors
None.
Portability
ISO predicate.

#### 6.18.4 `for/3`

Templates

  `for(?integer, +integer, +integer)`

Description
`for(Counter, Lower, Upper)` generates an sequence of backtracking choices instantiating `Counter` to the values `Lower`, `Lower+1`,..., `Upper`.
Errors

`Counter` is neither a variable nor an integer |  | `type_error(integer, Counter)`
`Lower` is a variable |  | `instantiation_error`
`Lower` is neither a variable nor an integer |  | `type_error(integer, Lower)`
`Upper` is a variable |  | `instantiation_error`
`Upper` is neither a variable nor an integer |  | `type_error(integer, Upper)`

Portability
GNU Prolog predicate.

Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
More about the copyright