Struct ShellNoun 

pub struct ShellNoun {
    pub lemma: String,
    pub class: ShellNounClass,
    pub determiner: Option<String>,
    pub start: usize,
    pub end: usize,
    pub full_text: Option<String>,
}

A shell noun that can refer to abstract antecedents.

Shell nouns are abstract nouns like “problem”, “issue”, “fact” that serve as “conceptual shells” for complex information.

Research Background

Schmid (2000) identified ~670 shell nouns in English, organized into six semantic classes: factual, linguistic, mental, modal, eventive, circumstantial.

Example

use anno::discourse::{ShellNoun, ShellNounClass};

let shell = ShellNoun::new("problem", ShellNounClass::Factual)
    .with_determiner("this")
    .at_span(32, 44);

assert!(shell.is_demonstrative());

Fields

lemma: String

The shell noun lemma (e.g., “problem”, “issue”, “fact”)

class: ShellNounClass

Semantic class of this shell noun

determiner: Option<String>

The determiner used (e.g., “this”, “the”, “such”)

start: usize

Start character offset

end: usize

End character offset

full_text: Option<String>

The full NP text (e.g., “this problem”)

Implementations

impl ShellNoun

pub fn new(lemma: impl Into<String>, class: ShellNounClass) -> ShellNoun

Create a new shell noun.

pub fn with_determiner(self, det: impl Into<String>) -> ShellNoun

Set the determiner.

pub fn at_span(self, start: usize, end: usize) -> ShellNoun

Set the span.

pub fn with_full_text(self, text: impl Into<String>) -> ShellNoun

Set full text.

pub fn is_demonstrative(&self) -> bool

Is this a demonstrative shell noun (e.g., “this problem”)?

pub fn typical_antecedent_types(&self) -> &[ReferentType]

Get the typical antecedent types for this shell noun.

Trait Implementations

impl Clone for ShellNoun

fn clone(&self) -> ShellNoun

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShellNoun

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShellNoun

fn deserialize<__D>( __deserializer: __D, ) -> Result<ShellNoun, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ShellNoun

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.