• Check a poem against one of the built-in poetic forms (Using an iPoe Language).

• Define a new poetic form (Defining a new iPoe Language).

• Add basic English-language processing to a Racket program (iPoe API).

• The #lang line declares a poetic form. Poetic forms can specify the number of lines, number of stanzas, rhyme scheme, and number of syllables in the following text. See Defining a new iPoe Language for more details.

• ipoe checks the internet to get the spelling, number of syllables, and rhymes for a given word. If you have an ipoe database, it stores this information. Otherwise, the data for words is cached locally (in ./compiled/ipoe.cache).

• Poems can start with a few keyword/value pairs to alter the poem-checker.

How much license? I don’t know. How much does it cost to break a rule? I don’t know, but I tried to set good defaults. Have fun with this until we have something better.

• The #:name statement must appear once. This statement declares the name of the poetic form (currently only used for debugging).

• The #:description statement may appear at most once; it gives a brief description of the poetic form (for debugging).

• The #:syllables statement may appear at most once. When #:syllables N is given, any wildcard syllables in the ‹rhyme-scheme› (implicit or explicit) are replaced with N.

• The #:rhyme-scheme statement may appear at most once. A ‹rhyme-scheme› specifies:

  • the number of stanzas in the poetic form,

  • the number of lines in each stanza,

  • the number of syllables in each line, and

  • which lines must rhyme with one another.

  An empty rhyme scheme allows any number of stanzas. A ‹line-scheme› that omits the ‹rhyme› or ‹syllable› component has an implicit wildcard in that component. A ‹rhyme› can be any symbol; lines that must rhyme must have equal symbols (in the sense of eq?).

• The #:constraint statement may appear any number of times. Each statement may contain arbitrary expressions using (most!) identifiers from the racket/base and ipoe/poetic-form namespaces.

1. Install the gnal-lang package.

2. Create a directory my-form/ and a sub-directory my-form/lang/.

3. Save your program as my-form/lang/reader.rkt.

1. Create the my-form/lang/ directory and save the ipoe program as my-form/lang/reader.rkt.

2. Run raco pkg install ./my-form.

3. Write programs that start with #lang my-form.

#lang ipoe

#:name haiku

#:rhyme-scheme {[5 7 5]}

#:description

"1 stanza, 3 lines

No rhyme constraints

5 syllables in first line

7 in second

5 in last"

#lang ipoe

#:name couplet

#:rhyme-scheme {[A A]}

#lang ipoe

#:name english-sonnet

#:syllables 10

#:rhyme-scheme {[A B A B]

[C D C D]

[E F E F]

[G G]}

#lang ipoe

#:name villanelle

#:rhyme-scheme {[R1 B R2]

[A  B R1]

[A  B R2]

[A  B R1]

[A  B R2]

[A  B R1 R2]}

#:syllables 10

#:constraint

(line=? (line 0 (stanza 0))

(line 2 (stanza 1))

(line 2 (stanza 3))

(line 2 (stanza 5)))

#:constraint

(line=? (line 2 (stanza 0))

(line 2 (stanza 2))

(line 2 (stanza 4))

(line 3 (stanza 5)))

procedure (infer-rhyme=? str1 str2) → boolean?

str1 : string?

str2 : string?

> (infer-rhyme=? "cat" "hat")

#t

> (infer-rhyme=? "sauce" "boss")

#f

> (infer-rhyme=? "books" "carrots")

#t

procedure (infer-syllables str) → exact-nonnegative-integer?

str : string?

> (infer-syllables "month")

1

> (infer-syllables "hour")

2

> (infer-syllables "munificent")

4

procedure (integer->word* i) → (listof string?)

i : exact-integer?

> (integer->word* 2)

'("two")

> (integer->word* -21)

'("negative" "twenty" "one")

procedure (integer->word/space i) → string?

i : exact-integer?

(string-join (integer->word* i) " ")

procedure (suggest-spelling   str            [ #:max-distance d             #:limit n])   →   (listof string?)

str : string?

d : exact-nonnegative-integer? = 2

n : exact-nonnegative-integer? = 10

> (suggest-spelling "tpyo")

'("to" "two" "try" "too" "toy" "pro" "spy")

> (suggest-spelling "balon" #:limit 3)

'("along" "alone" "below")

procedure (poem? x) → boolean?

x : any/c

procedure (stanza? x) → boolean?

x : any/c

procedure (line? x) → boolean?

x : any/c

procedure (word? x) → boolean?

x : any/c

procedure (stanza i [p]) → stanza?

i : integer?

p : poem? = (*current-poem*)

procedure (line i st) → line?

i : exact-nonnegative-integer?

st : stanza?

procedure (word i ln) → word?

i : exact-nonnegative-integer?

ln : line?

procedure (line=? ln1 ln2) → boolean?

ln1 : line?

ln2 : line?

procedure (word=? w1 w2) → boolean?

w1 : word?

w2 : word?

procedure (line->word* ln) → (sequence/c word?)

ln : line?

procedure (poem->stanza* p) → (sequence/c stanza?)

p : poem?

procedure (poem->word* p) → (sequence/c word?)

p : poem?

procedure (stanza->line* st) → (sequence/c line?)

st : stanza?

procedure (poem-count-stanza* p) → exact-nonnegative-integer?

p : poem?

procedure (stanza-count-line* st) → exact-nonnegative-integer?

st : stanza?

procedure (last-word ln) → word?

ln : line?

procedure (last-stanza [poem]) → stanza?

poem : poem? = *current-poem*

procedure (contains-word? ln w) → boolean?

ln : line?

w : word?

parameter (*current-poem*) → (or/c poem? #f)

(*current-poem* p) → void?

p : (or/c poem? #f)

=  #f

procedure (scrape-word str) → (or/c word-result? #f)

str : string?

procedure (word-result? x) → boolean?

x : any/c

procedure (word-scraper? x) → boolean?

x : any/c

procedure (make-word-scraper   sym       #:word->url word->url       #:sxml->definition sxml->defn       #:sxml->num-syllables sxml->syll       #:sxml->word sxml->word)

→ (-> string? (or/c word-result? #f))

sym : symbol?

word->url : (-> string? string?)

sxml->defn : (-> sxml (or/c string? #f))

sxml->syll : (-> sxml (or/c exact-nonnegative-integer? #f))

sxml->word : (-> sxml (or/c string? #f))

• sym briefly describes the resource being scraped.

• word->url converts a word to a URL for a web page that may have information about the word.

• sxml->defn parses an sxml page for the definition of a word.

• sxml->syll parses an sxml page for the number of syllables in a word.

• sxml->word parses an sxml page for the word the page describes.

value dictionary.com : word-scraper?

value american-heritage : word-scraper?

value merriam-webster : word-scraper?

value the-free-dictionary : word-scraper?

procedure (scrape-rhyme str) → rhyme-result?

str : string?

procedure (rhyme-result? x) → boolean?

x : any/c

procedure (almost-rhymes? rr str) → boolean?

rr : rhyme-result?

str : string?

procedure (rhymes? rr str) → boolean?

rr : rhyme-result?

str : string?

procedure (url->sxml url) → sxml:top?

url : (or/c url? string?)

procedure (sxml-200? sx) → boolean?

sx : sxml:top?

procedure (id? id-str) → (-> (listof sxml) any/c (listof sxml))

id-str : string?

> ((sxpath `(// div ,(id? "foo") *text*))    '(div       (div (@ id "foo") "foo-text")       (div (@ id "bar") "bar-text")))

'()

procedure (class? class-str [<?]) → (-> (listof sxml) any/c (listof sxml))

class-str : string?

<? : (-> string? string? boolean?) = string=?

> ((sxpath `(// div ,(class? "a" string-prefix?) *text*))    '(div       (div (@ class "abc") "success")       (div (@ class "def") "failure")))

'()

procedure (contains-text? pattern)

→ (-> (listof sxml) any/c (listof sxml))

pattern : regexp?

value scrape-logger : logger?