Dependent If Type

Author: sinclairzx81

design/syntax/syntax.ts

@@ -283,6 +283,7 @@ const Base = Runtime.Union([
   Runtime.Ref('Constructor'),
   Runtime.Ref('_Function_'),
   Runtime.Ref('Mapped'),
+  Runtime.Ref('_If_'),
   Runtime.Ref('Options'),
   Runtime.Ref('GenericCall'),
   Runtime.Ref('Reference')
@@ -638,6 +639,14 @@ const Mapped = Runtime.Tuple([
   Runtime.Const(RBrace),
 ])
 // ------------------------------------------------------------------
+// If
+// ------------------------------------------------------------------
+const _If_ = Runtime.Union([
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('then'), Runtime.Ref('Type'), Runtime.Const('else'), Runtime.Ref('Type')]),
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('then'), Runtime.Ref('Type')]),
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('else'), Runtime.Ref('Type')])
+])
+// ------------------------------------------------------------------
 // Options
 // ------------------------------------------------------------------
 const Options = Runtime.Tuple([
@@ -1008,6 +1017,9 @@ export const SyntaxModule = new Runtime.Module({
   MappedOptional,
   MappedAs,
   Mapped,
+
+  _If_,
+
   Reference,
   Options,
 

src/type/engine/instantiate.ts

@@ -50,6 +50,7 @@ import { type TDeferred, Deferred, IsDeferred } from '../types/deferred.ts'
 import { type TFunction, _Function_, IsFunction, FunctionOptions } from '../types/function.ts'
 import { type TCall, IsCall } from '../types/call.ts'
 import { type TIdentifier } from '../types/identifier.ts'
+import { type TIf, If, IsIf, IfOptions } from '../types/if.ts'
 import { type TIntersect, Intersect, IsIntersect, IntersectOptions } from '../types/intersect.ts'
 import { type TIterator, Iterator, IsIterator, IteratorOptions } from '../types/iterator.ts'
 import { type TObject, Object, IsObject, ObjectOptions } from '../types/object.ts'
@@ -305,9 +306,10 @@ export type TInstantiateType<Context extends TProperties, State extends TState,
     Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> :
     Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> :
     Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> :
-    Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State,Parameters>, TInstantiateType<Context, State,InstanceType>> :
+    Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State,Parameters>, TInstantiateType<Context, State, InstanceType>> :
     Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> :
     Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State,ReturnType>> :
+    Type extends TIf<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TIf<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> :
     Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> :
     Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> :
     Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> :
@@ -338,6 +340,7 @@ export function InstantiateType<Context extends TProperties, State extends TStat
     IsConstructor(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType) as never, ConstructorOptions(type)) :
     IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) :
     IsFunction(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType) as never, FunctionOptions(type)) :
+    IsIf(type) ? If(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), IfOptions(type)) :
     IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) :
     IsIterator(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) :
     IsObject(type) ? Object(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) :

src/type/script/mapping.ts

@@ -1208,6 +1208,25 @@ export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknow
   )
 }
 // -------------------------------------------------------------------
+// _If_: ['if', Type, 'then', Type, 'else', Type] | ['if', Type, 'then', Type] | ['if', Type, 'else', Type]
+// -------------------------------------------------------------------
+export type T_If_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]> = (
+  Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema, 'else', infer Else extends T.TSchema]
+    ? T.TIf<If, Then, Else> :
+  Input extends ['if', infer If extends T.TSchema, 'then', infer Then extends T.TSchema]
+    ? T.TIf<If, Then, T.TUnknown> :
+  Input extends ['if', infer If extends T.TSchema, 'else', infer Else extends T.TSchema]
+    ? T.TIf<If, T.TUnknown, Else> :
+  never
+)
+export function _If_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]): unknown {
+  return (
+    Guard.IsEqual(input.length, 6) ? T.If(input[1] as T.TSchema, input[3] as T.TSchema, input[5] as T.TSchema) :
+    Guard.IsEqual(input[2], 'then') ? T.If(input[1] as T.TSchema, input[3] as T.TSchema, T.Unknown()) :
+    T.If(input[1] as T.TSchema, T.Unknown(), input[3] as T.TSchema)
+  )
+}
+// -------------------------------------------------------------------
 // Reference: <Ident>
 // -------------------------------------------------------------------
 export type TReferenceMapping<Input extends string,