20160708-dojo-breaking-out-of-nested-loops-to-variable-levels.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plays with using try/raise to break out of nested loops.\n",
    "\n",
    "This is inspired by Travis Risner's\n",
    "[play_break.py](https://github.com/deeppunster/deep-punster/blob/master/play_break.py),\n",
    "but is much cruder than his code\n",
    "and has significant differences in kind from his code.\n",
    "- exception does not return (this is probably the biggest difference)\n",
    "- matches on a tuple\n",
    "- exception is an argument\n",
    "- range(2) for smaller example output\n",
    "\n",
    "This was fun to play with,\n",
    "but this variable level break stuff makes my head hurt.\n",
    "So it is probably a bad idea.\n",
    "One should probably rearrange the code some other way.\n",
    "What real world application can you think of where\n",
    "this kind of code is the simplest, most succinct,\n",
    "easiest to read solution?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class FirstLevelBreak(Exception): pass\n",
    "class SecondLevelBreak(Exception): pass\n",
    "class ThirdLevelBreak(Exception): pass\n",
    "\n",
    "def show_break(level, i, x_y_z):\n",
    "    print(\n",
    "        '    ',\n",
    "        'Broke with i={} at x,y,z = {} ({} level) '.format(\n",
    "        i,\n",
    "        x_y_z,\n",
    "        level))\n",
    "\n",
    "def foo(limit, exception):\n",
    "    print()\n",
    "    print('foo(limit=%r, exception=%r)' % (limit, exception))\n",
    "    i = 0\n",
    "    try:\n",
    "        for x in range(2):\n",
    "            try:\n",
    "                for y in range(2):\n",
    "                    try:\n",
    "                        for z in range(2):\n",
    "                            print('    ', (x,y,z))\n",
    "                            if (x,y,z) == limit:\n",
    "                                raise exception\n",
    "                            i += 1\n",
    "                    except ThirdLevelBreak:\n",
    "                        show_break('third', i, (x,y,z))\n",
    "            except SecondLevelBreak:\n",
    "                show_break('second', i, (x,y,z))\n",
    "    except FirstLevelBreak:\n",
    "        show_break('first', i, (x,y,z))\n",
    "    print('exiting with i=%s, x,y,z=%s' % (i, (x,y,z)))\n",
    "    return i, (x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "foo(limit=(0, 0, 0), exception=<class '__main__.ThirdLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     Broke with i=0 at x,y,z = (0, 0, 0) (third level) \n",
      "     (0, 1, 0)\n",
      "     (0, 1, 1)\n",
      "     (1, 0, 0)\n",
      "     (1, 0, 1)\n",
      "     (1, 1, 0)\n",
      "     (1, 1, 1)\n",
      "exiting with i=6, x,y,z=(1, 1, 1)\n",
      "\n",
      "foo(limit=(0, 0, 0), exception=<class '__main__.SecondLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     Broke with i=0 at x,y,z = (0, 0, 0) (second level) \n",
      "     (1, 0, 0)\n",
      "     (1, 0, 1)\n",
      "     (1, 1, 0)\n",
      "     (1, 1, 1)\n",
      "exiting with i=4, x,y,z=(1, 1, 1)\n",
      "\n",
      "foo(limit=(0, 0, 0), exception=<class '__main__.FirstLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     Broke with i=0 at x,y,z = (0, 0, 0) (first level) \n",
      "exiting with i=0, x,y,z=(0, 0, 0)\n",
      "\n",
      "foo(limit=(1, 0, 0), exception=<class '__main__.ThirdLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     (0, 0, 1)\n",
      "     (0, 1, 0)\n",
      "     (0, 1, 1)\n",
      "     (1, 0, 0)\n",
      "     Broke with i=4 at x,y,z = (1, 0, 0) (third level) \n",
      "     (1, 1, 0)\n",
      "     (1, 1, 1)\n",
      "exiting with i=6, x,y,z=(1, 1, 1)\n",
      "\n",
      "foo(limit=(1, 0, 0), exception=<class '__main__.SecondLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     (0, 0, 1)\n",
      "     (0, 1, 0)\n",
      "     (0, 1, 1)\n",
      "     (1, 0, 0)\n",
      "     Broke with i=4 at x,y,z = (1, 0, 0) (second level) \n",
      "exiting with i=4, x,y,z=(1, 0, 0)\n",
      "\n",
      "foo(limit=(1, 0, 0), exception=<class '__main__.FirstLevelBreak'>)\n",
      "     (0, 0, 0)\n",
      "     (0, 0, 1)\n",
      "     (0, 1, 0)\n",
      "     (0, 1, 1)\n",
      "     (1, 0, 0)\n",
      "     Broke with i=4 at x,y,z = (1, 0, 0) (first level) \n",
      "exiting with i=4, x,y,z=(1, 0, 0)\n",
      "\n",
      "foo(limit=(None, None, None), exception=None)\n",
      "     (0, 0, 0)\n",
      "     (0, 0, 1)\n",
      "     (0, 1, 0)\n",
      "     (0, 1, 1)\n",
      "     (1, 0, 0)\n",
      "     (1, 0, 1)\n",
      "     (1, 1, 0)\n",
      "     (1, 1, 1)\n",
      "exiting with i=8, x,y,z=(1, 1, 1)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(8, (1, 1, 1))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo((0, 0, 0), ThirdLevelBreak)\n",
    "foo((0, 0, 0), SecondLevelBreak)\n",
    "foo((0, 0, 0), FirstLevelBreak)\n",
    "foo((1, 0, 0), ThirdLevelBreak)\n",
    "foo((1, 0, 0), SecondLevelBreak)\n",
    "foo((1, 0, 0), FirstLevelBreak)\n",
    "foo((None, None, None), None)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}