Struct DiscourseScope 

pub struct DiscourseScope {
    pub sentence_boundaries: Vec<usize>,
    pub clause_boundaries: Vec<usize>,
    /* private fields */
}

A simple clause/sentence boundary detector for discourse scope analysis.

Why Bounded Context?

Abstract anaphora resolution requires finding antecedents in preceding discourse. But how far back should we look?

Empirical finding: Window size n=2-3 preceding clauses outperforms max-length concatenation by ~6% F1. Larger windows add noise without improving recall. This motivates bounded preceding_clauses(offset, n).

Antecedent Distance Distribution

For abstract anaphora, the antecedent is typically:

• Immediately preceding clause (~60%): “X happened. This…”
• Same sentence, different clause (~20%): “When X, this…”
• Previous sentence (~15%): “X. Y. This…”
• 2+ sentences back (~5%): Rare, usually with explicit markers

Theoretical Background (Dalrymple et al. 1991)

The equational view frames resolution as finding P such that P(parallel_elements) = source_interpretation. Crucially, parallelism need not be purely syntactic—semantic and pragmatic parallelism also license resolution (Section 5.1).

This means:

1. Syntactic distance isn’t the only constraint
2. Active/passive, logical subjects, and pragmatic factors affect parallelism
3. The candidate_antecedent_spans method returns spans in preference order, but semantic parallelism must be checked by higher-level resolution logic

Example

use anno::discourse::DiscourseScope;

let text = "Russia invaded Ukraine in 2022. This caused inflation. It affected everyone.";
let scope = DiscourseScope::analyze(text);

// For "This" at position 32, the immediately preceding clause is preferred
let candidates = scope.preceding_clauses(32, 2);
// Returns spans for "Russia invaded Ukraine in 2022" and potentially more

Character vs Byte Offsets

All offsets in DiscourseScope are character offsets, not byte offsets. This is critical for Unicode text where characters may be multi-byte:

use anno::discourse::DiscourseScope;

let text = "日本語。英語。"; // Japanese with periods
let scope = DiscourseScope::analyze(text);

// Character-based: each kanji is 1 character (but 3 bytes)
assert!(scope.sentence_count() >= 1);

Use extract_span to safely extract text from character offsets.

Fields

sentence_boundaries: Vec<usize>

Sentence boundaries (character offsets, NOT byte offsets)

clause_boundaries: Vec<usize>

Clause boundaries (character offsets, more fine-grained)

Implementations

impl DiscourseScope

pub fn analyze(text: &str) -> DiscourseScope

Analyze text for discourse boundaries.

Example

use anno::discourse::DiscourseScope;

let text = "Russia invaded Ukraine. This caused inflation.";
let scope = DiscourseScope::analyze(text);

assert_eq!(scope.sentence_count(), 2);

pub fn sentence_count(&self) -> usize

Number of sentences detected.

pub fn clause_count(&self) -> usize

Number of clauses detected.

pub fn sentence_at(&self, offset: usize) -> Option<(usize, usize)>

Get the sentence containing a character offset.

pub fn clause_at(&self, offset: usize) -> Option<(usize, usize)>

Get the clause containing a character offset.

pub fn preceding_clauses(&self, offset: usize, n: usize) -> Vec<(usize, usize)>

Get the N preceding clauses from an offset.

pub fn extract_span<'a>( &self, text: &'a str, start: usize, end: usize, ) -> &'a str

Get text for a span (character offsets).

Converts character offsets to byte offsets for safe extraction.

Arguments

• text - The original text (must match the text passed to analyze)
• start - Start character offset (inclusive)
• end - End character offset (exclusive)

Example

use anno::discourse::DiscourseScope;

let text = "日本語。英語。";
let scope = DiscourseScope::analyze(text);

// Extract first sentence (chars 0-4 = "日本語。")
if let Some((start, end)) = scope.sentence_at(0) {
    let extracted = scope.extract_span(text, start, end);
    assert!(!extracted.is_empty());
}

pub fn candidate_antecedent_spans( &self, anaphor_offset: usize, ) -> Vec<(usize, usize)>

For an anaphor at a given offset, find candidate antecedent spans.

Returns spans in order of preference (nearest first).

Trait Implementations

impl Clone for DiscourseScope

fn clone(&self) -> DiscourseScope

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DiscourseScope

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.