Joissain tilanteissa ei kannata käyttää asian täydellisesti määrittelevää ja monimutkaista regex:ää vaan yksinkertainen regex ajaa saman asian -> "hienommin" sanottuna estetään backtracking määräämällä se lyhyt regex atomic-groupiksi. Atomic-groupin myöskin estää joitain katastrofi-tilanteita muodostumasta. Atomic-group mielekästä käyttää kun regex:ät ovat vakioista koodattuja vakioita vaan ainoastaan silloin kun regex:istä ainakin toinen muodostetaan ohjelman käynnin aikana muuttujilla; helpompaahan olisi mikäli koodari kirjoittaisi pelkästään sen lyhyemmän regex:än.
  
- ehkä tuo väite että regex:ät voidaan muodostaa muuttujilla kaipaa sekin osoitusta: regex="[a-z]*"; echo "9 aaa b" | grep -o "$regex" # tulostaa kaksi riviä: aaa 
                                                                                                                                                               b 
Seuraavat esimerkit kertovat atomic-group:in toiminnan koodina: 
 
echo accc  | grep -Po 'a(?>b|cc)c'   # tulostaa: accc -> siis ?>b:llä ei ole mitään funktiota koska "echo:tussa" ei b:tä ole.           
echo abcc  | grep -Po 'a(?>b|bc)c'   # tulostaa: abc  -> siis ?>b määrää ettei muita vaihtoehtoja koeteta kun b löytyy 
echo abccc | grep -Po 'a(?>b|cc)c'   # tulostaa: abc  -> siis ?>b määrää ettei muita vaihtoehtoja koeteta kun b löytyy (varmistus)
     
echo abac  | grep -Po 'a(?>bb|ba)c'  # tulostaa: abac -> siis ?>bb määrää, että bb-alkuiset on lukittu mutta kaikki muut toimii kyllä, vaikka ba:kin toimii.
echo abc   | grep -Po 'a(?>bb|b)c'   # tulostaa: abc  -> siis ?>bb määrää, että bb-alkuiset on lukittu mutta kaikki muut toimii kyllä, vaikka b:kin toimii. Tämä osoittaa muös ettei atomic-group:in 
                                       tarvitse välttämättä olla se lyhyempi regex.
echo abbac | grep -Po 'a(?>bb|bba)c' # ei tulosta mitään, koska ?>bb määrää, ettei bb-alkuisten regex:ät eivät voi saada muita arvoja. 
**
Siis atomic-group voidaan kirjoittaa käyttäen "tavallisia" regex:iä, esimerkiksi tuo: echo accc  | grep -Po 'a(?>b|cc)c'
tulos=$( echo accc | grep 'abc'); [[ ! $tulos ]] && tulos=$( echo accc | grep accc); echo $tulos  
 
**
Regex:ästä voidaan tehdä atomic-group kirjoittamalla näin: grep -Po '(?>vanha ryhmä)' eikä se teoriassa muuta mitään. Mutta esimerkiksi:
echo c | grep -Po 'c*'c      # tulostaa: c, mutta:
echo c | grep -Po '(?>c*)'c  # ei tulosta mitään

**
(?>.*)  täytyy käsitellä erikseen koska kaikki tuntuvat olevan siihen ihastuneita. (?>.+) on melkein sama.

- huomautus ennen esimerkkiä jotta esimerkin voisi ymmärtää: grep käy sille annetun tekstin läpi rivi kerrallaan ja jokaisen rivin merkki kerrallaan järjestyksessä alusta loppuun ja tulostaa näytölle kaikki mikä sopii regex:ään. Tekstissä oleva rivinsiirto siirtyy sellaisenaan ellei toisin määrätä. Jokaisen merkin kohdalla kaikki arvioidaan uudelleen ja esimerkiksi .* saa arvon: käsiteltävästä merkistä loppuun.

esimerkki a: echo aabc | grep -Po 'a(?>.*)'   tulostaa aabc sillä: 
- merkkiä 1 käsiteltäessä (?>.*) saa arvon: aabc joten kokonaisuudessaan regex on aaabc mikä ei sovi joten ei tulosteta mitään.
- merkkiä 2 käsiteltäessä (?>.*) saa arvon: abc joten kokonaisuudessaan regex on aabc mikä sopii ja tulostetaan.
- tässävaiheessa lopetetaan, sillä samasta lohkosta ei tulosteta kahdesti.

esimerkki b: echo aabc | grep -Po '(?>.*)c' ei tulosta mitään sillä:
- merkkiä 1 käsiteltäessä (?>.*) saa arvon: aabc joten kokonaisuudessaan regex on aabcc mikä ei sovi joten ei tulosteta mitään.
- merkkiä 2 käsiteltäessä (?>.*) saa arvon: abc joten kokonaisuudessaan regex on abcc mikä ei sovi joten ei tulosteta mitään.
- merkkiä 3 käsiteltäessä (?>.*) saa arvon: bc joten kokonaisuudessaan regex on bcc mikä ei sovi joten ei tulosteta mitään.
- merkkiä 4 käsiteltäessä (?>.*) saa arvon: c joten kokonaisuudessaan regex on cc mikä ei sovi joten ei tulosteta mitään.
- ja laajemmin: (?>.*)mitätahansa ei voi koskaan tulostaa mitään

kummassakaan esimerkissä atomioc-group on itseasiassa tarpeeton eikä muuta mitään
**
Yritin puoliväkisin saada atomic-group:ista jotain hyötyä, esimerkiksi nopeushyötyä niinkuin kaikkialla lupaillaan. Yhdellä verkkosivulla tosin sanotaan että nopeushyöty on yleensä mitättömän pieni mutta että sitä tulee aina.

Pilasin yhden kovalevyn miljoonilla toistoilla (esimerkiksi suoritusajan keskiarvon saamiseksi) ja tuloksena oli vain epäilys että atomic-group yleensä päinvastoin kuluttaa aikaa. 

Tai tulihan sitä lähes-merkittävää nopeus-eroa atomic-group:in eduksi kun vertailee suoritusaikoja: 
time echo 'kymmenentuhatta a-kirjainta peräkkäin' | grep -P '(?>a*)' > /dev/null      tai:
time echo 'kymmenentuhatta a-kirjainta peräkkäin' | grep -P 'a*' > /dev/null

Pitää siis paikkansa että joissain mielettömissä tilanteissa atomic-group nopeuttaa ja varmaankin joskus todella paljon.
**
Sanotaan että atomic-group:ille annetaan alussa arvo ja sitten sen arvo ei enää muutu? Juuri niin, mutta kerrotaanpa mitä alulla tarkoitetaan: grep, sed ja muut alkavat käsitellä merkkiryhmää merkistä 1 ja sitten siirtyvät käsittelyssä merkki kerrallaan eteenpäin kohden loppua ja alkavat jokaisen merkin kohdalla sovittaa sitä regex:ään. Regex:än sovittaminen on se "alku". Siis atomic-group saa uuden arvon yhtämonta kertaa kuin merkkijonossa on merkkejä.
esimerkki: echo bbcdddceeeec | grep -Po '(?>[a-z][a-z][a-z]*c)'  #tulostaa: bbcdddceeeec . Tuloste on ihan sama vaikka atomic-group määrittelyä ei olisikaan, mutta tarkoituksena onkin osoittaa myös että kaikista regex:stä voidaan tehdä atomic-group.
- b* voi saada myös arvon ''
- echo 'aaaaa' | grep -Po '(?>a*)' tulostaa vain: aaaaa , sillä jos ryhmästä on tulostettu jokin joukko ei siitä samasta ryhmästä enää tulosteta tulostetun joukon ali-joukkoa.
- ryhmä muodostuu joukosta merkkejä jotka rajoittuvat joko välilyöntiin tai merkkijonon alkuun tai loppuun. Siten echo "aaa aaa" | grep -Po '(?>a*)' tulostaa 2 arvoa.           
**
Myöskin toiminnan nopeutumista kuulemma tapahtuu, mutta sensuhteen olen epäileväinen.

Teoriaväitteiden mukaan atomic-group kieltää back-trackingin elikä kieltää käsittelemästä jo kertaalleen käsiteltyä. Tämä ei vaikuta siihen mitä valitaan? vaan se on vain ohje regex:lle siitä että vanhojen kaivelemiseen kuluu nyt vain turhaa aikaa. Mutta toisaalta joitakin osumia voidaan menettää.
  
- tavallisesta regex-ryhmästä voidaan tehdä atomic-group kirjoittamalla näin: grep -Po '(?>vanha ryhmä)' , mutta käytännössä tehdään yleensä näin: grep -Po '(?>vanhan ryhmän osa)vanha ryhmä'
- sed:issä eteen kirjoitetaan -r mutta itse atomic-group on sama  . 
- atomic-group toimii kummalla etsintätavalla toimitaankin: echo teksti | grep -Po "atomic-group"Etsintämääreet   tai: grep -Po "atomic-group"Etsintämääreet tiedostonimi
**
Back-tracking kielto on sinällään selvä, mutta se kyllä kaivelee ettei missään ole määritelty mitä se atomic-group:issa tarkastiottaen kieltää kaivelemasta. Kun ei se ainoa vaihtoehto ole että back-tracking kielto kieltää käsittelemästä uudestaan tekstijonon jo käsiteltyä alkupäätä. 

Esimerkiksi jossakin sanottiin että grepillä on back-tracking rekisteri - tosin monet puhuvat ilman alaleukaa. Mutta toisaalta back-tracking kielto voisi olla kielto kaivella vanhoja löytöjä; ja eihän se oikeastaan tyystin eriasia ole.
Sitäpaitsi hälyttävän usein törmää back-tracking kieltoa tutkiessa sanoihin "etsintään määrätty rekursio".
**
Minun mielestäni jostain asiasta tehty esimerkki on aina jonkinverran käyttökelpoinen yksinäänkin, mutta teoria on aina vahingollinen jos siitä ei ole esimerkkiä elikä sovellusohjetta.
- jos minä tai kukatahansa tulkitsee teorioita niin asiat opitaan aina vähäsen väärin mikäli kunnollista sovellusohjetta ei ole. Ja väärin-opittua ei saa koskaan oikaistua täydellisesti. 

Eikä kunnollisia esimerkkejä atomic-group:ista esitetä missään - tarkoitan sellaisia esimerkkejä joista selviää nopeuttaako se tai estääkö se katastrofeja. Yhden esimerkin kokosin netin regex-info sivuilta. Koska se toimii oikein vielä paljon mukaeltuna niin voi sanoa että atomic-group tosiaan toimii niinkuin luulen:

echo 'tulostetaan jokainen sana jonka perässä on joku erikoismerkki'    | grep -Po '(\D+|\w)*[[:punct:]]'     # tämä kestää minun koneessani noin 60-100ms ja päätyy virheeseen.
echo 'tulostetaan jokainen sana jonka perässä on joku erikoismerkki'    | grep -Po '((?>\D+)|\w)*[[:punct:]]' # atomic-group:illa varustettuna sama kestää noin 4ms, ei pääty virheeseen muttei tulostakaan 
echo 'tulostetaan! jokainen sana jonka? perässä on# joku erikoismerkki' | grep -Po '((?>\D+)|\w)*[[:punct:]]' # tämä tulostaa ja kestää noin 4ms    

- atomic-group on tuo kahdessa viimeisessä esimerkissä oleva: (?>\D+) ja se atomic-lisäys on: (?> ... ) .
- esimerkki on silti "väkisin tehty" sillä: | grep -Po '\w*[[:punct:]]'   toimii kyllä aina erinomaisesti. Mutta jatketaan harjoituksia ...
**
Vihdoinkin sain atomic-group:ille normaalissa toiminnassa merkitsevää käyttöä heti vuoden ihmettelyn jälkeen - atomic-groupin toimintaa "selvennetään" parillakin korkea-tasoisella tiiliskiven kokoisella sivustolla. Mutta taas kertaalleen tämä sai ihmettelemään onko noiden "virtuoosi-sivustojen" tarkoitus neuvoa vai kätkeä toiminta niin ettei siitä saa selvää, sillä niiden esittämät esimerkit eivät ole tästä maailmasta.

Seuraava pätee kaikkiin regex:iin ja poistaa niiltä joitain pahoja puutteita:

Esimerkiksi kun muodostetaan päiväykselle regex niin jos odotetaan päiväystä muodossa vvvv.kk.pp niin mikäli kohdassa pp on jotain muuta kuin luku 01-31 niin kysymys ei voi olla päiväyksestä lukipa muualla mitätahansa, tai jos kohdassa kk on jotain muuta kuin luku 01-12 kysymys ei voi olla päiväyksestä lukipa muualla mitätahansa. Tämä esitettynä koodina jolla toimintaa voi tutkia:
echo 2001.02.12 | grep -P '[0-9][0-9][0-9][0-9][.-](?>[0-2][0-9]|30|31)[.-](?>[0][0-9]|10|12)'
- tottakai tämä on liian rajoittavaa eikä salli että hommissa mukana pyörii virheitä tekevä ihminen joka lisäksi saattaa jättää merkityksettömiä nollia pois elikä kirjoittaa päivän 09 tilalle 9. Mutta sen voi ottaa huomioon koodimuutoksin tai käyttämällä toisia työkaluja.
- samanaikaisesti tämä on liian lepsua - muutta esimerkiksi ankkurit auttavat jo paljon ( esimerkiksi määrätään että päiväys voi olla vain rivin alussa ).
- huomioi että koodissa on kaksi atomic-group:ia. 
- tuo [.-] sallii että välimerkkinä voi olla joko . tai -
- netistä löytyy mitätahansa joten varmaan tämäkin. Mutta hakukoneiden haku ei toimi BASH-koodille joten sivuja ei helposti löydä.
**
Atomic-groupista esitetään lähes kaikkialla hölmö esimerkki: a(?>bc|b)c matches abcc but not abc. 
Esimerkki on tällaisenaan hölmö siksi että |b:n paikalla voi olla mitähyvänsä b-alkuista tai sen voi jättää poiskin eikä se vaikuta mitään. 

Mutta pitäisi lisäksi kertoa että jos |b:n paikalla oleva ei ole b:n ali- tai ylijoukko niin se huomioidaan: 
echo ahc | grep -P a'(?>bc|h)c' valitsee samoinkuin: echo abcc | grep -P a'(?>bc|h)c' 
- melkein kaikki merkit kelpaavat ja vain jotkut erikoismerkit eivät kelpaa.

Atomic-group onkin tarkoitettu tilanteisiin joissa regex:ät ovat muuttujia jolloin mikäli regex2 on regex1:n ali- tai ylijoukko niin se ei tee mitään ja sen voi vaikka jättää pois.
Siis tuo edellinen esimerkki koodina kun regex:ät ovat muuttujia: 
regex1=bc; regex2=h; echo ahc | grep -P a"(?>$regex1|$regex2)c"
- huomioi että lainausmerkit ovat pehmeät.
- siis tässä taitaakin olla määritelmä siitä mitä backtracking on: kielletään ettei samaan paikkaan saa palata.

regex1=hihhih; regex2=hahhah; echo ahihhihc | grep -P a"(?>$regex1|$regex2)c" # valitsee myös: echo ahahhahc
 
  
 
