inferred-types 0.26.0 → 0.28.0

package/src/types/dictionary/MapTo.ts

@@ -1,23 +1,342 @@
+/* eslint-disable no-use-before-define */
+import { OptRequired } from "src/types/literal-unions";
+import {
+  DefaultManyToOneMapping,
+  DefaultOneToManyMapping,
+  DefaultOneToOneMapping,
+} from "src/utility/dictionary/mapTo";
+import { EnumValues } from "../EnumValues";
+import { TypeDefault } from "../TypeInfo/TypeDefault";
+
+/**
+ * Expresses relationship between inputs/outputs:
+ */
+export enum MapCardinality {
+  /** every input results in 0:M outputs */
+  OneToMany = "I -> O[]",
+  /** every input results in 0:1 outputs */
+  OneToOne = "I -> O",
+  /** every input is an array of type I and reduced to a single O  */
+  ManyToOne = "I[] -> O",
+}
+
+export type MapCardinalityIllustrated = EnumValues<MapCardinality>;
+
 /**
- * **MapTo**
+ * The _user_ configuration of a **mapTo** mapper function
+ * which will be finalized by merging it with the appropriate
+ * default mapping type.
+ */
+export interface MapConfig<
+  IR extends OptRequired | undefined = undefined,
+  D extends MapCardinalityIllustrated | undefined = undefined,
+  OR extends OptRequired | undefined = undefined
+> {
+  input?: IR;
+  output?: OR;
+  cardinality?: D;
+}
+
+/**
+ * A finalized configuration of a **mapTo** mapper functions cardinality
+ * relationships between _inputs_ and _outputs_.
  *
- * Maps from one type `I` to another `O[]`
+ * Note: _this configuration does _not_ yet include the actual mapping
+ * configuration between the input and output._
+ */
+export type FinalizedMapConfig<
+  IR extends OptRequired,
+  D extends MapCardinalityIllustrated,
+  OR extends OptRequired
+> = Required<MapConfig<IR, D, OR>> & { finalized: true };
+
+/**
+ * User configuration exposed by a config function which specifies the
+ * cardinality already (e.g., `oneToMany()`, `manyToOne()`)
+ */
+type MapCardinalityConfig<
+  IR extends OptRequired | undefined,
+  OR extends OptRequired | undefined
+> = {
+  input?: IR;
+  output?: OR;
+};
+
+/**
+ * **ConfiguredMap**
  *
- * **Note:** because the output is an array you can easily support `1:1` and `1:M` mappings
- * but not a filtering operation (e.g., `1:0`); if you need this then use `MapToWithFiltering`
- * instead.
+ * A partial application of the mapTo() utility which has expressed the
+ * configuration of the _inputs_ and _outputs_ and provides a `.map()`
+ * method which allows the user configure the specifics of the mapping.
+ */
+export type ConfiguredMap<
+  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = {
+  map: <I, O>(map: MapTo<I, O, C>) => MapFn<I, O, C>;
+  input: MapIR<C>;
+  cardinality: MapCard<C>;
+  output: MapOR<C>;
+};
+
+/**
+ * Extracts the IR, Cardinality, and OR generics from a FinalizedMapConfig
+ */
+export type DecomposeMapConfig<
+  M extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = M extends MapConfig<infer IR, infer D, infer OR>
+  ? IR extends OptRequired | undefined
+    ? D extends MapCardinalityIllustrated | undefined
+      ? OR extends OptRequired | undefined
+        ? [IR, D, OR]
+        : never
+      : never
+    : never
+  : M extends FinalizedMapConfig<infer IR, infer D, infer OR>
+  ? IR extends OptRequired
+    ? D extends MapCardinalityIllustrated
+      ? OR extends OptRequired
+        ? [IR, D, OR]
+        : never
+      : never
+    : never
+  : never;
+
+/** extracts IR from a `FinalizedMapConfig` */
+export type MapIR<
+  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = DecomposeMapConfig<T>[0];
+
+/**
+ * extracts the MapCardinality from a `FinalizedMapConfig`
  */
-export type MapTo<I extends {}, O extends {}> = (i: I) => O[];
+export type MapCard<
+  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = DecomposeMapConfig<T>[1];
+
+/** extracts OR from a `FinalizedMapConfig` */
+export type MapOR<
+  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = DecomposeMapConfig<T>[2];
+
+/**
+ * Merges the types of a userland configuration with a default configuration
+ */
+export type AsFinalizedConfig<
+  U extends MapConfig<
+    OptRequired | undefined,
+    MapCardinalityIllustrated | undefined,
+    OptRequired | undefined
+  >,
+  D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = TypeDefault<U, D> extends FinalizedMapConfig<infer IR, infer C, infer OR>
+  ? FinalizedMapConfig<IR, C, OR>
+  : never;
+
+export type MapperApi = {
+  /**
+   * Provides opportunity to configure _input_, _output_, and _cardinality_
+   * prior to providing a mapping function.
+   *
+   * Note: _the defaults for configuration are defined by the_ `DEFAULT_ONE_TO_MANY_MAPPING`
+   * _constant made available as a symbol from this library._
+   */
+  config: <
+    C extends MapConfig<
+      OptRequired, //
+      MapCardinalityIllustrated,
+      OptRequired
+    >
+  >(
+    config: C
+  ) => ConfiguredMap<
+    AsFinalizedConfig<
+      C, //
+      DefaultOneToManyMapping
+    >
+  >;
+
+  /**
+   * Provides a nice 1:1 ratio between the input and output.
+   *
+   * By default the input and output are considered to be _required_
+   * properties but this can be changed with the options hash provided.
+   * ```ts
+   * const mapper = mapTo.oneToOne().map(...);
+   * // add in ability to filter out some inputs
+   * const mapAndFilter = mapTo.oneToOne({ output: "opt" })
+   * ```
+   */
+  oneToOne: <C extends MapCardinalityConfig<OptRequired, OptRequired>>(
+    config?: C
+  ) => ConfiguredMap<
+    AsFinalizedConfig<
+      C, //
+      DefaultOneToOneMapping
+    >
+  >;
+
+  /**
+   * **manyToOne** _mapping_
+   *
+   * Provides a configuration where multiple inputs `I[]` will be mapped to a
+   * single output `O`.
+   *
+   * Choosing this configuration will, by default, set both input and output
+   * to be "required" but you can change this default if you so choose.
+   */
+  manyToOne: <
+    C extends MapCardinalityConfig<
+      OptRequired | undefined, //
+      OptRequired | undefined
+    >
+  >(
+    config?: C
+  ) => ConfiguredMap<
+    AsFinalizedConfig<
+      C, //
+      DefaultManyToOneMapping
+    >
+  >;
+
+  oneToMany: <
+    C extends MapCardinalityConfig<
+      OptRequired | undefined, //
+      OptRequired | undefined
+    >
+  >(
+    config?: C
+  ) => ConfiguredMap<
+    AsFinalizedConfig<
+      C, //
+      DefaultOneToManyMapping
+    >
+  >;
+};
+
+export type MapInput<
+  I, //
+  IR extends OptRequired,
+  C extends MapCardinalityIllustrated
+> = C extends MapCardinality.OneToMany | "I -> O[]"
+  ? IR extends "opt"
+    ? I | undefined
+    : I
+  : C extends MapCardinality.OneToOne | "I -> O"
+  ? IR extends "opt"
+    ? I | undefined
+    : I
+  : C extends MapCardinality.ManyToOne | "I[] -> O"
+  ? IR extends "opt"
+    ? I[] | undefined
+    : I[]
+  : never;
+
+export type MapOutput<
+  O, //
+  OR extends OptRequired,
+  C extends MapCardinalityIllustrated
+> = C extends MapCardinality.OneToMany | "I -> O[]"
+  ? OR extends "opt"
+    ? O[]
+    : [O, ...O[]]
+  : C extends MapCardinality.OneToOne | "I -> O"
+  ? OR extends "opt"
+    ? O | null
+    : O
+  : C extends MapCardinality.ManyToOne | "I[] -> O"
+  ? OR extends "opt"
+    ? O | null
+    : O
+  : never;
 
 /**
- * **MapToWithFiltering**
+ * **MapTo<I, O>**
  *
- * Maps from one type `I` to another `(O | null)[]`
+ * A mapping function between an input type `I` and output type `O`.
  *
- * **Note:** because the output is an array you can easily support `1:1` and `1:M` mappings
- * and the allowance of the conversion to result in a `null` value also means that filter
- * out an input value entirely is possible. If you don't need _filtering_ then use the
- * `MapTo` type instead.
+ * **Note:** this type is designed to guide the userland mapping; refer
+ * to `MapFn` if you want the type output by the `mapFn()` utility.
  */
+export type MapTo<
+  I,
+  O,
+  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = MapIR<C> extends "opt"
+  ? (source?: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>
+  : (source: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>;
+
+export type MapFnOutput<
+  I,
+  O,
+  S,
+  OR extends OptRequired,
+  C extends MapCardinalityIllustrated
+> = C extends "I -> O[]" | MapCardinality.OneToMany
+  ? S extends I[]
+    ? OR extends "opt"
+      ? O[]
+      : [O, ...O[]]
+    : OR extends "opt"
+    ? O[] | null
+    : O[]
+  : C extends MapCardinality.OneToOne | "I -> O"
+  ? S extends I[]
+    ? OR extends "opt"
+      ? O[]
+      : [O, ...O[]]
+    : OR extends "opt"
+    ? O | null
+    : O
+  : C extends MapCardinality.ManyToOne | "I[] -> O"
+  ? S extends I[][]
+    ? OR extends "opt"
+      ? O[]
+      : [O, ...O[]]
+    : OR extends "opt"
+    ? O | null
+    : O
+  : never;
 
-export type MapToWithFiltering<I extends {}, O extends {}> = (i: I) => O[] | null;
+export type MapFnInput<I, IR extends OptRequired, D extends MapCardinalityIllustrated> = D extends
+  | "I -> O[]"
+  | MapCardinality.OneToMany
+  ? IR extends "opt"
+    ? I | I[] | undefined
+    : I | I[]
+  : D extends MapCardinality.OneToOne | "I -> O"
+  ? IR extends "opt"
+    ? I | I[] | undefined
+    : I | I[]
+  : D extends MapCardinality.ManyToOne | "I[] -> O"
+  ? IR extends "opt"
+    ? I[] | I[][] | undefined
+    : I[] | I[][]
+  : never;
+
+/**
+ * The mapping function provided by the `mapFn()` utility. This _fn_
+ * is intended to be used in two ways:
+ *
+ * 1. Iterative:
+ *    ```ts
+ *    const m = mapTo<I,O>(i => [ ... ]);
+ *    // maps inputs to outputs
+ *    const out = inputs.map(m);
+ *    ```
+ * 2. Block:
+ *    ```ts
+ *    // maps inputs to outputs (filtering or splitting where appr.)
+ *    const out2 = m(inputs);
+ *    ```
+ */
+export type MapFn<
+  I,
+  O,
+  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+> = MapIR<C> extends "opt"
+  ? <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
+      source?: S
+    ) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>
+  : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
+      source: S
+    ) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;

package/src/types/dictionary/props.ts

@@ -1,4 +1,5 @@
 import { Alpha } from "../alphabetic/alpha-characters";
+import { Keys } from "../Keys";
 
 /**
  * Extracts the _required_ keys in the object's type. You also may
@@ -12,6 +13,16 @@ export type RequiredKeys<T extends object, V extends any = any> = {
     : never;
 }[keyof T];
 
+/**
+ * Extracts the intersecting/common keys to two objects
+ */
+export type IntersectingKeys<
+  T extends Record<string, any> | readonly string[],
+  U extends Record<string, any> | readonly string[]
+> = {
+  [K in keyof T]: K extends Keys<U> ? K : never;
+}[keyof T];
+
 /**
  * Extracts the _optional_ keys in the object's type. You also may
  * optionally filter by the _value_ of the key.

package/src/types/index.ts

@@ -37,6 +37,7 @@ export * from "./fluent/index";
 export * from "./functions/index";
 export * from "./kv/index";
 export * from "./lists/index";
+export * from "./literal-unions/index";
 export * from "./string-literals/index";
 export * from "./tuples/index";
 export * from "./type-conversion/index";

package/src/types/kv/DictFromKv.ts

@@ -1,3 +1,3 @@
-export type DictFromKv<T extends readonly Readonly<{ key: string; value: unknown }>[]> = {
+export type DictFromKv<T extends readonly { key: string; value: unknown }[]> = {
   [R in T[number] as R["key"]]: R["value"];
 };

package/src/types/literal-unions/OptRequired.ts

@@ -0,0 +1,4 @@
+/**
+ * Expresses whether an option is "opt" (optional) or "req" (required)
+ */
+export type OptRequired = "opt" | "req";

package/src/types/literal-unions/index.ts

@@ -0,0 +1 @@
+export * from "./OptRequired";

package/src/types/string-literals/Replace.ts

@@ -5,9 +5,13 @@
  * // "Foo"
  * type Foo = Replace<typeof fooy, "y", "">;
  * ```
- * 
+ *
  * Note: _the first match is replaced and all subsequent matches are ignored_
  */
-export type Replace<S extends string, W extends string, P extends string> =
-  S extends "" ? "" : W extends "" ? S :
-  S extends `${infer F}${W}${infer E}` ? `${F}${P}${E}` : S;
+export type Replace<S extends string, W extends string, P extends string> = S extends ""
+  ? ""
+  : W extends ""
+  ? S
+  : S extends `${infer F}${W}${infer E}`
+  ? `${F}${P}${E}`
+  : S;

package/src/types/type-testing.ts

@@ -8,10 +8,7 @@ export type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : fal
  */
 export type AssertExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? any : never;
 
-
-export type IfExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? VALUE : never;
-
 /**
- * Give a type `TValue` and a comparison type `TExtends` 
+ * Give a type `TValue` and a comparison type `TExtends`
  */
-export type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;
+export type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;

package/src/utility/dictionary/kv/kvToDict.ts

@@ -1,5 +1,4 @@
 import { DictFromKv } from "src/types/kv";
-import { Mutable } from "src/types/Mutable";
 import { Narrowable } from "src/types/Narrowable";
 
 /**
@@ -21,5 +20,5 @@ export function kvToDict<
     out[kv.key as keyof DictFromKv<T>] = kv.value;
   }
 
-  return out as DictFromKv<Mutable<T>>;
+  return out as DictFromKv<T>;
 }

package/src/utility/dictionary/mapTo.ts

@@ -1,37 +1,169 @@
-import { MapToWithFiltering } from "src/types/dictionary";
+import {
+  FinalizedMapConfig,
+  MapCardinalityIllustrated,
+  MapFnInput,
+  MapperApi,
+  MapTo,
+  AsFinalizedConfig,
+  MapConfig,
+  ConfiguredMap,
+  MapFnOutput,
+  MapIR,
+  MapCard,
+  MapOR,
+} from "src/types/dictionary";
+import { OptRequired } from "src/types/literal-unions";
+import { createFnWithProps } from "../createFnWithProps";
 
 /**
- * **mapTo**
- *
- * A utility function which maps one dictionary structure `I` to another `O`; which allows
- * the transform to:
- *
- * - _split_ inputs into multiple outputs
- * - _map_ 1:1 between input and output
- * - _filter_ inputs which don't meet certain criteria (by returning `null`)
+ * utility function to take a fully-qualified _user_ config
+ * and make it into a FinalizedMapConfig
+ */
+const toFinalizedConfig = <
+  IR extends OptRequired,
+  D extends MapCardinalityIllustrated,
+  OR extends OptRequired
+>(
+  config: MapConfig<IR, D, OR>
+) => {
+  return { ...config, finalized: true } as FinalizedMapConfig<IR, D, OR>;
+};
+
+export const DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "opt",
+  cardinality: "I -> O[]",
+});
+export const DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I -> O",
+});
+export const DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
+  input: "req",
+  output: "req",
+  cardinality: "I[] -> O",
+});
+
+export type DefaultOneToManyMapping = typeof DEFAULT_ONE_TO_MANY_MAPPING;
+export type DefaultOneToOneMapping = typeof DEFAULT_ONE_TO_ONE_MAPPING;
+export type DefaultManyToOneMapping = typeof DEFAULT_MANY_TO_ONE_MAPPING;
+
+/**
+ * The single implementation for all mapping
+ */
+const mapper =
+  <C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>>(config: C) =>
+  <I, O>(map: MapTo<I, O, C>) => {
+    return <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
+      source?: S
+    ): MapFnOutput<I, O, S, MapOR<C>, MapCard<C>> => {
+      /**
+       * Determine whether input is an array; this will be true
+       */
+      const isArray =
+        config.cardinality === "I -> O[]" && Array.isArray(source)
+          ? true
+          : config.cardinality === "I[] -> O" && Array.isArray(source) && Array.isArray(source[0])
+          ? true
+          : false;
+
+      if (isArray) {
+        // iterate over inputs with flatMap to return mapped values as
+        // well as supporting filtering functionality. We could achieve
+        // the same results by simply passing in all inputs to our mapper
+        // in most cardinalities but when cardinality is M:1 we need to
+        // make sure that the first array of elements is passed as a single
+        // item and this approach achieves this.
+        // TODO: we should check that the approach below doesn't work for M:1 here
+        // as well
+        return (source as any).flatMap(map) as MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+      } else {
+        // receive _all_ inputs provided as pass into ; this is just a single input unless the
+        // cardinality is
+        return map(source as any) as MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
+      }
+    };
+  };
+
+/**
+ * Takes a userland configuration and a default configuration and then produces
+ * the appropriately typed `ConfiguredMap` API surface.
+ */
+const setMapper = <
+  U extends MapConfig<
+    OptRequired | undefined,
+    MapCardinalityIllustrated | undefined,
+    OptRequired | undefined
+  >,
+  D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
+>(
+  config: U = { input: undefined, output: undefined, cardinality: undefined } as U,
+  defaultValue: D
+): ConfiguredMap<AsFinalizedConfig<U, D>> => ({
+  map: (source) => {
+    // merge userland config with defaults for a cardinality
+    const c = {
+      ...defaultValue,
+      ...config,
+    } as unknown as AsFinalizedConfig<U, D>;
+    return mapper(c)(source);
+  },
+  input: config?.input || defaultValue.input,
+  output: config?.output || defaultValue.output,
+  cardinality: config?.cardinality || defaultValue.cardinality,
+});
+
+/**
+ * **mapTo** _utility_
  *
- * This higher order function first asks for the mapping criteria:
+ * This utility -- by default -- creates a strongly typed 1:M data mapper which maps from one
+ * known source `I` to any array of another `O[]`:
  * ```ts
- * const mapper = mapTo<I,O>(i => i.name
- *  ? [
- *      { name: i.name, a: "static text", b: i.products.length }
- *    ]
- *  : null
- * );
+ * const mapper = mapTo<I, O>(i => [{
+ *    foo: i.bar
+ * }]);
  * ```
+ */
+export const mapToFn: ConfiguredMap<DefaultOneToManyMapping>["map"] = (map) => {
+  return mapper(DEFAULT_ONE_TO_MANY_MAPPING)(map);
+};
+
+/**
+ * Provides a `config` method which allows the relationships between _inputs_
+ * and _outputs_ to be configured.
+ */
+export const mapToDict: MapperApi = {
+  config(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  },
+  oneToOne(config) {
+    const c = { ...DEFAULT_ONE_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_ONE_MAPPING);
+  },
+  manyToOne(config) {
+    const c = { ...DEFAULT_MANY_TO_ONE_MAPPING, ...config };
+    return setMapper(c, DEFAULT_MANY_TO_ONE_MAPPING);
+  },
+  oneToMany(config) {
+    const c = { ...DEFAULT_ONE_TO_MANY_MAPPING, ...config };
+    return setMapper(c, DEFAULT_ONE_TO_MANY_MAPPING);
+  },
+};
+
+/**
+ * **mapTo** _utility_
  *
- * and now you'll have a _mapper_ variable will be assigned as a mapping fn:
+ * This utility creates a strongly typed data mapper which maps from one
+ * known source `I` to another `O`.
+ *
+ * Signatures:
  * ```ts
- * function (source: I | I[]): O[]
+ * const defMap = mapTo<I,O>( ... );
+ * const configured = mapTo.config({ output: "req" }).map<I,O>( ... );
+ * const one2one = mapTo.oneToOne().map<I,O>( ... );
+ * const many2one = mapTo.manyToOne().map<I,O>( ... );
  * ```
  */
-export const mapTo =
-  <I extends {}, O extends {}>(cb: MapToWithFiltering<I, O>) =>
-  (source: I | I[]) => {
-    if (Array.isArray(source)) {
-      return source.flatMap((i) => cb(i)).filter((i) => i !== null) as O[];
-    } else {
-      const result = cb(source);
-      return result ? result : ([] as O[]);
-    }
-  };
+export const mapTo = createFnWithProps(mapToFn, mapToDict);

package/src/utility/dictionary/merge.ts

@@ -0,0 +1,36 @@
+import { Mutable, Narrowable, SimplifyObject, TypeDefault } from "src/types";
+import { keys } from "../keys";
+import { isObject } from "../runtime";
+
+/**
+ * **merge**(val, defaultVal)
+ *
+ * Merges two values together where the second property is considered the
+ * the "default value". This means that in any cases where the primary value
+ * os _undefined_ it will be replaced by the default value. The merging will
+ * also recurse into object types to do matching at a property-by-property
+ * level.
+ *
+ * As much as is possible, this utility will maintain strong and narrow types
+ * across the merge process.
+ */
+export const merge = <T extends Narrowable, D extends Narrowable>(
+  val: T,
+  defVal: D
+): SimplifyObject<Mutable<TypeDefault<T, D>>> => {
+  const result =
+    val === undefined
+      ? // value is undefined; use default value
+        defVal
+      : isObject(defVal) && isObject(val)
+      ? // value and and default value are objects; recurse via default values
+        keys(defVal as Record<string, any>).reduce((acc, key) => {
+          const v = (val as Record<string, any>)[key];
+          const dv = (defVal as Record<string, any>)[key];
+
+          return { ...acc, [key]: merge(v, dv) };
+        }, {} as Record<string, any>)
+      : val;
+
+  return result as SimplifyObject<Mutable<TypeDefault<T, D>>>;
+};