free-types-core 0.2.0 → 0.4.0

package/apply.ts

@@ -1,5 +1,5 @@
 import { Type } from './Type';
-import { ArrayKeys, Slice } from './utils';
+import { ArrayKeys, Next } from './utils';
 
 export { apply, $apply, Generic }
 
@@ -19,7 +19,14 @@ type applyUnsafe<
     Args extends unknown[],
 > = number extends $T['constraints']['length']
     ? _apply<$T, Args>
-    : _apply<$T, Slice<Args, 0, $T['constraints']['length']>>;
+    : _apply<$T, Take<Args, Required<$T['constraints']>['length']>>;
 
 type _apply<T extends { type: unknown }, Args> = 
-    (T & Omit<Args, ArrayKeys> & { arguments: Args })['type'];
+    (T & Omit<Args, ArrayKeys> & { arguments: Args })['type'];
+
+type Take<
+    T extends unknown[],
+    To extends number,
+    I extends number = 0,
+    R extends unknown[] = [],
+> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>

package/helpers.ts

@@ -1,6 +1,6 @@
 import { Next, IsUnknown, Prev } from './utils'
 
-export { At, Checked, Lossy, A, B, C, D, E }
+export { At, Checked, Lossy, Optional, A, B, C, D, E }
 
 // Fake `Type` for user friendly error messages
 type Type<N extends number> = {
@@ -8,12 +8,17 @@ type Type<N extends number> = {
     arguments: unknown[]
 }
 
+type Type_ <N extends number> = {
+    constraints: { [K in Prev<N>]?: unknown; }
+    arguments: unknown[]
+}
 type Default = {
     constraints: [0,1,2,3,4]
     arguments: unknown[]
 }
 
-/** safely index `this`
+/** - safely index `this`
+ * - optionally take a fallback
 */
 type At<
     N extends number,
@@ -22,7 +27,9 @@ type At<
 > = IsUnknown<This['arguments'][N]> extends true ? Fallback
     : This['arguments'][N]
 
-/** safely index `this` and defuse the corresponding type constraint with an inline conditional
+/** - safely index `this`
+ * - defuse the corresponding type constraint with an inline conditional
+ * - optionally take a fallback
  */
 type Checked<
     N extends number,
@@ -33,8 +40,24 @@ type Checked<
         ? This['arguments'][N]
         : Fallback
     : never;
+    
+/** - safely index `this`
+ * - works on optional parameters
+ * - defuse the corresponding type constraint with an inline conditional
+ * - optionally take a fallback
+ */
+ type Optional<
+ N extends number,
+ This extends Type_<Next<N>>,
+ Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never
+> = N extends keyof This['constraints']
+     ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined>
+     ? This['arguments'][N]
+     : Fallback
+ : never;
 
-/** safely index `this` and intersect the corresponding type constraint
+/** - safely index `this`
+ * - intersect the corresponding type constraint
  */
 type Lossy<
     N extends number,
@@ -43,32 +66,37 @@ type Lossy<
     ? This['arguments'][N] & This['constraints'][N]
     : never;
 
-/** safely index `this` and intersect the corresponding type constraint
- * equals `0` When no argument is supplied
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `0` When no argument is supplied
 */
 type A<This extends Type<1> = Default> =
     This['arguments'][0] & This['constraints'][0];
 
-/** safely index `this` and intersect the corresponding type constraint
- * equals `1` When no argument is supplied
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `1` When no argument is supplied
 */
 type B<This extends Type<2> = Default> =
     This['arguments'][1] & This['constraints'][1];
 
-/** safely index `this` and intersect the corresponding type constraint
- * equals `2` When no argument is supplied
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `2` When no argument is supplied
 */
 type C<This extends Type<3> = Default> =
     This['arguments'][2] & This['constraints'][2];
 
-/** safely index `this` and intersect the corresponding type constraint
- * equals `3` When no argument is supplied
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `3` When no argument is supplied
 */
 type D<This extends Type<4> = Default> =
     This['arguments'][3] & This['constraints'][3];
 
-/** safely index `this` and intersect the corresponding type constraint
- * equals `4` When no argument is supplied
+/** - safely index `this`
+ * - intersect the corresponding type constraint
+ * - equals `4` When no argument is supplied
 */
 type E<This extends Type<5> = Default> =
     This['arguments'][4] & This['constraints'][4];

package/index.ts

@@ -9,4 +9,4 @@ export * from './unwrap';
 export * from './Replace';
 export * from './hkt';
 export * as free from './free-types';
-export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown } from './utils'
+export { Slice, ToTuple, Head, Tail, Last, Init, IsUnknown, IsOptional } from './utils'

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.2.0",
+    "version": "0.4.0",
     "description": "A type-level library enabling the creation and the manipulation of type constructors which are detached from their type parameters.",
     "keywords:": [
         "higher kinded type",

package/partial.ts

@@ -24,7 +24,7 @@ type _partial <$T extends Type, Args extends unknown[]> =
         Args,
         Slice<$T['constraints'],
         Args['length'],
-        $T['constraints']['length']>,
+        Required<$T['constraints']>['length']>,
         'left'
     >
 
@@ -37,7 +37,7 @@ type partialRight<
     $T extends $Model ? PartialType<
         $T,
         Args,
-        Slice<$T['constraints'], 0, Subtract<$T['constraints']['length'], Args['length']>>,
+        Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>,
         'right'
     > : never
 

package/utils.ts

@@ -2,7 +2,7 @@ export { Natural, Prev, Next, Subtract }
 
 export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init }
 
-export { Extends, Eq, IsUnknown, IsAny }
+export { Extends, Eq, IsUnknown, IsAny, IsOptional }
 
 // Numbers
 
@@ -35,12 +35,20 @@ type ArrayKeys = Exclude<keyof [], never>;
 type Slice<
     T extends unknown[],
     From extends number,
-    To extends number = T['length'],
+    To extends number = Required<T>['length'],
     I extends number = From,
     R extends unknown[] = [],
 > =
     I extends To ? R
-    : Slice<T, From, To, Next<I>, [...R, T[I]]>;
+    : Slice<T, From, To, Next<I>,
+        IsOptional<T, I> extends true
+        ? [...R, T[I]?]
+        : [...R, T[I]]
+    >
+
+type IsOptional<T extends unknown[], I extends number> = [{
+    [K in T['length'] as K]: K extends I ? never : unknown
+}[I]] extends [never] ? true : false;
 
 type ToTuple<
     T extends readonly unknown[],