Perl6_1liners_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Perl6 1-liners Tutorial\n",
    "\n",
    "### Examples from https://github.com/dnmfarrell/Perl6-One-Liners\n",
    "\n",
    "\n",
    "# INTRODUCTION\n",
    "\n",
    "One thing that sets Perl apart from other languages is the ability to write small programs in a single line of code, known as a \"one liner\". It's often faster to type a program directly into the terminal than to write a throwaway script. And one liners are powerful too; they're fully fledged programs which can load external libraries but also integrate into the terminal. You can pipe data in or out of a one liner.\n",
    "\n",
    "Like Perl 5, Perl 6 supports one liners. And just like Perl 6 cleaned up Perl 5's warts elsewhere, the one liner syntax is also better. It's cleaner with fewer special variables and options to memorize. This book provides many useful examples of Perl 6 one liners that can do everything from finding duplicate lines in a file to running a web server. Although Perl 6 has fewer special variables, because of its advanced object oriented syntax most of the one liners are shorter in Perl 6 than their Perl 5 equivalent.\n",
    "\n",
    "This book can be read in a number of ways. If you're new to one liners, start with the (tutorial)[#tutorial]. It walks you through the core concepts of a one liner; don't worry - it's really very simple once you get the hang of it. If you're familiar with Perl, Bash or Sed/Awk, you can probably get stuck in to the examples right away. Feel free to skim and scan the material for whatever piques your interest. If you don't understand some code, try it out in the terminal! Included in this repo is the ubiquitous example.txt file which is used in many of the one liners.\n",
    "\n",
    "Programming with one liners is just one paradigm that Perl 6 excels in. There's a beauty in the brevity of this code, but whilst you're learning a productive skill, remember that you're also learning the ropes of a powerful new programming language. Check out the perl6.org website for the official documentation.\n",
    "\n",
    "# TUTORIAL\n",
    "\n",
    "To get started with one liners, all you really need to understand is the -e option. This tells Perl to execute what follows as a program. For example:\n",
    "```perl\n",
    "perl6 -e 'say \"Hello, World!\"'\n",
    "```\n",
    "\n",
    "Let's step through this code. perl6 invokes the Perl 6 program, -e tells Perl 6 to execute and 'say \"Hello, World!\"' is the program. Every program must be surrounded in single quotes (except on Windows, see Converting for Windows). To run the one-liner, just type it into the terminal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello World"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -e 'say \"Hello World\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to load a file, just add the path to the file after the program code.\n",
    "\n",
    "Let's create a file with 3 lines of text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "cat <<EOF >testfile\n",
    "line1\n",
    "\n",
    "line2\n",
    "EOF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we read and *say* those lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e 'for (lines) { say $_ }' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This program prints every line in testfile.\n",
    "\n",
    "You may know that $_ is the default variable, which in this case is the current line being looped through. lines is a list that is automatically created for you whenever you pass a filepath to a one-liner.\n",
    "\n",
    "Now let's re-write that one liner, step-by-step. These are all equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e 'for (lines) { say $_ }' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e 'for (lines) { $_.say }' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e 'for (lines) { .say }' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e '.say for (lines)' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -e '.say for lines' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like $_ is the default variable, methods called on the default variable can omit the variable reference.\n",
    "\n",
    "They become default methods.\n",
    "\n",
    "So $_.say becomes .say.\n",
    "\n",
    "This brevity pays off with one liners - it's less typing!\n",
    "\n",
    "The -n option changes the behavior of the program:\n",
    "\n",
    "it executes the code once for every line of the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -ne '.say' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and of course with the -p option we dont even need to *say* the text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "line1\r\n",
      "\r\n",
      "line2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -pe '' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So to uppercase and print every line of testfile you can type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LINE1\r\n",
      "\r\n",
      "LINE2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -ne '.uc.say' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The -p option is just like -n except that it will automatically print $_. So another way we could uppercase a file would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LINE1\r\n",
      "\r\n",
      "LINE2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -pe '$_ = .uc' testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or two shorter versions that do the same thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LINE1\r\n",
      "\r\n",
      "LINE2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -pe '.=uc' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LINE1\r\n",
      "\r\n",
      "LINE2\r\n"
     ]
    }
   ],
   "source": [
    "perl6 -pe .=uc testfile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second example we were able to completely remove the surrounding single quotes. This is a rare scenario, but in the event your one liner has no spaces and no sigils or quotes in it, you can usually remove the outer quotes.\n",
    "\n",
    "The -n and -p options are really useful. There are lots of example one-liners that use them in this book."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 line1\r\n",
       "2 \r\n",
       "3 line2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -ne 'say \"{++$} $_\"' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 line1\r\n",
       "\r\n",
       "2 line2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -pe '$_ = \"{++$} $_\" if /\\S/' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 line1\r\n",
       "\r\n",
       "3 line2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -pe '$_ = $*ARGFILES.ins ~ \" $_\" if /\\S/' testfile\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -e 'lines.Int.say' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -e 'lines.grep(/\\S/).elems.say' testfile\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -e 'lines.grep(/^\\s*$/).elems.say' testfile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7 is prime"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perl6 -e 'say \"7 is prime\" if 7.is-prime'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {},
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#perl6 -ne 'say [+] .split(\"\\t\")'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {},
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#perl6 -e 'say [+] lines.split(\"\\t\")'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {},
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#perl6 -ne '.split(\"\\t\").pick(*).join(\"\\t\").say'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Rest - to be done ...\n",
    "\n",
    "### also from https://github.com/dnmfarrell/Perl6-One-Liners"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "The final thing you should know is how to load a module. This is really powerful as you can extend Perl 6's capabilities by importing external libraries. The -M switch stands for load module:\n",
    "\n",
    "perl6 -M URI::Encode -e 'say uri_encode(\"example.com/10 ways to crush it with Perl 6\")'\n",
    "This: -M URI::Encode loads the URI::Encode module, which exports the uri_encode subroutine. You can use -M more than once if you want to load more than one module:\n",
    "\n",
    "perl6 -M URI::Encode -M URI -e '<your code here>'\n",
    "What if you have a local module, that is not installed yet? Easy, just pass use the -I switch to include the directory:\n",
    "\n",
    "perl6 -I lib -M URI::Encode -e '<your code here>'\n",
    "Now Perl 6 will search for URI::Encode in lib as well as the standard install locations.\n",
    "\n",
    "To get a list of Perl 6 command line switches, use the -h option for help:\n",
    "\n",
    "perl6 -h\n",
    "This prints a nice summary of the available options.\n",
    "\n",
    "FILE SPACING\n",
    "\n",
    "Double space a file\n",
    "\n",
    "perl6 -pe '$_ ~= \"\\n\"' example.txt\n",
    "N-space a file (e.g. quadruple space)\n",
    "\n",
    "perl6 -pe '$_ ~= \"\\n\" x 4' example.txt\n",
    "Add a blank line before every line\n",
    "\n",
    "perl6 -pe 'say \"\"' example.txt\n",
    "Remove all blank lines\n",
    "\n",
    "perl6 -ne '.say if /\\S/' example.txt\n",
    "perl6 -ne '.say if .chars' example.txt\n",
    "Remove all consecutive blank lines, leaving just one\n",
    "\n",
    "perl6 -e '$*ARGFILES.slurp.subst(/\\n+/, \"\\n\\n\", :g).say' example.txt\n",
    "LINE NUMBERING\n",
    "\n",
    "Number all lines in a file\n",
    "\n",
    "perl6 -ne 'say \"{++$} $_\"' example.txt\n",
    "perl6 -ne 'say $*ARGFILES.ins ~ \" $_\"' example.txt\n",
    "Number only non-empty lines in a file\n",
    "\n",
    "perl6 -pe '$_ = \"{++$} $_\" if /\\S/' example.txt\n",
    "Number all lines but print line numbers only for non-empty lines\n",
    "\n",
    "perl6 -pe '$_ = $*ARGFILES.ins ~ \" $_\" if /\\S/' example.txt\n",
    "Print the total number of lines in a file (emulate wc -l)\n",
    "\n",
    "perl6 -e 'say lines.elems' example.txt\n",
    "perl6 -e 'say lines.Int' example.txt\n",
    "perl6 -e 'lines.Int.say' example.txt\n",
    "Print the number of non-empty lines in a file\n",
    "\n",
    "perl6 -e 'lines.grep(/\\S/).elems.say' example.txt\n",
    "Print the number of empty lines in a file\n",
    "\n",
    "perl6 -e 'lines.grep(/^\\s*$/).elems.say' example.txt\n",
    "CALCULATIONS\n",
    "\n",
    "Check if a number is a prime\n",
    "\n",
    "perl6 -e 'say \"7 is prime\" if 7.is-prime'\n",
    "Print the sum of all the fields on a line\n",
    "\n",
    "perl6 -ne 'say [+] .split(\"\\t\")'\n",
    "Print the sum of all the fields on all lines\n",
    "\n",
    "perl6 -e 'say [+] lines.split(\"\\t\")'\n",
    "Shuffle all fields on a line\n",
    "\n",
    "perl6 -ne '.split(\"\\t\").pick(*).join(\"\\t\").say'\n",
    "Find the lexically minimum element on a line\n",
    "\n",
    "perl6 -ne '.split(\"\\t\").min.say'\n",
    "Find the lexically minimum element over all the lines\n",
    "\n",
    "perl6 -e 'lines.split(\"\\t\").min.say'\n",
    "Find the lexically maximum element on a line\n",
    "\n",
    "perl6 -ne '.split(\"\\t\").max.say'\n",
    "Find the lexically maximum element over all the lines\n",
    "\n",
    "perl6 -e 'lines.split(\"\\t\").max.say'\n",
    "Find the numerically minimum element on a line\n",
    "\n",
    "perl6 -ne '.split(\"\\t\")».Numeric.min.say'\n",
    "Find the numerically maximum element on a line\n",
    "\n",
    "perl6 -ne '.split(\"\\t\")».Numeric.max.say'\n",
    "Replace each field with its absolute value\n",
    "\n",
    "perl6 -ne '.split(\"\\t\").map(*.abs).join(\"\\t\").say'\n",
    "Find the total number of letters on each line\n",
    "\n",
    "perl6 -ne '.chars.say' example.txt\n",
    "Find the total number of words on each line\n",
    "\n",
    "perl6 -ne '.words.elems.say' example.txt\n",
    "Find the total number of elements on each line, split on a comma\n",
    "\n",
    "perl6 -ne '.split(\",\").elems.say' example.txt\n",
    "Find the total number of fields (words) on all lines\n",
    "\n",
    "perl6 -e 'say lines.split(\"\\t\").elems' #fields\n",
    "perl6 -e 'say lines.words.elems' example.txt #words\n",
    "Print the total number of fields that match a pattern\n",
    "\n",
    "perl6 -e 'say lines.split(\"\\t\").comb(/pattern/).elems' #fields\n",
    "perl6 -e 'say lines.words.comb(/pattern/).elems' #words\n",
    "Print the total number of lines that match a pattern\n",
    "\n",
    "perl6 -e 'say lines.grep(/in/).elems'\n",
    "Print the number PI to n decimal places (e.g. 10)\n",
    "\n",
    "perl6 -e 'say pi.fmt(\"%.10f\");'\n",
    "Print the number PI to 15 decimal places\n",
    "\n",
    "perl6 -e 'say π'\n",
    "Print the number E to n decimal places (e.g. 10)\n",
    "\n",
    "perl6 -e 'say e.fmt(\"%.10f\");'\n",
    "Print the number E to 15 decimal places\n",
    "\n",
    "perl6 -e 'say e'\n",
    "Print UNIX time (seconds since Jan 1, 1970, 00:00:00 UTC)\n",
    "\n",
    "perl6 -e 'say time'\n",
    "Print GMT (Greenwich Mean Time) and local computer time\n",
    "\n",
    "perl6 -MDateTime::TimeZone -e 'say to-timezone(\"GMT\",DateTime.now)'\n",
    "perl6 -e 'say DateTime.now'\n",
    "Print local computer time in H:M:S format\n",
    "\n",
    "perl6 -e 'say DateTime.now.map({$_.hour, $_.minute, $_.second.round}).join(\":\")'\n",
    "Print yesterday's date\n",
    "\n",
    "perl6 -e 'say DateTime.now.earlier(:1day)'\n",
    "Print date 14 months, 9 days and 7 seconds ago\n",
    "\n",
    "perl6 -e 'say DateTime.now.earlier(:14months).earlier(:9days).earlier(:7seconds)'\n",
    "Prepend timestamps to stdout (GMT, localtime)\n",
    "\n",
    "tail -f logfile | perl6 -MDateTime::TimeZone -ne 'say to-timezone(\"GMT\",DateTime.now) ~ \"\\t$_\"'\n",
    "tail -f logfile | perl6 -ne 'say DateTime.now ~ \"\\t$_\"'\n",
    "Calculate factorial of 5\n",
    "\n",
    "perl6 -e 'say [*] 1..5'\n",
    "Calculate greatest common divisor\n",
    "\n",
    "perl6 -e 'say [gcd] @list_of_numbers'\n",
    "Calculate GCM of numbers 20 and 35 using Euclid's algorithm\n",
    "\n",
    "perl6 -e 'say (20, 35, *%* ... 0)[*-2]'\n",
    "Calculate least common multiple (LCM) of 20 and 35\n",
    "\n",
    "perl6 -e 'say 20 lcm 35'\n",
    "Calculate LCM of 20 and 35 using Euclid's algorithm: n*m/gcd(n,m)\n",
    "\n",
    "perl6 -e 'say 20 * 35 / (20 gcd 35)'\n",
    "Generate 10 random numbers between 5 and 15 (excluding 15)\n",
    "\n",
    "perl6 -e '.say for (5..^15).roll(10)'\n",
    "Find and print all permutations of a list\n",
    "\n",
    "perl6 -e 'say .join for [1..5].permutations'\n",
    "Generate the power set\n",
    "\n",
    "perl6 -e '.say for <1 2 3>.combinations'\n",
    "Convert an IP address to unsigned integer\n",
    "\n",
    "perl6 -e 'say :256[\"127.0.0.1\".comb(/\\d+/)]'\n",
    "perl6 -e 'say +\":256[{q/127.0.0.1/.subst(:g,/\\./,q/,/)}]\"'\n",
    "perl6 -e 'say Buf.new(+«\"127.0.0.1\".split(\".\")).unpack(\"N\")'\n",
    "Convert an unsigned integer to an IP address\n",
    "\n",
    "perl6 -e 'say join \".\", @(pack \"N\", 2130706433)'\n",
    "perl6 -e 'say join \".\", map { ((2130706433+>(8*$_))+&0xFF) }, (3...0)'\n",
    "STRING CREATION AND ARRAY CREATION\n",
    "\n",
    "Generate and print the alphabet\n",
    "\n",
    "perl6 -e '.say for \"a\"..\"z\"'\n",
    "Generate and print all the strings from \"a\" to \"zz\"\n",
    "\n",
    "perl6 -e '.say for \"a\"..\"zz\"'\n",
    "Convert a integer to hex\n",
    "\n",
    "perl6 -e 'say 255.base(16)'\n",
    "perl6 -e 'say sprintf(\"%x\", 255)'\n",
    "Print an int to hex translation table\n",
    "\n",
    "perl6 -e 'say sprintf(\"%3i => %2x\", $_, $_) for 0..255'\n",
    "Percent encode an integer\n",
    "\n",
    "perl6 -e 'say sprintf(\"%%%x\", 255)'\n",
    "Generate a random 10 a-z character string\n",
    "\n",
    "perl6 -e 'print roll 10, \"a\"..\"z\"'\n",
    "perl6 -e 'print roll \"a\"..\"z\": 10'\n",
    "Generate a random 15 ASCII Character password\n",
    "\n",
    "perl6 -e 'print roll 15, \"0\"..\"z\"'\n",
    "perl6 -e 'print roll \"0\"..\"z\": 15'\n",
    "Create a string of specific length\n",
    "\n",
    "perl6 -e 'print \"a\" x 50'\n",
    "Generate and print an array of even numbers from 1 to 100\n",
    "\n",
    "perl6 -e '(1..100).grep(* %% 2).say'\n",
    "Find the length of the string\n",
    "\n",
    "perl6 -e '\"storm in a teacup\".chars.say'\n",
    "Find the number of elements in an array\n",
    "\n",
    "perl6 -e 'my @letters = \"a\"..\"z\"; @letters.Int.say'\n",
    "TEXT CONVERSION AND SUBSTITUTION\n",
    "\n",
    "ROT 13 a file\n",
    "\n",
    "perl6 -pe 'tr/A..Za..z/N..ZA..Mn..za..m/' example.txt\n",
    "Base64 encode a string\n",
    "\n",
    "perl6 -MMIME::Base64 -ne 'print MIME::Base64.encode-str($_)' example.txt\n",
    "Base64 decode a string\n",
    "\n",
    "perl6 -MMIME::Base64 -ne 'print MIME::Base64.decode-str($_)' base64.txt\n",
    "URL-escape a string\n",
    "\n",
    "perl6 -MURI::Encode -le 'say uri_encode($string)'\n",
    "URL-unescape a string\n",
    "\n",
    "perl6 -MURI::Encode -le 'say uri_decode($string)'\n",
    "HTML-encode a string\n",
    "\n",
    "perl6 -MHTML::Entity -e 'print encode-entities($string)'\n",
    "HTML-decode a string\n",
    "\n",
    "perl6 -MHTML::Entity -e 'print decode-entities($string)'\n",
    "Convert all text to uppercase\n",
    "\n",
    "perl6 -pe '.=uc' example.txt\n",
    "perl6 -ne 'say .uc' example.txt\n",
    "Convert all text to lowercase\n",
    "\n",
    "perl6 -pe '.=lc' example.txt\n",
    "perl6 -ne 'say .lc' example.txt\n",
    "Uppercase only the first word of each line\n",
    "\n",
    "perl6 -ne 'say s/(\\w+){}/{$0.uc}/' example.txt\n",
    "Invert the letter case\n",
    "\n",
    "perl6 -pe 'tr/a..zA..Z/A..Za..z/' example.txt\n",
    "perl6 -ne 'say tr/a..zA..Z/A..Za..z/.after' example.txt\n",
    "Camel case each line\n",
    "\n",
    "perl6 -ne 'say .wordcase' example.txt\n",
    "Strip leading whitespace (spaces, tabs) from the beginning of each line\n",
    "\n",
    "perl6 -ne 'say .trim-leading' example.txt\n",
    "Strip trailing whitespace (space, tabs) from the end of each line\n",
    "\n",
    "perl6 -ne 'say .trim-trailing' example.txt\n",
    "Strip whitespace from the beginning and end of each line\n",
    "\n",
    "perl6 -ne 'say .trim' example.txt\n",
    "Convert UNIX newlines to DOS/Windows newlines\n",
    "\n",
    "perl6 -ne 'print .subst(/\\n/, \"\\r\\n\")' example.txt\n",
    "Convert DOS/Windows newlines to UNIX newlines\n",
    "\n",
    "perl6 -ne 'print .subst(/\\r\\n/, \"\\n\")' example.txt\n",
    "Find and replace all instances of \"ut\" with \"foo\" on each line\n",
    "\n",
    "perl6 -pe 's:g/ut/foo/' example.txt\n",
    "Find and replace all instances of \"ut\" with \"foo\" on each line that contains \"lorem\"\n",
    "\n",
    "perl6 -pe 's:g/ut/foo/ if /Lorem/' example.txt\n",
    "Convert a file to JSON\n",
    "\n",
    "perl6 -M JSON::Tiny -e 'say to-json(lines)' example.txt\n",
    "Pick 5 random words from each line of a file\n",
    "\n",
    "perl6 -ne 'say .words.pick(5)' example.txt\n",
    "TEXT ANALYSIS\n",
    "\n",
    "Print n-grams of a string\n",
    "\n",
    "perl6 -e 'my $n=2; say \"banana\".comb.rotor($n,$n-1).map({[~] @$_})'\n",
    "Print unique n-grams\n",
    "\n",
    "perl6 -e 'my $n=2; say \"banana\".comb.rotor($n,$n-1).map({[~] @$_}).Set.sort'\n",
    "Print occurrence counts of n-grams\n",
    "\n",
    "perl6 -e 'my $n=2; say \"banana\".comb.rotor($n,$n-1).map({[~] @$_}).Bag.sort.join(\"\\n\")'\n",
    "Print occurrence counts of words (1-grams)\n",
    "\n",
    "perl6 -e 'say lines[0].words.map({[~] @$_}).Bag.sort.join(\"\\n\")' example.txt\n",
    "Print Dice similarity coefficient based on sets of 1-grams\n",
    "\n",
    "perl6 -e 'my $a=\"banana\".comb;my $b=\"anna\".comb;say ($a (&) $b)/($a.Set + $b.Set)'\n",
    "Print Jaccard similarity coefficient based on 1-grams\n",
    "\n",
    "perl6 -e 'my $a=\"banana\".comb;my $b=\"anna\".comb;say ($a (&) $b) / ($a (|) $b)'\n",
    "Print overlap coefficient based on 1-grams\n",
    "\n",
    "perl6 -e 'my $a=\"banana\".comb;my $b=\"anna\".comb;say ($a (&) $b)/($a.Set.elems,$b.Set.elems).min'\n",
    "Print cosine similarity based on 1-grams\n",
    "\n",
    "perl6 -e 'my $a=\"banana\".comb;my $b=\"anna\".comb;say ($a (&) $b)/($a.Set.elems.sqrt*$b.Set.elems.sqrt)'\n",
    "Build an index of characters within a string and print it\n",
    "\n",
    "perl6 -e 'say {}.push: %(\"banana\".comb.pairs).invert'\n",
    "Build an index of words within a line and print it\n",
    "\n",
    "perl6 -e '({}.push: %(lines[0].words.pairs).invert).sort.join(\"\\n\").say' example.txt\n",
    "SELECTIVE LINE PRINTING\n",
    "\n",
    "Print the first line of a file (emulate head -1)\n",
    "\n",
    "perl6 -ne '.say;exit' example.txt\n",
    "perl6 -e 'lines[0].say' example.txt\n",
    "perl6 -e 'lines.shift.say' example.txt\n",
    "Print the first 10 lines of a file (emulate head -10)\n",
    "\n",
    "perl6 -pe 'exit if ++$ > 10' example.txt\n",
    "perl6 -ne '.say if ++$ < 11' example.txt\n",
    "Print the last line of a file (emulate tail -1)\n",
    "\n",
    "perl6 -e 'lines.pop.say' example.txt\n",
    "Print the last 5 lines of a file (emulate tail -5)\n",
    "\n",
    "perl6 -e '.say for lines[*-5..*]' example.txt\n",
    "Print only lines that contain vowels\n",
    "\n",
    "perl6 -ne '/<[aeiou]>/ && .print' example.txt\n",
    "Print lines that contain all vowels\n",
    "\n",
    "perl6 -ne '.say if .comb (>=) <a e i o u>' example.txt\n",
    "perl6 -ne '.say if .comb ⊇ <a e i o u>' example.txt\n",
    "Print lines that are 80 chars or longer\n",
    "\n",
    "perl6 -ne '.print if .chars >= 80' example.txt\n",
    "perl6 -ne '.chars >= 80 && .print' example.txt\n",
    "Print only line 2\n",
    "\n",
    "perl6 -ne '.print if ++$ == 2' example.txt\n",
    "Print all lines except line 2\n",
    "\n",
    "perl6 -pe 'next if ++$ == 2' example.txt\n",
    "Print all lines 1 to 3\n",
    "\n",
    "perl6 -ne '.print if (1..3).any == ++$' example.txt\n",
    "Print all lines between two regexes (including lines that match regex)\n",
    "\n",
    "perl6 -ne '.print if /^Lorem/../laborum\\.$/' example.txt\n",
    "Print the length of the longest line\n",
    "\n",
    "perl6 -e 'say lines.max.chars' example.txt\n",
    "perl6 -ne 'state $l=0; $l = .chars if .chars > $l;END { $l.say }' example.txt\n",
    "Print the longest line\n",
    "\n",
    "perl6 -e 'say lines.max' example.txt\n",
    "perl6 -e 'my $l=\"\"; for (lines) {$l = $_ if .chars > $l.chars};END { $l.say }' example.txt\n",
    "Print all lines that contain a number\n",
    "\n",
    "perl6 -ne '.say if /\\d/' example.txt\n",
    "perl6 -e '.say for lines.grep(/\\d/)' example.txt\n",
    "perl6 -ne '/\\d/ && .say' example.txt\n",
    "perl6 -pe 'next if ! $_.match(/\\d/)' example.txt\n",
    "Find all lines that contain only a number\n",
    "\n",
    "perl6 -ne '.say if /^\\d+$/' example.txt\n",
    "perl6 -e '.say for lines.grep(/^\\d+$/)' example.txt\n",
    "perl6 -ne '/^\\d+$/ && .say' example.txt\n",
    "perl6 -pe 'next if ! $_.match(/^\\d+$/)' example.txt\n",
    "Print every odd line\n",
    "\n",
    "perl6 -ne '.say if ++$ % 2' example.txt\n",
    "Print every even line\n",
    "\n",
    "perl6 -ne '.say if ! (++$ % 2)' example.txt\n",
    "Print all lines that repeat\n",
    "\n",
    "perl6 -ne 'state %l;.say if ++%l{$_}==2' example.txt\n",
    "Print unique lines\n",
    "\n",
    "perl6 -ne 'state %l;.say if ++%l{$_}==1' example.txt\n",
    "Print the first field (word) of every line (emulate cut -f 1 -d ' ')\n",
    "\n",
    "perl6 -ne '.words[0].say' example.txt\n",
    "DATA TRANSFORMATION WITH PIPES\n",
    "\n",
    "Perl 6 programs integrate straight into the command line. You can pipe data in-to and out-of a one liner by using the pipe | character. For piping data in, Perl 6 automatically sets STDIN to $*IN. Just like with files, data piped in can be looped through using -n and is also available in lines. To pipe data out of a one liner just use print or say.\n",
    "\n",
    "JSON-encode a list of all files in the current directory\n",
    "\n",
    "ls | perl6 -M JSON::Tiny -e 'say to-json(lines)'\n",
    "Print a random sample of approx 5% of lines in a file\n",
    "\n",
    "perl6 -ne '.say if 1.rand <= 0.05' /usr/share/dict/words\n",
    "Color conversion, HTML to RGB\n",
    "\n",
    "echo \"#ffff00\" | perl6 -ne '.comb(/\\w\\w/).map({:16($_)}).say'\n",
    "Color conversion, RGB to HTML\n",
    "\n",
    "echo \"#ffff00\" | perl6 -ne '.comb(/\\w\\w/).map({:16($_)}).say'\n",
    "WWW\n",
    "\n",
    "Download a webpage\n",
    "\n",
    "perl6 -M HTTP::UserAgent -e 'say HTTP::UserAgent.new.get(\"google.com\").content'\n",
    "Download a webpage and strip out the HTML\n",
    "\n",
    "wget -O - \"http://perl6.org\" | perl6 -ne 's:g/\\<.+?\\>//.say'\n",
    "Download a webpage, strip out and decode the HTML\n",
    "\n",
    "wget -O - \"http://perl6.org\" | perl6 -MHTML::Strip -ne 'strip_html($_).say'\n",
    "Launch a simple web server\n",
    "\n",
    "perl6 -M HTTP::Server::Simple -e 'HTTP::Server::Simple.new.run'\n",
    "CONVERTING FOR WINDOWS\n",
    "\n",
    "Running one liners on Windows is a piece of cake once you know the rules of the road. One liners work on both cmd.exe and PowerShell. The cardinal rule is: replace the outer single-quotes with double quotes and use the interpolated quoting operator qq// for quoting strings inside a one liner. For non-interpolated quoting, you can use single-quotes. Let's look at some examples.\n",
    "\n",
    "Here's a simple one liner to print the time:\n",
    "\n",
    "perl6 -e 'say DateTime.now'\n",
    "To run on Windows, we just replace the single quotes with double quotes:\n",
    "\n",
    "perl6 -e \"say DateTime.now\"\n",
    "This one liner appends a newline to every line in a file, using an interpolated string:\n",
    "\n",
    "perl6 -pe '$_ ~= \"\\n\"' example.txt\n",
    "On Windows this should be written as:\n",
    "\n",
    "perl6 -pe \"$_ ~= qq/\\n/\" example.txt\n",
    "In this case we want to interpolate \\n as a newline and not literally add a backslash and an \"n\" to the line, so we have to use qq. But you can usually use single-quotes within a one liner so:\n",
    "\n",
    "perl6 -e 'say \"Hello, World!\"'\n",
    "On Windows can be written as:\n",
    "\n",
    "perl6 -e \"say 'hello, World!'\"\n",
    "Simple output redirection works like it does on Unix-based systems. This one liner prints an ASCII character index table to a file using >:\n",
    "\n",
    "perl6 -e \"say .chr ~ ' ' ~ $_ for 0..255\" > ascii_codes.txt\n",
    "When using > if the file doesn't exist, it will be created. If the file does exist, it will be overwritten. If you'd rather append to a file, use >> instead."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}