-- Create a simple player systemlocal player = { name = "Hero", health = 100, position = {x = 0, y = 0}}function player:move(dx, dy) self.position.x = self.position.x + dx self.position.y = self.position.y + dy print(string.format("%s moved to (%d, %d)", self.name, self.position.x, self.position.y))endfunction player:takeDamage(amount) self.health = self.health - amount if self.health <= 0 then print(self.name .. " has been defeated!") endend-- Test the playerplayer:move(10, 5)player:takeDamage(30)print("Health remaining: " .. player.health)
4
Add Type Annotations
Now let’s make the code better with EmmyLua annotations. Update main.lua:
---@class Player---@field name string The player's name---@field health number Current health points (0-100)---@field position Position The player's position in world spacelocal Player = {}Player.__index = Player---@class Position---@field x number X coordinate---@field y number Y coordinate---Create a new player instance---@param name string The player's name---@param health? number Starting health (defaults to 100)---@return Playerfunction Player.new(name, health) local self = setmetatable({}, Player) self.name = name self.health = health or 100 self.position = {x = 0, y = 0} return selfend---Move the player by the specified delta---@param dx number Change in x direction---@param dy number Change in y directionfunction Player:move(dx, dy) self.position.x = self.position.x + dx self.position.y = self.position.y + dy print(string.format("%s moved to (%d, %d)", self.name, self.position.x, self.position.y))end---Apply damage to the player---@param amount number Damage amount---@return boolean alive True if player is still alivefunction Player:takeDamage(amount) self.health = self.health - amount if self.health <= 0 then print(self.name .. " has been defeated!") return false end return trueend---Get the distance from another position---@param pos Position Target position---@return number distance The Euclidean distancefunction Player:distanceTo(pos) local dx = self.position.x - pos.x local dy = self.position.y - pos.y return math.sqrt(dx * dx + dy * dy)end-- Example usagelocal hero = Player.new("Hero", 100)hero:move(10, 5)local alive = hero:takeDamage(30)if alive then print("Health remaining: " .. hero.health)endlocal target = {x = 20, y = 10}local distance = hero:distanceTo(target)print(string.format("Distance to target: %.2f", distance))
5
Experience the Features
Open the file in your editor and try these features:
Auto-Completion
Type hero: and you’ll see:
move - Move the player by the specified delta
takeDamage - Apply damage to the player
distanceTo - Get the distance from another position
All fields: name, health, position
The completion includes type information and documentation!
Hover Information
Hover over:
Player.new → See the function signature and documentation
hero → See it’s type Player with all fields
self.health → See it’s type number and description
Go to Definition
Ctrl+Click (or Cmd+Click) on Player.new to jump to its definition
Works across files in your project
Jump back with Alt+Left Arrow
Find References
Right-click on Player and select “Find All References”
Let’s create a more advanced example with generics:
---A generic container for storing items---@class Container<T>---@field private items T[]---@field capacity number Maximum number of itemslocal Container = {}Container.__index = Container---Create a new container---@generic T---@param capacity number Maximum capacity---@return Container<T>function Container.new(capacity) local self = setmetatable({}, Container) self.items = {} self.capacity = capacity return selfend---Add an item to the container---@generic T---@param item T The item to add---@return boolean success True if item was addedfunction Container:add(item) if #self.items >= self.capacity then return false end table.insert(self.items, item) return trueend---Get all items matching a predicate---@generic T---@param predicate fun(item: T): boolean Filter function---@return T[] matches Items matching the predicatefunction Container:filter(predicate) local result = {} for _, item in ipairs(self.items) do if predicate(item) then table.insert(result, item) end end return resultend---Map items to a new type---@generic T, R---@param mapper fun(item: T): R Transform function---@return Container<R> newContainer Container with transformed itemsfunction Container:map(mapper) local result = Container.new(self.capacity) for _, item in ipairs(self.items) do result:add(mapper(item)) end return resultend-- Example usage with full type inferencelocal numbers = Container.new(10) ---@type Container<number>numbers:add(1)numbers:add(2)numbers:add(3)-- Filter even numberslocal evens = numbers:filter(function(n) return n % 2 == 0end)-- Map to stringslocal strings = numbers:map(function(n) return tostring(n)end) -- Type: Container<string>print("Container demo complete!")
Notice how EmmyLua tracks the generic types through the filter and map operations, providing accurate type information at every step!
