protocol

# `characterp`

Character protocol.

Author: Paulo Moura
Version: 1:3:0
Date: 2019-06-29
Compilation flags:
`static`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

See also

character