Sample Code

wiki

Lua 5.x

• Metatables - Classes
  • ClassesAndMethodsExample - a simple class implementation with inheritance (module)
  • LuaClassesWithMetatable - creating classes via metatables (tutorial and code) (editor note: possibly move)
  • YetAnotherClassImplementation - a complex class implementation with inheritance (module)
  • SimpleLuaClasses - class declaration - a metatable approach (tutorial, design pattern, and function)
  • MultipleInheritanceClasses - A multiple-inheritance class system including shared (virtual) inheritance (module)
  • ObjectLua - a simple implementation with single inheritance, virtual methods only, and Python-like access to super methods
  • ClassesViaModules - Each class is stored in a module and is automatically wrapped on require(). Supports namespaces.
  • See also ObjectOrientedProgramming.
• Metatables - Other Design Patterns
  • AccessHiddenTables - Access hidden tables using metatables (functions)
  • ComparisonByValue - make a table compare its keys by value rather than by reference
  • FuncTables - memoization of functions using callable tables (design pattern, code, and tutorial) (editor note: possibly move)
  • FunctionalTuples - implementing tuples in terms functions (design pattern and tutorial) (editor note: possibly move)
  • MutableFunctions - using functions to simulate the semantics of tables (design pattern)
  • ObjectProperties - implementing object properties - obj.field (function and design pattern)
  • ReadOnlyTables - making a table read-only via metamethods (function and design pattern)
  • OrderedAssociativeTable - iterate over a table using a sorted index (function and design pattern)
  • OrderedTable - iterate over tables in the order of key insertion (function and design pattern)
  • OrderedTableSimple - iterate over tables in the order of key insertion (function and design pattern)
  • ProxyBasedEncapsulation - encapsulation of objects via proxy tables (function/design pattern)
  • RecursiveDataTypes - handling recursive data types (design pattern and tutorial)
  • RecursiveReadOnlyTables - making a nested table read-only via metamethods (function and design pattern)
  • SetVariablesAndTablesWithFunction - recursively build and set table fields with dot notation--e.g. "x.y.z" (function and design pattern)
  • GeneralizedPairsAndIpairs - next, pairs, and ipairs reimplemented to call metamethods (design pattern and functions)
  • NextMetamethodForIndexTable - next()-like function for iterating table against table __index (function and design pattern)
  • AsciiMenu - console-based menu system, illustrating menu definition via chain of '.' calls (design pattern)
  • OverloadedFunctions - function dispatch by argument types which is defined implicitly by assignment into a virtual table
  • StrictStructs - create tables from a template, with checking for unknown fields
• Data Structures
  • See DataStructures
• Algorithms/Traversal
  • BinaryInsert - inserts a value into a sorted array via a binary search algorithm (function)
  • BinarySearch - searches for a value in a sorted array via a binary search algorithm (function)
  • InterpolatingSearch - searches for a value in a sorted array via an interpolating search algorithm (function)
  • LazySort - sort only as much of a table as is necessary (function and tutorial)
  • LuaSorting - a sample shellsort implementation in pure Lua (function)
  • SortedIteration - iterating a table in order by keys (function)
  • SortedIterationSimple - iterating a table in order by keys (function)
  • RangeIterator - a 'range' iterator function that acts like basic for loops
  • MultipleKeyIndexing - indexing by multiple keys implemented as a hash tree (module)
• String/Table Manipulation
  • SplitJoin - Perl-like string split/join functions (functions)
  • StandardLibraries - os, io, getopt, string, regex, xml, list/set/table, object, and math modules (modules)
  • StringInterpolation - interpolating variables into strings in Lua (functions and design patterns)
  • StringRecipes - solutions to various common string manipulation needs (example code)
  • VarExpand - bash-style inline variable and code expansion
  • LuaRecipes - useful code snippets and functions (design patterns)
  • LuaPrintf - emulation of printf string formatting (function)
  • FormattingNumbers - format numbers in monetary format (function)
  • EnhancedFileLines - functions for portably handling '\r\n' chars (functions)
  • StringIndexing - easy access to characters and substrings
• Preprocessing/Templates/Parsing
  • SimpleLuaPreprocessor - macro processor (function)
  • TextTemplate - macro processor (module)
  • SlightlyLessSimpleLuaPreprocessor - macro processor (function/program)
  • LpegRecipes - examples of using LPeg for parsing (examples)
  • LuaCsv - a simple comma-separated-value line parser (function)
  • See also LuaGrammar.
• Serialization
  • CopyTable - return deep copy of table (function)
  • DataDumper - dumps nearly any data into a Lua chunk string (function)
  • SaveTableToFile - Save a table to file/string (functions)
  • ReadWriteFormat - a way to pack / unpack integer values into a binary string (functions)
  • OutputLuaTableToHtmlFile - converts a Lua table into an HTML file (function)
  • PersistentTablesSqlite - persist Lua tables in SQLite database (sample code)
  • PickleTable - Lua table serialization (module)
  • ReadDefinedChunks - read delimited chunks from an file (function)
  • See also TableSerialization.
• Mathematics/Numbers
  • FloatSum - accurate floating point summation
  • SimpleRound - round number to n decimal places (functions)
  • SimpleStats - some simple statistics routes for tables.
  • LuaMatrix - basic matrix functions (module)
  • SimpleFit - curve fitting (module)
  • HammingNumbers - enumerate hamming numbers (function)
  • HammingNumbersVariant - enumerate hamming numbers, with lazy list (function)
  • ComplexNumbers - simple attempt to handle complex numbers (functions)
  • IntegerDomain - calculates the actual limits for integer numbers which can be exactly represented by Lua (function)
  • UnitConversion - converting intervals of time (can be extended to any non-uniform system of measurement, such as Imperial units)
  • HyperbolicFunctions - a pure Lua implementation for the hyperbolic trigonometric functions
• Encoding/Cryptography/Compression
  • BaseSixtyFour - Base64 encode/decode (functions)
  • HexDump - dump a string in typical 'hex dump' format
  • PortableNetworkGraphicsParser - partial PNG graphics file parser (example)
  • SymbolicDifferentiation - as titled, using Penlight library
  • SecureHashAlgorithm - hash functions SHA224 and SHA256 (for Lua 5.2)
• Filesystem
  • DirTreeIterator - iterator function for recursive file/directory traversal (function)
  • FileInputOutput - input/output file utility functions (functions)
  • FileGlob - matching filenames with glob expressions (function)
  • ExtensionProposal - extended os and io API (modules)
  • CppStreamChunkReader - lua_load chunk reader for any C++ std::istream (function)
• Coroutines
  • CopasExample - TCP socket server utilizing Copas library (examples)
  • CoroutinesAsConnectionHandlers - scaffolding for handling multiple sockets using coroutines (design pattern)
  • CoroutinesAsEventHandlers - scaffolding for handling event responders (design pattern)
  • FunWithCoroutines - tricks using coroutines: reverse string and control inversion (design patterns)
• Error Handling
  • LuaCarp - ensures error function is passed correct level, like Perl Carp (module)
• Testing / Types Checking / Profiling
  • LuaTypeChecking - implementing type checking in Lua (design patterns and code)
  • LuaUnit - LuaUnit unit testing framework (module)
  • ProfilerInLua - very simple Lua profiler (module)
  • See also UnitTesting
• Command Line
  • CommandLineModule - command line parsing
  • LappFramework - command line parsing
  • CompleteWithReadline - completion engine for standalone interpreter (functions)
• Module System
  • LuaModulesLoader - a Lua implementation of the standard Lua module loader
  • BinaryModulesLoader - a Lua implementation of the standard binary module loader
  • HashedModulesLoader - a module loader that verifies the module cryptographic hash prior to loading
  • RecursiveRequire - Handles recursive requires to a degree
• Time/Date
  • DealingWithDateTime - how do I simply add/remove any unit of time easily without worrying about dst (example code)
  • TimeZone - obtaining portable timezone string in form +hhmm or -hhmm (function)
  • DateFormattingFunctions - format date into various date string format (functions)
  • DayOfWeekAndDaysInMonthExample - calculate number of days in month or day of week in calendar day (functions)
  • WeekNumberInYear - calculate week number of the year according to ISO8601 (function)
  • DisplayCalendarInHtml - creates calendar in HTML (function)
• XML
  • LuaXml - handling XML with various libraries (sample code)
  • LxpTree - constructs an XML tree from a string/file using LazyKit (example code)
  • LuaProjectListToXml - read list of Lua projects from Lua website and output as XML (program)
• Web/HTML
  • GdThumbnail - thumbnailer using lua-gd (e.g. for web galleries or similar)
  • GettingTheTitleFromHtmlFiles - parse title tag from HTML files (command-line program)
  • LuaToHtml - convert (htmlize) Lua source to HTML (command-line program)
• Device I/O
  • SerialCommunication - RS-232 serial communication (module)
• Techniques / Design Patterns / Code Structure
  • SwitchStatement - emulating a C-style switch statement in Lua (design pattern)
  • ResourceAcquisitionIsInitialization - automatically releasing acquired resources on scope exit, RAII (module,pattern)
  • CppMetaprogramming - C++ metaprogramming using Lua (design pattern, library)
  • FiniteStateMachine - finite state machine (FSMs) (design pattern)
  • MakingLuaLikePhp - PHP-like functions implemented in Lua (functions)
  • MakingLuaLikeRuby - Simulating some of the semantics of Ruby in Lua (design pattern)
  • CurriedMemoization - A simple memoization implementation allowing multiple arguments and return values.
• Other
  • LuaCompilerInLua - reimplements the Lua compiler front-end (luac.c) in Lua (program)
  • LuaInterpreterInLua - reimplements the Lua interpreter (lua.c) in Lua (program)
  • RandomSample - random permutation/combination via lazy table approach (design pattern)
  • RandomStrings - generate random strings from defined char sets (function)
  • DemoScripts - random examples to showcase Lua
  • StlToObj - convert ASCII STL files to OBJ (Wavefront) files with optional coloring
  • LuaCad - Simple OpenSCAD wrapper for Lua in Windows
• Lua C API samples
  • C
    • BindingWithMetatableAndClosures
    • BindingWithMembersAndMethods
    • DeferredCall - deferred calls using C closures
    • EasyManualLibraryLoad - greatly simplifies manual loading (GetProcAddress or dlsym) of Lua 5.1 shared library (.dll or .so)
    • GettingValuesFromLua (4.x and 5.x)
    • LibraryWithUserdataExample (5.2)
    • LuaGenericCall - a single function to call Lua interpreter from C, exchanging nearly any type of data
    • LuaLaunchers - sample code for launching Lua as a standalone app
    • LexicalAnalysis
    • SimpleLuaApiExample - simple intro to interfacing to Lua from C: C program loads/runs a Lua script file, sets Lua variables and retrieves return value (example)
    • StringReplace
    • UserDataExample
    • UserDataWithPointerExample
    • FileLineMacros - implements a simple __FILE__ and __LINE__ macro mechanism in the Lua parser. (Uses the internals of Lua, not the official Lua C API.)
    • ValidateUnicodeString - extends Lua to handle UTF-8 strings with new string.* methods.
    • UnicodeIdentifers - extends Lua to handle Lua UTF-8 identifiers (variable and function names)
  • C++
    • CallingLuaFromCpp
    • CppConvenientLuaWrapperClass
    • CppLuaDataPassing - passsing data between C++ and Lua
    • CppObjectBinding
    • DoItYourselfCppBinding
    • ExtractingWxClasses
    • SimplerCppBinding
  • Objective-C
    • VeritasMachine(Lua-ObjC bind and implementation)

Lua 4.x

These should be upgraded to the latest Lua version.

• Lua samples
  • ClassesAndMethods
  • DebuggingAndTesting
  • ListDep - outputs a list of dependencies between Lua files (command-line program)
  • ListOperations - utility functions operating on lists, functional programming (functions)
  • LuaFunctors
  • MailBoxParsing
  • NamespacesAndModules - module/namespace handling in Lua 4 (design pattern) (Lua 4 specific)

• PersistentTables
• PhiLhoSoftLuaSamples
• PythonDictionaries
• PythonLists
• ShellAccess
• SimpleDebugger
• TextJustification
• TextProcessing
• VectorGlue
• Lua C API samples
  • C
    • VectorLibrarySample
  • C++
    • SimpleCppBinding

See also

• OptimisationTips - for making Lua code more efficient
• OptimizedSampleCode - for best known algorithms that perform the specified tasks
• LuaDirectory - for solutions to common problems
• LuaTutorial - for usage examples of core Lua functions (examples)
• LibrariesAndBindings - for modules (modules)
• LuaForge - for programs and modules in Lua (modules, programs)
• LuaDesignPatterns - for design patterns in Lua (design patterns)