scala/RegexExamples.ipynb

{
 "cells": [
  {
   "source": [
    "\n",
    "# Scala Regex Examples\n",
    "\n",
    "## Useful links\n",
    "\n",
    "* https://docs.scala-lang.org/tour/regular-expression-patterns.html\n",
    "* https://www.scala-lang.org/api/current/scala/util/matching/Regex.html\n",
    "* https://www.regular-expressions.info/\n",
    "* https://regex101.com/\n",
    "* https://regexr.com/\n",
    "* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "functioning-participant",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32mimport \u001b[39m\u001b[36mscala.util.matching.Regex\u001b[39m"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import scala.util.matching.Regex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "appropriate-north",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defined \u001b[32mfunction\u001b[39m \u001b[36mmatchesAny\u001b[39m\n",
       "defined \u001b[32mfunction\u001b[39m \u001b[36mmatchesAll\u001b[39m\n",
       "defined \u001b[32mfunction\u001b[39m \u001b[36mtest\u001b[39m\n",
       "defined \u001b[32mfunction\u001b[39m \u001b[36mtestAll\u001b[39m"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " def matchesAny(regex: Regex, s: String): Boolean =\n",
    "    regex.findFirstMatchIn(s) match {\n",
    "      case Some(_) => true\n",
    "      case None    => false\n",
    "    }\n",
    "\n",
    "  def matchesAll(regex: Regex, s: String): Boolean =\n",
    "    regex.pattern.matcher(s).matches\n",
    "\n",
    "  def test(regex: Regex, s: String): Unit =\n",
    "    println(s\"\"\"\"$s\" match $regex ==> ${matchesAny(regex, s)}\"\"\")\n",
    "\n",
    "  def testAll(regex: Regex, s: String): Unit =\n",
    "    println(s\"\"\"\"$s\" match $regex\\t==>\\t${matchesAll(regex, s)}\"\"\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "instructional-tomato",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"abc\" match [0-9] ==> false\n",
      "\"121\" match [0-9] ==> true\n",
      "\"aaksldjasljdf(foobar)laksjfdlaks\" match .+?\\(foobar\\).+ ==> true\n",
      "\"1<\" match [0-9A-Za-z.-_]+\t==>\ttrue\n",
      "\"123_ABC_abc_<\" match [-._0-9A-Za-z]+\t==>\tfalse\n",
      "\"123_ABC_abc_.....-------abc-.__a\" match [-._0-9A-Za-z]+\t==>\ttrue\n"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[31mscala.MatchError: 123_ABC_abc_< (of class java.lang.String)\u001b[39m\n  ammonite.$sess.cmd2$Helper.<init>(\u001b[32mcmd2.sc\u001b[39m:\u001b[32m41\u001b[39m)\n  ammonite.$sess.cmd2$.<clinit>(\u001b[32mcmd2.sc\u001b[39m:\u001b[32m7\u001b[39m)"
     ]
    }
   ],
   "source": [
    "\n",
    "  // The raw interpolator\n",
    "  // normal strings use backslash '\\' as an escape character.\n",
    "  // so the string \"\\n\" is one character, end-of-line (EOL), rather than two characters, \"\\\" and \"n\"\n",
    "  // the raw interpolator turns this behavior off, so that raw\"\\n\" means \"\\\" + \"n\" rather than EOL\n",
    "  // this is useful with regexes that need to match literal \\ or that need to use backslash to change the\n",
    "  // meaning of a character in the regex. An example of this is \"(\" could either mean to match a literal\n",
    "  // parenthesis, or the start of a capturing group.  Also, regex character classes are preceded by a backslash,\n",
    "  // so it can get confusing as to how many backslashes you need to apply.  Many IDEs will incorrectly give\n",
    "  // errors on regexes because they violated what a \"normal\" string should look like.\n",
    "\n",
    "  // even though the type on this is Regex, we call this the Pattern because that's what the same type of\n",
    "  // thing is called in Java (java.util.Pattern).\n",
    "\n",
    "  val digitsPattern: Regex = \"[0-9]\".r\n",
    "\n",
    "  val digitsPatternRaw: Regex = \"[0-9]\".r\n",
    "\n",
    "  // \\d isn't a valid escape sequence, so this won't even compile, giving an \"invalid escape character\" error\n",
    "  // val digitsPatternCharacterClass: Regex = \"\\d\".r\n",
    "\n",
    "  // the first backslash escapes the second backslash, to give the character class for digit (\\d)\n",
    "  val digitsPatternCharacterClass: Regex = \"\\\\d\".r\n",
    "\n",
    "  // a raw string doesn't need escapes\n",
    "  // IntelliJ has a bug https://youtrack.jetbrains.com/issue/SCL-18824 and shows this as an error\n",
    "  val digitsPatternCharacterClassRaw: Regex = raw\"\\d\".r\n",
    "\n",
    "  // a raw string doesn't need escapes\n",
    "  // IntelliJ has a bug https://youtrack.jetbrains.com/issue/SCL-18824 and shows this as an error\n",
    "  val digitsPatternCharacterClassRawTriple: Regex = raw\"\"\"\\d\"\"\".r\n",
    "\n",
    "  val x  = raw\".+?\\(foobar\\).+\".r\n",
    "  val x2 = raw\"\"\".+?\\(foobar\\).+\"\"\".r\n",
    "\n",
    "  test(digitsPattern, \"abc\")\n",
    "  test(digitsPattern, \"121\")\n",
    "\n",
    "  test(x2, \"aaksldjasljdf(foobar)laksjfdlaks\")\n",
    "\n",
    "  // character class with -\n",
    "  // character classes can express ranges, for example, [0-9a-fA-F] would be a case-insensitive match on a hex number\n",
    "  // however, this gets confusing if you want to match a string with a literal - in it.\n",
    "  // http://www.asciitable.com/   46 to 95\n",
    "  val wrong = raw\"[0-9A-Za-z.-_]+\".r\n",
    "\n",
    "\n",
    "  testAll(wrong, \"1<\")\n",
    "\n",
    "  val correct = raw\"[-._0-9A-Za-z]+\".r\n",
    "\n",
    "  testAll(correct, \"123_ABC_abc_<\")\n",
    "  testAll(correct, \"123_ABC_abc_.....-------abc-.__a\")\n",
    "\n",
    "  val correct(someofit) = \"123_ABC_abc_<\"\n",
    "  println(someofit)\n",
    "\n",
    "  val notOneOf = raw\"[^-._0-9A-Za-z]+\".r\n",
    "\n",
    "  // [-.\\w]\n",
    "\n",
    "  // inside character class - right bracket ], backslash \\, caret ^, and hyphen -\n",
    "\n",
    "  // hyphen between two characters is a range -- so needs to be at very beginning or very end\n",
    "  // convention -- just put non-alphanumeric characters at the beginning\n",
    "\n",
    "  // backslash needs to be escaped with another backslash\n",
    "  // caret at the beginning negates\n",
    "  //\n",
    "  // right bracket -- at beginning or escaped -- just escape it\n",
    "  //\n",
    "  // escape hyphen?\n",
    "\n",
    "  // [^-\\]\n",
    "\n",
    "  val matchClosingBracket = \"[]a]\"\n",
    "\n",
    "  //back references ([0-9])\\1+\n",
    "\n",
    "//  shorthand character classes\n",
    "\n",
    "  // \\d digits\n",
    "  // \\w [A-Za-z0-9_]\n",
    "  // \\s [ \\t\\r\\n\\f]\n",
    "\n",
    "//  \\D \\W \\S\n",
    "\n",
    "  // reverse interpolation\n",
    "\n",
    "  val s\"$foo.$bar\" = \"1.2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "earned-coast",
   "metadata": {},
   "outputs": [],
   "source": [
    "import scala.util.Try\n",
    "\n",
    "Try(raw\"\"\"[0-9A-Za-z_-.]+\"\"\".r).recover{e => println(e)}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "expressed-ethernet",
   "metadata": {},
   "outputs": [],
   "source": [
    "testAll(raw\"\"\"[0-9A-Za-z.-_]+\"\"\".r, \"1Aa<>:=;._\") // 46 to 95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "terminal-translation",
   "metadata": {},
   "outputs": [],
   "source": [
    "testAll(raw\"\"\"[A-Za-z.-_]+\"\"\".r, \"1Aa<>:=;._\") // numbers are 48-57"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "spatial-scheme",
   "metadata": {},
   "outputs": [],
   "source": [
    "testAll(raw\"\"\"[a-z.-_]+\"\"\".r, \"1Aa<>:=;._\") // upper case is 41-90"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "swiss-attention",
   "metadata": {},
   "outputs": [],
   "source": [
    "testAll(raw\"\"\"[.-z]+\"\"\".r, \"1Aa<>:=;._\") // only adds backtick!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "subjective-crack",
   "metadata": {},
   "outputs": [],
   "source": [
    "val moreCorrect = raw\"[-.\\w]+\".r\n",
    "\n",
    "testAll(moreCorrect, \"123_ABC_abc_<\")\n",
    "testAll(moreCorrect, \"123_ABC_abc_.....-------abc-.__a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "wound-punishment",
   "metadata": {},
   "outputs": [],
   "source": [
    "val r1 = raw\"\"\"[0-9A-Za-z.-_]+\"\"\".r \n",
    "val r2 = raw\"\"\"[.-z]+\"\"\".r\n",
    "val s = \"\\u0060\\u002d\\u002c\"\n",
    "\n",
    "println(s)\n",
    "println()\n",
    "\n",
    "testAll(r1, \"\\u0060\\u0060\\u0060\")\n",
    "testAll(r2, \"\\u0060\\u0060\\u0060\")\n",
    "\n",
    "testAll(r1, s)\n",
    "testAll(r2, s)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Scala",
   "language": "scala",
   "name": "scala"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".sc",
   "mimetype": "text/x-scala",
   "name": "scala",
   "nbconvert_exporter": "script",
   "version": "2.13.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}