Additional Work

Author: sinclairzx81

example/index.ts

@@ -1,38 +1,35 @@
+import { Settings} from 'typebox/system'
 import Type from 'typebox'
 
-// investigating Extends logic
+Settings.Set({ enumerableKind: true })
 
-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
 
-// which approximates as the following
+type IfThenElse<If, Then, Else, Right> = If extends Right
+  ? (Then extends Right ? true : false)
+  : (Else extends Right ? true : false)
 
-type IfThenElse<If, Then, Else> = (If & Then) | Exclude<Else, If>
+type X = IfThenElse<boolean, true, false, true>  // boolean
+type Y = IfThenElse<boolean, false, true, false> // boolean
 
-// and would be used in contexts like the following
+// const T1:  Type.TLiteral<false>  = Type.Script(`(if number then 1 else string) extends 1 ? true : false`)           // false  ✓
+// const T2:  Type.TLiteral<true>   = Type.Script(`(if number then 1 else never) extends 1 ? true : false`)            // true   ✓
+// const T3:  Type.TLiteral<true>   = Type.Script(`(if string then number else never) extends number ? true : false`)  // true   ✓
+// const T4:  Type.TLiteral<true>   = Type.Script(`(if number then number else never) extends number ? true : false`)  // true   ✓
+// const T5:  Type.TLiteral<false>  = Type.Script(`(if number then 1) extends 1 ? true : false`)                       // false  ✓
+// const T6:  Type.TLiteral<true>   = Type.Script(`(if number then 1) extends unknown ? true : false`)                 // true   ✓
+// const T7:  Type.TLiteral<true>   = Type.Script(`(if string then "hello" else never) extends string ? true : false`) // true   ✓
+// const T8:  Type.TLiteral<true>   = Type.Script(`(if number then 2 else never) extends number ? true : false`)       // true   ✓
+// const T9:  Type.TLiteral<true>   = Type.Script(`(if number then 2 else never) extends 2 ? true : false`)            // true   ✓
+// const T10: Type.TLiteral<false>  = Type.Script(`(if number then 2 else never) extends 1 ? true : false`)            // false
+// const T11: Type.TLiteral<true>   = Type.Script(`(if boolean then true else never) extends true ? true : false`)     // true   ✓
+// const T12: Type.TLiteral<true>   = Type.Script(`(if boolean then true else false) extends true ? true : false`)     // true   ✓
+// const T13: Type.TLiteral<true>   = Type.Script(`(if boolean then false else true) extends false ? true : false`)    // true   ✓
+// const T14: Type.TLiteral<true>   = Type.Script(`(if unknown then 1 else never) extends 1 ? true : false`)           // true   ✓
+// const T15: Type.TLiteral<true>   = Type.Script(`(if never then 1 else never) extends 1 ? true : false`)             // true   ✓
 
-// 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 }
+// type Xs = boolean extends true ? 1 : 2
 
 
-// Vector Intersected with Rules
-type Vector = {
-  x: number
-  y: number
-} & if { x: 1 } then { y: 1 } else
-    if { x: 2 } then { y: 2 }
-`)
-
-type A = Type.Static<typeof A>
-type B = Type.Static<typeof B>
-type C = Type.Static<typeof C>
-
-type Vector = Type.Static<typeof Vector>
 
 
 

src/type/engine/evaluate/evaluate.ts

@@ -31,27 +31,27 @@ 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 TIntersect, IsIntersect, Intersect } from '../../types/intersect.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'
+import { type TExcludeOperation, ExcludeOperation } from '../exclude/operation.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]>
+  Intersect extends TSchema = TIntersect<[If, Then]>,
+  Negated extends TSchema = TExcludeOperation<Else, If>,
+  Result extends TSchema = TEvaluateUnion<[Intersect, Negated]>
 > = 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])
+  const intersect = Intersect([if_, then_])
+  const negation = ExcludeOperation(else_, if_)
+  const result = EvaluateUnion([intersect, negation])
   return result as never
 }
 // ------------------------------------------------------------------

src/type/extends/extends_left.ts

@@ -36,7 +36,6 @@ 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'
@@ -66,7 +65,6 @@ 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'
@@ -101,7 +99,6 @@ 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> :
@@ -133,7 +130,6 @@ 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) :