ballerina-core 1.0.0

package/src/forms/domains/singleton/template.tsx

@@ -0,0 +1,92 @@
+import { List, OrderedMap, OrderedSet } from "immutable"
+import { BasicUpdater, id, BasicPredicate, SimpleCallback, Unit, Debounced, Synchronized, unit, replaceWith, CoTypedFactory, Debounce, Synchronize, BasicFun, EntityFormState, EntityFormContext, EntityFormForeignMutationsExpected, EntityFormTemplate, EntityFormView, FieldTemplates, FieldValidationWithPath, FormValidatorSynchronized, OnChange, SharedFormState } from "../../../../main"
+import { Template, View } from "../../../template/state"
+import { Value } from "../../../value/state"
+
+export const Form = <Entity, FieldStates, Context, ForeignMutationsExpected>() => ({
+  Default: <Fields extends (keyof Entity) & (keyof FieldStates)>() => {
+    type State = EntityFormState<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>
+    type FieldTemplate<f extends Fields> = Template<Context & State[f] & Value<Entity[f]>, State[f], ForeignMutationsExpected & { onChange: OnChange<Entity[f]> }>
+    type EntityFormConfig = { [f in Fields]: FieldTemplate<f> }
+
+    return {
+      config: id<EntityFormConfig>,
+      template: (config: EntityFormConfig, validation:BasicFun<Entity, Promise<FieldValidationWithPath>>): EntityFormTemplate<Entity, Fields, FieldStates, Context, ForeignMutationsExpected> => {
+        const fieldTemplates: FieldTemplates<Entity, Fields, FieldStates, Context, ForeignMutationsExpected> = {} as FieldTemplates<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>
+        const setFieldTemplate = <field extends Fields>(field: field) => {
+          fieldTemplates[field] =
+            config[field]
+              .mapContext<EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>>(_ => 
+                ({ ..._, value: _.value[field], ...(_[field]) }) as any)
+              .mapState<State>(_ => current => ({ ...current, [field]: _(current[field]) }))
+              .mapForeignMutationsFromProps<EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>>(props =>
+              ({
+                ...props.foreignMutations,
+                onChange: (_: BasicUpdater<Entity[field]>, path) => {
+                  props.setState(_ => ({ ..._, 
+                    modifiedByUser: true, 
+                    validation:Debounced.Updaters.Template.value<FormValidatorSynchronized>(Synchronized.Updaters.value(replaceWith(unit)))(_.validation),
+                    [field]:({
+                      ..._[field], 
+                      modifiedByUser:true,
+                      validation:Debounced.Updaters.Template.value<FormValidatorSynchronized>(Synchronized.Updaters.value(replaceWith(unit)))(_[field].validation),
+                    }) }))
+                  setTimeout(() =>
+                    props.foreignMutations.onChange((current: Entity): Entity => ({
+                      ...current,
+                      [field]: _(current[field])
+                    }), path.push(field as string)),
+                    0)
+                }
+              }))
+        }
+        Object.keys(config).forEach((_) => {
+          const field = _ as Fields
+          setFieldTemplate(field)
+        })
+        return Template.Default<EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>, State,
+          EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+          EntityFormView<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>>(props => {
+            let visibleFieldKeys: OrderedSet<Fields> = OrderedSet()
+            props.context.visibleFields.forEach((showField, field) => {
+              if (!showField(props.context)) return
+              visibleFieldKeys = visibleFieldKeys.add(field)
+            })
+            return <>
+              <props.view {...props}
+                VisibleFieldKeys={visibleFieldKeys}
+                EmbeddedFields={fieldTemplates}
+              />
+            </>
+          })
+          .any([
+            ValidateRunner<
+              EntityFormContext<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>, 
+              State, 
+              EntityFormForeignMutationsExpected<Entity, Fields, FieldStates, Context, ForeignMutationsExpected>,
+              Entity>(validation),
+          ])
+      }
+    }
+  }
+})
+
+export const ValidateRunner = <Context, FormState extends SharedFormState, ForeignMutationsExpected, Entity,>(
+  validation:BasicFun<Entity, Promise<FieldValidationWithPath>>,
+) => {
+  const Co = CoTypedFactory<Context & Value<Entity> & FormState, FormState>()
+  return Co.Template<ForeignMutationsExpected & { onChange: OnChange<Entity>; }>(
+    Co.Repeat(
+      Debounce<FormValidatorSynchronized, Value<Entity>>(
+        Synchronize<Unit, FieldValidationWithPath, Value<Entity>>(
+          _ => validation(_.value),
+          () => "transient failure", 3, 50
+        ), 50
+      ).embed(_ => ({..._.validation, value:_.value}), (_) => curr => ({...curr, validation:_(curr.validation)}))
+    ),
+    {
+      interval:15,
+      runFilter:props => Debounced.Operations.shouldCoroutineRun(props.context.validation)
+    }
+  )
+}

package/src/forms/domains/singleton/views/field-views.ts

@@ -0,0 +1,23 @@
+import { FormInput } from "./simple-inputs/base";
+import { SimpleBooleanInput } from "./simple-inputs/boolean";
+import { SimpleDateInput } from "./simple-inputs/date";
+import { SimpleNumberInput } from "./simple-inputs/number";
+import { SimpleStringInput } from "./simple-inputs/string";
+
+
+export type FieldViews = {
+  string: FormInput<string>;
+  number: FormInput<number>;
+  boolean: FormInput<boolean>;
+  date: FormInput<Date>;
+};
+export const FieldViews = {
+  Default: {
+    simple: (): FieldViews => ({
+      string: SimpleStringInput,
+      number: SimpleNumberInput,
+      boolean: SimpleBooleanInput,
+      date: SimpleDateInput,
+    })
+  }
+};

package/src/forms/domains/singleton/views/simple-inputs/base.ts

@@ -0,0 +1,5 @@
+import { SimpleCallback } from "../../../../../../main";
+import { BasicFun } from "../../../../../fun/state";
+
+
+export type FormInput<T> = BasicFun<{ value: T; onChange: SimpleCallback<T>; }, JSX.Element>;

package/src/forms/domains/singleton/views/simple-inputs/boolean.tsx

@@ -0,0 +1,4 @@
+import { FormInput } from "./base";
+
+
+export const SimpleBooleanInput: FormInput<boolean> = props => <input type="checkbox" checked = { props.value } onChange = { e => props.onChange(e.currentTarget.checked) } />;

package/src/forms/domains/singleton/views/simple-inputs/date.tsx

@@ -0,0 +1,4 @@
+import { FormInput } from "./base";
+
+
+export const SimpleDateInput: FormInput<Date> = props => <input type="date" value = { props.value.toDateString() } onChange = { e => props.onChange(new Date(Date.parse(e.currentTarget.value))) } />;

package/src/forms/domains/singleton/views/simple-inputs/number.tsx

@@ -0,0 +1,4 @@
+import { FormInput } from "./base";
+
+
+export const SimpleNumberInput: FormInput<number> = props => <input type="number" value = { props.value } onChange = { e => props.onChange(parseInt(e.currentTarget.value)) } />;

package/src/forms/domains/singleton/views/simple-inputs/string.tsx

@@ -0,0 +1,4 @@
+import { FormInput } from "./base";
+
+
+export const SimpleStringInput: FormInput<string> = props => <input value={ props.value } onChange = { e => props.onChange(e.currentTarget.value)}/>;

package/src/fun/domains/curry/state.ts

@@ -0,0 +1,6 @@
+export const curry =
+  <A, B, C>(f: (a: A, b: B) => C) =>
+  (a: A) =>
+  (b: B): C =>
+    f(a, b);
+  

package/src/fun/domains/id/state.ts

@@ -0,0 +1,2 @@
+
+export const id = <a>(_: a) => _;

package/src/fun/domains/predicate/domains/bool-expr.ts

@@ -0,0 +1,98 @@
+import { BasicFun } from "../../../state"
+import { Predicate } from "../state"
+
+export type BoolExprSerializable<Leaf> =
+  {
+    kind: "leaf",
+    operation: keyof Leaf,
+    arguments: Leaf[keyof Leaf]
+  } |
+  {
+    kind: "true"
+  } | {
+    kind: "false"
+  } | {
+    kind: "and" | "or",
+    operands: [BoolExprSerializable<Leaf>, BoolExprSerializable<Leaf>]
+  } | {
+    kind: "not",
+    operand: BoolExprSerializable<Leaf>
+  }
+
+export type LeafPredicatesEvaluators<Leaf, Context> = { [leaf in keyof Leaf]: BasicFun<Leaf[leaf], Predicate<Context>> }
+export type BoolExpr<Leaf> =
+  ({
+    kind: "leaf",
+    operation: keyof Leaf,
+    arguments: Leaf[keyof Leaf]
+  } |
+  {
+    kind: "true"
+  } | {
+    kind: "false"
+  } | {
+    kind: "and" | "or",
+    operands: [BoolExpr<Leaf>, BoolExpr<Leaf>]
+  } | {
+    kind: "not",
+    operand: BoolExpr<Leaf>
+  }) & ({
+    not: () => BoolExpr<Leaf>,
+    and: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>,
+    or: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>,
+    eval: <Context>(evalLeaf: LeafPredicatesEvaluators<Leaf, Context>) => Predicate<Context>
+  })
+
+export const BoolExpr = {
+  Default: Object.assign(<Leaf>(_: BoolExprSerializable<Leaf>): BoolExpr<Leaf> => {
+    return Object.assign(
+      _.kind == "and" || _.kind == "or" ?
+        ({ kind: _.kind, operands: [BoolExpr.Default(_.operands[0]), BoolExpr.Default(_.operands[1])] as [BoolExpr<Leaf>, BoolExpr<Leaf>] })
+        : _.kind == "not" ?
+          ({ kind: _.kind, operand: BoolExpr.Default(_.operand) })
+          : _.kind == "leaf" ?
+            ({ kind: _.kind, operation: _.operation, arguments: _.arguments })
+            : _.kind == "true" ?
+              ({ kind: _.kind })
+              :
+              ({ kind: _.kind }),
+      {
+        not: function (this: BoolExpr<Leaf>): BoolExpr<Leaf> {
+          return BoolExpr.Default({
+            kind: "not", operand: this
+          })
+        },
+        and: function (this: BoolExpr<Leaf>, other: BoolExpr<Leaf>): BoolExpr<Leaf> {
+          return BoolExpr.Default({
+            kind: "and", operands: [this, other]
+          })
+        },
+        or: function (this: BoolExpr<Leaf>, other: BoolExpr<Leaf>): BoolExpr<Leaf> {
+          return BoolExpr.Default({
+            kind: "or", operands: [this, other]
+          })
+        },
+        eval: function <Context>(this: BoolExpr<Leaf>, evalLeaf: { [leaf in keyof Leaf]: BasicFun<Leaf[leaf], Predicate<Context>> }): Predicate<Context> {
+          return this.kind == "not" ? this.operand.eval(evalLeaf).not()
+            : this.kind == "and" ? this.operands[0].eval(evalLeaf).and(this.operands[1].eval(evalLeaf))
+              : this.kind == "or" ? this.operands[0].eval(evalLeaf).or(this.operands[1].eval(evalLeaf))
+                : this.kind == "leaf" ? evalLeaf[this.operation](this.arguments)
+                  : this.kind == "true" ? Predicate.True()
+                    : Predicate.False()
+        },
+      })
+  },
+    {
+      true: <Leaf>(): BoolExpr<Leaf> => BoolExpr.Default({
+        kind: "true"
+      }),
+      false: <Leaf>(): BoolExpr<Leaf> => BoolExpr.Default({
+        kind: "false"
+      }),
+      leaf: <Leaf>() => <operation extends keyof Leaf>(operation: operation, args: Leaf[operation]): BoolExpr<Leaf> => BoolExpr.Default({
+        kind: "leaf",
+        operation,
+        arguments: args
+      }),
+    })
+}

package/src/fun/domains/predicate/state.ts

@@ -0,0 +1,29 @@
+import { BasicFun, Fun } from "../../state"
+
+export type BasicPredicate<c> = BasicFun<c, boolean>
+export type Predicate<c> = Fun<c, boolean> & { 
+  not:() => Predicate<c>,
+  and:(other:Predicate<c>) => Predicate<c>,
+  or:(other:Predicate<c>) => Predicate<c>,
+}
+
+export const Predicate = Object.assign(<c>(actual:BasicPredicate<c>) : Predicate<c> => 
+  Object.assign(
+    Fun(actual),
+    {
+      not:function(this:Predicate<c>) : Predicate<c> {
+        return Predicate(_ => !this(_))
+      },
+      and:function(this:Predicate<c>, other:Predicate<c>) : Predicate<c> {
+        return Predicate(_ => this(_) && other(_))
+      },
+      or:function(this:Predicate<c>, other:Predicate<c>) : Predicate<c> {
+        return Predicate(_ => this(_) || other(_))
+      }
+    }
+  ),
+  {
+    True:<c>() => Predicate<c>(_ => true),
+    False:<c>() => Predicate<c>(_ => false),
+  }
+)

package/src/fun/domains/simpleCallback/state.ts

@@ -0,0 +1,3 @@
+import { BasicFun } from "../../state";
+
+export type SimpleCallback<E = void> = BasicFun<E, void>

package/src/fun/domains/uncurry/state.ts

@@ -0,0 +1,5 @@
+export const uncurry =
+  <A, B, C>(f: (a: A) => (b: B) => C) =>
+  (a: A, b: B): C =>
+    f(a)(b);
+  

package/src/fun/domains/unit/state.ts

@@ -0,0 +1,3 @@
+
+export type Unit = {} // { kind:"unit" };
+export const unit: Unit = {} // { kind:"unit" };

package/src/fun/domains/updater/domains/caseUpdater/state.ts

@@ -0,0 +1,44 @@
+import { BasicFun } from "../../../../state";
+import { BasicUpdater, Updater } from "../../state";
+
+export type Kind<T> = T extends { kind:infer k } ? k : never
+
+export type CaseUpdater<Entity, Field extends keyof Entity, CaseName extends Kind<Entity[Field]> & string> = {
+  [f in CaseName]: BasicFun<BasicUpdater<Entity[Field] & { kind: CaseName; }>, Updater<Entity>>;
+};
+
+export const caseUpdater = <Entity>() => <Field extends keyof Entity>(field:Field) => <CaseName extends Kind<Entity[Field]> & string>(caseName: CaseName): 
+  CaseUpdater<Entity, Field, CaseName> => ({
+  [caseName]: (caseUpdater: BasicUpdater<Entity[Field]>): Updater<Entity & { [_ in Field]:{ kind:CaseName } }> => {
+    return Updater<Entity & { [_ in Field]:{ kind:CaseName } }>(currentEntity => (currentEntity[field].kind == caseName) ? 
+      ({...currentEntity, [field]:caseUpdater(currentEntity as Entity[Field] & { kind: CaseName; }) }) 
+      : currentEntity
+    );
+  },
+}) as CaseUpdater<Entity, Field, CaseName>;
+
+
+
+import { LeftValue, RightValue, Sum } from "../../../../../collections/domains/sum/state";
+type Y = Sum<number,boolean>
+const Y = Sum<number,boolean>()
+type X = {
+  y:Y
+}
+const X = {
+  Default:() : X => ({ y:Y.Default.left(10) }),
+  Updaters:{
+    y:{
+      ...caseUpdater<X>()("y")("l"),
+      ...caseUpdater<X>()("y")("r"),
+    }
+  }
+}
+
+const visitor = 
+  X.Updaters.y.l(LeftValue.Updaters.value(_ => _ + 1)).then(
+    X.Updaters.y.r(RightValue.Updaters.value(_ => !_))
+  )
+
+
+console.log(visitor)

package/src/fun/domains/updater/domains/mapUpdater/state.ts

@@ -0,0 +1,36 @@
+import { BasicFun, Fun } from "../../../../state";
+import { unit, Unit } from "../../../unit/state";
+import { BasicUpdater, Updater } from "../../state";
+import { Map } from "immutable";
+
+export type MapUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+  [_ in Field]: Map<infer key, infer value>;
+} ? {
+    [f in DisplayName]: {
+      add: Fun<[key, value], Updater<Entity>>;
+      remove: Fun<key, Updater<Entity>>;
+      set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
+      upsert: Fun<[key, BasicFun<Unit, value>, BasicUpdater<value>], Updater<Entity>>;
+    };
+  } : "Error: mapUpdater has been invoked on a field which is not a map";
+
+
+export const mapUpdater = <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName:DisplayName): MapUpdater<Entity, Field, DisplayName> => ({
+  [displayName]: {
+    add: Fun(([key, value]: [unknown, unknown]): Updater<Entity> => Updater(entity => ({ ...entity, [field]: (entity[field] as Map<unknown, unknown>).set(key, value) }) as Entity)),
+    remove: Fun((key: unknown): Updater<Entity> => Updater(entity => ({ ...entity, [field]: (entity[field] as Map<unknown, unknown>).remove(key) }) as Entity)),
+    set: Fun((key: unknown) => (Fun((fieldUpdater: BasicUpdater<unknown>): Updater<Entity> => Updater(entity => ({
+      ...entity, [field]: (entity[field] as Map<unknown, unknown>).has(key) == false ? entity[field] :
+        (entity[field] as Map<unknown, unknown>).set(key, fieldUpdater((entity[field] as Map<unknown, unknown>).get(key)!))
+    }) as Entity)
+    ))),
+    upsert: Fun(([key, fallback, fieldUpdater]: [unknown, BasicFun<Unit, unknown>, BasicUpdater<unknown>]) : Updater<Entity> => Updater(entity => ({
+      ...entity, [field]: 
+        (entity[field] as Map<unknown, unknown>).set(key, 
+          (entity[field] as Map<unknown, unknown>).has(key) ?
+            fieldUpdater((entity[field] as Map<unknown, unknown>).get(key)!)
+          : fieldUpdater(fallback(unit)))
+    }) as Entity)
+    ),
+  }
+}) as MapUpdater<Entity, Field, DisplayName>;

package/src/fun/domains/updater/domains/maybeUpdater/state.ts

@@ -0,0 +1,45 @@
+import { Fun } from "../../../../state";
+import { BasicUpdater, Updater } from "../../state";
+
+
+
+
+
+export type MaybeUpdater<Entity, Field extends keyof Entity> = Entity extends {
+  [_ in Field]: infer value | undefined;
+} ? Required<{
+    [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & { both:Fun<BasicUpdater<value | undefined>, Updater<Entity>> };
+  }> : Entity extends {
+    [_ in Field]?: infer value;
+  } ? Required<{
+    [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & { both:Fun<BasicUpdater<value | undefined>, Updater<Entity>> };
+  }> : "Error: maybeUpdater has been invoked on a field which cannot be undefined";
+
+export const maybeUpdater = <Entity>() => <Field extends keyof Entity>(field: Field): MaybeUpdater<Entity, Field> => ({
+  [field]: Object.assign(Fun((fieldUpdater: BasicUpdater<Entity[Field]>): Updater<Entity> => {
+    return Updater(currentEntity => currentEntity[field] == undefined ? currentEntity :
+      ({ ...currentEntity, [field]: fieldUpdater(currentEntity[field]) }) as Entity
+    );
+  }), {
+    both:Fun((fieldUpdater: BasicUpdater<Entity[Field] | undefined>): Updater<Entity> => {
+      return Updater(currentEntity => ({ ...currentEntity, [field]: fieldUpdater(currentEntity[field]) }) as Entity
+      );
+    })
+  }),
+}) as MaybeUpdater<Entity, Field>;
+
+
+// // reference examples:
+// type T = {
+//   x:number,
+//   y:string | undefined,
+//   z?:boolean
+// }
+
+// const T = {
+//   Updaters:{
+//     ...maybeUpdater<T>()("x"),
+//     ...maybeUpdater<T>()("y").y(...),
+//     ...maybeUpdater<T>()("z").z.both(...),
+//   }
+// }

package/src/fun/domains/updater/domains/orderedMapUpdater/state.ts

@@ -0,0 +1,26 @@
+import { Fun } from "../../../../state";
+import { BasicUpdater, Updater } from "../../state";
+import { OrderedMap } from "immutable";
+
+export type OrderedMapUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+  [_ in Field]: OrderedMap<infer key, infer value>;
+} ? {
+    [f in DisplayName]: {
+      add: Fun<[key, value], Updater<Entity>>;
+      remove: Fun<key, Updater<Entity>>;
+      set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
+    };
+  } : "Error: orderedMapUpdater has been invoked on a field which is not an OrderedMap";
+
+
+export const orderedMapUpdater = <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName:DisplayName): OrderedMapUpdater<Entity, Field, DisplayName> => ({
+  [displayName]: {
+    add: Fun(([key, value]: [unknown, unknown]): Updater<Entity> => Updater(entity => ({ ...entity, [field]: (entity[field] as OrderedMap<unknown, unknown>).set(key, value) }) as Entity)),
+    remove: Fun((key: unknown): Updater<Entity> => Updater(entity => ({ ...entity, [field]: (entity[field] as OrderedMap<unknown, unknown>).remove(key) }) as Entity)),
+    set: Fun((key: unknown) => (Fun((fieldUpdater: BasicUpdater<unknown>): Updater<Entity> => Updater(entity => ({
+      ...entity, [field]: (entity[field] as OrderedMap<unknown, unknown>).has(key) == false ? entity[field] :
+        (entity[field] as OrderedMap<unknown, unknown>).set(key, fieldUpdater((entity[field] as OrderedMap<unknown, unknown>).get(key)!))
+    }) as Entity)
+    ))),
+  }
+}) as OrderedMapUpdater<Entity, Field, DisplayName>;

package/src/fun/domains/updater/domains/orderedSetUpdater/state.ts

@@ -0,0 +1,23 @@
+import { Fun } from "../../../../state";
+import { BasicUpdater, Updater } from "../../state";
+import { OrderedSet } from "immutable";
+
+export type OrderedSetUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+  [_ in Field]: OrderedSet<infer value>;
+} ? {
+  [f in DisplayName]: {
+    add: Fun<value, Updater<Entity>>;
+    remove: Fun<value, Updater<Entity>>;
+  };
+} : "Error: orderedSetUpdater has been invoked on a filed which is not an OrderedSet";
+
+export const orderedSetUpdater = <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName: DisplayName): OrderedSetUpdater<Entity, Field, DisplayName> => ({
+  [displayName]: {
+    add: Fun((value: unknown): Updater<Entity> =>
+      Updater(entity =>
+        ({ ...entity, [field]: (entity[field] as OrderedSet<unknown>).add(value) }) as Entity)),
+    remove: Fun((value: unknown): Updater<Entity> =>
+      Updater(entity =>
+        ({ ...entity, [field]: (entity[field] as OrderedSet<unknown>).remove(value) }) as Entity)),
+  }
+}) as OrderedSetUpdater<Entity, Field, DisplayName>;

package/src/fun/domains/updater/domains/replaceWith/state.ts

@@ -0,0 +1,3 @@
+import { Updater } from "../../state";
+
+export const replaceWith = <V>(v: V) => Updater((_: V) => v);

package/src/fun/domains/updater/domains/simpleUpdater/domains/baseSimpleUpdater/state.ts

@@ -0,0 +1,18 @@
+import { Fun } from "../../../../../../state";
+import { BasicUpdater, Updater } from "../../../../state";
+
+
+
+export type BaseWidening<c, p extends c> = Fun<BasicUpdater<c>, Updater<p>>;
+
+export type BaseSimpleUpdater<BaseEntity, Entity extends BaseEntity, Name extends string> = Required<{
+  [_ in Name]: BaseWidening<BaseEntity, Entity>;
+}>;
+export const baseSimpleUpdater = <BaseEntity, Entity extends BaseEntity>() => <Name extends string>(name: Name): BaseSimpleUpdater<BaseEntity, Entity, Name> => ({
+  [name]: Fun((baseUpdater: BasicUpdater<BaseEntity>): Updater<Entity> => {
+    return Updater<Entity>(current => ({
+      ...current,
+      ...(baseUpdater(current)),
+    }));
+  }),
+}) as BaseSimpleUpdater<BaseEntity, Entity, Name>;

package/src/fun/domains/updater/domains/simpleUpdater/state.ts

@@ -0,0 +1,72 @@
+import { Fun } from "../../../../state";
+import { Unit } from "../../../unit/state";
+import { BasicUpdater, Updater } from "../../state";
+
+export type Widening<p, c extends keyof p> = Fun<BasicUpdater<p[c]>, Updater<p>>;
+
+export type SimpleUpdater<Entity, Field extends keyof Entity> = Required<{
+  [f in Field]: Widening<Entity, Field>;
+}>;
+export const simpleUpdater = <Entity>() => <Field extends keyof Entity>(field: Field): SimpleUpdater<Entity, Field> => ({
+  [field]: Fun((fieldUpdater: BasicUpdater<Entity[Field]>): Updater<Entity> => {
+    return Updater<Entity>(currentEntity => ({ ...currentEntity, [field]: fieldUpdater(currentEntity[field]) }) as Entity
+    );
+  }),
+}) as SimpleUpdater<Entity, Field>;
+
+
+export type WidenedChildren<p, children> =
+  { [k in Exclude<keyof children, "Core" | "Template" | "Coroutine">]:
+    children[k] extends WideningWithChildren<infer child, infer nephew, infer nephews> ?
+      Fun<BasicUpdater<child[nephew]>, Updater<p>> & { children:WidenedChildren<p, nephews> }
+    : children[k] extends Widening<infer child, infer nephew> ? Fun<BasicUpdater<child[nephew]>, Updater<p>>
+    : "cannot invoke custom updaters through automated nesting"
+  } & (children extends { Core:Unit } ? {
+    Core:WidenedChildren<p, children["Core"]>
+   } : Unit) & (children extends { Template:Unit } ? {
+    Template:WidenedChildren<p, children["Template"]>
+   } : Unit) & (children extends { Coroutine:Unit } ? {
+    Coroutine:WidenedChildren<p, children["Coroutine"]>
+   } : Unit);
+
+export type WideningWithChildren<p, c extends keyof p, children> =
+  Fun<BasicUpdater<p[c]>, Updater<p>> & { children:WidenedChildren<p, children> }
+
+export type SimpleUpdaterWithChildren<Entity, Field extends keyof Entity, children> = {
+  [f in Field]: WideningWithChildren<Entity, Field, children>;
+};
+export const simpleUpdaterWithChildren = <Entity>() => <children>(children:children) => <Field extends keyof Entity>(field: Field): SimpleUpdaterWithChildren<Entity, Field, children> => ({
+  [field]: Object.assign(Fun((fieldUpdater: BasicUpdater<Entity[Field]>): Updater<Entity> => {
+    const basicUpdater:BasicUpdater<Entity> = currentEntity => ({ ...currentEntity, [field]: fieldUpdater(currentEntity[field]) })
+    return Updater<Entity>(basicUpdater);
+  }),
+    { children:widenChildren<Entity, Entity[Field], children>(simpleUpdater<Entity>()(field)[field], children, ) }
+  ),
+}) as SimpleUpdaterWithChildren<Entity, Field, children>;
+
+
+export const widenChildren = <p, child, children>(childToParent:Fun<BasicUpdater<child>, Updater<p>>, children:children) : WidenedChildren<p, children> => {
+  if (children == undefined) return {} as any
+  const result = {} as WidenedChildren<p, children>
+  Object.keys(children as any).forEach(key => {
+    if (key == "Core" || key == "Template" || key == "Coroutine") return
+    // Fun<BasicUpdater<child[key]>, Updater<child>>
+    const fieldOfChildUpdater = (children as any)[key] as any;
+    (result as any)[key] = Fun(_ => childToParent(fieldOfChildUpdater(_)))
+
+    if (Object.keys(fieldOfChildUpdater).includes("children")) {
+      (result as any)[key]["children"] = widenChildren<p, any, any>(childToParent, fieldOfChildUpdater["children"])
+    }
+  })
+
+  const updateBlock = (block:string) => {
+    if ((children as any)[block] != undefined) {
+      (result as any)[block] = widenChildren<p, any, any>(childToParent, (children as any)[block])    
+    }
+  }
+  updateBlock("Core")
+  updateBlock("Template")
+  updateBlock("Coroutines")
+
+  return result
+}