Elements of the SenseTalk Pattern Language

The SenseTalk pattern language lets you define patterns that you can use to match strings in text. As explained in SenseTalk Pattern Language Basics, the pattern matching capabilities are built on top of regular expressions (regex). The SenseTalk pattern language lets you define patterns in easy-to-read syntax.

You can create pattern definitions for simple patterns, such as the occurrence of any three digits. You can also define patterns for complex patterns that have optional or alternative portions, and that can have varying lengths. Every pattern, however simple or complex, is built from a number of basic pattern elements.

Pattern Language Syntax

Pattern definitions in the SenseTalk pattern language consist of the pattern description enclosed in angle brackets (< ... >).

Syntax:

Note the word pattern is optional with the pattern language and typically will be omitted.

A pattern definition—represented in the syntax above by patternLanguageExpression—can be a single element, such as 7 digits to find any occurrence of seven digits in a row. However, most patterns will include a sequence of elements, or subpatterns. The sequence is specified by listing each subpattern one after another separated by commas, separated by the word then, or separated by listing each element on a new line (or some combination of these options).

Therefore, the following examples are all equivalent methods of representing a pattern definition for a Social Security identification number:

You can use the word or to specify alternative choices in a subpattern. For example,

matches either cat or cow.

You can use parentheses to group elements when necessary. For example,

matches text like cat24 or cow17. But

matches either cat (with no digits needed) or something like cow97.

Pattern Elements

A pattern definition is made up of individual elements, or subpatterns. An element can be the characters included in a quoted string, such as "cat". It can also be a SenseTalk variable, an expression in parentheses, or one of several pattern elements described in the Pattern Definition Elements table below.

Note the following about how elements can be defined:

• Most pattern elements can be singular or plural.
  • Singular elements match exactly one of the specified value.
  • Plural elements match a sequence of one or more of the indicated value.
• Quantifiers can be used to explicitly control the number of characters or values you want an element to match.

Pattern Definition Elements

Elements	Definition
"quoted string"	Use an exact string of characters
variable	Use any valid element or combination of elements stored in a variable
expression	Use any SenseTalk expression, in parentheses, that yields a string
character characters	Matches any characters
letter letters	Matches letters of any alphabet
nonletter nonletters	Matches characters other than letters of an alphabet
lowercase letter lowercase letters	Matches lowercase letters in any language
nonlowercase letter nonlowercase letters	Matches letters other than lowercase letters in any language
uppercase letter, capital letter uppercase letters, capital letters	Matches uppercase letters in any language
nonuppercase letter, noncapital letter nonuppercase letters, noncapital letters	Matches letters other than uppercase letters in any language
digit digits	Matches digits from 0 to 9
nondigit nondigits	Matches characters other than digits
letterOrDigit, alphanumeric lettersOrDigits, alphanumerics	Matches either letters or digits
nonLetterOrDigit, nonAlphanumeric nonLettersOrDigits, nonAlphanumerics	Matches characters other than letters or digits
whitespace character whitespace characters	Matches white space characters (space, tab, line separator, etc.)
nonwhitespace character nonwhitespace characters	Matches characters other than white space characters
word character word characters	Matches word characters (letters or digits)
nonword character nonword characters	Matches characters other than word characters
punctuation character punctuation characters	Matches punctuation characters
nonpunctuation character nonpunctuation characters	Matches nonpunctuation characters
character [of | in | from] characterSet characters [of | in | from] characterSet	Matches characters that are in the characterSet (string, range, character class identifier, or list of these items)
character not [of | in | from] characterSet characters not [of | in | from] characterSet	Matches character that are not in the characterSet

Quantifiers and Elements

When you specify a singular pattern element, such as letter or digit, exactly one of that type of element creates a match for the pattern. Specifying a plural form, such as letters or digits, indicates that one or more of that element can create a match.

In addition, there are a number of quantifiers that you can use to specify how many times an element should appear to create a pattern match.

Terms that Mean Exactly One Character

Example:

Matches Patterns Like: (w) ( ) (7) (.) ())

Doesn't Match: () (42) (salamander) otherStuff

Terms that Mean an Exact Number of Characters

The number 2 is shown in these examples, but any positive integer can be used. A variable whose value is an integer can also be used, but the word "exactly" must be used in this case.

Example:

Matches Patterns Like: (42) (CO) (())

Doesn't Match: () (w) ( ) (7) (.) ()) (salamander) otherStuff

Terms that Mean Zero or One Character

Example:

Matches Patterns Like: () (w) ( ) (7) (.)

Doesn't Match: (42) (salamander) otherStuff

Terms that Mean One or More Characters

Example:

Matches Patterns Like: (w) ( ) (7) (.) ()) (42) (salamander)

Doesn't Match: () otherStuff

In the sentence example below, matches two strings: (a woman) and (her cat)

Terms that Mean Zero or More Characters

Example:

Matches Patterns Like: () (w) ( ) (7) (.) (42) (salamander)

Doesn't Match: otherStuff

In the sentence example below, matches two strings: (a woman) and (her cat)

Terms that Specify a Minimum Number of Characters

The number 2 is shown in these examples, but any positive integer can be used. A variable whose value is an integer can also be used in place of specific number.

Example:

Matches Patterns Like: (42) (salamander)

Doesn't Match: () (w) ( ) (7) (.) ()) otherStuff

In the sentence example below, matches two strings: (a woman) and (her cat)

Terms that Specify a Minimum and Maximum Number of Characters

A range of 2 to 4 is shown in these examples, but any range of positive integers can be used. A variable whose value is an integer can also be used in place of either or both numbers.

Example:

Matches Patterns Like: (42)

Doesn't Match: () (w) ( ) (7) (.) ()) (salamander) otherStuff

Lazy vs. Greedy Quantifiers

When you create a pattern that can match a varying number of values, the match can be either lazy or greedy. A lazy subpattern matches as few occurrences as possible while still providing a match to the overall pattern. A greedy subpattern matches as many as possible.

In SenseTalk, pattern matches are lazy by default. So the pattern

will match a sequence beginning with ( followed by one or more characters up to and including the first occurrence of ) that is encountered. The pattern

on the other hand, will match a sequence beginning with ( then greedily consume as many characters as it can, up to and including the final occurrence of ) in the source text.

To illustrate the difference, consider this example sentence:

And this pattern:

Now, assuming the example text is read into a variable, myText, the following code would return two values:

Output: ((a woman),(her cat))

It works this way because one or more characters in SenseTalk is lazy—it consumes the smallest number of characters needed to satisfy the pattern.

However, sometimes you might need to create a greedy match. The greedy behavior can be achieved in this example by changing the pattern to this:

By specifying that you prefer to have the pattern match more characters if possible, the expression every occurrence of myPattern in myText now returns just one value that includes everything from the first ( to the last ):

(a woman) and Flossie (her cat)

Terms that Mean Zero or One Character, But Prefer One

Example:

Matches Patterns Like: () (w) ( ) (7) (.) ())

Doesn't Match: (42) (salamander) otherStuff

Terms that Mean One or More Characters, But Prefer as Many as Possible:

Example:

Matches Patterns Like: (w) ( ) (7) (.) ()) (42) (salamander)

Doesn't Match: () otherStuff

In the sentence example above, matches: (a woman) and Flossie (her cat)

Terms that Mean Zero or More Characters, But Prefer as Many as Possible

Example:

Matches Patterns Like: () (w) ( ) (7) (.) ()) (42) (salamander)

Doesn't Match: otherStuff

In the sentence example above, matches one string: (a woman) and Flossie (her cat)

Terms that Specify a Minimum Number of Characters, but Prefer as Many as Possible

The number 2 is shown in these examples, but any positive integer can be used.

Example:

Matches Patterns Like: (42) (salamander)

Doesn't Match: () (w) ( ) (7) (.) ()) otherStuff

In the sentence example above, matches one string: (a woman) and Flossie (her cat)

Terms that Specify a Minimum and Maximum Number of Characters, but Prefer as Many as Possible

A range of 2 to 4 is shown in these examples, but any range of positive integers can be used.

Example:

Matches Pattern Like: (42)

Doesn't Match: () (w) ( ) (7) (.) ()) (salamander) otherStuff

Explicitly Forcing Greedy or Lazy Behavior

You can use the terms greedily or lazily after any term that represents a variable number of characters to explicitly enforce greedy or lazy behavior. When used, these terms always take precedence, regardless of the usual behavior of the preceding term.

Here are a few examples to illustrate this behavior:

Greedy Synonyms

All of these terms can be used interchangeably when specifying a greedy quantifier:

Case Sensitivity in Patterns

Text comparisons in SenseTalk are typically not case sensitive, as explained in Expressions. This behavior also applies to pattern matches. Therefore, when your pattern looks for letters, a match is met whether the letters are capitals or lowercase. You can change the default behavior to require case sensitivity by using the caseSensitive local property.

Most comparison operators also allow case-sensitivity to be specified directly as an option of the operator, which overrides the global setting. These options apply to pattern comparisons as well as ordinary text comparisons, as shown in the following example:

Case-Sensitivity Settings Within a Pattern

You can incorporate case-sensitivity settings directly into a pattern definition. These in-line settings always take precedence over the default settings or options specified in the command. You can include these options within a pattern for fine-grained control over case-sensitivity in different parts of the pattern.

Case-Sensitivity Elements Syntax:

Example:

Example:

Example:

 

This topic was last updated on August 19, 2021, at 03:30:51 PM.

Eggplantsoftware.com | Documentation Home | User Forums | Support | Copyright © 2022 Eggplant