.. index:: single: number_grammars(Format)
.. _number_grammars/1:

.. rst-class:: right

**object**

``number_grammars(Format)``
===========================

Number grammars.

| **Availability:** 
|    ``logtalk_load(grammars(loader))``

| **Author:** Paulo Moura
| **Version:** 0:3:0
| **Date:** 2025-10-06

| **Compilation flags:**
|    ``static, context_switching_calls``


| **Uses:**
|    :ref:`list <list/0>`

| **Remarks:**
|    (none)

| **Inherited public predicates:**
|    (none)

.. contents::
   :local:
   :backlinks: top

Public predicates
-----------------

.. index:: bit//1
.. _number_grammars/1::bit//1:

``bit//1``
^^^^^^^^^^

Parses a single bit.

| **Compilation flags:**
|    ``static``

| **Template:**
|    ``bit(Bit)``
| **Mode and number of proofs:**
|    ``bit(?integer)`` - ``zero_or_one``


------------

.. index:: bits//1
.. _number_grammars/1::bits//1:

``bits//1``
^^^^^^^^^^^

Parses a sequence of one or more bits.

| **Compilation flags:**
|    ``static``

| **Template:**
|    ``bits(Bits)``
| **Mode and number of proofs:**
|    ``bits(?list(integer))`` - ``zero_or_one``


------------

.. index:: digit//1
.. _number_grammars/1::digit//1:

``digit//1``
^^^^^^^^^^^^

Parses a single decimal digit.

| **Compilation flags:**
|    ``static``

| **Template:**
|    ``digit(Digit)``
| **Mode and number of proofs:**
|    ``digit(?atomic)`` - ``zero_or_one``


------------

.. index:: digits//1
.. _number_grammars/1::digits//1:

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


------------

.. index:: hex_digit//1
.. _number_grammars/1::hex_digit//1:

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


------------

.. index:: hex_digits//1
.. _number_grammars/1::hex_digits//1:

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


------------

.. index:: natural//1
.. _number_grammars/1::natural//1:

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


------------

.. index:: integer//1
.. _number_grammars/1::integer//1:

``integer//1``
^^^^^^^^^^^^^^

Parses an integer.

| **Compilation flags:**
|    ``static``

| **Template:**
|    ``integer(Integer)``
| **Mode and number of proofs:**
|    ``integer(?integer)`` - ``zero_or_one``


------------

.. index:: float//1
.. _number_grammars/1::float//1:

``float//1``
^^^^^^^^^^^^

Parses a float.

| **Compilation flags:**
|    ``static``

| **Template:**
|    ``float(Float)``
| **Mode and number of proofs:**
|    ``float(?float)`` - ``zero_or_one``


------------

.. index:: number//1
.. _number_grammars/1::number//1:

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


------------

.. index:: sign//1
.. _number_grammars/1::sign//1:

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


------------

.. index:: dot//1
.. _number_grammars/1::dot//1:

``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)

