Sentence

Instance Constructors

new Sentence(words: Seq[Word])

words
문장에 포함되는 어절의 나열.

Type Members

type Self = Iterable[Word]

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(s: Sentence): Sentence

문장을 이어붙여, 새로운 문장을 생성함.
문장을 이어붙여, 새로운 문장을 생성함.
s
이어붙일 다른 문장 Sentence 객체
returns
문장이 이어붙여진 새로운 Sentence 객체
def ++[B >: Word, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: Word, That](that: Traversable[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike
def ++:[B >: Word, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike
def /:[B](z: B)(op: (B, Word) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (Word, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, Word) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def apply(index: Int): Option[Word]

주어진 위치의 어절을 반환.
주어진 위치의 어절을 반환. Option[Word] 객체.
index
어절의 위치.
returns
어절이 있다면, Some(어절)을, 없다면 None.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(that: Any): Boolean

Definition Classes
IterableLike → Equals
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B, That](pf: PartialFunction[Word, B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[Word, B]): Option[B]

Definition Classes
TraversableOnce
def companion: GenericCompanion[Iterable]

Definition Classes
Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate
def concat(s: Sentence): Sentence

문장을 이어붙여, 새로운 문장을 생성함.
문장을 이어붙여, 새로운 문장을 생성함.
s
이어붙일 다른 문장 Sentence 객체
returns
문장이 이어붙여진 새로운 Sentence 객체
def copyToArray[B >: Word](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: Word](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: Word](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: Word](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: (Word) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def drop(n: Int): Iterable[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def dropRight(n: Int): Iterable[Word]

Definition Classes
IterableLike
def dropWhile(p: (Word) ⇒ Boolean): Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(p: (Word) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def existsMorpheme(tag: String): Boolean

주어진 품사를 갖는 형태소가 존재하는지 확인.
주어진 품사를 갖는 형태소가 존재하는지 확인.
예를 들어, N은 체언인지 확인하고, NP는 대명사인지 확인. 품사 표기는 여기 에서 확인
tag
확인할 통합 품사 표기
returns
True: 존재하는 경우.
def filter(p: (Word) ⇒ Boolean): Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (Word) ⇒ Boolean): Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (Word) ⇒ Boolean): Option[Word]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap[B, That](f: (Word) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: (Word) ⇒ GenTraversableOnce[B]): Iterable[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: Word](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, Word) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (Word, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall(p: (Word) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: (Word) ⇒ U): Unit

Definition Classes
IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def genericBuilder[B]: Builder[B, Iterable[B]]

Definition Classes
GenericTraversableTemplate
final def get(index: Int): Word

주어진 위치의 어절을 반환.
주어진 위치의 어절을 반환. Word 객체.
index
어절의 위치.
returns
어절이 있다면, 어절을, 없다면 Exception.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (Word) ⇒ K): Map[K, Iterable[Word]]

Definition Classes
TraversableLike → GenTraversableLike
def grouped(size: Int): Iterator[Iterable[Word]]

Definition Classes
IterableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
AnyRef → Any
final def head: Word

문장의 첫 어절
문장의 첫 어절
returns
문장의 첫 어절인 Word 객체.

Definition Classes
Sentence → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike
def headOption: Option[Word]

Definition Classes
TraversableLike → GenTraversableLike
final def indexOf(word: Word): Int

주어진 어절의 위치를 찾는다.
주어진 어절의 위치를 찾는다.
word
위치를 확인할 어절
returns
어절의 위치.
def init: Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[Iterable[Word]]

Definition Classes
TraversableLike
def isEmpty: Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def iterator: Iterator[Word]

어절을 문장의 순서대로 순회하는 iterator.
어절을 문장의 순서대로 순회하는 iterator.
returns
어절 순회 Iterator.

Definition Classes
Sentence → IterableLike → GenIterableLike
def jIterator: Iterator[Word]

(Java) 어절을 문장의 순서대로 순회하는 iterator.
(Java) 어절을 문장의 순서대로 순회하는 iterator.
returns
어절 순회 Iterator.
final def jModifiers: List[Word]

(Java) 수식언^{관형사, 부사}을 포함하는 어절들
(Java) 수식언^{관형사, 부사}을 포함하는 어절들
returns
수식언을 포함하는 어절들의 Sequence
final def jNouns: List[Word]

(Java) 체언^{명사, 수사, 대명사}을 포함하는 어절들
(Java) 체언^{명사, 수사, 대명사}을 포함하는 어절들
returns
체언을 포함하는 어절들의 Sequence
def jTopLevels: List[Word]

(Java)의존 구문 분석 결과, 나타난 핵심어들.
final def jVerbs: List[Word]

(Java) 용언^{동사, 형용사}을 포함하는 어절들
(Java) 용언^{동사, 형용사}을 포함하는 어절들
returns
용언을 포함하는 어절들의 Sequence
def jWords: List[Word]

(Java) 어절 목록.
(Java) 어절 목록. java.util.List<Word>
returns
어절 목록.
final def last: Word

문장의 끝 어절
문장의 끝 어절
returns
문장의 끝 어절인 Word 객체.

Definition Classes
Sentence → TraversableLike → GenTraversableLike
def lastOption: Option[Word]

Definition Classes
TraversableLike → GenTraversableLike
def map[B, That](f: (Word) ⇒ B)(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
final def matches(tag: Seq[Seq[String]]): Boolean

주어진 품사 표기의 Sequence를 포함하는지 확인.
주어진 품사 표기의 Sequence를 포함하는지 확인.
Seq[Seq[POSTag] ]의 형태이며, 이는 품사가 어절을 구성하고^Seq[POSTag], 어절이 문장을 구성한 형태^{Seq[Seq[POSTag.Value] ]}를 따른 것임.
Sequence가 *연속되지 않더라도* 확인함. 즉, "나/NP는/JKS 밥/NNG을/JKO 먹/VV고/EC,"라는 문장구조가 있다면, Seq(Seq(POS.NP,POS.JKS),Seq(POS.VV))는 중간 어절에 대응하는 품사의 Sequence가 없지만, 순서는 포함되므로, true를 반환함.
tag
확인할 통합 품사 표기의 Sequence. Seq[Seq[POSTag] ] 객체.
returns
True: 존재하는 경우
final def matches(tag: Array[Array[String]]): Boolean

(Java) 주어진 품사 표기의 Sequence를 포함하는지 확인.
(Java) 주어진 품사 표기의 Sequence를 포함하는지 확인.
POS$.Value[][]의 형태이며, 이는 품사가 어절을 구성하고^POS$.Value[], 어절이 문장을 구성한 형태^{POS$.Value[][]}를 따른 것임.
Sequence가 *연속되지 않더라도* 확인함. 즉, "나/NP는/JKS 밥/NNG을/JKO 먹/VV고/EC,"라는 문장구조가 있다면, {{POSTag.NP,POSTag.JKS},{POSTag.VV}}는 중간 어절에 대응하는 품사의 Sequence가 없지만, 순서는 포함되므로, true를 반환함.
tag
확인할 통합 품사 표기의 Sequence. POS$.Value[][] 객체.
returns
True: 존재하는 경우
def max[B >: Word](implicit cmp: Ordering[B]): Word

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (Word) ⇒ B)(implicit cmp: Ordering[B]): Word

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: Word](implicit cmp: Ordering[B]): Word

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (Word) ⇒ B)(implicit cmp: Ordering[B]): Word

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def modifiers: Seq[Word]

수식언^{관형사, 부사}을 포함하는 어절들
수식언^{관형사, 부사}을 포함하는 어절들
returns
수식언을 포함하는 어절들의 Sequence
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[Word, Iterable[Word]]

Attributes
protected[this]
Definition Classes
GenericTraversableTemplate → HasNewBuilder
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def nouns: Seq[Word]

체언^{명사, 수사, 대명사}을 포함하는 어절들
체언^{명사, 수사, 대명사}을 포함하는 어절들
returns
체언을 포함하는 어절들의 Sequence
def par: ParIterable[Word]

Definition Classes
Parallelizable
def parCombiner: Combiner[Word, ParIterable[Word]]

Attributes
protected[this]
Definition Classes
TraversableLike → Parallelizable
def partition(p: (Word) ⇒ Boolean): (Iterable[Word], Iterable[Word])

Definition Classes
TraversableLike → GenTraversableLike
def product[B >: Word](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: Word](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: Word](op: (B, Word) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: Word](op: (B, Word) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: Word](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: Word](op: (Word, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: Word](op: (Word, B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr: Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
def reversed: List[Word]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements[B >: Word](that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan[B >: Word, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, Word) ⇒ B)(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (Word, B) ⇒ B)(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def seq: Iterable[Word]

Definition Classes
Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def singleLineString: String

품사분석 결과를, 1행짜리 String으로 변환.
품사분석 결과를, 1행짜리 String으로 변환.
returns
품사분석 결과를 담은 1행짜리 String.
final def size: Int

문장의 길이
문장의 길이
returns
문장의 길이

Definition Classes
Sentence → GenTraversableLike → TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Iterable[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding(size: Int, step: Int): Iterator[Iterable[Word]]

Definition Classes
IterableLike
def sliding(size: Int): Iterator[Iterable[Word]]

Definition Classes
IterableLike
def span(p: (Word) ⇒ Boolean): (Iterable[Word], Iterable[Word])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (Iterable[Word], Iterable[Word])

Definition Classes
TraversableLike → GenTraversableLike
def stringPrefix: String

Definition Classes
TraversableLike → GenTraversableLike
def sum[B >: Word](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def surfaceString(delimiter: String = " "): String

띄어쓰기 된 문장을 반환.
띄어쓰기 된 문장을 반환.
delimiter
어절 사이의 띄어쓰기 방식. 기본값 = 공백(" ")
returns
띄어쓰기 된 문장.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Iterable[Word]

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[Iterable[Word]]

Definition Classes
TraversableLike
def take(n: Int): Iterable[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight(n: Int): Iterable[Word]

Definition Classes
IterableLike
def takeWhile(p: (Word) ⇒ Boolean): Iterable[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection: Iterable[Word]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Word, Col[Word]]): Col[Word]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: Word](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: Word]: Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toCollection(repr: Iterable[Word]): Iterable[Word]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def toIndexedSeq: IndexedSeq[Word]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[Word]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator: Iterator[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toList: List[Word]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[Word, (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq: Seq[Word]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSet[B >: Word]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[Word]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
def toString(): String

구문분석과 품사분석의 결과를 String으로 변환.
구문분석과 품사분석의 결과를 String으로 변환.
returns
본 객체의 정보를 담은 String.

Definition Classes
Sentence → TraversableLike → AnyRef → Any
def toTraversable: Traversable[Word]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[Word]

Definition Classes
TraversableOnce → GenTraversableOnce
val topLevels: ArrayBuffer[Word]

의존 구문 분석 결과, 나타난 핵심어들.
def transpose[B](implicit asTraversable: (Word) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def treeString: String

의존구문분석트리를 String형태로 그립니다.
의존구문분석트리를 String형태로 그립니다.
returns
트리 String.
def unzip[A1, A2](implicit asPair: (Word) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: (Word) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

Definition Classes
GenericTraversableTemplate
final def verbs: Seq[Word]

용언^{동사, 형용사}을 포함하는 어절들
용언^{동사, 형용사}을 포함하는 어절들
returns
용언을 포함하는 어절들의 Sequence
def view(from: Int, until: Int): IterableView[Word, Iterable[Word]]

Definition Classes
IterableLike → TraversableLike
def view: IterableView[Word, Iterable[Word]]

Definition Classes
IterableLike → TraversableLike
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(p: (Word) ⇒ Boolean): FilterMonadic[Word, Iterable[Word]]

Definition Classes
TraversableLike → FilterMonadic
val words: Seq[Word]

문장에 포함되는 어절의 나열.
def zip[A1 >: Word, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Iterable[Word], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll[B, A1 >: Word, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Iterable[Word], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex[A1 >: Word, That](implicit bf: CanBuildFrom[Iterable[Word], (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike

Inherited from Iterable[Word]

Inherited from IterableLike[Word, Iterable[Word]]

Inherited from Equals

Inherited from GenIterable[Word]

Inherited from GenIterableLike[Word, Iterable[Word]]

Inherited from Traversable[Word]

Inherited from GenTraversable[Word]

Inherited from GenericTraversableTemplate[Word, Iterable]

Inherited from TraversableLike[Word, Iterable[Word]]

Inherited from GenTraversableLike[Word, Iterable[Word]]

Inherited from Parallelizable[Word, ParIterable[Word]]

Inherited from TraversableOnce[Word]

Inherited from GenTraversableOnce[Word]

Inherited from FilterMonadic[Word, Iterable[Word]]

Inherited from HasNewBuilder[Word, Iterable[kr.bydelta.koala.data.Word] @scala.annotation.unchecked.uncheckedVariance]

Inherited from AnyRef

Inherited from Any

Ungrouped

Related Doc: package data

class Sentence extends Iterable[Word]

Instance Constructors

new Sentence(words: Seq[Word])

Type Members

type Self = Iterable[Word]

class WithFilter extends FilterMonadic[A, Repr]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(s: Sentence): Sentence

def ++[B >: Word, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

def ++:[B >: Word, That](that: Traversable[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

def ++:[B >: Word, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

def /:[B](z: B)(op: (B, Word) ⇒ B): B

def :\[B](z: B)(op: (Word, B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, Word) ⇒ B, combop: (B, B) ⇒ B): B

final def apply(index: Int): Option[Word]

final def asInstanceOf[T0]: T0

def canEqual(that: Any): Boolean

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[Word, B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

def collectFirst[B](pf: PartialFunction[Word, B]): Option[B]

def companion: GenericCompanion[Iterable]

def concat(s: Sentence): Sentence

def copyToArray[B >: Word](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: Word](xs: Array[B]): Unit

def copyToArray[B >: Word](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: Word](dest: Buffer[B]): Unit

def count(p: (Word) ⇒ Boolean): Int

def drop(n: Int): Iterable[Word]

def dropRight(n: Int): Iterable[Word]

def dropWhile(p: (Word) ⇒ Boolean): Iterable[Word]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (Word) ⇒ Boolean): Boolean

final def existsMorpheme(tag: String): Boolean

def filter(p: (Word) ⇒ Boolean): Iterable[Word]

def filterNot(p: (Word) ⇒ Boolean): Iterable[Word]

def finalize(): Unit

def find(p: (Word) ⇒ Boolean): Option[Word]

def flatMap[B, That](f: (Word) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

def flatten[B](implicit asTraversable: (Word) ⇒ GenTraversableOnce[B]): Iterable[B]

def fold[A1 >: Word](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, Word) ⇒ B): B

def foldRight[B](z: B)(op: (Word, B) ⇒ B): B

def forall(p: (Word) ⇒ Boolean): Boolean

def foreach[U](f: (Word) ⇒ U): Unit

def genericBuilder[B]: Builder[B, Iterable[B]]

final def get(index: Int): Word

final def getClass(): Class[_]

def groupBy[K](f: (Word) ⇒ K): Map[K, Iterable[Word]]

def grouped(size: Int): Iterator[Iterable[Word]]

def hasDefiniteSize: Boolean

def hashCode(): Int

final def head: Word

def headOption: Option[Word]

final def indexOf(word: Word): Int

def init: Iterable[Word]

def inits: Iterator[Iterable[Word]]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraversableAgain: Boolean

def iterator: Iterator[Word]

def jIterator: Iterator[Word]

final def jModifiers: List[Word]

final def jNouns: List[Word]

def jTopLevels: List[Word]

final def jVerbs: List[Word]

def jWords: List[Word]

final def last: Word

def lastOption: Option[Word]

def map[B, That](f: (Word) ⇒ B)(implicit bf: CanBuildFrom[Iterable[Word], B, That]): That

final def matches(tag: Seq[Seq[String]]): Boolean

final def matches(tag: Array[Array[String]]): Boolean