code: def terms(
      doclike: types.DocLike,
      *,
      ngs: Optional[
          int | Collection[int] | types.DocLikeToSpans
      ] = None,
      ents: Optional[bool | types.DocLikeToSpans] = None,
      ncs: Optional[bool | types.DocLikeToSpans] = None,
      dedupe: bool = True,
  ) -> Iterable[Span]:
      """
      Extract one or multiple types of terms -- ngrams, entities, and/or noun chunks --
      from ``doclike`` as a single, concatenated collection, with optional deduplication
      of spans extracted by more than one type.
  
      .. code-block:: pycon
  
          >>> extract.terms(doc, ngs=2, ents=True, ncs=True)
          >>> extract.terms(doc, ngs=lambda doc: extract.ngrams(doc, n=2))
          >>> extract.terms(doc, ents=extract.entities)
          >>> extract.terms(doc, ents=partial(extract.entities, include_types="PERSON"))
  
      Args:
          doclike
          ngs: N-gram terms to be extracted.
              If one or multiple ints, :func:`textacy.extract.ngrams(doclike, n=ngs)` is
              used to extract terms; if a callable, ``ngs(doclike)`` is used to extract
              terms; if None, no n-gram terms are extracted.
          ents: Entity terms to be extracted.
              If True, :func:`textacy.extract.entities(doclike)` is used to extract terms;
              if a callable, ``ents(doclike)`` is used to extract terms;
              if None, no entity terms are extracted.
          ncs: Noun chunk terms to be extracted.
              If True, :func:`textacy.extract.noun_chunks(doclike)` is used to extract
              terms; if a callable, ``ncs(doclike)`` is used to extract terms;
              if None, no noun chunk terms are extracted.
          dedupe: If True, deduplicate terms whose spans are extracted by multiple types
              (e.g. a span that is both an n-gram and an entity), as identified by
              identical (start, stop) indexes in ``doclike``; otherwise, don't.
  
      Returns:
          Next term from ``doclike``, in order of n-grams then entities then noun chunks,
          with each collection's terms given in order of appearance.
  
      Note:
          This function is *not* to be confused with keyterm extraction, which leverages
          statistics and algorithms to quantify the "key"-ness of terms before returning
          the top-ranking terms. There is no such scoring or ranking here.
  
      See Also:
          - :func:`textacy.extact.ngrams()`
          - :func:`textacy.extact.entities()`
          - :func:`textacy.extact.noun_chunks()`
          - :mod:`textacy.extact.keyterms`
      """
      extractors = _get_extractors(ngs, ents, ncs)
      terms_ = itertoolz.concat(
          extractor(doclike) for extractor in extractors
      )
      if dedupe is True:
          terms_ = itertoolz.unique(
              terms_, lambda span: (span.start, span.end)
          )
      for term in terms_:
          yield term
  
file_path: textacy/src/textacy/extract/basics.py
imports: from __future__ import annotations
  from functools import partial
  from typing import Collection, Iterable, Optional, Union
  from cytoolz import itertoolz
  from spacy.parts_of_speech import DET
  from spacy.tokens import Span, Token
  from ..None import constants, errors, types, utils
label_desc: Use image node_id 6 for calling a global function with example usage: terms(doclike) without return types