kraken/tests/test_adt.krak

import io:*

adt options {
    option0,
    option1
}

adt maybe_int {
    no_int,
    an_int: int
}

fun TestObj(num: int): TestObj {
    print("gonna make object in function ")
    println(num)
    var toRet.construct(num): TestObj
    return toRet
}
obj TestObj (Object) {
    var obj_num: int
    var ref_num: int
    fun construct(num:int): *TestObj {
        obj_num = num
        ref_num = num
        print("constructed object ")
        print(obj_num);print(" : ");println(ref_num)
    }
    fun copy_construct(old: *TestObj) {
        obj_num = old->obj_num
        ref_num = old->ref_num + 100
        print("copy constructed object ")
        print(obj_num);print(" : ");print(ref_num)
        print(" from ")
        print(old->obj_num);print(" : ");println(old->ref_num)
    }
    fun destruct() {
        print("destructed object ")
        print(obj_num);print(" : ");println(ref_num)
    }
    /*fun operator==(other: ref TestObj): bool {*/
    fun operator==(other: TestObj): bool {
        return obj_num == other.obj_num;
    }
}

adt maybe_object {
    no_obj,
    an_obj: TestObj,
    an_int: int
}

fun handle_possibility(it: maybe_int) {
    if (it == maybe_int::no_int()) {
        println("no int")
    } else {
        print("an int: ")
        println(it.an_int)
    }
}

fun give_maybe(give_it: bool): maybe_int {
    if (give_it)
        return maybe_int::an_int(7)
    return maybe_int::no_int()
}

fun can_pass(it: options): options {
    return it
}

fun main():int {
    var it: options = can_pass(options::option1())
    if (it == options::option0()) {
        println("nope")
    }
    if (it == options::option1()) {
        println("option1")
    }

    var possibility = give_maybe(false)
    handle_possibility(possibility)
    possibility = give_maybe(true)
    handle_possibility(possibility)
    if ( maybe_int::an_int(7) == maybe_int::an_int(7) )
        println("equality true works!")
    else
        println("equality true fails!")
        
    if ( maybe_int::an_int(7) != maybe_int::an_int(8) )
        println("equality false works!")
    else
        println("equality false fails!")

    match (maybe_int::an_int(11)) {
        maybe_int::an_int(the_int) {
            print("matched an int:")
            print(the_int)
            println(" correctly!")
        }
        maybe_int::no_int() {
            println("matched no int incorrectly!")
        }
    }
    match (maybe_int::no_int()) {
        maybe_int::an_int(the_int) println("matched an int incorrectly!")
        maybe_int::no_int() println("matched no int correctly!")
    }
    var obj_item = maybe_object::no_obj()
    match (obj_item) {
        maybe_object::no_obj() println("matched no_obj correctly")
        maybe_object::an_obj(obj_instance) {
            print("matched an_obj incorrectly ")
            println(obj_instance.obj_num)
        }
        maybe_object::an_int(int_thiny) {
            print("matched an_intj incorrectly ")
            println(int_thiny)
        }
    }
    println("assignment to old variable")
    obj_item = maybe_object::an_obj(TestObj(100))
    println("done assignment to old variable")
    match (obj_item) {
        maybe_object::no_obj() println("matched no_obj incorrectly")
        maybe_object::an_obj(obj_instance) {
            print("matched an_obj correctly ")
                print(obj_instance.obj_num);print(" : ");println(obj_instance.ref_num)
        }
        maybe_object::an_int(int_thiny) {
            print("matched an_intj incorrectly ")
            println(int_thiny)
        }
    }
    println("int assignment to old var")
    obj_item = maybe_object::an_int(1337)
    println("done int assignment to old var")
    /*println("test copying thing");*/
    /*var obj_item_new = maybe_object::an_obj(TestObj(1000))*/
    /*println("new object assingment")*/
    /*var obj_item_new_copy = obj_item_new;*/
    /*println("done new object assingment")*/
    /*println("done test copying thing");*/
    match (obj_item) {
        maybe_object::no_obj() println("matched no_obj incorrectly")
        maybe_object::an_obj(obj_instance) {
            print("matched an_obj incorrectly ")
            print(obj_instance.obj_num);print(" : ");println(obj_instance.ref_num)
        }
        maybe_object::an_int(int_thiny) {
            print("matched an_int correctly ")
            println(int_thiny)
        }
    }
    println("test copy_construct for non ref equality");
    if (maybe_object::an_obj(TestObj(110)) == maybe_object::an_obj(TestObj(110)))
        println("equality an_obj correctly ")
    else
        println("equality an_obj incorrectly ")
    println("done test copy_construct for non ref equality");
    println(maybe_object::an_int(10).an_int)
    return 0
}