sketching/april_2025/hkt.dm

@@ -1,5 +1,5 @@
 pub hkt Functor[Self<T>] {
-    fn <U> map(f: fn (t: &T) -> U) -> Self<U> // &self implied
+    fn <U> map(f: fn &T -> U) -> Self<U> // &self implied
 }
 
 pub hkt Applicative[Self<T>] : Functor[Self<T>] {

sketching/april_2025/template.dm

@@ -1,150 +0,0 @@
-/* Necessary utility types */
-
-pub type First<T : Tuple(infer U, ...)> = U
-pub type Last<T : Tuple(..., infer U)> = U
-pub type Prefix<T : Tuple(...infer U, _)> = Tuple(...U)
-pub type Suffix<T : Tuple(_, ...infer U)> = Tuple(...U)
-
-/* Closure interfaces */
-
-/**
- * Type is `cons fn (P)<D> -> T`
- */
-pub int ConsClosure(P : Tuple = ())<D = Any> -> T {
-    ref fn getDelegate() -> Option<&D>
-    mut fn setDelegate(d: D) -> Void
-
-    cons fn call(...p: P) -> T
-
-    cons fn applyFirst(first: First<P>) -> Self(Suffix<P>)<D> -> T
-    cons fn applyLast(last: Last<P>) -> Self(Prefix<P>)<D> -> T
-
-    def cons op >> alias applyFirst
-    def cons op << alias applyLast
-}
-
-/**
- * Type is `mut ref fn (P)<D> -> T`
- */
-pub int MutRefClosure(P : Tuple = ())<D = Any> -> T : ConsClosure(P)<D> -> T {
-    mut ref fn call(...p: P) -> T
-}
-
-/**
- * Type is `ref fn (P)<D> -> T`
- */
-pub int ReadRefClosure(P : Tuple = ())<D = Any> -> T : MutRefClosure(P)<D> -> T {
-    ref fn call(...p: P) -> T
-}
-
-/**
- * Type is `mut fn (P)<D> -> T`
- */
-pub int MutClosure(P : Tuple = ())<D = Any> -> T : ConsClosure(P)<D> -> T {
-    mut fn call(...p: P) -> T
-}
-
-/**
- * Type is `fn (P)<D> -> T`
- */
-pub int ReadClosure(P : Tuple = ())<D = Any> -> T : MutClosure(P)<D> -> T {
-    fn call(...p: P) -> T
-}
-
-/* Closure partial implementations */
-
-pub template class ClosureBase!($T: type, $P: type = (), $D: type = Any)
-    where Self : ConsClosure($P)<$D> -> $T {
-    mut fld delegate: Option<$D>
-
-    impl ref fn getDelegate() -> Option<&$D> = delegate is Some(d) ? Some(&d) : None
-
-    impl mut fn setDelegate(d: $D) {
-        delegate = Some(d)
-    }
-}
-
-pub abstract class AbstractConsClosure(P : Tuple = ())<D> -> T : ConsClosure(P)<D> -> T {
-    include ClosureBase!(T, P, D)
-}
-
-pub abstract class AbstractMutRefClosure(P : Tuple = ())<D> -> T : MutRefClosure(P)<D> -> T {
-    include ClosureBase!(T, P, D)
-}
-
-pub abstract class AbstractMutClosure(P : Tuple = ())<D> -> T : MutClosure(P)<D> -> T {
-    include ClosureBase!(T, P, D)
-}
-
-pub abstract class AbstractReadRefClosure(P : Tuple = ())<D> -> T : ReadRefClosure(P)<D> -> T {
-    include ClosureBase!(T, P, D)
-}
-
-pub abstract class AbstractReadClosure(P : Tuple = ())<D> -> T : ReadClosure(P)<D> -> T {
-    include ClosureBase!(T, P, D)
-}
-
-/* Templates for ApplyFirst and ApplyLast */
-
-pub template class-fn ApplyFirst!($T: type, $P: type, ...$callMods: fn-mod)
-    where Self : Closure($P)<$D> -> $T && $P : Tuple {
-    $P is Tuple() => {},
-    $P is Tuple($Param) && Self has (impl $callMods fn call($Param) -> $T) => {
-        impl cons fn applyFirst(first: First<$P>) -> Self()<$D> -> $T {
-            return |self| {
-                call(first)
-            }
-        }
-    }
-    $P is Tuple($First, ...$Suffix) && Self has (impl $callMods fn call($First, ...$Suffix) -> $T) => {
-        impl cons fn applyFirst(first: First<$P>) -> Self($Suffix)<$D> -> $T {
-            return |self| { ...suffix: Suffix<$P> ->
-                call(first, ...suffix)
-            }
-        }
-    }
-    _ => Unreachable!
-}
-
-pub template class-fn ApplyLast!($T: type, $P: type, ...$callMods: fn-mod)
-    where Self : Closure($P)<$D> -> $T && $P : Tuple {
-    $P is Tuple() => {},
-    $P is Tuple($Param) && Self has (impl $callMods fn call($Param) -> $T) => {
-        impl cons fn applyLast(last: Last<$P>) -> Self()<$D> -> $T {
-            return |self| {
-                call(last)
-            }
-        }
-    }
-    $P is Tuple(...$Prefix, $Last) && Self has (impl $callMods fn call(...$Prefix, $Last) -> T) => {
-        impl cons fn applyLast(last: Last<$P>) -> Self($Prefix)<$D> -> $T) => {
-            return |self| { ...prefix: Prefix<$P> ->
-                call(...prefix, last)
-            }
-        }
-    }
-    _ => Unreachable!
-}
-
-/* Example */
-
-@Synthetic
-class CompiledReadClosure(captured: Int) : ReadClosureBase(Int, Int) -> Int {
-    include ApplyFirst!(Int, (Int, Int))
-    include ApplyLast!(Int, (Int, Int))
-
-    impl fn call(x: Int, y: Int) -> Int = captured + x + y
-}
-
-// Example main
-
-fn main() {
-    let captured = 7
-    let cl: fn (Int, Int) -> Int = { x, y -> captured + x + y } // the capture of `captured` is automatically inferred
-                                                                // because Int is Copy, everything is okay
-                                                                // cl is ReadClosure(Int, Int)<Any> -> Int
-    let applied0: fn (Int) -> Int = cl >> 16
-    let applied1: fn () -> Int = applied0 >> 42
-    let result = applied1()
-    assertEq(result, 65)
-}