From 2ff4152415755546455d8b792bb062b882213127 Mon Sep 17 00:00:00 2001
From: Bruce Hill <bitbucket@bruce-hill.com>
Date: Sun, 11 Feb 2018 16:50:03 -0800
Subject: [PATCH] Added `lua` markdown.

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 0391d09..6aba2ea 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ This code has been tested with Lua 5.1.5, Lua 5.2.3, Lua 5.3.5, and LuaJIT 2.0.5
 
 ## Usage
 Here's a simple implementation of a 2-d vector using immutable tables:
-```
+```lua
 immutable = require "immutable"
 Vec = immutable({"x","y"}, {
     name='Vector',
@@ -45,19 +45,19 @@ assert(NotVec(1,2) ~= Vec(1,2))
 
 ## Singleton recipe
 Singletons are pretty straightforward:
-```
+```lua
 Singleton = immutable()
 assert(Singleton() == Singleton())
 ```
 Or if you want methods/class variables:
-```
+```lua
 DogSingleton = immutable(0, {name="DogSingleton", bark=function(self) print("woof") end})
 DogSingleton():bark()
 ```
 
 ## Tuple recipe
 With immutable tables, it's pretty simple to emulate Python-like tuples:
-```
+```lua
 local tuple_classes = {}
 Tuple = function(...)
     local n = select('#', ...)
@@ -73,7 +73,7 @@ assert(tostring(Tuple(8,9)) == "(8, 9)")
 ## General purpose immutable table recipe
 Using the tuple recipe above, you can make a function that returns an immutable version
 of a table with arbitrary keys.
-```
+```lua
 local immutable_classes = {}
 Immutable = function(t)
     local keys = {}
@@ -90,7 +90,7 @@ assert(Immutable{a=1,b=2,c=3} == Immutable{a=1,b=2,c=3})
 
 ## Implementation details
 Under the hood, immutable tables are implemented in C as a userdata (that stores a hash value) with a metatable. That metatable has a weak-keyed mapping from hash -> userdata -> associated data. Immutable tables *are* garbage collected, so if you no longer have any references to the userdata, the userdata will get garbage collected, which will result in the entry being removed from the metatable's mapping. When new instances are created, a hash value is computed, and all the data in the associated hash bucket is scanned to look for duplicates. If a match is found, that existing instance is returned, otherwise a new one is created and added to the hash bucket. The following lua pseudocode approximates the C implementation's behavior:
-```
+```lua
 function immutable(fields, class_fields)
     local cls = {
         __index = function(self, key)