Metatable

local x = {}
local metaTable = {} -- Metatable'lar da tablodur!
setmetatable(x, metaTable) -- x'e metaTable adında bir metatable ver!
print(getmetatable(x)) --> table: [hexadecimal memory address]

local x = {}
setmetatable(x, {})

local x = setmetatable({}, {})

local vector2 = {__type = "vector2"}
local mt = {__index = vector2}

function mt.__div(a, b)
	if type(a) == "number" then
		-- a bir skalar, b bir vektör
		local scalar, vector = a, b
		return vector2.new(scalar / vector.x, scalar / vector.y)
	elseif type(b) == "number" then
		-- a bir vektör, b bir skalar
		local vector, scalar = a, b
		return vector2.new(vector.x / scalar, vector.y / scalar)
	elseif (a.__type and a.__type == "vector2" and b.__type and b.__type == "vector2") then
		-- hem a hem de b vektörler
		return vector2.new(a.x / b.x, a.y / b.y)
	end
end

function mt.__tostring(t)
	return t.x .. ", " .. t.y
end

function vector2.new(x, y)
	local self = setmetatable({}, mt)
	self.x = x or 0
	self.y = y or 0
	return self
end

local a = vector2.new(10, 5)
local b = vector2.new(-3, 4)

print(a / b) -- -3.3333333333333, 1.25
print(b / a) -- -0.3, 0.8
print(2 / a) -- 0.2, 0.4
print(a / 2) -- 5, 2.5

local metatable = {
	__unm = function(t) -- __unm unary - operatörü içindir
    local negated = {}
  	for key, value in t do
  		negated[key] = -value -- bu tablodaki tüm değerleri negatif hale getir
  	end
  	return negated -- tabloyu döndür
	end
}

local table1 = setmetatable({10, 11, 12}, metatable)
print(table.concat(-table1, "; ")) --> -10; -11; -12

local metatable = {
	__index = {x = 1}
}

local t = setmetatable({}, metatable)
print(t.x) --> 1

local t = {10, 20, 30}
print(t(5))

local metatable = {
	__call = function(t, param)
	local sum = {}
		for i, value in ipairs(t) do
			sum[i] = value + param -- Argümanı (5) değere ekleyin, ardından yeni tabloya (t) yerleştirin.
		end
		return unpack(sum) -- Bireysel tablo değerlerini döndür
	end
}

local t = setmetatable({10, 20, 30}, metatable)
print(t(5)) --> 15 25 35

local table1 = {10, 11, 12}
local table2 = {13, 14, 15}

for k, v in table1 + table2 do
	print(k, v)
end

local metatable = {
	__add = function(t1, t2)
		local sum = {}
		for key, value in t1 do
			sum[key] = value
		end

		for key, value in t2 do
			if sum[key] then
				sum[key] += value
			else
				sum[key] = value
			end
		end
		return sum
	end
}

local table1 = setmetatable({10, 11, 12}, metatable)
local table2 = setmetatable({13, 14, 15}, metatable)

for k, v in table1 + table2 do
	print(k, v)
end

local t = setmetatable({}, {
    __index = function(self, i)
    	self[i] = i * 10
    	return self[i]
    end,
    __newindex = function(self, i, v)
    	-- Değerleri tabloya normal şekilde ayarlamayın
    end
})
print(t[1]) -- Yığın taşması oluşturur

local t = setmetatable({}, {
	__index = function(self, i)
		rawset(self, i, i * 10)
		return self[i]
	end,
	__newindex = function(self, i, v)
		-- Değerleri tabloya normal şekilde ayarlamayın
	end
})
print(t[1]) --> 10

local map = {key = 1}
local mapReference = map
print(map == mapReference) --> true
print(map == {key = 1}) --> false

local function func() end
local funcReference = func
print(func == funcReference) --> true

local part = Instance.new("Part")
local partReference = part
print(part == partReference) --> true

local child = {}
local parent = {Child = child}
child = nil

print(parent.Child) --> table: [hexadecimal memory address]

local children = setmetatable({}, {
	__mode = "v",
})

do
	local child = {}
	children.example = child
end

local Set = {}
Set.__index = Set

-- Opsiyonel bir öğe listesi ile bir set oluşturma fonksiyonu
function Set.new(items)
	local newSet = {}
	for key, value in items or {} do
		newSet[value] = true
	end
	return setmetatable(newSet, Set)
end

-- Bir öğeyi bir sete eklemek için fonksiyon
function Set:add(item)
	self[item] = true
end

-- Bir öğeyi bir setten çıkarmak için fonksiyon
function Set:remove(item)
	self[item] = nil
end

-- Bir setin bir öğeyi içerip içermediğini kontrol etmek için fonksiyon
function Set:contains(item)
	return self[item] == true
end

-- Hata ayıklama için seti virgülle ayrılmış bir liste olarak çıktısını almak için fonksiyon
function Set:output()
	local elems = {}
	for key, value in self do
		table.insert(elems, tostring(key))
	end
	print(table.concat(elems, ", "))
end

local fruits = Set.new({"Elma", "Limon", "Portakal", "Kiraz", "Lime", "Şeftali"})

local fruits = Set.new({"Elma", "Limon", "Portakal", "Kiraz", "Lime", "Şeftali"})
fruits:add("Mango")

local fruits = Set.new({"Elma", "Limon", "Portakal", "Kiraz", "Lime", "Şeftali"})
fruits:remove("Portakal")

local fruits = Set.new({"Elma", "Limon", "Portakal", "Kiraz", "Lime", "Şeftali"})

local result1 = fruits:contains("Kiraz")
print(result1) -- true

local result2 = fruits:contains("Karpuz")
print(result2) -- false

local function getIntersection(set1, set2)
	local result = Set.new()
	for key, value in set1 do
		if set2:contains(key) then
			result:add(key)
		end
	end
	return result
end

local freshFruits = Set.new({"Mango", "Limon", "Portakal", "Kiraz", "Lime", "Şeftali"})
local frozenFruits = Set.new({"Mango", "Şeftali", "Ananas"})

local commonFruits = getIntersection(freshFruits, frozenFruits)
commonFruits:output() -- Mango, Şeftali

function Set:__add(otherSet)
	local result = Set.new()
	for entry in self do
		result[entry] = true
	end
	for entry in otherSet do
		result[entry] = true
	end
	return result
end

local sweetFruits = Set.new({"Elma", "Mango", "Kiraz", "Şeftali"})
local sourFruits = Set.new({"Limon", "Lime"})

local allFruits = sweetFruits + sourFruits
allFruits:output() -- Şeftali, Lime, Elma, Kiraz, Limon, Mango

function Set:__sub(otherSet)
	local result = Set.new()
	for entry in self do
		result[entry] = true
	end
	for entry in otherSet do
		result[entry] = nil
	end
	return result
end

local allFruits = Set.new({"Elma", "Limon", "Mango", "Kiraz", "Lime", "Şeftali"})
local sourFruits = Set.new({"Limon", "Lime"})

local sweetFruits = allFruits - sourFruits
sweetFruits:output() -- Mango, Elma, Kiraz, Şeftali