1 changed files with 0 additions and 198 deletions
--- a/sketching/september_2025/map/Map.dm
+++ b/sketching/september_2025/map/Map.dm
@ -1,198 +0,0 @@
 pub trait Functor<T>[Self<T>]
    fn map(mapper: fn (t: &T) -> U) -> Self<U>
 end
 pub trait Sum<T>
    fn sum() -> T
 end
 pub trait Default
    fn default() -> Self
 end
 pub trait Iter<T>
    ref fn iter() -> Iterator<&T>
 end
 pub trait ConsIter<T>
    cons fn consIter() -> Iterator<T>
 end
 pub int Iterator<T>
    fn next() -> Option<T>
 end
 pub int List<T> impl Functor<T>, Iter<T>, ConsIter<T>
    fn add(t: T) -> Void
 end
 pub class ArrayList<T> : List<T>
    let mut currentIndex = 0
    let mut inner: Array<T>
    ctor(capacity: Int) where T impl Default
        inner = Array(capacity, Default[T])
    end
    ctor(capacity: Int, init: fn () -> T)
        inner = Array(capacity, init)
    end
    impl fn add(t: T) -> Void
        inner[currentIndex] = t
        let currentCapacity = inner.capacity()
        currentIndex++
        if currentIndex == currentCapacity then
            let oldInner = std::mem::take(inner, Array(currentCapacity * 2))
            arrays::copy(oldInner, inner)
        end
    end
 end
 impl Functor[ArrayList<*>]
    fn map(mapper: fn (t: &T) -> U) -> Self<U>
        let mut result: Array<U> = Array(inner.capacity)
        for (i, t) in inner.iterWithIndex() do
            result[i] = mapper(t)
        end
        result
    end
 end
 impl Sum[Self = List<Int>, T = Int]
    fn sum() -> Int
        let mut result = 0
        for value in self do
            result += value
        end
        result
    end
 end
 impl<T impl Default> Default[ArrayList<T>]
    const DEFAULT_SIZE = 10
    static fn default() -> Self = ArrayList(DEFAULT_SIZE, Default[T]::default)
 end
 impl<T> Iter[ArrayList<T>]
    ref fn iter() -> Iterator<&T>
        let mut currentIndex = 0
        return {
            if currentIndex < inner.count() then
                let item = inner[currentIndex]
                currentIndex++
                Some(item)
            else
                None
            end
        }
    end
 end
 impl<T impl Default> ConsIter[ArrayList<T>]
    cons fn consIter() -> Iterator<T>
        let mut currentIndex = 0
        let inner = std::mem::take(inner, std::arrays::empty())
        return |inner| {
            if currentIndex < inner.count() then
                let item = inner.take(currentIndex, Default[T]::default)
                currentIndex++
                Some(item)
            else
                None
            end
        }
    end
 end
 pub enum Option<T>
    Some(t: T),
    None
 end
 impl Default[Option<*>]
    static fn default() -> Self = None
 end
 pub trait HashCode
    fn hash() -> USize
 end
 pub int Map<K, V>
    fn get(key: K) -> Option<&V>
    fn put(key: K, value: V) -> Void
    fn take(key: K) -> Option<V>
 end
 pub class HashMap<K, V> : Map<K, V>
    where K impl HashCode
    const LOAD_FACTOR = 0.8
    class Entry<K, V>(pub key: K, pub value: V) end
    let mut buckets: List<List<Option<Entry<K, V>>>> = ArrayList(10)
    fn getBucketIndex(key: K) -> Int
        HashCode[K].hash(key) % buckets.size()
    end
    fn getCount() -> Int = buckets.map { it.count() }.sum::<Int>()
    fn getCapacity() -> Int = buckets.map { it.capacity() }.sum::<Int>()
    fn redistribute()
        use std::mem::take
        let oldBucketCapacity = buckets.first().unwrap().capacity()
        let oldBuckets = take(buckets, ArrayList(oldBucketCapacity * 2))
        for bucket in oldBuckets.consIter() do
            for entry in bucket.consIter() do
                let newIndex = getBucketIndex(entry.key)
                let newBucket = buckets[newIndex]
                newBucket.add(Entry(entry.key, entry.value))
            end
        end
    end
    impl fn put(key: K, value: V) -> Void
        let bucket = buckets[getBucketIndex(key)]
        bucket.add(Entry(key, value))
        if getCount() / getCapacity() > LOAD_FACTOR then
            redistribute()
        end
    end
    impl fn get(key: K) -> Option<&V>
        let bucket = buckets[getBucketIndex(key)] // bucket: &List<Entry<K, V>>
        bucket.find { it.key == key } // it: &Entry<K, V>
            .map { it.value } // it.value: &V
    end
    impl fn take(key: K) -> Option<V>
        let mut bucket = buckets.take(getBucketIndex(key)) // bucket: List<Entry<K, V>>
        if bucket.findIndex { it.key == key } is Some(index) then
            let entry = bucket.take(index) // entry: Entry<K, V>
            Some(entry.value) // moved out of Entry
        else
            None
        end
    end
 end
 impl HashCode for String
    fn hash() -> Int = todo()
 end
 class Greeter(pub greeting: String) end
 fn main()
    let greeterMap: Map<String, Greeter> = HashMap()
    greeterMap.put("friendly", Greeter("Friendly hello!"))
    greeterMap.put("nasty", Greeter("Nasty hello!"))
    let friendlyGreeter: &Greeter = greeterMap.get("friendly").unwrap()
    println friendlyGreeter.greeting
    let nastyGreeter: Greeter = greeterMap.take("nasty").unwrap()
    println nastyGreeter.greeting
 end