ref_lower now generates C, though a ton of syntax errors

2017-01-20 01:11:06 -05:00
parent b0d2a6918d
commit e2639989c9
16 changed files with 345 additions and 56 deletions
--- a/stdlib/hash_set.krak
+++ b/stdlib/hash_set.krak
@@ -0,0 +1,113 @@
+import hash_map
+import vector
+import io
+import serialize
+
+fun hash_set<T>(): hash_set<T> {
+    var toRet.construct() : hash_set<T>
+    return toRet
+}
+
+fun hash_set<T>(item: T): hash_set<T> {
+    var toRet.construct() : hash_set<T>
+    toRet.add(item)
+    return toRet
+}
+
+fun from_vector<T>(items: vector::vector<T>): hash_set<T> {
+    var toRet.construct() : hash_set<T>
+    items.for_each( fun(item: T) toRet.add(item); )
+    return toRet
+}
+
+obj hash_set<T> (Object, Serializable) {
+    var data: hash_map::hash_map<T>
+    fun construct(): *hash_set<T> {
+        data.construct()
+        return this
+    }
+    /*fun construct(ammt: int): *hash_set<T> {*/
+        /*data.construct(ammt)*/
+        /*return this*/
+    /*}*/
+    fun copy_construct(old: *hash_set<T>) {
+        data.copy_construct(&old->data)
+    }
+    fun operator=(rhs: ref hash_set<T>) {
+        data = rhs.data
+    }
+    fun serialize(): vector::vector<char> {
+        return serialize::serialize(data)
+    }
+    fun unserialize(it: ref vector::vector<char>, pos: int): int {
+        return data.unserialize(it, pos)
+    }
+    fun operator==(rhs: ref hash_set<T>): bool {
+        if (size() != rhs.size())
+            return false
+        return !data.any_true( fun(item: T): bool return !rhs.contains(item); )
+    }
+    fun operator!=(rhs: ref hash_set<T>): bool {
+        return ! (*this == rhs)
+    }
+    fun destruct() {
+        data.destruct()
+    }
+    fun size():int {
+        return data.size
+    }
+    fun contains(items: ref hash_set<T>): bool {
+        return items.size() == 0 || !items.any_true( fun(item: T): bool return !contains(item); )
+    }
+    fun contains(item: ref T): bool {
+        return data.contains_key(item)
+    }
+    fun operator+=(item: ref T) {
+        add(item)
+    }
+    fun operator+=(items: ref hash_set<T>) {
+        add(items)
+    }
+    fun operator+(items: ref hash_set<T>): hash_set<T> {
+        var to_ret.copy_construct(this): hash_set<T>
+        to_ret.add(items)
+        return to_ret
+    }
+    fun add(item: ref T) {
+        if (!contains(item))
+            data.set(item,true)
+    }
+    fun add_all(items: ref hash_set<T>) {
+        add(items)
+    }
+    fun add(items: ref hash_set<T>) {
+        items.for_each( fun(item: ref T) add(item); )
+    }
+    fun remove(item: ref T) {
+        data.remove(item)
+    }
+    fun for_each(func: fun(ref T):void) {
+        data.for_each(func)
+    }
+    fun for_each(func: fun(T):void) {
+        data.for_each(func)
+    }
+    fun any_true(func: fun(T):bool):bool {
+        return data.any_true(func)
+    }
+    fun reduce<U>(func: fun(T,U): U, initial: U): U {
+        return data.reduce(func, initial)
+    }
+    fun flatten_map<U>(func: fun(T):hash_set<U>):hash_set<U> {
+        var newSet.construct(size()): hash_set<U>
+        for (var i = 0; i < size(); i++;)
+            func(data[i]).for_each(fun(item: ref U) newSet.add(item);)
+        return newSet
+    }
+    fun filter(func: fun(T):bool):hash_set<T> {
+        var newSet.construct(): hash_set<T>
+        newSet.data = data.filter(func)
+        return newSet
+    }
+}
+