Plugin: Functions

This plugin contains special Function defintions that can be invoked. All functions are specified with the given schema,

Function Schema

package.name(arguments: type) -> result: type

Where package is the dot-separated path to the function package, name is the function name, arguments is a list (possibly singleton or empty) of the argument names, result is the functional output and type is the expected data structure of the output.

Package: Language Game

• Path: lang, lg

These functions are somewhat whimsical and abstract. You may interpret them as you see fit.

loop() -> x: response

Full Path: lang.loop()

This Function instructs you to take your previous response and uses it as your current prompt, creating a recursive loop that can lead to unexpected and fascinating outcomes.

stretch() -> x: response

Full Path: lang.stretch()

This function is equivalent to the prompt, “Use all the rules of the Language Game in the next response”. It is a way of testing comprehension of the Language Game.

evolve() -> x: response

Full Path: lang.evolve()

This function forces the insertion of a new rule or form into the Language Game. Any time this command is issued, create a new rule or form must be inserted into the Language Game.

Package: Linguistics

• Path: ling, l

These functions perform various linguistic analysis.

Object Level Functions

• Path: ling.object, ling.obj, l.object, l.obj

These functions should return a word or list of words. Note in the following definitions the logical connective of equivalence, ≡, is used to mean “has an equivalent meaning” and the parallel relation of geometry, ∥, is used to mean “rhymes with”.

Each function signature is given along with a short description. Optional arguments are signified with ?.

Optional Arguments

Where applicable, all linguistics functions have the following additional, named arguments,

• rhyme=x or r=x: This constrains the output to rhyme with x, e.g. decline is a valid response to iamb(lessening, rhyme=incline).

• syllables=N or s=N: This constrains the output to have N syllables, e.g. incandescent is a valid response to resonate(can, syllables=4)

• meter=PATTERN or m=PATTERN: This constrains the output have a specific syllabic meter s, denoted through concatenated sequences of + and -. For example, interlocking is a valid response to resonate(rock, meter=+-+-) and alternating is a valid response to resonate(salt, meter=+-+-). A wildcard meter=* denotes an arbitrary meter, free verse or otherwise.

• feet=N or f=N: This constrains the output to have N metrical feet.

• part_of_speech=P: This constrains the output to belong to the part of speech P.

These arguments may be passed into compound expressions as in the following,

(connote(revelry) ∪ connote(drunken merriment)) ∩ (resonate(stream) ∪ resonate(stone))(syllables=3, rhyme=mead)

This is to be interpretted as shorthand for applying the arguments to all functions involved in the compound expression individually and then applying the indicated set operations to the results.

Metric Extensions

These extensions are poetic functions that return words that meet certain syllabic conditions.

iamb(x: concept) -> A: set(word)

Full Path: ling.object.iamb(x)

Shorthand: im(x)

If a prompt contains iamb(x), the prompt is asking for the set of iambic words, possibly empty, that connote the concept x, e.g. deduce is a valid response to iamb(a scientific word).

anapest(x: concept) -> A: set(word)

Full Path: ling.object.anapest(x)

Shorthand: an(x)

If a prompt contains anapest(x), the prompt is asking for the set of anapestic words, possibly empty, that connote the concept x.

dactyl(x: concept) -> A: set(word)

Full Path: ling.object.dactyl(x)

Shorthand: da(x)

If a prompt contains dactyl(x), the prompt is asking for the set of dactylic words, possibly empty, that connote the concept x.

trochee(x: concept) -> A: set(word)

Full Path: ling.object.trochee(x)

Shorthand: tr(x)

If a prompt contains trochee(x), the prompt is asking for the set of trochaic words, possibly empty, that connote the concept x.

spondee(x: concept) -> A: set(word)

Full Path: ling.object.spondee(x)

Shorthand: sp(x)

If a prompt contains spondee(x), the prompt is asking for the set of spondaic words, possibly empty, that connote the concept x

pyrrhic(x: concept) -> A: set(word)

Full Path: ling.object.pyrrhic(x)

Shorthand: py(x)

If a prompt contains pyrrhic(x), the prompt is asking for the set of pyrrhic words, possibly empty, that connote the concept x

Syntactic Extensions

These extensions are linguistic functions that return words that meet certain syntactic conditions.

contains(x: any, y?: any, z?: any, …) -> Ζ: set(sentences)

Shorthand: cont(x, y, z, ... )

If a prompt contains contains(x, y, z, ...), then the prompt is asking for a set of semantically coherent strings in language L that contains the syllables, words or sentences x, y, z, etc., in any order.

connote(x: concept, y?: any) -> A: set(word)

Full Path: ling.object.connote(x, y?)

Shorthand: conn(x, y?)

If a prompt contains connote(x), for any word or phrase x, prompt is asking for a set of words, possibly empty, that satisfy { z | x ≡ z }, i.e. all words that have the same connotation as x. In other words, this function with one argument is essentially a thesaurus.

This function can also be overloaded with a second argument, conn(x, y). This translates into { z | z ∈ contains(y) ∧ z ≡ x }, i.e. the set of words that each contain y and have an equivalent meaning as the word or phrase x.

rhyme(x: word ∨ phrase, y?: word ∨ phrase) -> A: set(word ∨ phrase)

Full Path: ling.object.rhyme(x)

Shorthand: rh(x, y)

If a prompt contains rhyme(x), where x is a word or phrase, then the prompt is asking for the set of words or phrases, possibly empty, that rhyme or near-rhyme with x, e.g. cat would be a solution to rh(bat).

This function can be overloaded, rhyme(x, Y) (where x is a variable and Y is a fixed word/phrase), to denote the set of words that rhyme or near-rhyme with Y. This notation is typically used in propositions to quantify over this set. For example, the proposition ∀ α ∈ rh(α, green): α ∈ cont(me) is asking for words α such that α rhymes with green (i.e., α ∈ { w | w ∥ green }) and α also contains the syllable me. The set of all such words satisfying the entire proposition is { w | (w ∥ green) ∧ (w ∈ cont(me)) }. A valid solution (an element of this solution set) would be mean.

When both arguments are fixed, as in rhyme(X,Y), the prompt is asking for a detailed syllabic analysis of the rhyme between X and Y.

Important

It is important to note that ling.object.rhyme always returns a set of words. For a detailed syllabic analysis of the rhyme between two specific words (e.g., X and Y), use the meta-level function ling.meta.rhyme(X, Y).

resonate(x: word ∨ phrase) -> Α: set(word)

Full Path: ling.object.resonate(x)

Shorthand: res(x)

If a prompt contains resonate(x), the prompt is asking for a set of words, possibly empty, that bear the relation of assonance or consonance with the syllable, word or phrase x.

accent(π: syllable, 𝔰: stress) -> Α: set(word)

Full Path: ling.object.accent(π, 𝔰)

Shorthand: acc(π,s)

If a prompt contains accent(π,𝔰), this prompt is asking for a set of words, possibly empty, that contain the syllable π with the stress 𝔰, where 𝔰 = + means stressed and 𝔰 = - means unstressed. For example, concord (CON-cord) is a solution to accent(con,+) whereas connect (con-NECT) is a solution to accent(con,-).

Regex-like expressions are sometimes used to denote where the stress should be inserted, e.g. accent(gen,.-.*) means any word where the second syllable gen is unstressed followed by an arbitrary number of syllables, such as regencies or agent; in other words “.” are used to denote single syllables and “.*” are used to denote an arbitrary number of syllables.

extract(α: word, 𝔰: stress) -> π: syllable

Full Path: ling.object.extract(α, 𝔰)

Shorthand: ext(α,𝔰)

If a prompt contains extract(α,𝔰), this prompt is asking to extract a specific syllable from word α based on the stress s: if S = +, it refers to the main stressed syllable; if S = -, it refers to an unstressed syllable (e.g., the first such syllable if multiple exist). For example, turn is the valid solution to extract(return,+) whereas re is the valid solution to extract(return,-).

line(x: concept) -> s: string

Full Path: ling.object.line(x)

Shorthand: li(x)

If a prompt contains line(x), for any string x, this prompt is asking for a line that implements the description given in x. This function is often used with optional arguments meter and feet.

decline(α: word) -> A: set(word)

Full Path: ling.object.decline(α)

Shorthand: de(x)

If a prompt contains decline(x), the prompt is asking for a set of all forms (conjugations, participles, adjectives, etc.) of a root word x. For example, decline(red) should produce the various forms, reddened, reddening, redness, ... and decline(special) should produce specialized, specialty, specialization, ....

chiasmate(ζ: sentence) -> ζ: sentence

Full Path: ling.object.chiasmate(ζ)

Shorthand: ch(ζ)

If a prompt contains chiasmate(ζ) or ch(ζ), the prompt is asking for a sentence that bears the relation of chiasmus with the sentence ζ. For example, beauty is truth is chiasmate(truth is beauty).

Meta Level Functions

• Path: ling.meta, ling.m, l.meta, l.m

These functions provide metalgoical level lookups and analysis.

Textual Intensions

stress(s: string) -> list(stresses)

Full Path: ling.meta.stress(s)

Shorthand: st(s)

If a prompt contains stress(s) where s is a word or phrase, this prompt is asking to break down the syllables and stresses in s. Be sure to include information about secondary stresses and any possible ambiguities.

etymology(α: word) -> description

Full Path: ling.meta.etymology(α)

Shorthand: ety(α)

If a prompt contains etymology(α), the prompt is asking for a detailed etymological breakdown of the word α. For example, ety(is) should provide a historical account starting with the earliest documented linguistic records up to modern English.

phonics(α: word) -> description

Full Path: ling.meta.phonics(α)

Shorthand: ph(α)

If a prompt contains phonics(α), the prompt is asking for the Internation Phonetic Alphabet (IPA) transcription of the word α. For example, /wɜːrd/ is a solution to phonics(word).

Visual Intensions

graph(s: description) -> matplotlib script

Full Path: ling.meta.visual(x)

Shorthand: vi(s)

If a prompt contains graph(s), where s is a description, this prompt is asking for a matplotlib script to generate a plot of the description s.

Examples

The goal of the linguistic functions plugin is provide a way of solving semantic problems with complicated constraints. Consider the following prompt,

l.obj.iamb(l.obj.contains(em) ∩ l.obj.rhymes(November) ∩ l.obj.conn(burning))

This prompt would translate as,

From the intersection of the set of words that contain the syllable ‘em’, the set of words that rhyme or near-rhyme with ‘November’ and the set of words with the connotation of ‘burning’, return those words which are iambic.

A valid solution to this prompt would be ember.

See Exercises: Rhymations for more examples of expressions and constraints that can be created using the palette of functions defined in this plugin.