01-lua-basics.ipynb

{
 "metadata": {
  "language": "lua",
  "name": "",
  "signature": "sha256:907c16d0af4248ec6721b3aed641eca6a5d3f40d6cc0576042b15092661e1c66"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#An overview of Lua, by http://learnxinyminutes.com/docs/lua/"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Two dashes start a one-line comment."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "--[[\n",
      "     Adding two ['s and ]'s makes it a\n",
      "     multi-line comment.\n",
      "--]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Variables and flow control"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "num = 42  -- All numbers are doubles."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = 'walternate'  -- Immutable strings like Python."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t = \"double-quotes are also fine\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "u = [[ Double brackets\n",
      "       start and end\n",
      "       multi-line strings.]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t = nil  -- Undefines t; Lua has garbage collection."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Blocks are denoted with keywords like do/end:\n",
      "while num < 50 do\n",
      "  num = num + 1  -- No ++ or += type operators.\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- If clauses:\n",
      "if num > 40 then\n",
      "  print('over 40')\n",
      "elseif s ~= 'walternate' then  -- ~= is not equals.\n",
      "  -- Equality check is == like Python; ok for strs.\n",
      "  io.write('not over 40\\n')  -- Defaults to stdout.\n",
      "else\n",
      "  -- Variables are global by default.\n",
      "  thisIsGlobal = 5  -- Camel case is common.\n",
      "\n",
      "  -- How to make a variable local:\n",
      "  local line = io.read()  -- Reads next stdin line.\n",
      "\n",
      "  -- String concatenation uses the .. operator:\n",
      "  print('Winter is coming, ' .. line)\n",
      "end\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "over 40\t\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Undefined variables return nil.\n",
      "-- This is not an error:\n",
      "foo = anUnknownVariable  -- Now foo = nil."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "aBoolValue = false"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Only nil and false are falsy; 0 and '' are true!\n",
      "if not aBoolValue then print('twas false') end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "twas false\t\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- 'or' and 'and' are short-circuited. This is similar to the a?b:c operator\n",
      "-- in C/js:\n",
      "aBoolValue and 'yes' or 'no'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "no\t\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "karlSum = 0\n",
      "for i = 1, 100 do  -- The range includes both ends.\n",
      "  karlSum = karlSum + i\n",
      "end\n",
      "print(karlSum)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "5050\t\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Use \"100, 1, -1\" as the range to count down:\n",
      "fredSum = 0\n",
      "for j = 100, 1, -1 do fredSum = fredSum + j end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- In general, the range is begin, end[, step]."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Another loop construct:\n",
      "num = 100\n",
      "repeat\n",
      "  num = num - 1\n",
      "until num == 0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function fib(n)\n",
      "  if n < 2 then return n end\n",
      "  return fib(n - 2) + fib(n - 1)\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Closures and anonymous functions are ok:\n",
      "function adder(x)\n",
      "  -- The returned function is created when adder is called, and remembers the\n",
      "  -- value of x:\n",
      "  return function (y) return x + y end\n",
      "end\n",
      "a1 = adder(9)\n",
      "a2 = adder(36)\n",
      "print(a1(16))  --> 25\n",
      "print(a2(64))  --> 100"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "25\t\n",
        "100\t\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Returns, func calls, and assignments all work with lists that may be\n",
      "-- mismatched in length. Unmatched receivers are nil; unmatched senders are\n",
      "-- discarded.\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, y, z = 1, 2, 3, 4\n",
      "-- Now x = 1, y = 2, z = 3, and 4 is thrown away."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function bar(a, b, c)\n",
      "  print(a, b, c)\n",
      "  return 4, 8, 15, 16, 23, 42\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, y = bar('zaphod')  --> prints \"zaphod  nil nil\"\n",
      "-- Now x = 4, y = 8, values 15..42 are discarded."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "zaphod\tnil\tnil\t\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Functions are first-class, may be local/global. These are the same:\n",
      "function f(x) return x * x end\n",
      "f = function (x) return x * x end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- And so are these:\n",
      "local function g(x) return math.sin(x) end\n",
      "local g = function(x) return math.sin(x) end\n",
      "-- Equivalent to local function g(x)..., except referring to g in the function\n",
      "-- body won't work as expected.\n",
      "local g; g  = function (x) return math.sin(x) end\n",
      "-- the 'local g' decl makes g-self-references ok."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Calls with one string param don't need parens:\n",
      "print 'hello'  -- Works fine."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "hello\t\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Calls with one table param don't need parens either (more on tables below):\n",
      "print {} -- Works fine too."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "{\n",
        "}\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Tables"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Lua's only compound data structure; they are associative arrays.  \n",
      "Similar to php arrays or js objects, they are hash-lookup dicts that can also be used as lists."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Using tables as dictionaries / maps:\n",
      "\n",
      "-- Dict literals have string keys by default:\n",
      "t = {key1 = 'value1', key2 = false}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- String keys can use js-like dot notation:\n",
      "print(t.key1)  -- Prints 'value1'.\n",
      "t.newKey = {}  -- Adds a new key/value pair.\n",
      "t.key2 = nil   -- Removes key2 from the table.\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "value1\t\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Literal notation for any (non-nil) value as key:\n",
      "u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}\n",
      "print(u[6.28])  -- prints \"tau\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "tau\t\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Key matching is basically by value for numbers and strings, but by identity\n",
      "-- for tables.\n",
      "a = u['@!#']  -- Now a = 'qbert'.\n",
      "b = u[{}]     -- We might expect 1729, but it's nil:\n",
      "-- b = nil since the lookup fails. It fails because the key we used is not the\n",
      "-- same object as the one used to store the original value. So strings &\n",
      "-- numbers are more portable keys."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- A one-table-param function call needs no parens:\n",
      "function h(x) print(x.key1) end\n",
      "h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "Sonmi~451\t\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for key, val in pairs(u) do  -- Table iteration.\n",
      "  print(key, val)\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 33,
       "text": [
        "@!#\tqbert\t\n",
        "{\n",
        "}\n",
        "1729\t\n",
        "6.28\ttau\t\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- _G is a special table of all globals.\n",
      "print(_G['_G'] == _G)  -- Prints 'true'.\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 34,
       "text": [
        "true\t\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- Using tables as lists / arrays:\n",
      "-- List literals implicitly set up int keys:\n",
      "v = {'value1', 'value2', 1.21, 'gigawatts'}\n",
      "for i = 1, #v do  -- #v is the size of v for lists.\n",
      "  print(v[i])  -- Indices start at 1 !! SO CRAZY!\n",
      "end\n",
      "-- A 'list' is not a real type. v is just a table with consecutive integer\n",
      "-- keys, treated as a list."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 35,
       "text": [
        "value1\t\n",
        "value2\t\n",
        "1.21\t\n",
        "gigawatts\t\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Metatables and metamethods."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- A table can have a metatable that gives the table operator-overloadish\n",
      "-- behavior. Later we'll see how metatables support js-prototypey behavior.\n",
      "\n",
      "f1 = {a = 1, b = 2}  -- Represents the fraction a/b.\n",
      "f2 = {a = 2, b = 3}\n",
      "\n",
      "-- This would fail:\n",
      "-- s = f1 + f2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "metafraction = {}\n",
      "function metafraction.__add(f1, f2)\n",
      "  local sum = {}\n",
      "  sum.b = f1.b * f2.b\n",
      "  sum.a = f1.a * f2.b + f2.a * f1.b\n",
      "  return sum\n",
      "end\n",
      "\n",
      "setmetatable(f1, metafraction)\n",
      "setmetatable(f2, metafraction)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = f1 + f2  -- call __add(f1, f2) on f1's metatable\n",
      "print(s)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 38,
       "text": [
        "{\n",
        "  b : 6\n",
        "  a : 7\n",
        "}\n"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- f1, f2 have no key for their metatable, unlike prototypes in js, so you must\n",
      "-- retrieve it as in getmetatable(f1). The metatable is a normal table with\n",
      "-- keys that Lua knows about, like __add.\n",
      "-- But the next line fails since s has no metatable:\n",
      "-- t = s + s\n",
      "-- Class-like patterns given below would fix this."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- An __index on a metatable overloads dot lookups:\n",
      "defaultFavs = {animal = 'gru', food = 'donuts'}\n",
      "myFavs = {food = 'pizza'}\n",
      "setmetatable(myFavs, {__index = defaultFavs})\n",
      "eatenBy = myFavs.animal  -- works! thanks, metatable\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "--------------------------------------------------------------------------------\n",
      "-- Direct table lookups that fail will retry using the metatable's __index\n",
      "-- value, and this recurses.\n",
      "\n",
      "-- An __index value can also be a function(tbl, key) for more customized\n",
      "-- lookups.\n",
      "\n",
      "-- Values of __index,add, .. are called metamethods.\n",
      "-- Full list. Here a is a table with the metamethod.\n",
      "\n",
      "-- __add(a, b)                     for a + b\n",
      "-- __sub(a, b)                     for a - b\n",
      "-- __mul(a, b)                     for a * b\n",
      "-- __div(a, b)                     for a / b\n",
      "-- __mod(a, b)                     for a % b\n",
      "-- __pow(a, b)                     for a ^ b\n",
      "-- __unm(a)                        for -a\n",
      "-- __concat(a, b)                  for a .. b\n",
      "-- __len(a)                        for #a\n",
      "-- __eq(a, b)                      for a == b\n",
      "-- __lt(a, b)                      for a < b\n",
      "-- __le(a, b)                      for a <= b\n",
      "-- __index(a, b)  <fn or a table>  for a.b\n",
      "-- __newindex(a, b, c)             for a.b = c\n",
      "-- __call(a, ...)                  for a(...)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Class-like tables and inheritance."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Dog = {}                                   -- 1.\n",
      "\n",
      "function Dog:new()                         -- 2.\n",
      "  local newObj = {sound = 'woof'}          -- 3.\n",
      "  self.__index = self                      -- 4.\n",
      "  return setmetatable(newObj, self)        -- 5.\n",
      "end\n",
      "\n",
      "function Dog:makeSound()                   -- 6.\n",
      "  print('I say ' .. self.sound)\n",
      "end\n",
      "\n",
      "mrDog = Dog:new()                          -- 7.\n",
      "mrDog:makeSound()  -- 'I say woof'         -- 8."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 42,
       "text": [
        "I say woof\t\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1. Dog acts like a class; it's really a table.\n",
      "2. \"function tablename:fn(...)\" is the same as\n",
      "    \"function tablename.fn(self, ...)\", The : just adds a first arg called\n",
      "    self. Read 7 & 8 below for how self gets its value.\n",
      "3. newObj will be an instance of class Dog.\n",
      "4. \"self\" is the class being instantiated. Often self = Dog, but inheritance\n",
      "    can change it. newObj gets self's functions when we set both newObj's\n",
      "    metatable and self's __index to self.\n",
      "5. Reminder: setmetatable returns its first arg.\n",
      "6. The : works as in 2, but this time we expect self to be an instance\n",
      "   instead of a class.\n",
      "7. Same as Dog.new(Dog), so self = Dog in new().\n",
      "8. Same as mrDog.makeSound(mrDog); self = mrDog."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}