sketching/september_2025/hkt/functor.dm

@@ -16,8 +16,8 @@ pub enum Either<L, R>
     Right(R)
 end
 
-pub impl Functor[*T] for Option<T>
-    fn <U> map(ftu: fn (t: &*T) -> U) -> Self<U>
+pub inst Functor[*T] for Option<T>
+    impl 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 impl Functor[*T] for Option<T>
     end
 end
 
-pub impl Functor[*R] for Either<_, *R>
-    fn <U> map(f: fn (t: &*R) -> U) -> Self<_, U>
+pub inst Functor[*T] for Either<_, *T>
+    impl fn <U> map(ftu: fn (t: *T) -> U) -> Self<U>
         if self is Right(t) then
-            Right(f(t))
+            Right(ftu(t))
         else
             self
         end
     end
 end
 
-pub impl Functor[*L -> *R] for Either<L, R>
-    fn mapLeft(f: fn (l: &*L) -> *R) -> Self<*L, *R>
+pub inst Functor[*L -> *R] for Either<L, R>
+    impl fn mapLeft(flr: fn (l: *L) -> *R) -> Self<*L, *R>
         if self is Left(l) then
-            Right(f(l))
+            Right(flr(l))
         else
             self
         end
@@ -48,94 +48,46 @@ 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]
+pub trait Empty[*T] where *T has Default
     static fn empty() -> Self<*T>
 end
 
 pub trait Semigroup[*T]
-    type Other<*T>
-
-    fn concat(other: &Other<*T>) -> Self<&*T>
-    cons fn consConcat(other: Other<*T>) -> Self<*T>
+    fn concat(other: &Self<*T>) -> Self<&*T>
+    cons fn consConcat(other: Self<*T>) -> Self<*T>
 end
 
 pub int Iterable<T>
-    fn iter() -> Iterator<T> ref self
+    fn iter() -> Iterator<T>
     cons fn consIter() -> ConsIterator<T>
 end
 
 pub int Iterator<T>
-    fn next() -> Option<&T ref self>
+    fn next() -> Option<&T>
+    fn withIndex() -> Iterator<Option<(Int, &T)>>
 end
 
 pub int ConsIterator<T>
     fn next() -> Option<T>
+    fn withIndex() -> Iterator<Option<(Int, T)>>
 end
 
-pub impl Semigroup[*T] for Iterable<*T>
-    type Other = Iterable<*T>
-
-    fn concat(other: &Other<*T>) -> Self<*T>
-        let result: Self<*T> = ArrayList(count())
-        for t in self do
-            result.add(t)
-        end
-        for t in other do
-            result.add(t)
-        end
-        result
-    end
-
-    cons fn consConcat(other: Other<*T>) -> Self<*T>
-        let result: Self<*T> = ArrayList(count())
-        for t in self do
-            result.add(t)
-        end
-        for t in other do
-            result.add(t)
-        end
-        result
-    end
-end
-
-pub int List<T> : Iterable<T>
+pub int List<T> : Iterable<T> req Monad, Functor, Semigroup, Empty
     fn add(t: T) -> Void
 end
 
-pub impl Functor[*T] for List<*T>
-    fn <U> map(f: (t: &*T) -> U) -> Self<U>
-        let mut result: Self<U> = ArrayList(count())
+pub inst Functor[*T] for List<*T> where *T has Default
+    impl fn <U> map(ftu: (t: *T) -> U) -> Self<U>
+        let mut result: Self<U> = Self::empty()
         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
-
-    fn <U> flatMap(f: fn (t: &*T) -> List<U>) -> List<U>
-        let result: List<U> = ArrayList(count())
-        for t in self do
-            for u in f(t).consIter() do
-                result.add(u)
-            end
+            result += Self::lift(ftu(t))
         end
         result
     end
@@ -143,52 +95,29 @@ end
 
 pub class ArrayList<T> : List<T>
 
+    let init: fn () -> T // ?: sugar for Option<fn () -> T>
     let capacity: USize
-    let mut ts: Array<Option<T>>
+    let mut ts: Array<T>
     let count: USize = 0
 
-    pub ctor(startCapacity: USize = 10)
+    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, None)
+        ts = array(startCapacity, init)
     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()))
+    impl fn iter() -> Iterator<T>
+        todo()
     end
 
     impl fn add(t: T) -> Void
-        ts[count] = Some(t)
+        ts[count] = t
         count++
         if count == capacity then
             resize()
@@ -196,14 +125,52 @@ pub class ArrayList<T> : List<T>
     end
 
     fn resize() -> Void
-        let oldTs = mem::take(&ts, array(capacity * 2, None))
-        for (i, wrappedT) in oldTs.consIter() do
-            ts[i] = wrappedT
+        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
+        for t in other do
+            result.add(t)
+        end
+        result
+    end
+end
+
+pub inst Monad[*T] for ArrayList<*T>
+    where T has Default
+    impl static fn lift(t: *T) -> List<*T>
+        let result: List<*T> = Self()
+        result.add(t)
+        result
+    end
+
+    impl fn <U> flatMap(f: fn (t: *T) -> List<U>) -> List<U>
+        let result: List<U> = Self()
+        for t in self do
+            for u in f(t) do
+                result.add(u)
+            end
+        end
+        result
+    end
+end
+
 pub mod std::core
 
     pub mod mem
@@ -214,8 +181,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>
-        let result = ArrayList(items.capacity())
+    pub fn <T> list(...items: Array<T>) -> List<T> where T has Default
+        let result = ArrayList(items.capacity(), Default[T]::default)
         for item in items.consIter() do
             result.add(item)
         end
@@ -224,7 +191,8 @@ pub mod std::core
 
 end
 
-// Other file
+// other file
+use std::collections::List
 use std::hkt::{Functor[List], Monad[List]}
 
 fn main()

src/bin/dmc/main.rs

@@ -1,10 +1,10 @@
-mod name_analysis;
+// mod name_analysis;
 mod p3;
 // mod unparse;
 
 use std::path::PathBuf;
 
-use crate::name_analysis::name_analysis;
+// use crate::name_analysis::name_analysis;
 use crate::p3::pretty_print_parse;
 // use crate::unparse::unparse;
 use clap::{Parser, Subcommand};
@@ -44,12 +44,12 @@ fn main() {
                 pretty_print_parse(&path)
             }
         }
-        Commands::NameAnalysis { paths } => {
-            let result = name_analysis(&paths);
-            if let Err(e) = result {
-                eprintln!("{}", e)
-            }
-        }
+        // Commands::NameAnalysis { paths } => {
+        //     let result = name_analysis(&paths);
+        //     if let Err(e) = result {
+        //         eprintln!("{}", e)
+        //     }
+        // }
         _ => todo!(),
     }
 }

src/bin/dmc/name_analysis.rs.bak

@@ -20,7 +20,8 @@ pub fn name_analysis(paths: &Vec<PathBuf>) -> Result<(), Box<dyn std::error::Err
 
         match parse_result {
             Ok(mut pairs) => {
-                let compilation_unit = build_ast(file_id, &mut pairs);
+                let compilation_unit_pair = pairs.next().unwrap();
+                let compilation_unit = build_ast(&path.display().to_string(), file_id, compilation_unit_pair);
                 compilation_units.push(compilation_unit);
                 Ok::<(), Box<dyn std::error::Error>>(())
             }
@@ -31,10 +32,7 @@ pub fn name_analysis(paths: &Vec<PathBuf>) -> Result<(), Box<dyn std::error::Err
     let mut symbol_table = SymbolTable::new();
     add_std_core_symbols(&mut symbol_table).expect("Failed to add std::core symbols.");
     
-    let diagnostics = analyze_names(
-        &mut compilation_units.iter().map(Box::as_mut),
-        &mut symbol_table
-    );
+    let diagnostics = analyze_names(&mut compilation_units, &mut symbol_table);
     if diagnostics.is_empty() {
         println!("Name analysis complete.");
         println!("Symbol table\n-------\n{}", symbol_table);

src/lib.rs

@@ -5,7 +5,7 @@ extern crate core;
 pub mod ast;
 pub mod diagnostic;
 pub mod module;
-pub mod name_analysis;
+// pub mod name_analysis;
 pub mod object_file;
 pub mod parser;
 pub mod std_core;

src/name_analysis/mod.rs.bak

@@ -32,7 +32,7 @@ pub mod symbol;
 pub mod symbol_table;
 
 pub fn analyze_names(
-    compilation_units: &mut [CompilationUnit],
+    compilation_units: &mut Vec<CompilationUnit>,
     symbol_table: &mut SymbolTable,
 ) -> Vec<DmDiagnostic> {
     let mut diagnostics = vec![];

src/name_analysis/resolve.rs.bak

@@ -1,9 +1,11 @@
+use crate::ast::node::named::Named;
 use crate::ast::node::*;
 use crate::diagnostic::DmDiagnostic;
 use crate::name_analysis::symbol::Symbol;
 use crate::name_analysis::symbol_table::{SymbolLookupError, SymbolTable};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use std::range::Range;
+/* Type Use */
 
 fn resolve_type_use(
     type_use: &mut TypeUse,

src/name_analysis/symbol.rs.bak

@@ -1,4 +1,3 @@
-use crate::ast::node::Identifier;
 use std::cell::RefCell;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::Deref;

src/std_core/mod.rs

@@ -1,14 +1,14 @@
-use crate::name_analysis::symbol::{FunctionSymbol, ParameterSymbol};
-use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};
-
-pub fn add_std_core_symbols(symbol_table: &mut SymbolTable) -> Result<(), SymbolInsertError> {
-    symbol_table.insert_function_symbol(
-        FunctionSymbol::new("std::core::println", "println", true, true, None)
-            .with_parameters(vec![ParameterSymbol::new("msg", None)]),
-    )?;
-    symbol_table.insert_function_symbol(
-        FunctionSymbol::new("std::core::print", "print", true, true, None)
-            .with_parameters(vec![ParameterSymbol::new("msg", None)]),
-    )?;
-    Ok(())
-}
+// use crate::name_analysis::symbol::{FunctionSymbol, ParameterSymbol};
+// use crate::name_analysis::symbol_table::{SymbolInsertError, SymbolTable};
+//
+// pub fn add_std_core_symbols(symbol_table: &mut SymbolTable) -> Result<(), SymbolInsertError> {
+//     symbol_table.insert_function_symbol(
+//         FunctionSymbol::new("std::core::println", "println", true, true, None)
+//             .with_parameters(vec![ParameterSymbol::new("msg", None)]),
+//     )?;
+//     symbol_table.insert_function_symbol(
+//         FunctionSymbol::new("std::core::print", "print", true, true, None)
+//             .with_parameters(vec![ParameterSymbol::new("msg", None)]),
+//     )?;
+//     Ok(())
+// }