codon/stdlib/operator.codon

# (c) 2022 Exaloop Inc. All rights reserved.

lt = lambda a, b: a < b
le = lambda a, b: a <= b
eq = lambda a, b: a == b
ne = lambda a, b: a != b
gt = lambda a, b: a > b
ge = lambda a, b: a >= b
__lt__ = lt
__le__ = le
__eq__ = eq
__ne__ = ne
__gt__ = gt
__ge__ = ge


def not_(a) -> bool:
    if hasattr(a, "__bool__"):
        return not bool(a)
    elif hasattr(a, "__len__"):
        return len(a) == 0
    else:
        compile_error("argument has no __bool__ or __len__ methods")


def truth(a) -> bool:
    return bool(a)


def is_(a, b) -> bool:
    return a is b


def is_not(a, b) -> bool:
    return a is not b


def abs(a):
    return a.__abs__()


__abs__ = abs


def add(a, b):
    return a + b


__add__ = add


def and_(a, b):
    return a & b


__and__ = and_


def floordiv(a, b):
    return a // b


__floordiv__ = floordiv


def index(a):
    return a.__index__()


__index__ = index


def inv(a):
    return ~a


invert = inv
__inv__ = inv
__invert__ = inv


def lshift(a, b):
    return a << b


__lshift__ = lshift


def mod(a, b):
    return a % b


__mod__ = mod


def mul(a, b):
    return a * b


__mul__ = mul


def matmul(a, b):
    return a @ b


__matmul__ = matmul


def neg(a):
    return -a


__neg__ = neg


def or_(a, b):
    return a | b


__or__ = or_


def pos(a):
    return +a


__pos__ = pos


def pow(a, b):
    return a ** b


__pow__ = pow


def rshift(a, b):
    return a >> b


__rshift__ = rshift


def sub(a, b):
    return a - b


__sub__ = sub


def truediv(a, b):
    return a / b


__truediv__ = truediv


def xor(a, b):
    return a ^ b


__xor__ = xor


def concat(a, b):
    return a + b


__concat__ = concat


def contains(a, b):
    return b in a  # intentionally reversed


__contains__ = contains


def countOf(a, b):
    n = 0
    for x in a:
        if x == b:
            n += 1
    return n


def delitem(a, b):
    del a[b]


__delitem__ = delitem


def getitem(a, b):
    return a[b]


__getitem__ = getitem


def indexOf(a, b):
    n = 0
    for x in a:
        if x == b:
            return n
        n += 1
    raise ValueError(f"sequence.index(x): x not in sequence")


def setitem(a, b, c):
    a[b] = c


__setitem__ = setitem


def length_hint(a, default=0):
    if hasattr(a, "__len__"):
        return len(a)
    elif hasattr(a, "__length_hint__"):
        return a.__length_hint__()
    else:
        return default


# attrgetter not implemented


def itemgetter(*items):
    if staticlen(items) == 1:
        item = items[0]

        def g(obj):
            return obj[item]

        return g
    else:

        def g(obj):
            return tuple(obj[item] for item in items)

        return g


# methodcaller not implemented


def iadd(a, b):
    a += b
    return a


__iadd__ = iadd


def iand(a, b):
    a &= b
    return a


__iand__ = iand


def iconcat(a, b):
    a += b
    return a


__iconcat__ = iconcat


def ifloordiv(a, b):
    a //= b
    return a


__ifloordiv__ = ifloordiv


def ilshift(a, b):
    a <<= b
    return a


__ilshift__ = ilshift


def imod(a, b):
    a %= b
    return a


__imod__ = imod


def imul(a, b):
    a *= b
    return a


__imul__ = imul


def imatmul(a, b):
    a @= b
    return a


__imatmul__ = imatmul


def ior(a, b):
    a |= b
    return a


__ior__ = ior


def ipow(a, b):
    a **= b
    return a


__ipow__ = ipow


def irshift(a, b):
    a >>= b
    return a


__irshift__ = irshift


def isub(a, b):
    a -= b
    return a


__isub__ = isub


def itruediv(a, b):
    a /= b
    return a


__itruediv__ = itruediv


def ixor(a, b):
    a ^= b
    return a


__ixor__ = ixor