Inference breaking when 2 parts is calling the same function

[ernisto]

This error appear when i call the same function eval in another part of the code

isolated repro

local t = {}

type constructor<data, methods = {}, handler = data & methods> = typeof(setmetatable({}, {
    __call = function(_,p: data): handler return nil :: any end
}))

type evaluable<T> = (any) -> T|T
local function eval<T>(evaluable: evaluable<T>, wrong: any?): T
    return if typeof(evaluable) == 'function' then evaluable(wrong) else evaluable
end

function t.number(default: evaluable<number?>, min: number?, max: number?, step: number?): (number, constructor<number>)
    local self = {} :: any
    -- local meta = { __index = methods }

    return setmetatable(self :: any, {
        -- __newindex = methods,
        __call = function(n: any?)
            if typeof(n) ~= 'number' then return assert(eval(default, n)) end
            if min then n = math.max(min, n) end
            if max then n = math.min(max, n) end
            if step then n = n // step * step end
            return n
        end
    }), self
end
function t.string(default: evaluable<string?>, regex: string?): (string, constructor<string>)
    local self = {} :: any
    -- local meta = { __index = methods }

    return setmetatable(self :: any, {
        -- __newindex = methods,
        __call = function(text: any?)
            return if text == nil or regex and not text:match(regex) then assert(eval(default, text)) else text
        end
    }), self
end

[ernisto]

bruh, i just fixed changing type evaluable to ```luau
type evaluable = T|(any) -> T

[aatxe]

I'm fairly certain type evaluable<T> = (any) -> T|T is not parsing how you want it to. It should be parsing T | T as the return type there, but I believe you wanted ((any) -> T) | T instead. So, I believe this is just user error.

[ernisto]

i forgot to close, srr