31:T418,here you can see here that the document now has **#Actor1** and **#Actor2** tags. you can implement match-groups, or safe-tagging like so: ```js let matches=[ // only tag the capture-group: {match:'the ballad of [#Person+]', tag:'Character', group:0}, // only tag if it could-be a verb: {match:'shake and [.] baby?', tag:'Imperative', group:0, safe:true} ] ``` --- Because things are optimized up-front, no changes to the document will *'cascade'* into the subsequent matches. This can be a gotcha. Fortunately, you can run `.sweep()` several times, as it is quite fast, and tagging is *[idempotent](https://developer.mozilla.org/en-US/docs/Glossary/Idempotent)*. Any multi-step changes should shake-out, after a few runs. --- ### Tagging considerations compromise offers two features that let you make more-careful tagging decisions, inside of a sweep statement #### freeze: true You can implement [freeze](https://observablehq.com/@spencermountain/compromise-freeze) on a tag, to protect it from other taggers over-writing its tags:32:[] 2f:{"title":"Compromise-sweep","cells":[{"id":0,"value":"# Compromise-sweep\n**.sweep()** is a feature of [compromise](https://observablehq.com/@spencermountain/nlp-compromise) that can greatly speed-up a series of [matches](https://observablehq.com/@spencermountain/compromise-match) on a text. \n\nIf you're looking for information in a text, you'll often find yourself writing a list of matches - to support different possible varieties.\n\nMatches, in general, are pretty laborious to run - even if a document isn't too long, token-by-token comparisons are compute-heavy, and subject to [catastrophic backtracking](https://community.appway.com/screen/kb/article/checking-strings-avoiding-catastrophic-backtracking-1482810891360). The internal compromise [tagger](https://observablehq.com/@spencermountain/compromise-tagger) uses the same process, and is subject to the same problems.\n\nThis is why we've made effort to optimize a list of matches up-front, so that redundant look-ups can be reduced. It is remarkably faster.\n\n`.sweep()`is included in `compromise/one`:\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":55,"value":"viewof sentence = html``","pinned":false,"hidden":false,"mode":"ojs"},{"id":16,"value":"{\n let matches = [\n { match: 'john c .' },\n { match: 'john foo' },\n { match: 'john .? reilly'},\n ]\n //compile them into an efficient index\n let net = nlp.buildNet(matches)\n\n // pass some text through it\n let doc = nlp(sentence)\n let res = doc.sweep(net)\n \n //return a list of unique results\n let m = res.view.settle()\n return m.text()\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":29,"value":"\n\n---\nFor the curious, the `.buildNet()` method parses [match expressions](https://observablehq.com/@spencermountain/compromise-match-syntax). and brings all of their requirements up-front. It collects the matches by their shared requirements, so that it will only ever need to lookup *'john'* one time.\n\nSweep works well in conjunction with [.cache()](https://observablehq.com/@spencermountain/compromise-cache) - which stores which sentences have 'john' in a fast lookup table.\n\nIn the end, a large number of sentences can be skipped-over. The number of actual exhaustive matches to run may be very low. \n\n---\n### Tagging\nanother handy feature of `.sweep()` is the ability to combine your matches with tagging instructions, to make changes in your text on the fly:\n\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":78,"value":"{\n let matches = [\n { match: 'john c .', tag:'Actor1' },\n { match: 'john foo', tag:'Foo' },\n { match: 'john .? reilly', tag:'Actor2'},\n ]\n //compile them into an index\n let net = nlp.buildNet(matches)\n\n // throw some text at it\n let doc = nlp(sentence)\n let res = doc.sweep(net)\n\n // highlight any #Actor2 terms\n return html`${doc.html({'.red':'#Actor2+'})}`\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":82,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":195,"value":"{\n let matches = [\n { match: 'juicy fruit', tag: 'Singular', freeze: true }, // ✅\n { match: 'juicy', tag: 'Adjective' }, // ❌\n ]\n let doc = nlp(`i ate juicy fruit on the front steps`)\n let net = nlp.buildNet(matches)\n doc.sweep(net)\n \n // see that 'juicy fruit' is unchanged\n return doc.match('#Singular+').text()\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":200,"value":"note that the terms do not *stay* frozen, after the process.\nTo keep them frozen, you can run `doc.sweep(net).freeze()`\n\n#### safe:true\nif your tag is tentative, you can add `safe:true` to your match, and the tag will only be applied if it is consistent with the term's current tags. This will only allow *additive* tags, and will prevent any destructive tag changes, to the term:","pinned":false,"hidden":false,"mode":"md"},{"id":206,"value":"{\n let matches = [\n { match: 'united', tag: 'Adjective', safe:true }, // ❌\n ]\n let doc = nlp(`i visited the United Arab Emirates`)\n let net = nlp.buildNet(matches)\n doc.sweep(net)\n \n // see that 'united' is a country, and not an adjective\n return doc.match('#Country+').text()\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":189,"value":"\n---\n\n### Guarding for exceptions\nYou may find yourself wanting to guard your matches, against possible exceptions. You can add a **notIf : 'match'** property on any match, which will run on anything found by the original match:","pinned":false,"hidden":false,"mode":"md"},{"id":167,"value":"{ \n let doc = nlp('i swim in the lake. i walk in the road')\n let net = nlp.buildNet([{ match: 'i (swim|walk) in the .', notIf: 'in the (park|lake)' }])\n let m = doc.match(net)\n return m.out('array')\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":173,"value":"note that ***notIf** runs on a full match, before selecting a sub-group:","pinned":false,"hidden":false,"mode":"md"},{"id":175,"value":"{ \n let doc = nlp('i swim in the lake')\n let net = nlp.buildNet([{ match: 'i #Verb in the [.]', group: 0, notIf: 'swim' }])\n let m = doc.match(net)\n return m.out('array')\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":73,"value":"\n\n---\n### API\n\n```js\ndoc.sweep(net, { tagger: false, matchOne: true })\n```\n\nOften you'll write a sequence of matches where ***order-matters*** - where the most-specific matches should happen first, and the most unsafe matches happen last. There are a few ways to do this. You can pass `matchOne:true`, which will stop after one match:\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":110,"value":"{\n let matches = [\n { match: 'john c #LastName' }, // first match\n { match: 'foo' },\n { match: '#Person+'}, // this would also match\n ]\n let net = nlp.buildNet(matches)\n \n let doc = nlp(sentence)\n let { found } = doc.sweep(net, { matchOne: true }) //stop at 1\n return found[0]\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":126,"value":"---\n\nyou can also step-through all results, (in order) yourself, and apply your custom logic:","pinned":false,"hidden":false,"mode":"md"},{"id":122,"value":"{\n let matches = [\n { match: 'john c #LastName' }, // first match\n { match: 'foo' },\n { match: '#Person+'}, // matches both actors\n ]\n let net = nlp.buildNet(matches)\n \n let doc = nlp(sentence)\n let { found } = doc.sweep(net)\n \n //draw-up a little html\n return html`\n \n \n \n ${found.map((res,i)=> {\n return ''\n })}\n

index	match	results
'+i+'	' + res.match + '	' + JSON.stringify(res.view.out('array')) + '

`\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":11,"value":"style = html`