object

# `number_grammars(Format)`

Number grammars.

Author: Paulo Moura
Version: 0:2:0
Date: 2022-02-15
Compilation flags:
`static, context_switching_calls`
Uses:
list
Remarks:
(none)
Inherited public predicates:
(none)

- Public predicates

  - `bit//1`

  - `bits//1`

  - `digit//1`

  - `digits//1`

  - `hex_digit//1`

  - `hex_digits//1`

  - `natural//1`

  - `integer//1`

  - `float//1`

  - `number//1`

  - `sign//1`

  - `dot//1`

- Protected predicates

- Private predicates

- Operators

## Public predicates

### `bit//1`

Parses a single bit.

Compilation flags:
`static`
Mode and number of proofs:
`bit(?integer)` - `zero_or_one`

### `bits//1`

Parses a sequence of one of more bits.

Compilation flags:
`static`
Mode and number of proofs:
`bits(?list(integer))` - `zero_or_one`

### `digit//1`

Parses a single decimal digit.

Compilation flags:
`static`
Mode and number of proofs:
`digit(?atomic)` - `zero_or_one`

### `digits//1`

Parses a sequence of zero of more digits.

Compilation flags:
`static`
Mode and number of proofs:
`digits(?list(atomic))` - `one`

### `hex_digit//1`

Parses a single hexa-decimal digit.

Compilation flags:
`static`
Mode and number of proofs:
`hex_digit(?atomic)` - `zero_or_one`

### `hex_digits//1`

Parses a sequence of zero or more hexa-decimal digits.

Compilation flags:
`static`
Mode and number of proofs:
`hex_digits(?list(atomic))` - `one`

### `natural//1`

Parses a natural number (a non signed integer).

Compilation flags:
`static`
Mode and number of proofs:
`natural(?non_negative_integer)` - `zero_or_one`

### `integer//1`

Parses an integer.

Compilation flags:
`static`
Mode and number of proofs:
`integer(?integer)` - `zero_or_one`

### `float//1`

Parses a float.

Compilation flags:
`static`
Mode and number of proofs:
`float(?float)` - `zero_or_one`

### `number//1`

Parses a number (an integer or a float).

Compilation flags:
`static`
Mode and number of proofs:
`number(?number)` - `zero_or_one`

### `sign//1`

Parses a number sign.

Compilation flags:
`static`
Mode and number of proofs:
`sign(?atomic)` - `zero_or_one`

### `dot//1`

Parses a decimal dot.

Compilation flags:
`static`
Mode and number of proofs:
`dot(?atomic)` - `zero_or_one`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

(no local declarations; see entity ancestors if any)

## Operators

(none)