Working trait expression implements

src/expresses.ts

@@ -1,6 +1,7 @@
-import { AbstractClass, Opaque } from "type-fest"
+import { Fn, Pipe, Tuples } from "hotscript"
-import { Trait, TraitApplierSuperTag } from "."
+import { AbstractClass, Opaque, Simplify } from "type-fest"
-import { MergeInheritanceTree, TraitsAbstractMembers } from "./util"
+import { Trait, TraitAbstractMembersFn, TraitApplierSuperTag } from "."
+import { ExtendFn } from "./util"
 
 
 class TraitsExpression<
@@ -12,14 +13,6 @@ class TraitsExpression<
         readonly traits:      Traits,
     ) {}
 
-    implements(): (
-        MergeInheritanceTree<
-            TraitsAbstractMembers<Traits>
-        >
-    ) {
-        return {} as any
-    }
-
     extends() {
         return this.traits.reduce(
             (previous, trait) => trait.apply(previous),
@@ -29,6 +22,21 @@ class TraitsExpression<
 }
 
 
+interface SimplifyFn extends Fn {
+    return: Simplify<this["arg0"]>
+}
+
+export type Implements<Exp extends TraitsExpression<any, any>> = (
+    Exp extends TraitsExpression<any, infer Traits>
+        ? Pipe<Traits, [
+            Tuples.Map<TraitAbstractMembersFn>,
+            ExtendFn,
+            SimplifyFn,
+        ]>
+        : never
+)
+
+
 export function extendsAndExpresses<
     Super  extends AbstractClass<any>,
     Traits extends readonly Trait<any, any>[],

src/tests.ts

@@ -1,7 +1,4 @@
-import { Simplify } from "type-fest"
+import { Implements, TraitAbstractMembers, expresses, trait } from "."
-import { GetTraitAbstractMembers, GetTraitClass, GetTraitImplClass, GetTraitImplInstance, GetTraitInstance, Trait, TraitAbstractMembers, TraitImplInstance, expresses, trait } from "."
-import { MergeInheritanceTree, TraitsAbstractMembers } from "./util"
-import { Call, Fn, Tuples } from "hotscript"
 
 
 const PrintsHelloOnNew = trait()(Super =>
@@ -41,28 +38,16 @@ const ActiveStatefulSubscription = trait<ActiveStatefulSubscriptionAbstractMembe
     class ActiveStatefulSubscription extends Super {}
 )
 
-// type Test = Simplify<TraitImplInstance<ReturnType<typeof Identifiable<bigint>>>>
+
-type Test1 = [
-    TraitAbstractMembers<typeof StatefulSubscription>,
-    TraitAbstractMembers<typeof ActiveStatefulSubscription>,
-]
-type Test2 = TraitsAbstractMembers<[
-    typeof StatefulSubscription,
-    typeof ActiveStatefulSubscription,
-]>
-type Test3 = Simplify<
-    Call<Tuples.Map<GetTraitClass>, [
-        typeof StatefulSubscription,
-        typeof ActiveStatefulSubscription,
-    ]>
->
 // type Test2 = Simplify<MergeInheritanceTree<Test1>>
 
 
-const appliedIdentifiable = Identifiable<bigint>().apply({} as any)
+const exp = expresses(
+    Identifiable<bigint>(),
+    // Identifiable<number>()
+)
+type Impl = Implements<typeof exp>
 
-const exp = expresses(Identifiable<bigint>(), Identifiable<number>())
+class User implements Implements<typeof exp> {
-
-class User implements ReturnType<typeof exp.implements> {
     id: bigint = -1n
 }

src/trait.ts

@@ -57,7 +57,7 @@ export type TraitAbstractMembers<T> = (
         : never
 )
 
-export interface GetTraitAbstractMembers extends Fn {
+export interface TraitAbstractMembersFn extends Fn {
     return: TraitAbstractMembers<this["arg0"]>
 }
 
@@ -70,7 +70,7 @@ export type TraitImplClass<T> = (
         : never
 )
 
-export interface GetTraitImplClass extends Fn {
+export interface TraitImplClassFn extends Fn {
     return: TraitImplClass<this["arg0"]>
 }
 
@@ -83,7 +83,7 @@ export type TraitImplInstance<T> = (
         : never
 )
 
-export interface GetTraitImplInstance extends Fn {
+export interface TraitImplInstanceFn extends Fn {
     return: TraitImplInstance<this["arg0"]>
 }
 
@@ -93,7 +93,7 @@ export type TraitClass<T> = (
         : never
 )
 
-export interface GetTraitClass extends Fn {
+export interface TraitClassFn extends Fn {
     return: TraitClass<this["arg0"]>
 }
 
@@ -103,7 +103,7 @@ export type TraitInstance<T> = (
         : never
 )
 
-export interface GetTraitInstance extends Fn {
+export interface TraitInstanceFn extends Fn {
     return: TraitInstance<this["arg0"]>
 }
 

src/util/extend.ts

@@ -0,0 +1,16 @@
+import { Call, Fn, Tuples } from "hotscript"
+
+
+type CommonKeys<A, B> = Extract<keyof A, keyof B>
+
+type ExtendReducer<Super, Self> = (
+    Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+        ? Omit<Super, CommonKeys<Self, Super>> & Self
+        : never
+)
+interface ExtendReducerFn extends Fn {
+    return: ExtendReducer<this["arg0"], this["arg1"]>
+}
+
+export type ExtendFn = Tuples.Reduce<ExtendReducerFn, {}>
+export type Extend<T extends readonly object[]> = Call<ExtendFn, T>

src/util/index.ts

@@ -1,3 +1,3 @@
 export * from "./class"
+export * from "./extend"
 export * from "./inheritance"
-export * from "./trait"

src/util/trait.ts

@@ -1,22 +0,0 @@
-import { Trait, TraitAbstractMembers, TraitClass } from ".."
-
-
-export type TraitsAbstractMembers<Traits extends readonly Trait<any, any>[]> = (
-    Traits extends [infer T, ...infer Rest]
-        ? T extends Trait<any, any>
-            ? Rest extends Trait<any, any>[]
-                ? [TraitAbstractMembers<T>, ...TraitsClasses<Rest>]
-                : never
-            : never
-        : []
-)
-
-export type TraitsClasses<Traits extends readonly Trait<any, any>[]> = (
-    Traits extends [infer T, ...infer Rest]
-        ? T extends Trait<any, any>
-            ? Rest extends Trait<any, any>[]
-                ? [TraitClass<T>, ...TraitsClasses<Rest>]
-                : never
-            : never
-        : []
-)