code: def demo():
      """
      A demonstration for the ``RegexpChunkParser`` class.  A single text is
      parsed with four different chunk parsers, using a variety of rules
      and strategies.
      """
  
      from nltk import Tree, chunk
  
      text = """\
      [ the/DT little/JJ cat/NN ] sat/VBD on/IN [ the/DT mat/NN ] ./.
      [ John/NNP ] saw/VBD [the/DT cats/NNS] [the/DT dog/NN] chased/VBD ./.
      [ John/NNP ] thinks/VBZ [ Mary/NN ] saw/VBD [ the/DT cat/NN ] sit/VB on/IN [ the/DT mat/NN ]./.
      """
  
      print("*" * 75)
      print("Evaluation text:")
      print(text)
      print("*" * 75)
      print()
  
      grammar = r"""
      NP:                   # NP stage
        {<DT>?<JJ>*<NN>}    # chunk determiners, adjectives and nouns
        {<NNP>+}            # chunk proper nouns
      """
      cp = chunk.RegexpParser(grammar)
      demo_eval(cp, text)
  
      grammar = r"""
      NP:
        {<.*>}              # start by chunking each tag
        }<[\.VI].*>+{       # unchunk any verbs, prepositions or periods
        <DT|JJ>{}<NN.*>     # merge det/adj with nouns
      """
      cp = chunk.RegexpParser(grammar)
      demo_eval(cp, text)
  
      grammar = r"""
      NP: {<DT>?<JJ>*<NN>}    # chunk determiners, adjectives and nouns
      VP: {<TO>?<VB.*>}       # VP = verb words
      """
      cp = chunk.RegexpParser(grammar)
      demo_eval(cp, text)
  
      grammar = r"""
      NP: {<.*>*}             # start by chunking everything
          }<[\.VI].*>+{       # strip any verbs, prepositions or periods
          <.*>}{<DT>          # separate on determiners
      PP: {<IN><NP>}          # PP = preposition + noun phrase
      VP: {<VB.*><NP|PP>*}    # VP = verb words + NPs and PPs
      """
      cp = chunk.RegexpParser(grammar)
      demo_eval(cp, text)
  
      # Evaluation
  
      from nltk.corpus import conll2000
  
      print()
      print("Demonstration of empty grammar:")
  
      cp = chunk.RegexpParser("")
      print(
          chunk.accuracy(
              cp,
              conll2000.chunked_sents("test.txt", chunk_types=("NP",)),
          )
      )
  
      print()
      print("Demonstration of accuracy evaluation using CoNLL tags:")
  
      grammar = r"""
      NP:
        {<.*>}              # start by chunking each tag
        }<[\.VI].*>+{       # unchunk any verbs, prepositions or periods
        <DT|JJ>{}<NN.*>     # merge det/adj with nouns
      """
      cp = chunk.RegexpParser(grammar)
      print(chunk.accuracy(cp, conll2000.chunked_sents("test.txt")[:5]))
  
      print()
      print("Demonstration of tagged token input")
  
      grammar = r"""
      NP: {<.*>*}             # start by chunking everything
          }<[\.VI].*>+{       # strip any verbs, prepositions or periods
          <.*>}{<DT>          # separate on determiners
      PP: {<IN><NP>}          # PP = preposition + noun phrase
      VP: {<VB.*><NP|PP>*}    # VP = verb words + NPs and PPs
      """
      cp = chunk.RegexpParser(grammar)
      print(
          cp.parse(
              [
                  ("the", "DT"),
                  ("little", "JJ"),
                  ("cat", "NN"),
                  ("sat", "VBD"),
                  ("on", "IN"),
                  ("the", "DT"),
                  ("mat", "NN"),
                  (".", "."),
              ]
          )
      )
  
imports: import re
  import regex
  from nltk.chunk.api import ChunkParserI
  from nltk.tree import Tree
label_desc: Use image node_id 3 for calling a global function with example usage: demo() without return types