More sketching of functor, list, and related.

sketching/september_2025/hkt/functor.dm

@@ -16,8 +16,8 @@ pub enum Either<L, R>
     Right(R)
 end
 
-pub inst Functor[*T] for Option<T>
+pub impl Functor[*T] for Option<T>
-    impl fn <U> map(ftu: fn (t: T) -> U) -> Self<U>
+    fn <U> map(ftu: fn (t: &*T) -> U) -> Self<U>
         if self is Some(t) then
             Some(ftu(t))
         else
@@ -26,20 +26,20 @@ pub inst Functor[*T] for Option<T>
     end
 end
 
-pub inst Functor[*T] for Either<_, *T>
+pub impl Functor[*R] for Either<_, *R>
-    impl fn <U> map(ftu: fn (t: *T) -> U) -> Self<U>
+    fn <U> map(f: fn (t: &*R) -> U) -> Self<_, U>
         if self is Right(t) then
-            Right(ftu(t))
+            Right(f(t))
         else
             self
         end
     end
 end
 
-pub inst Functor[*L -> *R] for Either<L, R>
+pub impl Functor[*L -> *R] for Either<L, R>
-    impl fn mapLeft(flr: fn (l: *L) -> *R) -> Self<*L, *R>
+    fn mapLeft(f: fn (l: &*L) -> *R) -> Self<*L, *R>
         if self is Left(l) then
-            Right(flr(l))
+            Right(f(l))
         else
             self
         end
@@ -48,100 +48,53 @@ end
 
 pub trait Monad[*T]
     static fn lift(t: *T) -> Self<*T>
-    fn <U> flatMap(f: fn (t: *T) -> Self<U>) -> Self<U>
+    fn <U> flatMap(f: fn (t: &*T) -> Self<U>) -> Self<U>
 end
 
 pub trait Default
     static fn default() -> Self
 end
 
-pub trait Empty[*T] where *T has Default
+pub trait Empty[*T]
     static fn empty() -> Self<*T>
 end
 
 pub trait Semigroup[*T]
-    fn concat(other: &Self<*T>) -> Self<&*T>
+    type Other<*T>
-    cons fn consConcat(other: Self<*T>) -> Self<*T>
+
+    fn concat(other: &Other<*T>) -> Self<&*T>
+    cons fn consConcat(other: Other<*T>) -> Self<*T>
 end
 
 pub int Iterable<T>
-    fn iter() -> Iterator<T>
+    fn iter() -> Iterator<T> ref self
     cons fn consIter() -> ConsIterator<T>
 end
 
 pub int Iterator<T>
-    fn next() -> Option<&T>
+    fn next() -> Option<&T ref self>
-    fn withIndex() -> Iterator<Option<(Int, &T)>>
 end
 
 pub int ConsIterator<T>
     fn next() -> Option<T>
-    fn withIndex() -> Iterator<Option<(Int, T)>>
 end
 
-pub int List<T> : Iterable<T> req Monad, Functor, Semigroup, Empty
+pub impl Semigroup[*T] for Iterable<*T>
-    fn add(t: T) -> Void
+    type Other = Iterable<*T>
-end
 
-pub inst Functor[*T] for List<*T> where *T has Default
+    fn concat(other: &Other<*T>) -> Self<*T>
-    impl fn <U> map(ftu: (t: *T) -> U) -> Self<U>
+        let result: Self<*T> = ArrayList(count())
-        let mut result: Self<U> = Self::empty()
         for t in self do
-            result += Self::lift(ftu(t))
+            result.add(t)
+        end
+        for t in other do
+            result.add(t)
         end
         result
     end
-end
 
-pub class ArrayList<T> : List<T>
+    cons fn consConcat(other: Other<*T>) -> Self<*T>
-
+        let result: Self<*T> = ArrayList(count())
-    let init: fn () -> T // ?: sugar for Option<fn () -> T>
-    let capacity: USize
-    let mut ts: Array<T>
-    let count: USize = 0
-
-    pub ctor(startCapacity: USize = 10, init: fn () -> T = Default::default) where T has Default
-        := init
-        capacity = startCapacity  // ?= sugar for Some(expr)
-        ts = array(startCapacity, init)
-    end
-
-    pub ctor(init: fn () -> T, startCapacity: USize = 10)
-        := init
-        capacity = startCapacity
-        ts = array(startCapacity, init)
-    end
-
-    impl fn iter() -> Iterator<T>
-        todo()
-    end
-
-    impl fn add(t: T) -> Void
-        ts[count] = t
-        count++
-        if count == capacity then
-            resize()
-        end
-    end
-
-    fn resize() -> Void
-        let oldTs = mem::take(&ts, array(capacity * 2, init))
-        for (i, t) in oldTs.consIter().withIndex() do
-            ts[i] = t
-        end
-    end
-
-end
-
-pub inst Empty[*T] for ArrayList<*T>
-    where *T has Default
-    impl static fn empty() -> List<*T> = Self()
-end
-
-pub inst Semigroup[*T] for ArrayList<*T>
-    where *T has Default
-    impl fn concat(other: List<*T>) -> List<*T>
-        let result = Self()
         for t in self do
             result.add(t)
         end
@@ -152,18 +105,35 @@ pub inst Semigroup[*T] for ArrayList<*T>
     end
 end
 
-pub inst Monad[*T] for ArrayList<*T>
+pub int List<T> : Iterable<T>
-    where T has Default
+    fn add(t: T) -> Void
-    impl static fn lift(t: *T) -> List<*T>
+end
-        let result: List<*T> = Self()
+
+pub impl Functor[*T] for List<*T>
+    fn <U> map(f: (t: &*T) -> U) -> Self<U>
+        let mut result: Self<U> = ArrayList(count())
+        for t in self do
+            result.add(f(t))
+        end
+        result
+    end
+end
+
+pub impl Empty[*T] for List<*T>
+    static fn empty() -> List<*T> = ArrayList()
+end
+
+pub inst Monad[*T] for List<*T>
+    static fn lift(t: *T) -> List<*T>
+        let result: List<*T> = ArrayList()
         result.add(t)
         result
     end
 
-    impl fn <U> flatMap(f: fn (t: *T) -> List<U>) -> List<U>
+    fn <U> flatMap(f: fn (t: &*T) -> List<U>) -> List<U>
-        let result: List<U> = Self()
+        let result: List<U> = ArrayList(count())
         for t in self do
-            for u in f(t) do
+            for u in f(t).consIter() do
                 result.add(u)
             end
         end
@@ -171,6 +141,69 @@ pub inst Monad[*T] for ArrayList<*T>
     end
 end
 
+pub class ArrayList<T> : List<T>
+
+    let capacity: USize
+    let mut ts: Array<Option<T>>
+    let count: USize = 0
+
+    pub ctor(startCapacity: USize = 10)
+        capacity = startCapacity
+        ts = array(startCapacity, None)
+    end
+
+    class ArrayListIterator<T>(owner: &ArrayList<T>) /* ref owner (implied by constructor) */ : Iterator<T>
+        let i: USize = 0
+
+        impl fn next() -> Option<&T ref self>
+            if owner.ts[i] is Some(t) then
+                i++
+                Some(t)
+            else
+                None
+            end
+        end
+    end
+
+    class ConsArrayListIterator<T>(ts: Array<Option<T>>) : ConsIterator<T>
+        let i: USize = 0
+
+        impl fn next() -> Option<T>
+            if ts[i] is Some then
+                let wrappedT = mem::take(ts[i], None)
+                i++
+                wrappedT
+            else
+                None
+            end
+        end
+    end
+
+    impl fn iter() -> Iterator<&T> ref self
+        ArrayListIterator(&self)
+    end
+
+    impl cons fn consIter() -> Iterator<T>
+        ConsArrayListIterator(mem::take(ts, arrays::empty()))
+    end
+
+    impl fn add(t: T) -> Void
+        ts[count] = Some(t)
+        count++
+        if count == capacity then
+            resize()
+        end
+    end
+
+    fn resize() -> Void
+        let oldTs = mem::take(&ts, array(capacity * 2, None))
+        for (i, wrappedT) in oldTs.consIter() do
+            ts[i] = wrappedT
+        end
+    end
+
+end
+
 pub mod std::core
 
     pub mod mem
@@ -181,8 +214,8 @@ pub mod std::core
 
     pub native fn <T> array(capacity: USize) -> Array<T> where T has Default
 
-    pub fn <T> list(...items: Array<T>) -> List<T> where T has Default
+    pub fn <T> list(...items: Array<T>) -> List<T>
-        let result = ArrayList(items.capacity(), Default[T]::default)
+        let result = ArrayList(items.capacity())
         for item in items.consIter() do
             result.add(item)
         end
@@ -191,8 +224,7 @@ pub mod std::core
 
 end
 
-// other file
+// Other file
-use std::collections::List
 use std::hkt::{Functor[List], Monad[List]}
 
 fn main()