HERE'S HOW YOU CAN USE SWITCH CASES IN LUA
       
   IMG iillustration-9.png
       
       Kidding! You can't! Lua doesn't have a `switch'
       operator. Instead, it has tables. And tables are actually
       much more interesting, and far easier to work into a routine
       that requires evaluating statements based on
       conditions. Don't believe me? Here's an example of how I've
       put tables to use.
       
       The context: I'm building a RSS reader for
       KOReader. Sometimes the RSS reader needs to fetch a web
       page, which it then parses, deconstructs, and re-builds as
       an EPUB. To re-build the web page into an EPUB, I create
       objects for each of the website's components, like the HTML
       document and any images it contains. I call these
       "items". Different types of items have different private
       methods, but they all share the same two data points: `path'
       and `content'. Because all items share these two data
       points, I've decided to make a common interface for their
       construction: `ItemFactory'.  Supplying the `makeItem'
       method within `ItemFactory' with the item's `path' and
       `content' will "automatically" construct the item with the
       appropriate constructor.
       
       How? First: a file extension is derived from the item's
       `path.' This value is matched against the `ITEM_TYPES'
       table. The keys of this table represent the supported item
       types. The values for each key represent the item type's
       supported file formats (given as extensions). When a match
       is found, the table key is stored in a variable. Next, (and
       this is the exciting part) that variable's value is used as
       an index into the `ITEM_CONSTRUCTORS' table, which contains
       constructors for each supported item type. The indexed
       constructor is returned and then supplied with the `path'
       and `content' data that was passed to the factory.
       
       Cool, right? What I love so much about this no-switch
       switch-like logic is that the `makeItem' method basically
       reads like a unit test. It stays focused on returning errors
       when conditions aren't met. The actually divining of what
       code gets evaluated, and what that code does/looks like gets
       tucked away into a table. Extending the code is simple,
       maintaining the code is clear. It's bliss!
       
       ,----
       |   local ItemFactory = {
       | 
       |   }
       | 
       |   ItemFactory.ITEM_TYPES = {
       |      xhtml = XHtmlItem.SUPPORTED_FORMATS,
       |      image = Image.SUPPORTED_FORMATS
       |   }
       | 
       |   ItemFactory.ITEM_CONSTRUCTORS = {
       |      xhtml = function(path, content)
       |         return XHtmlItem:new{
       |            path = path,
       |            content = content,
       |         }
       |      end,
       |      image = function(path, content)
       |         return Image:new{
       |            path = path,
       |            content = content
       |         }
       |      end
       |   }
       | 
       |   function ItemFactory:makeItem(path, content)
       |      local suffix = util.getFileNameSuffix(
       |         string.lower(path)
       |      )
       | 
       |      local matched_type = ItemFactory:getItemTypeFromFileNameSuffix(suffix)
       |      if not matched_type
       |      then
       |         return false, EpubError.ITEMFACTORY_UNSUPPORTED_TYPE
       |      end
       | 
       |      local item_constructor = ItemFactory.ITEM_CONSTRUCTORS[matched_type]
       |      if not item_constructor
       |      then
       |         return false, EpubError.ITEMFACTORY_NONEXISTENT_CONSTRUCTOR
       |      end
       | 
       |      return item_constructor(path, content)
       |   end
       | 
       |   function ItemFactory:getItemTypeFromFileNameSuffix(suffix)
       |      local matched_item_type = nil
       |      for item_type, supported_formats in pairs(ItemFactory.ITEM_TYPES) do
       |         if supported_formats[suffix]
       |         then
       |            matched_item_type = item_type
       |            break
       |         end
       |      end
       |      return matched_item_type
       |   end
       | 
       |   return ItemFactory
       `----