Traits manual apply

.eslintrc.js

@@ -26,6 +26,12 @@ module.exports = {
         'max-len': ['error', 150],
         'nonblock-statement-body-position': ['warn', 'below'],
         'no-return-assign': 'error',
+        '@typescript-eslint/ban-types': ['error', {
+            types: {
+                "{}": false,
+                "Function": false
+            }
+        }],
         '@typescript-eslint/brace-style': ['error'],
         '@typescript-eslint/prefer-optional-chain': ['warn'],
         '@typescript-eslint/prefer-nullish-coalescing': ['warn'],

packages/immutable/src/index.ts

@@ -1,2 +1,3 @@
 export * from './traits'
+
 export * from './structs'

packages/immutable/src/structs/array-struct.test.ts

@@ -3,7 +3,14 @@ import { RecordStruct } from './record-struct'
 
 import { test, expect } from '@jest/globals'
 import { expectTypeOf } from 'expect-type'
-import { equals, Stateful, StructState, Structural } from '../traits'
+
+import {
+    equals,
+    PublicStructural,
+    Stateful,
+    StructState,
+    Structural
+} from '../traits'
 
 //// Setup ////
 
@@ -13,6 +20,10 @@ const array = new ArrayStruct(...data)
 
 //// Tests ////
 
+test('public structural methods', () => {
+    expect(PublicStructural.is(array)).toBe(true)
+})
+
 test('get State', () => {
 
     const state = Stateful.get(array)
@@ -26,51 +37,60 @@ test('get State', () => {
     })
 
     expect(state).toEqual({ ...array })
+
+    expect(array.get()).toEqual(state)
 })
 
-test('apply', () => {
+test('create', () => {
 
-    const array2 = Structural.apply(array, [5,4,3,2,1,0])
+    const array2 = Structural.create(array, [5,4,3,2,1,0])
 
-    expect(Structural.getIn(array2)).toEqual({
+    expect(Structural.get(array2)).toEqual({
         '0': 5,
         '1': 4,
         '2': 3,
         '3': 2,
         '4': 1,
         '5': 0,
     })
+
+    expect(array.create([5,4,3,2,1,0])).toEqual(array2)
 })
 
-test('deep apply', () => {
+test('deep create', () => {
 
-    const array2 = Structural.apply(array, 0, 100)
+    const array2 = Structural.create(array, 0, 100)
 
-    expect(Structural.getIn(array2)).toEqual({
+    expect(Structural.get(array2)).toEqual({
         0: 100,
         1: 2,
         2: 3,
         3: 4,
         4: 5
     })
+
+    expect(array2.create(0, 100)).toEqual(array2)
 })
 
-test('deep nested apply', () => {
+test('deep nested create', () => {
 
     const array = new ArrayStruct(
+
         new RecordStruct({
             foo: 0,
             bar: 'yes' 
         }),
+
         new RecordStruct({
             foo: 'bar',
             bar: 10 
         })
+
     )
 
-    const array2 = Structural.apply(array, 0, 'bar', 100)
+    const array2 = Structural.create(array, 0, 'bar', 100)
 
-    expect(Structural.getIn(array2)).toEqual({
+    expect(Structural.get(array2)).toEqual({
         0: {
             bar: 100,
             foo: 0
@@ -81,6 +101,16 @@ test('deep nested apply', () => {
         }
     })
 
+    expect(array.create(0, 'bar', 100)).toEqual(array2)
+
+})
+
+test('copy', () => {
+    expect(array.copy()).toEqual(array)
+})
+
+test('equals', () => {
+    expect(array.copy().equals(array)).toBe(true)
 })
 
 test('state type', () => {
@@ -202,17 +232,7 @@ describe('array interface', () => {
 
     test('filter', () => {
         const arrayFiltered = array.filter(i => i < 2)
-        expect(Stateful.get(arrayFiltered)).toEqual({
-            0: 1
-        }) 
-        expect(array).not.toBe(arrayFiltered)
-    })
-
-    test('filter', () => {
-        const arrayFiltered = array.filter(i => i < 2)
-        expect(Stateful.get(arrayFiltered)).toEqual({
-            0: 1
-        }) 
+        expect(Stateful.get(arrayFiltered)).toEqual({ 0: 1 })
         expect(array).not.toBe(arrayFiltered)
     })
 

packages/immutable/src/structs/array-struct.ts

@@ -2,7 +2,8 @@ import { assign, each, Func, Mutable, nil, omit } from '@benzed/util'
 
 import { adjacent, shuffle } from '@benzed/array'
 import { Traits } from '@benzed/traits'
-import { Stateful, Structural } from '../traits'
+
+import { PublicStructural, Stateful, Structural } from '../traits'
 
 //// EsLint ////
 
@@ -18,8 +19,6 @@ type ArrayMethodNames = keyof {
 
 type ArrayParams<T, M extends ArrayMethodNames> = Parameters<Array<T>[M]>
 
-// type ArrayReturns<T, M extends ArrayMethodNames> = ReturnType<Array<T>[M]>
-
 //// Helper ////
 
 const ArrayMethods = Array.prototype
@@ -47,7 +46,7 @@ function applyArrayState<
 
     // clone struct and apply state
     const newArrayStruct = Object.create(arrayStruct.constructor.prototype)
-    Structural.setIn(newArrayStruct, state)
+    Structural.set(newArrayStruct, state)
     return newArrayStruct
 
 }
@@ -58,7 +57,7 @@ function applyArrayState<
  * An ArrayStruct implements a subset of the Array's methods, with the caveat that
  * none of the methods mutate the original array.
  */
-class ArrayStruct<T> extends Traits.use(Structural) implements Iterable<T> {
+class ArrayStruct<T> extends Traits.use(PublicStructural) implements Iterable<T> {
 
     readonly [index: number]: T
 
@@ -73,7 +72,7 @@ class ArrayStruct<T> extends Traits.use(Structural) implements Iterable<T> {
     //// Interface ////
 
     get length(): number {
-        return each.nameOf(this).count
+        return each.nameOf(this).count()
     }
 
     at(index: number): T | nil {
@@ -202,7 +201,7 @@ class ArrayStruct<T> extends Traits.use(Structural) implements Iterable<T> {
     // TODO indexOf
     // TODO keys
     // TODO lastIndexOf
-    // TODO getIn
+    // TODO get
     // TODO applyIn
     // TODO copy
     // TODO equals
@@ -221,11 +220,11 @@ class ArrayStruct<T> extends Traits.use(Structural) implements Iterable<T> {
 
     //// State ////
 
-    get [Stateful.key](): { [index: number]: T } {
+    get [Stateful.state](): { [index: number]: T } {
         return { ...this }
     }
 
-    set [Stateful.key](state: { [index: number]: T }) {
+    set [Stateful.state](state: { [index: number]: T }) {
         assign(this, state)
     }
 

packages/immutable/src/structs/index.ts

@@ -1,6 +1,6 @@
 
-export * from './data-struct'
-
 export * from './public-struct'
 
-export * from './record-struct'
+export * from './record-struct'
+
+export * from './array-struct'

packages/immutable/src/structs/public-struct.test.ts

@@ -13,14 +13,14 @@ const vector = new class Vector extends PublicStruct {
 
 const edge = new class Edge extends PublicStruct {
     readonly a = vector
-    readonly b = vector
+    readonly b = vector 
 }
 
 test('get', () => {
-    const vstate = Structural.getIn(vector)
+    const vstate = Structural.get(vector)
     expect(vstate).toEqual(vector.get())
 
-    const estate = Structural.getIn(edge)
+    const estate = Structural.get(edge)
     expect(estate).toEqual(edge.get())
 })
 
@@ -34,29 +34,24 @@ test('get deep', () => {
 
 test('apply', () => {
 
-    const vector2 = vector.apply({ x: 100 })
+    const vector2 = vector.create({ x: 100 })
     expect(vector2.get()).toEqual({ x: 100, y: 0 })
 
-    const edge2 = edge.apply({ a: vector2 })
+    const edge2 = edge.create({ a: vector2 })
     expect(edge2.get()).toEqual({ a: { x: 100, y: 0 }, b: { x: 0, y: 0 }})
-
 })
 
 test('apply deep', () => {
-
-    const edge3 = edge.apply('a', 'x', 50)
-
+    const edge3 = edge.create('a', 'x', 50)
     expect(edge3.get()).toEqual({ a: { x: 50, y: 0 }, b: { x: 0, y: 0 }})
 })
 
 test('copy', () => {
-
     expect(edge.copy()).not.toBe(edge)
     expect(edge.copy()).toEqual(edge)
-
 })
 
 test('equals', () => {
     expect(edge.equals(edge.copy())).toBe(true)
-    expect(edge.equals(edge.apply('a', 'x', 50 ))).not.toBe(true)
+    expect(edge.equals(edge.create('a', 'x', 50 ))).not.toBe(true)
 })

packages/immutable/src/structs/public-struct.ts

@@ -1,64 +1,47 @@
 import { Traits } from '@benzed/traits'
 import { assign, NamesOf, omit } from '@benzed/util'
-import { copy, equals, StructState, StructStateApply, StructStatePath, Structural } from '../traits'
+
+import { PublicStructural, Structural } from '../traits'
 
 //// EsLint ////
 
-/* eslint-disable 
-    @typescript-eslint/no-explicit-any,
+/* eslint-disable
+    @typescript-eslint/no-explicit-any
 */ 
 
-//// PublicStruct ////
-
 /**
- * State preset for a generic objects.
- * Any property is considered state, so long as it isn't an object prototype property.
+ * State preset for a public structural objects.
+ * Any property is considered state, as long as it isn't a immutable interface method, or
+ * a built-in object method.
  */
 export type PublicStructState<T extends object> = 
     Pick<
     T,
     Exclude<NamesOf<T>, 'toString' | 'valueOf' | 'copy' | 'equals' | 'get' | 'apply'>
     >
 
+//// PublicStruct ////
+
 /**
- * A public struct is a structural object with a public interface for immutable operations
- * It assumes that any non-public-interface key is state.
+ * A PublicStruct implements the PublicStructural interface, and treats
+ * everything except public immutability methods (and toString, valueOf)
+ * as state.
  */
-export abstract class PublicStruct extends Traits.use(Structural) {
+export abstract class PublicStruct extends Traits.use(PublicStructural) {
 
-    //// Public Immutability Interface ////
-
-    get<P extends StructStatePath>(...path: P): StructState<this, P> {
-        return Structural.getIn(this, ...path)
-    }
-
-    apply<P extends StructStatePath>(...pathAndState: [...path: P, state: StructStateApply<this, P>]): this {
-        return Structural.apply(this, ...pathAndState)
-    }
-
-    copy(): this {
-        return copy(this)
-    }
-
-    equals(other: unknown): other is this {
-        return equals(this, other)
-    }
-
-    //// Structural Implemenation ////
-
-    get [Structural.key](): PublicStructState<this> {
+    get [Structural.state](): PublicStructState<this> {
         return omit(
-            this, 
-            'toString', 
+            this,
+            'toString',
             'valueOf',
             'get',
             'apply',
             'copy',
             'equals'
         ) as PublicStructState<this>
     }
-
-    protected set [Structural.key](state: PublicStructState<this>) {
+    
+    protected set [Structural.state](state: PublicStructState<this>) {
         assign(this, state)
     }