Different small module extensions for Killa

/*
    Different small module extensions for Killa
    by YellowAfterlife
*/
// 'shortcut' functions:
global.typeof = global.type
// Returns [nvalue] if [value] is null, [value] otherwise.
global.ifnull = function(value, nvalue) {
    if (value == null) { return nvalue }
    return value
}
/*
    math module:
*/
// returns sign of value (-1/0/+1)
global.math.sign = function(n) {
    if (n > 0) {
        return 1
    } else if (n < 0) {
        return -1
    } else {
        return 0
    }
}
// adds value to number. returns null if type coercion fails
global.math.add = function(a, b) {
    if (typeof(b) == 'number') {
        return a + b
    } else if (typeof(b) == 'table') {
        // number + table : add i.indexed values to number
        var c
        for each (var i, v in ipairs(b)) {
            c = tonumber(v)
            if (c == null) { return null }
            a = a + c
        }
        return a
    } else {
        b = tonumber(b)
        if (b == null) { return null }
        return a + b
    }
}
/*
    string module:
*/
// string.indexof(string, substring, from)
global.string.indexof = function(s, o, f) {
    return ifnull(string.match(s, o, f), -1)
}
//
global.string.substr = global.string.sub
global.string.add = function(a, b) {
    if (typeof(b) == 'string') {
        return a .. b
    } else if (typeof(b) == 'table') {
        return a .. table.tostring(b)
    } else {
        return a .. tostring(b)
    }
}
/*
    metatable module:
*/
// creates a copy of a metatable:
global.table.clone = function(a) {
    var r = { }
    for each (var i, v in pairs(a)) {
        r[i] = v
    }
    return r
}
// creates a copy of metatable, containing only integer indexes:
global.table.iclone = function(a) {
    var r = { }
    for each (var i, v in ipairs(a)) {
        r[i] = v
    }
    return r
}
// adds data to end of metatable:
global.table.add = function(a, b) {
    if (typeof(b) == 'table') {
        for each (var i, v in ipairs(b)) {
            table.insert(a, v)
        }
    } else {
        table.insert(a, b)
    }
}
global.table.tostring = function(t) {
    if (t.tostring) { return t.tostring(t) }
    var r = '{'
    var n = 0
    for each (var i, v in pairs(t)) {
        r = r .. ((n == 0) ? ' ' : ', ') .. tostring(i) .. ': ' .. tostring(v)
        n += 1
    }
    return r .. ' }'
}
// adds values together with type coercion. resulting type is determined by left-most argument.
global.add = function(a, ...) {
    var b = { ... }
    var r = a
    if (typeof(a) == 'string') {
        for each (var i, v in ipairs(b)) {
            r = string.add(r, v)
        }
    } else if (typeof(a) == 'number') {
        for each (var i, v in ipairs(b)) {
            r = math.add(r, v)
        }
    } else if (typeof(a) == 'boolean') {
        // boolean + values : returns if at least one element is true
        if (a) { return a }
        for each (var i, v in ipairs(b)) {
            if (v) { return true }
        }
        return a
    } else if (typeof(a) == 'table') {
        r = table.clone(a)
        for each (var i, v in ipairs(b)) {
            table.add(r, v)
        }
    }
    return r
}
//
print(add('String + Number: ', add('4', 5)))
print(add('Number + String: ', add(5, '4')))
print(add('String + Table: ', add('Text', { 7 })))
print(add('Table + String: ', add({ 7 }, 'Text')))
print(add('Table + Table: ', add({ 1 }, { 2 })))
//