Short form of a Cite2Urn containing only collection and object ID.

Value for CexTrait

Citable analysis of a string value.

An Analysis has seven members: string values for the orthographic token and the morphological token, four abbreviated URNs, one each for the lexeme, form, rule and stem, and a sequence ID for the morphological token.

Define CexTrait for Analysis type.

Morphological analyses for a token identified by CTS URN.

A collection of analyzed tokens.

Value for CexTrait for AnalyzedToken

Value for CitableTrait.

Value for CitableTrait.

A parser parsing tokens by looking them up in a precomputed data frame of all recognized forms.

Create a dataframe-backed parser from a string-backed parser.

DFParser(sp)

Serializable trait for DF Parser.

Abbreviated URN for a morphological form.

POS tagger keyed to the text of the Gettysburg address. data is a dictionary of tokens to form POS tag.

Abbreviated URN for a lexeme.

Supertype of all concrete Rule structures.

Abbreviated URN for rule.

Supertype of all concrete Stem structures.

Abbreviated URN for a morphological stem.

A parser parsing tokens by looking them up in a precomputed dictionary of all recognized forms.

Construct a string-backed parser from a dataframe-backed parser.

StringParser(dfp; delim)

Override Base.== for Analysis.

==(a1, a2)

Override Base.== for AnalyzedToken.

==(atoken1, atoken2)

Override Base.== for AnalyzedTokenCollection.

==(at1, at2)

Override Base.== for AbbreviatedUrn.

==(au1, au2)

Implement base element type for AnalyzedTokenCollection.

eltype(atc)

Implement iteration with state for AnalyzedTokenCollection.

iterate(atc, state)

Implement iteration for AnalyzedTokenCollection.

iterate(atc)

Default implementation of function to find the object identifier of AbbreviatedUrn.

objectid(au)

Override Base.show for AnalyzedTokenCollection.

show(io, atc)

Override Base.show for AnalyzedToken.

show(io, atoken)

Override Base.show for AbbreviatedUrn.

show(io, au)

Implementation of cex function for an Analysis.

cex(a; delim, registry)

Format an AnalyzedTokenCollection collection as a delimited-text string.

cex(atc; delimiter, registry)

Required function for Citable abstraction.

Serialize an AnalyzedToken as delimited text (required for Citable interface).

cex(at; delimiter, registry)

Uses abbreviated URNs. These can be expanded to full CITE2 URNs when read back with a URN registry, or the delimited function can be used with a URN registry to write full CITE2 URNs.

Compose delimited text string for a DFParser.

cex(dfp; delimiter)

DefineCexTrait value for AnalyzedTokenCollection.

cextrait(_)

DefineCexTrait value for CitableToken.

cextrait(_)

Get serializable trait for DFParser type.

cextrait(_)

DefineCitableTrait value for AnalyzedTokenCollection.

citablecollectiontrait(_)

DefineCitableTrait value for CitableToken.

citabletrait(_)

Parse a delimited-text string into an AnalyzedTokenCollection collection.

fromcex(trait, s, ; delimiter, configuration, strict)

Implementation of fromcex function for an Analysis.

fromcex(
    traitvalue,
    cexsrc,
    T;
    delimiter,
    configuration,
    strict
)

Parse a one-line delimited-text representation into an AnalyzedToken, using abbreviated URNs for identifiers. Note that for a sigle CEX line, the AnalyzedToken will have a single Analysis in its vector of analyses.

fromcex(
    traitvalue,
    cexsrc,
    T;
    delimiter,
    configuration,
    strict
)

Create a DFParser from a delimited-text source.

fromcex(trait, cexsrc, T; delimiter, configuration, strict)

Label for analyses.

label(atc)

Required function for Citable abstraction.

Label for AnalyzedToken (required for Citable interface).

label(at)

Unique identifier for AnalyzedToken (required for Citable interface).

urn(at)

Typeof URN identifying analyses in an an AnalyzedTokenCollection collection.

urntype(analyses)

Required function for Citable abstraction.

Identify URN type for an AnalyzedToken as CtsUrn.

urntype(at)

Required function for Citable abstraction.

Get URN for analysis.

text(at)

Constructs an AbbreviatedUrn string from a Cite2Urn.

abbreviate(urn)

Example:

julia> abbreviate(Cite2Urn("urn:cite2:kanones:lsj.v1:n123"))
"lsj.n123"

Example: a pipeline abbreviating a Cite2Urn and forming a LexemeUrn from the abbreviated string value.

julia> Cite2Urn("urn:cite2:kanones:lsj.v1:n123") |> abbreviate |> LexemeUrn
LexemeUrn("lsj", "n123")

Default implementation of function to find the collection value of an AbbreviatedUrn.

collection(au)

Compute pct of words in list of words analyzed by parser.

coverage(vocablist, p; data)

Compute pct of tokens in corpus analyzed by parser.

coverage(tokencorpus, p; data)

Get citable token for analysis.

ctoken(at)

Get DataFrame object backing the dataframe parser.

datasource(dfp)

Create a DFParser from delimited text file.

dfParser(delimitedfile; ...)
dfParser(delimitedfile, ortho; delimiter)

Constructs a Cite2Urn from an AbbreviatedUrn and a dictionary mapping collection identifiers in AbbreviatedUrns's to full Cite2Urns for a versioned collection.

Flatten a Vector of AnalyzedTokens into passage+anlaysis pairs.

flatpairs(v)

Compute morphological ambiguity in list of words analyzed by parser.

formal_ambiguity(vocablist, p; data)

Compute morphological ambiguity in corpus analyzed by parser.

formal_ambiguity(c, p; data)

Compute frequencies of forms in corpus analyzed by parser.

formal_frequencies(c, p; data)

True if atkn can be analyzed to more than one form.

formally_ambiguous(atkn)

True if Analysis items in a vector of analyses identify more than one form.

formally_ambiguous(vect)

Extract a list of forms from a Vector of Analysis objects.

forms(v)

Extract a list of forms from a Vector of AnalyzedToken objects.

forms(v)

Extract a list of forms from an AnalyzedTokenCollection object.

forms(atokens)

Identify morphlogical form identifed in analysis.

formurn(a)

Compose SFST representation of an AbbreviatedUrn.

fstsafe(au)

Example:

julia> LexemeUrn("lexicon.lex123") |> fstsafe
"<u>lexicon\.lex123</u>"

Generate all possible morphological analyses for a given lexeme and form.

generate(lex, mform, parser)

Generate all possible morphological analyses for a given lexeme and form.

generate(lex, mform, parser; delim)

Catch failure to implement generate function for a subtype of CitableParser.

generate(lex, mform, p)

Instatiate GettysburgParser as a dfParser from a local file source.

gettysburgParser(repo; delimiter)

Instantiate a GettysburgParser as a dfParser by downloading source dictionary over the internet.

Function required to get ID value of a Rule implementation.

Function required to get ID value of a Stem implementation.

Function required to get string value for inflection class of a Rule implementation.

Function required to get string value for inflection class of a Stem implementation.

Function required to get lexeme value of a Stem implementation.

From a vector of AnalyzedTokens and an index of tokens in a corpus, construct a dictionary keyed by lexemes, mapping to a further dictionary of surface forms to passages.

lexemedictionary(parses, tokenindex)

Compute histogram of lexemes in AnalyzedTokenCollection.

lexemehisto(parses)

All distinct lexemes for a token are counted; there is no weighting of counts for lexically ambiguous tokens.

Extract a list of lexemes from a Vector of Analysis objects.

lexemes(v)

Extract a list of lexemes from a Vector of AnalyzedToken objects.

lexemes(v)

Extract a list of lexemes from an AnalyzedTokenCollection object.

lexemes(atokens)

Identify lexeme identifed in analysis.

lexemeurn(a)

Compute lexical ambiguity in list of words analyzed by parser.

lexical_ambiguity(vocablist, p; data)

Compute lexical ambiguity in corpus analyzed by parser.

lexical_ambiguity(c, p; data)

Compute frequencies of lexemes in corpus analyzed by parser.

lexical_frequencies(c, p; data)

True if atkn can be analyzed to more than one lexeme.

lexically_ambiguous(atkn)

True if Analysis items in a vector of analyses identify more than one lexeme.

lexically_ambiguous(vect)

Identify morphologocal token identified in analysis.

mtoken(a)

Identify morphological token identified in analysis.

mtokenid(a)

True if any element in stringlist is empty.

Get orthographic system for a dataframe parser.

orthography(dfp)

Catch failure to implement orthography function for a subtype of CitableParser.

orthography(p)

Use a CitableParser to parse a CitableTextCorpus with each citable node containing containg a single token of type LexicalToken.

parsecorpus(c, p; data, countinterval)

Returns anAnalyzedTokenCollection object.

Parse a list of tokens with a CitableParser.

parselist(vocablist, p; countinterval)

Returns a Dict mapping strings to a (possibly empty) vector of Analysis objects. Blank lines in input are silently ignored.

Read a list of tokens from file f and parse with p.

parselist(f, p, reader; countinterval)

Returns a Dict mapping strings to a (possibly empty) vector of Analysis objects.

Read a list of tokens from URL u and parse with p.

parselist(u, p, reader; countinterval)

Returns a Dict mapping strings to a (possibly empty) vector of Analysis objects.

Parse a CitablePassage with text for a single token with a CitableParser.

parsepassage(cn, p; data)

Returns a single AnalyzedToken.

Parse a CitablePassage with text for a single token with a CitableParser.

parsepassage(ct, p; data)

Returns a single AnalyzedToken.

Parse a single token using parser.

parsetoken(s, parser)

Find URNs for all tokens in a vector of AnalyzedTokens parsed to a given lexeme.

passagesforlexeme(v, lexstr)

Escape characters reserved for SFST syntax.

protectreserved(s)

Read SFST output from file f, and parse into a dictionary keying tokens to a (possibly empty) array of SFST strings.

readfst(f)

Compose a CEX relationset block for a set of analyses.

relationsblock(urn, label, v; ...)
relationsblock(urn, label, v, delim; registry)

Extract a list of rules from a Vector of Analysis objects.

rules(v)

Extract a list of rules from a Vector of AnalyzedToken objects.

rules(v)

Extract a list of rules from an AnalyzedTokenCollection object.

rules(atokens)

Identify inflectional rule identifed in analysis.

ruleurn(a)

Extract a list of stems from a Vector of Analysis objects.

stems(v)

Extract a list of stems from a Vector of AnalyzedToken objects.

stems(v)

Extract a list of stems from an AnalyzedTokenCollection object.

stems(atokens)

Identify lexical stem identifed in analysis.

stemurn(a)

Construct a string-backed parser from a dataframe.

stringParser(df)
stringParser(df, ortho)
stringParser(df, ortho, delim)

Instantiate a StringParser from a set of analyses read from a file.

stringParser(f, freader; o, delim)

Instantiate a StringParser from a set of analyses read from a string.

stringParser(s, freader; ortho, delim)

Instantiate a StringParser from a set of analyses read from a URL.

stringParser(u, ureader; o, delim)

Find token string values for all tokens in a vector of AnalyzedTokens parsed to a given lexeme.

stringsforlexeme(v, lexstr)

Write dataframe parser to a delimited file.

tofile(dfp, outfile; delimiter)

Identify orthographic token analyzed.

token(a)

Extract a list of string token values from a Vector of Analysis objects.

tokens(v)

Extract a list of string token values from a Vector of AnalyzedToken objects.

tokens(v)

Extract a list of string token values from an AnalyzedTokenCollection object.

tokens(atokens)