Evaluate and Extends Logic

Author: sinclairzx81

design/syntax/syntax.ts

@@ -283,7 +283,7 @@ const Base = Runtime.Union([
   Runtime.Ref('Constructor'),
   Runtime.Ref('_Function_'),
   Runtime.Ref('Mapped'),
-  Runtime.Ref('_If_'),
+  Runtime.Ref('IfThenElse'),
   Runtime.Ref('Options'),
   Runtime.Ref('GenericCall'),
   Runtime.Ref('Reference')
@@ -639,12 +639,11 @@ const Mapped = Runtime.Tuple([
   Runtime.Const(RBrace),
 ])
 // ------------------------------------------------------------------
-// If
+// IfThenElse
 // ------------------------------------------------------------------
-const _If_ = Runtime.Union([
+const IfThenElse = 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')])
+  Runtime.Tuple([Runtime.Const('if'), Runtime.Ref('Type'), Runtime.Const('then'), Runtime.Ref('Type')])
 ])
 // ------------------------------------------------------------------
 // Options
@@ -1018,9 +1017,8 @@ export const SyntaxModule = new Runtime.Module({
   MappedAs,
   Mapped,
 
-  _If_,
-
   Reference,
+  IfThenElse,
   Options,
 
   // ----------------------------------------------------------------

example/index.ts

@@ -1,70 +1,38 @@
-import Compile from 'typebox/compile'
-import System from 'typebox/system'
-import Guard from 'typebox/guard'
-import Format from 'typebox/format'
-import Schema from 'typebox/schema'
-import Value from 'typebox/value'
 import Type from 'typebox'
 
-// ------------------------------------------------------------------
-// Settings
-// ------------------------------------------------------------------
+// investigating Extends logic
 
-System.Settings.Set({ enumerableKind: false })
+const { A, B, C, Vector } = Type.Script(`
+  
+type A = if number then 1              // 1 | unknown - (technically 1 & (unknown & not number)) 
+type B = if number then 1 else 'hello' // 1 | 'hello'
+type C = if number then 1 else never   // 1
 
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
+// which approximates as the following
 
-const A = Guard.GraphemeCount('type-📦')      // 6
-const B = Guard.HasPropertyKey({ x: 1 }, 'x') // true
+type IfThenElse<If, Then, Else> = (If & Then) | Exclude<Else, If>
 
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
+// and would be used in contexts like the following
 
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
+// Rules
+type RuleA = if { x: 1 } then { y: 1 }
+type RuleB = if { x: 2 } then { y: 2 }
+type RuleC = if { x: 3 } then { y: 3 }
 
-// ------------------------------------------------------------------
-// Script
-// ------------------------------------------------------------------
 
-const S = Type.Script({ T }, `{
-  [K in keyof T]: T[K] | null
-}`)
+// Vector Intersected with Rules
+type Vector = {
+  x: number
+  y: number
+} & if { x: 1 } then { y: 1 } else
+    if { x: 2 } then { y: 2 }
+`)
 
-// ------------------------------------------------------------------
-// Infer
-// ------------------------------------------------------------------
+type A = Type.Static<typeof A>
+type B = Type.Static<typeof B>
+type C = Type.Static<typeof C>
 
-type T = Type.Static<typeof T>
-type S = Type.Static<typeof S>
+type Vector = Type.Static<typeof Vector>
 
-// ------------------------------------------------------------------
-// Parse
-// ------------------------------------------------------------------
 
-const R = Value.Parse(T, { x: 1, y: 2, z: 3 })
 
-// ------------------------------------------------------------------
-// Compile
-// ------------------------------------------------------------------
-const C = Compile(S)
-
-const X = C.Parse({ x: 1, y: 2, z: 3 })
-
-// ------------------------------------------------------------------
-// Format
-// ------------------------------------------------------------------
-
-const E = Format.IsEmail('user@domain.com')
-
-// ------------------------------------------------------------------
-// Schema
-// ------------------------------------------------------------------
-
-const D = Schema.Parse({ const: 'hello' }, 'hello')

src/type/engine/evaluate/evaluate.ts

@@ -30,12 +30,30 @@ THE SOFTWARE.
 
 import { Guard } from '../../../guard/index.ts'
 import { type TSchema } from '../../types/schema.ts'
+import { type TIfThenElse, IsIfThenElse } from '../../types/if_then_else.ts'
 import { type TIntersect, IsIntersect } from '../../types/intersect.ts'
-import { type TDistribute, Distribute } from './distribute.ts'
-import { type TBroaden, Broaden } from './broaden.ts'
 import { type TUnion, Union, IsUnion } from '../../types/union.ts'
 import { type TNever, Never } from '../../types/never.ts'
 
+import { type TDistribute, Distribute } from './distribute.ts'
+import { type TBroaden, Broaden } from './broaden.ts'
+import { type TExcludeAction, ExcludeAction } from '../exclude/index.ts'
+
+// ------------------------------------------------------------------
+// EvaluateIfThenElse
+// ------------------------------------------------------------------
+export type TEvaluateIfThenElse<If extends TSchema, Then extends TSchema, Else extends TSchema,
+  Left extends TSchema = TEvaluateIntersect<[If, Then]>,
+  Right extends TSchema = TEvaluateType<TExcludeAction<Else, Left>>,
+  Result extends TSchema = TEvaluateUnion<[Left, Right]>
+> = Result
+export function EvaluateIfThenElse<If extends TSchema, Then extends TSchema, Else extends TSchema>
+  (if_: If, then_: Then, else_: Else): TEvaluateIfThenElse<If, Then, Else> {
+  const left = EvaluateIntersect([if_, then_])
+  const right = EvaluateType(ExcludeAction(else_, left, {}))
+  const result = EvaluateUnion([left, right])
+  return result as never
+}
 // ------------------------------------------------------------------
 // EvaluateIntersect
 // ------------------------------------------------------------------
@@ -63,13 +81,15 @@ export function EvaluateUnion<Types extends TSchema[]>(types: [...Types]): TEval
 // ------------------------------------------------------------------
 export type TEvaluateType<Type extends TSchema,
   Result extends TSchema = (
+    Type extends TIfThenElse<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TEvaluateIfThenElse<If, Then, Else> :
     Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> :
     Type extends TUnion<infer Types extends TSchema[]> ? TEvaluateUnion<Types> :
     Type
   )
 > = Result
 export function EvaluateType<Type extends TSchema>(type: Type): TEvaluateType<Type> {
   return (
+    IsIfThenElse(type) ? EvaluateIfThenElse(type.if, type.then, type.else) :
     IsIntersect(type) ? EvaluateIntersect(type.allOf) :
     IsUnion(type) ? EvaluateUnion(type.anyOf) :
     type

src/type/engine/instantiate.ts

@@ -50,7 +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 TIfThenElse, IfThenElse, IsIfThenElse, IfThenElseOptions } from '../types/if_then_else.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'
@@ -309,7 +309,7 @@ export type TInstantiateType<Context extends TProperties, State extends TState,
     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 TIfThenElse<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TIfThenElse<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>> :
@@ -340,7 +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)) :
+    IsIfThenElse(type) ? IfThenElse(InstantiateType(context, state, type.if), InstantiateType(context, state, type.then), InstantiateType(context, state, type.else), IfThenElseOptions(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/extends/extends_left.ts

@@ -36,6 +36,7 @@ import { type TExtendsBoolean, ExtendsBoolean } from './boolean.ts'
 import { type TExtendsConstructor, ExtendsConstructor } from './constructor.ts'
 import { type TExtendsEnum, ExtendsEnum } from './enum.ts'
 import { type TExtendsFunction, ExtendsFunction } from './function.ts'
+import { type TExtendsIfThenElse, ExtendsIfThenElse } from './if_then_else.ts'
 import { type TExtendsInteger, ExtendsInteger } from './integer.ts'
 import { type TExtendsIntersect, ExtendsIntersect } from './intersect.ts'
 import { type TExtendsIterator, ExtendsIterator } from './iterator.ts'
@@ -65,6 +66,7 @@ import { type TBoolean, IsBoolean  } from '../types/boolean.ts'
 import { type TConstructor, IsConstructor } from '../types/constructor.ts'
 import { type TEnum, type TEnumValue, IsEnum } from '../types/enum.ts'
 import { type TFunction, IsFunction } from '../types/function.ts'
+import { type TIfThenElse, IsIfThenElse } from '../types/if_then_else.ts'
 import { type TInteger, IsInteger } from '../types/integer.ts'
 import { type TIntersect, IsIntersect } from '../types/intersect.ts'
 import { type TIterator, IsIterator } from '../types/iterator.ts'
@@ -99,6 +101,7 @@ export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Rig
   Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> :
   Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> :
   Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> :
+  Left extends TIfThenElse<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TExtendsIfThenElse<Inferred, If, Then, Else, Right> :
   Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> :
   Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> :
   Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> :
@@ -130,6 +133,7 @@ export function ExtendsLeft<Inferred extends TProperties, Left extends TSchema,
     IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
     IsEnum(left) ? ExtendsEnum(inferred, left, right) :
     IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
+    IsIfThenElse(left) ? ExtendsIfThenElse(inferred, left.if, left.then, left.else, right) :
     IsInteger(left) ? ExtendsInteger(inferred, left, right) :
     IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
     IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :

src/type/extends/if_then_else.ts

@@ -0,0 +1,49 @@
+/*--------------------------------------------------------------------------
+
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2026 Haydn Paterson 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// deno-fmt-ignore-file
+
+import { type TProperties } from '../types/properties.ts'
+import { type TSchema } from '../types/schema.ts'
+import { type TUnknown, Unknown } from '../types/unknown.ts'
+import { type TExtendsLeft, ExtendsLeft } from './extends_left.ts'
+
+// ----------------------------------------------------------------------------
+// EvaluateIfThenElse
+// ----------------------------------------------------------------------------
+import { type TEvaluateIfThenElse, EvaluateIfThenElse } from '../engine/evaluate/index.ts'
+
+export type TExtendsIfThenElse<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema,
+  // Evaluated extends TSchema = TEvaluateIfThenElse<If, Then, Else>
+> = TExtendsLeft<Inferred, TUnknown, Right>
+export function ExtendsIfThenElse<Inferred extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, Right extends TSchema>
+  (inferred: Inferred, if_: If, then_: Then, else_: Else, right: Right): 
+    TExtendsIfThenElse<Inferred, If, Then, Else, Right> {
+  // const evaluated = EvaluateIfThenElse(if_, then_, else_)
+  return ExtendsLeft(inferred, Unknown(), right) as never
+}

src/type/script/mapping.ts

@@ -1208,22 +1208,19 @@ export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknow
   )
 }
 // -------------------------------------------------------------------
-// _If_: ['if', Type, 'then', Type, 'else', Type] | ['if', Type, 'then', Type] | ['if', Type, 'else', Type]
+// IfThenElse: ['if', Type, 'then', Type, 'else', Type] | ['if', Type, 'then', Type]
 // -------------------------------------------------------------------
-export type T_If_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]> = (
+export type TIfThenElseMapping<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> :
+    ? T.TIfThenElse<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> :
+    ? T.TIfThenElse<If, Then, T.TUnknown> :
   never
 )
-export function _If_Mapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown]): unknown {
+export function IfThenElseMapping(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)
+    Guard.IsEqual(input.length, 6) ? T.IfThenElse(input[1] as T.TSchema, input[3] as T.TSchema, input[5] as T.TSchema) :
+    T.IfThenElse(input[1] as T.TSchema, input[3] as T.TSchema, T.Unknown())
   )
 }
 // -------------------------------------------------------------------