object

# `number_grammars(Format)`

Number grammars.

Availability:
`logtalk_load(grammars(loader))`
Author: Paulo Moura
Version: 0:2:1
Date: 2022-10-08
Compilation flags:
`static, context_switching_calls`
Uses:
list
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

### `bit//1`

Parses a single bit.

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

### `bits//1`

Parses a sequence of one of more bits.

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

### `digit//1`

Parses a single decimal digit.

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

### `digits//1`

Parses a sequence of zero of more digits.

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

### `hex_digit//1`

Parses a single hexa-decimal digit.

Compilation flags:
`static`
Template:
`hex_digit(HexDigit)`
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`
Template:
`hex_digits(HexDigits)`
Mode and number of proofs:
`hex_digits(?list(atomic))` - `one`

### `natural//1`

Parses a natural number (a non signed integer).

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

### `integer//1`

Parses an integer.

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

### `float//1`

Parses a float.

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

### `number//1`

Parses a number (an integer or a float).

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

### `sign//1`

Parses a number sign (plus or minus).

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

### `dot//1`

Parses a decimal dot.

Compilation flags:
`static`
Template:
`dot(Dot)`
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)