.. index:: single: characterp
.. _characterp/0:

.. rst-class:: right

**protocol**

``characterp``
==============

Character protocol.

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

| **Author:** Paulo Moura
| **Version:** 1:3:0
| **Date:** 2019-06-29

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


| **Dependencies:**
|   (none)


| **Remarks:**
|    (none)

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

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

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

.. index:: is_ascii/1
.. _characterp/0::is_ascii/1:

``is_ascii/1``
^^^^^^^^^^^^^^

True if the argument is an ASCII character.

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

| **Template:**
|    ``is_ascii(Char)``
| **Mode and number of proofs:**
|    ``is_ascii(+char)`` - ``zero_or_one``


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

.. index:: is_alphanumeric/1
.. _characterp/0::is_alphanumeric/1:

``is_alphanumeric/1``
^^^^^^^^^^^^^^^^^^^^^

True if the argument is an alphanumeric character.

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

| **Template:**
|    ``is_alphanumeric(Char)``
| **Mode and number of proofs:**
|    ``is_alphanumeric(+char)`` - ``zero_or_one``


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

.. index:: is_alpha/1
.. _characterp/0::is_alpha/1:

``is_alpha/1``
^^^^^^^^^^^^^^

True if the argument is a letter or an underscore.

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

| **Template:**
|    ``is_alpha(Char)``
| **Mode and number of proofs:**
|    ``is_alpha(+char)`` - ``zero_or_one``


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

.. index:: is_letter/1
.. _characterp/0::is_letter/1:

``is_letter/1``
^^^^^^^^^^^^^^^

True if the argument is a letter.

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

| **Template:**
|    ``is_letter(Char)``
| **Mode and number of proofs:**
|    ``is_letter(+char)`` - ``zero_or_one``


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

.. index:: is_bin_digit/1
.. _characterp/0::is_bin_digit/1:

``is_bin_digit/1``
^^^^^^^^^^^^^^^^^^

True if the argument is a binary digit.

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

| **Template:**
|    ``is_bin_digit(Char)``
| **Mode and number of proofs:**
|    ``is_bin_digit(+char)`` - ``zero_or_one``


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

.. index:: is_octal_digit/1
.. _characterp/0::is_octal_digit/1:

``is_octal_digit/1``
^^^^^^^^^^^^^^^^^^^^

True if the argument is an octal digit.

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

| **Template:**
|    ``is_octal_digit(Char)``
| **Mode and number of proofs:**
|    ``is_octal_digit(+char)`` - ``zero_or_one``


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

.. index:: is_dec_digit/1
.. _characterp/0::is_dec_digit/1:

``is_dec_digit/1``
^^^^^^^^^^^^^^^^^^

True if the argument is a decimal digit.

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

| **Template:**
|    ``is_dec_digit(Char)``
| **Mode and number of proofs:**
|    ``is_dec_digit(+char)`` - ``zero_or_one``


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

.. index:: is_hex_digit/1
.. _characterp/0::is_hex_digit/1:

``is_hex_digit/1``
^^^^^^^^^^^^^^^^^^

True if the argument is an hexadecimal digit.

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

| **Template:**
|    ``is_hex_digit(Char)``
| **Mode and number of proofs:**
|    ``is_hex_digit(+char)`` - ``zero_or_one``


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

.. index:: is_lower_case/1
.. _characterp/0::is_lower_case/1:

``is_lower_case/1``
^^^^^^^^^^^^^^^^^^^

True if the argument is a lower case letter.

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

| **Template:**
|    ``is_lower_case(Char)``
| **Mode and number of proofs:**
|    ``is_lower_case(+char)`` - ``zero_or_one``


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

.. index:: is_upper_case/1
.. _characterp/0::is_upper_case/1:

``is_upper_case/1``
^^^^^^^^^^^^^^^^^^^

True if the argument is a upper case letter.

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

| **Template:**
|    ``is_upper_case(Char)``
| **Mode and number of proofs:**
|    ``is_upper_case(+char)`` - ``zero_or_one``


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

.. index:: is_vowel/1
.. _characterp/0::is_vowel/1:

``is_vowel/1``
^^^^^^^^^^^^^^

True if the argument is a vowel.

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

| **Template:**
|    ``is_vowel(Char)``
| **Mode and number of proofs:**
|    ``is_vowel(+char)`` - ``zero_or_one``


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

.. index:: is_white_space/1
.. _characterp/0::is_white_space/1:

``is_white_space/1``
^^^^^^^^^^^^^^^^^^^^

True if the argument is a white space character (a space or a tab) inside a line of characters.

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

| **Template:**
|    ``is_white_space(Char)``
| **Mode and number of proofs:**
|    ``is_white_space(+char)`` - ``zero_or_one``


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

.. index:: is_layout/1
.. _characterp/0::is_layout/1:

``is_layout/1``
^^^^^^^^^^^^^^^

True if the argument is a layout character.

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

| **Template:**
|    ``is_layout(Char)``
| **Mode and number of proofs:**
|    ``is_layout(+char)`` - ``zero_or_one``


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

.. index:: is_quote/1
.. _characterp/0::is_quote/1:

``is_quote/1``
^^^^^^^^^^^^^^

True if the argument is a quote character.

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

| **Template:**
|    ``is_quote(Char)``
| **Mode and number of proofs:**
|    ``is_quote(+char)`` - ``zero_or_one``


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

.. index:: is_punctuation/1
.. _characterp/0::is_punctuation/1:

``is_punctuation/1``
^^^^^^^^^^^^^^^^^^^^

True if the argument is a sentence punctuation character.

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

| **Template:**
|    ``is_punctuation(Char)``
| **Mode and number of proofs:**
|    ``is_punctuation(+char)`` - ``zero_or_one``


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

.. index:: is_period/1
.. _characterp/0::is_period/1:

``is_period/1``
^^^^^^^^^^^^^^^

True if the argument is a character that ends a sentence.

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

| **Template:**
|    ``is_period(Char)``
| **Mode and number of proofs:**
|    ``is_period(+char)`` - ``zero_or_one``


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

.. index:: is_control/1
.. _characterp/0::is_control/1:

``is_control/1``
^^^^^^^^^^^^^^^^

True if the argument is an ASCII control character.

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

| **Template:**
|    ``is_control(Char)``
| **Mode and number of proofs:**
|    ``is_control(+char)`` - ``zero_or_one``


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

.. index:: is_newline/1
.. _characterp/0::is_newline/1:

``is_newline/1``
^^^^^^^^^^^^^^^^

True if the argument is the ASCII newline character.

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

| **Template:**
|    ``is_newline(Char)``
| **Mode and number of proofs:**
|    ``is_newline(+char)`` - ``zero_or_one``


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

.. index:: is_end_of_line/1
.. _characterp/0::is_end_of_line/1:

``is_end_of_line/1``
^^^^^^^^^^^^^^^^^^^^

True if the argument is the ASCII end-of-line character (either a carriage return or a line feed).

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

| **Template:**
|    ``is_end_of_line(Char)``
| **Mode and number of proofs:**
|    ``is_end_of_line(+char)`` - ``zero_or_one``


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

.. index:: parenthesis/2
.. _characterp/0::parenthesis/2:

``parenthesis/2``
^^^^^^^^^^^^^^^^^

Recognizes and converts between open and close parenthesis.

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

| **Template:**
|    ``parenthesis(Char1,Char2)``
| **Mode and number of proofs:**
|    ``parenthesis(?char,?char)`` - ``zero_or_more``
|    ``parenthesis(+char,?char)`` - ``zero_or_one``
|    ``parenthesis(?char,+char)`` - ``zero_or_one``


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

.. index:: lower_upper/2
.. _characterp/0::lower_upper/2:

``lower_upper/2``
^^^^^^^^^^^^^^^^^

Recognizes and converts between lower and upper case letters.

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

| **Template:**
|    ``lower_upper(Char1,Char2)``
| **Mode and number of proofs:**
|    ``lower_upper(?char,?char)`` - ``zero_or_more``
|    ``lower_upper(+char,?char)`` - ``zero_or_one``
|    ``lower_upper(?char,+char)`` - ``zero_or_one``


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

Protected predicates
--------------------

(none)

Private predicates
------------------

(none)

Operators
---------

(none)

.. seealso::

   :ref:`character <character/0>`

