peon/tests/std.pn

## The peon standard library

# Builtin arithmetic operators for Peon
# Note: Most of these do nothing on their own. All they do
# is serve as placeholders for emitting specific VM
# instructions. They're implemented this way because:
# - They tie into the existing type system nicely
# - It makes the implementation easier and more flexible


operator `+`*(a, b: int): int {
    #pragma[magic: "SignedAdd", pure]
}


operator `+`*(a, b: uint64): uint64 {
    #pragma[magic: "Add", pure]
}


operator `+`*(a, b: int32): int32 {
    #pragma[magic: "SignedAdd", pure]
}


operator `+`*(a, b: uint32): uint32 {
    #pragma[magic: "Add", pure]
}


operator `+`*(a, b: int16): int16 {
    #pragma[magic: "SignedAdd", pure]
}


operator `+`*(a, b: uint16): uint16 {
    #pragma[magic: "Add", pure]
}


operator `+`*(a, b: int8): int8 {
    #pragma[magic: "Add", pure]
}


operator `+`*(a, b: uint8): uint8 {
    #pragma[magic: "AddUInt8", pure]
}


operator `+`*(a, b: float64): float64 {
    #pragma[magic: "AddFloat64", pure]
}


operator `+`*(a, b: float32): float32 {
    #pragma[magic: "AddFloat32", pure]
}


operator `-`*(a, b: int): int {
    #pragma[magic: "SubInt64", pure]
}


operator `-`*(a, b: uint64): uint64 {
    #pragma[magic: "SubUInt64", pure]
}


operator `-`*(a, b: int32): int32 {
    #pragma[magic: "SubInt32", pure]
}


operator `-`*(a, b: uint32): uint32 {
    #pragma[magic: "SubUInt32", pure]
}


operator `-`*(a, b: int16): int16 {
    #pragma[magic: "SubInt16", pure]
}


operator `-`*(a, b: uint16): uint16 {
    #pragma[magic: "SubUInt16", pure]
}


operator `-`*(a, b: int8): int8 {
    #pragma[magic: "SubInt8", pure]
}


operator `-`*(a, b: uint8): uint8 {
    #pragma[magic: "SubUInt8", pure]
}


operator `-`*(a, b: float64): float64 {
    #pragma[magic: "SubFloat64", pure]
}


operator `-`*(a, b: float32): float32 {
    #pragma[magic: "SubFloat32", pure]
}


operator `*`*(a, b: int): int {
    #pragma[magic: "SignedMultiply", pure]
}


operator `*`*(a, b: uint64): uint64 {
    #pragma[magic: "MulUInt64", pure]
}


operator `*`*(a, b: int32): int32 {
    #pragma[magic: "SignedMultiply", pure]
}


operator `*`*(a, b: uint32): uint32 {
    #pragma[magic: "MulUInt32", pure]
}


operator `*`*(a, b: int16): int16 {
    #pragma[magic: "SignedMultiply", pure]
}


operator `*`*(a, b: uint16): uint16 {
    #pragma[magic: "MulUInt16", pure]
}


operator `*`*(a, b: int8): int8 {
    #pragma[magic: "SignedMultiply", pure]
}


operator `*`*(a, b: uint8): uint8 {
    #pragma[magic: "MulUInt8", pure]
}


operator `*`*(a, b: float64): float64 {
    #pragma[magic: "MulFloat64", pure]
}


operator `*`*(a, b: float32): float32 {
    #pragma[magic: "MulFloat32", pure]
}


operator `/`*(a, b: int): int {
    #pragma[magic: "DivInt64", pure]
}


operator `/`*(a, b: uint64): uint64 {
    #pragma[magic: "DivUInt64", pure]
}


operator `/`*(a, b: int32): int32 {
    #pragma[magic: "DivInt32", pure]
}


operator `/`*(a, b: uint32): uint32 {
    #pragma[magic: "DivUInt32", pure]
}


operator `/`*(a, b: int16): int16 {
    #pragma[magic: "DivInt16", pure]
}


operator `/`*(a, b: uint16): uint16 {
    #pragma[magic: "DivUInt16", pure]
}


operator `/`*(a, b: int8): int8 {
    #pragma[magic: "DivInt8", pure]
}


operator `/`*(a, b: uint8): uint8 {
    #pragma[magic: "DivUInt8", pure]
}


operator `/`*(a, b: float64): float64 {
    #pragma[magic: "DivFloat64", pure]
}


operator `/`*(a, b: float32): float32 {
    #pragma[magic: "DivFloat32", pure]
}


operator `**`*(a, b: int64): int64 {
    #pragma[magic: "PowInt64", pure]
}


# Comparison operators

operator `>`*(a, b: int): bool {
    #pragma[magic: "GreaterThanInt64", pure]
}


operator `<`*(a, b: int): bool {
    #pragma[magic: "LessThanInt64", pure]
}


operator `==`*(a, b: int): bool {
    #pragma[magic: "EqualInt64", pure]

}

operator `!=`*(a, b: int): bool {
    #pragma[magic: "NotEqualInt64", pure]
}


operator `>`*(a, b: uint64): bool {
    #pragma[magic: "GreaterThanUInt64", pure]
}


operator `<`*(a, b: uint64): bool {
    #pragma[magic: "LessThanUInt64", pure]
}


operator `==`*(a, b: uint64): bool {
    #pragma[magic: "EqualUInt64", pure]
}


operator `!=`*(a, b: uint64): bool {
    #pragma[magic: "NotEqualUInt64", pure]
}


operator `>`*(a, b: int32): bool {
    #pragma[magic: "GreaterThanInt32", pure]
}


operator `<`*(a, b: int32): bool {
    #pragma[magic: "LessThanInt32", pure]
}


operator `==`*(a, b: int32): bool {
    #pragma[magic: "EqualInt32", pure]
}


operator `!=`*(a, b: int32): bool {
    #pragma[magic: "NotEqualInt32", pure]
}

operator `>`*(a, b: uint32): bool {
    #pragma[magic: "GreaterThanUInt32", pure]
}


operator `<`*(a, b: uint32): bool {
    #pragma[magic: "LessThanUInt32", pure]
}


operator `==`*(a, b: uint32): bool {
    #pragma[magic: "EqualUInt32", pure]
}


operator `!=`*(a, b: uint32): bool {
    #pragma[magic: "NotEqualUInt32", pure]
}


operator `>`*(a, b: int16): bool {
    #pragma[magic: "GreaterThanInt16", pure]
}


operator `<`*(a, b: int16): bool {
    #pragma[magic: "LessThanInt16", pure]
}


operator `==`*(a, b: int16): bool {
    #pragma[magic: "EqualInt16", pure]
}


operator `!=`*(a, b: int16): bool {
    #pragma[magic: "NotEqualInt16", pure]
}


operator `>`*(a, b: uint16): bool {
    #pragma[magic: "GreaterThanUInt16", pure]
}


operator `<`*(a, b: uint16): bool {
    #pragma[magic: "LessThanUInt16", pure]
}


operator `==`*(a, b: uint16): bool {
    #pragma[magic: "EqualUInt16", pure]
}


operator `!=`*(a, b: uint16): bool {
    #pragma[magic: "NotEqualUInt16", pure]
}


operator `>`*(a, b: int8): bool {
    #pragma[magic: "GreaterThanInt8", pure]
}


operator `<`*(a, b: int8): bool {
    #pragma[magic: "LessThanInt8", pure]
}


operator `==`*(a, b: int8): bool {
    #pragma[magic: "EqualInt8", pure]
}


operator `!=`*(a, b: int8): bool {
    #pragma[magic: "NotEqualInt8", pure]
}


operator `>`*(a, b: uint8): bool {
    #pragma[magic: "GreaterThanUInt8", pure]
}


operator `<`*(a, b: uint8): bool {
    #pragma[magic: "LessThanUInt8", pure]
}


operator `==`*(a, b: uint8): bool {
    #pragma[magic: "EqualUInt8", pure]
}


operator `!=`*(a, b: uint8): bool {
    #pragma[magic: "NotEqualUInt8", pure]
}


operator `>`*(a, b: float): bool {
    #pragma[magic: "GreaterThanFloat64", pure]
}


operator `<`*(a, b: float): bool {
    #pragma[magic: "LessThanFloat64", pure]
}


operator `==`*(a, b: float): bool {
    #pragma[magic: "EqualFloat64", pure]
}


operator `!=`*(a, b: float): bool {
    #pragma[magic: "NotEqualFloat64", pure]
}


operator `>`*(a, b: float32): bool {
    #pragma[magic: "GreaterThanFloat32", pure]
}


operator `<`*(a, b: float32): bool {
    #pragma[magic: "LessThanFloat32", pure]
}


operator `==`*(a, b: float32): bool {
    #pragma[magic: "EqualFloat32", pure]
}


operator `!=`*(a, b: float32): bool {
    #pragma[magic: "NotEqualFloat32", pure]
}


operator `>=`*(a, b: int): bool {
    #pragma[magic: "GreaterOrEqualInt64", pure]
}


operator `<=`*(a, b: int): bool {
    #pragma[magic: "LessOrEqualInt64", pure]
}


operator `>=`*(a, b: uint64): bool {
    #pragma[magic: "GreaterOrEqualUInt64", pure]
}


operator `<=`*(a, b: uint64): bool {
    #pragma[magic: "LessOrEqualUInt64", pure]
}


operator `>=`*(a, b: int32): bool {
    #pragma[magic: "GreaterOrEqualInt32", pure]
}


operator `<=`*(a, b: int32): bool {
    #pragma[magic: "LessOrEqualInt32", pure]
}


operator `>=`*(a, b: uint32): bool {
    #pragma[magic: "GreaterOrEqualUInt32", pure]
}


operator `<=`*(a, b: uint32): bool {
    #pragma[magic: "LessOrEqualUInt32", pure]
}


operator `>=`*(a, b: int16): bool {
    #pragma[magic: "GreaterOrEqualInt16", pure]
}


operator `<=`*(a, b: int16): bool {
    #pragma[magic: "LessOrEqualInt16", pure]
}


operator `>=`*(a, b: uint16): bool {
    #pragma[magic: "GreaterOrEqualUInt16", pure]
}


operator `<=`*(a, b: uint16): bool {
    #pragma[magic: "LessOrEqualUInt16", pure]
}


operator `>=`*(a, b: int8): bool {
    #pragma[magic: "GreaterOrEqualInt8", pure]
}


operator `<=`*(a, b: int8): bool {
    #pragma[magic: "LessOrEqualInt8", pure]
}


operator `>=`*(a, b: uint8): bool {
    #pragma[magic: "GreaterOrEqualUInt8", pure]
}


operator `<=`*(a, b: uint8): bool {
    #pragma[magic: "LessOrEqualUInt8", pure]
}


operator `>=`*(a, b: float): bool {
    #pragma[magic: "GreaterOrEqualFloat64", pure]
}


operator `<=`*(a, b: float): bool {
    #pragma[magic: "LessOrEqualFloat64", pure]
}


operator `>=`*(a, b: float32): bool {
    #pragma[magic: "GreaterOrEqualFloat32", pure]
}


operator `<=`*(a, b: float32): bool {
    #pragma[magic: "LessOrEqualFloat32", pure]
}


operator `and`*(a, b: bool): bool {
    #pragma[magic: "LogicalAnd", pure]
}


operator `or`*(a, b: bool): bool {
    #pragma[magic: "LogicalOr", pure]
}


# Assignment operators

operator `=`[T: Any](a: var T, b: T) {
    #pragma[magic: "GenericAssign"]
}


# Some useful builtins

fn clock*: float {
    #pragma[magic: "SysClock64", pure]
}


# TODO: Replace with generics

fn print*(x: float) {
    #pragma[magic: "GenericPrint"]
}


fn print*(x: int) {
    #pragma[magic: "GenericPrint"]
}


fn print*(x: string) {
    #pragma[magic: "GenericPrint"]
}


fn print*(x: bool) {
    #pragma[magic: "GenericPrint"]
}