From f6d2d68eeee521caf0e1b79f115b308640f4e080 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Sun, 4 Feb 2024 03:19:33 +0100
Subject: [PATCH] Subtrait work

---
 src/TraitExpression.ts | 38 ++++++++++----------------------------
 src/tests.ts           | 22 +++++++++++++++++++---
 src/trait.ts           | 13 ++-----------
 3 files changed, 31 insertions(+), 42 deletions(-)

diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index a20ca73..2d3f207 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -1,6 +1,6 @@
-import { Call, Fn, Pipe, Tuples } from "hotscript"
+import { Call, ComposeLeft, Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Class, Opaque } from "type-fest"
-import { AbstractTag, Trait, TraitAbstractFn, TraitApplierSuperTag, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, TraitSupertraitsFn } from "."
+import { AbstractTag, Trait, TraitApplierSuperTag, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, TraitSupertraitsFn } from "."
 import { ExtendFn, ExtendableFn, SimplifyFn, StaticMembersFn } from "./util"
 
 
@@ -48,10 +48,10 @@ export class TraitExpression<
         SubtraitImplWithAbstract extends Class<{}>,
     >(
         abstract: (
-            abstract: Pipe<Traits, [
-                Tuples.Map<TraitOwnAbstractFn>,
-                SimplifyFn,
-            ]>
+            abstract: Call<
+                ComposeLeft<[TraitExpressionAbstractFn, SimplifyFn]>,
+                typeof this
+            >
         ) => Opaque<SubtraitAbstract, AbstractTag>,
 
         // impl: ()
@@ -77,33 +77,15 @@ export interface TraitExpressionTraitsFn extends Fn {
 }
 
 export interface TraitExpressionAbstractFn extends Fn {
-    return: this["arg0"] extends TraitExpression<any, infer Traits>
-        ? Pipe<Traits, [
-            TraitAbstractFn,
+    return: this["arg0"] extends TraitExpression<any, any>
+        ? Pipe<this["arg0"], [
+            TraitExpressionTraitsFn,
+            Tuples.Map<TraitOwnAbstractFn>,
             ExtendFn,
         ]>
         : never
 }
 
-export interface TraitExpressionInstanceFn extends Fn {
-    return: this["arg0"] extends TraitExpression<infer Super, infer Traits>
-        ? Pipe<Traits, [
-            TraitAbstractFn,
-            ExtendFn,
-        ]>
-        : never
-}
-
-export interface TraitExpressionStaticFn extends Fn {
-    return: this["arg0"] extends TraitExpression<infer Super, infer Traits>
-        ? Pipe<Traits, [
-            TraitAbstractFn,
-            ExtendFn,
-        ]>
-        : never
-}
-
-
 export type Implements<Exp extends TraitExpression<any, any>> = (
     Exp extends TraitExpression<any, infer Traits>
         ? Pipe<Traits, [
diff --git a/src/tests.ts b/src/tests.ts
index 421b746..4ef5de9 100644
--- a/src/tests.ts
+++ b/src/tests.ts
@@ -1,5 +1,7 @@
-import { Call } from "hotscript"
-import { Implements, TraitExpressionTraitsFn, abstract, expression, trait } from "."
+import { Call, ComposeLeft, Pipe } from "hotscript"
+import { Implements, TraitExpressionAbstractFn, TraitExpressionTraitsFn, abstract, expression, trait } from "."
+import { Simplify } from "type-fest"
+import { SimplifyFn } from "./util"
 
 
 const PrintsHelloOnNew = trait(
@@ -59,9 +61,23 @@ const builder = expression
     )
 
 const exp = builder.get()
-type Abs = Call<TraitExpressionTraitsFn, typeof exp>
+type Abs = Call<ComposeLeft<[
+    TraitExpressionAbstractFn,
+    SimplifyFn,
+]>, typeof exp>
+
+exp.subtrait(
+    s => {
+        interface Subtrait extends (typeof s) {
+
+        }
+
+        return abstract<Subtrait>()
+    },
+)
 
 class User extends exp.extends implements Implements<typeof exp> {
+    declare status: { _tag: "awaitingPayment" } | { _tag: "active"; activeSince: Date; expiresAt?: Date | undefined } | { _tag: "expired"; expiredSince: Date }
     id: bigint = -1n
 }
 
diff --git a/src/trait.ts b/src/trait.ts
index a028dc8..fda5316 100644
--- a/src/trait.ts
+++ b/src/trait.ts
@@ -1,7 +1,7 @@
 import { Call, Fn } from "hotscript"
 import { AbstractClass, Class, Opaque } from "type-fest"
-import { AbstractTag, TraitExpression, TraitExpressionAbstractFn, TraitExpressionNullSuperclass, TraitExpressionTraitsFn, emptyTraitExpression } from "."
-import { ExtendFn, StaticMembers } from "./util"
+import { AbstractTag, TraitExpression, TraitExpressionNullSuperclass, TraitExpressionTraitsFn, emptyTraitExpression } from "."
+import { StaticMembers } from "./util"
 
 
 type AddAbstractToImplClass<
@@ -83,15 +83,6 @@ export interface TraitSupertraitsFn extends Fn {
         : never
 }
 
-export interface TraitAbstractFn extends Fn {
-    return: this["arg0"] extends Trait<infer Super, infer Abstract, any>
-        ? Call<ExtendFn, [
-            ...Call<TraitExpressionAbstractFn, Super>,
-            Abstract,
-        ]>
-        : never
-}
-
 
 export type TraitApplierSuperTag = "@thilawyn/traitify-ts/TraitApplierSuper"