Defunc everything!

[upsiflu]

1. [x] Re-add type parameter wrapper to Ui and Layout -> b4fdd8b
2. [x] Replace Wrap... with Wrap wrapper
3. [x] Refactor item.get : AssocSet region (Ui aspect wrapper html)
4. [x] Refactor item.mask to : (statePredicate, AssocSet (OrInline (OrHeader aspect)) wrapper)
5. [x] Create type mutationResolution wrapper

Motivation

I had a nasty 'comparing functions' bug, and now I feel it would be solid to refactor restrictive to store no functions in the data structure. There are currently 4 types that store functions:

• Get, which is a simple key -> Maybe value
• Wrap : List html -> List html
• Mask : Get k v -> Get k v
• Item.mask : ( OrHeader aspect, Url ) -> Mask (OrHeader aspect) (Ui aspect html)

Discussion

https://elm.dmy.fr/packages/lue-bird/elm-keysset/latest/ has a complete discussions of Dict implementations. My Get is

just the function key -> Maybe value instead of a data structure examples jjant/elm-dict AllDict 👎 >= n runtime 👎 doesn't simplify it's structure. Every remove, insert, union, difference, adds to the function logic 👍 pretty easy to understand and build on with powerful features like assigning a specific value x whenever a condition is met

In comparison, KeysSet offers

• 🔑 element -> key function as part of a given Key
• defunc
• customizable sorting (may be useful for the layouting)
• typed emptiness (instead of Maybe, identity, [])

[2023-04-09] KeysSet seems very complex and extensive, although this makes it adaptable. In our use case, we only want the following functionality:

• Item.get: Store an immutable sparse population of region -> ui
• Item.mask: Manipulate this population according to the state, i.e. (OrHeader region, Url)
• Layout.regions: a sorted list of regions for view. May be omitted if Layout.view takes over this functionality?

This could be implemented with sparse arrays or hashtables. Here are the constraints:

• Regions are always sorted. As keys, they are always unique.
• We don't store functions (lamdera & serialization & comparison friendly)
• We may be able to specify mask
• Region as a key includes Handle

It seems like KeysSet and friends can easily implement these constraints, but at the cost of importing lots of steep learning. If we go a simpler route, we may have to give up on some constraints at compile-time. Let's try!

Implementation

• Get -> KeysSet
• Wrap can be reverted to accept a wrapper, where Layout provides `wrapper -> (List html -> List html)
• Mask key Ui is used for two operations:
  1. Append an additional Ui at key
  2. Delete the key, discarding its value
• Mask key (List html) is used for marking up resultant changes:
  1. forget an html fragment, for example by surrounding it with deletion flag nodes or nesting it into a fading node
  2. substitute { current, previous }, for example by comparing the elements, or simply replacing previous with current
     • ... which together implement mutation handling to enable smooth transitions and should be combined to a single thing.
• Item.mask : ( OrHeader aspect, Url ) -> Mask (OrHeader aspect) (Ui aspect html) can easily be replaced with KeysSet ( OrHeader aspect, Url ) ( Mask ... ), which would beneficially encode the identity case as Nothing. Though the selector inside the key is perhaps a bit tricky to serialize... perhaps we do need a fourth type parameter urlPredicate which is resolved to some Url->Bool function at Layout.

[upsiflu]

Concerning KeysSet, Get, Dict...:

What we currently use

Layout:

Get.concatValues : List key -> Get key (List a) -> List a Get.get : key -> (key -> value) -> value Get.toListBy : Get key (a -> b) -> List key -> Get key a -> List b Get.fromList : List ( key, a ) -> Get key a

Ui:

Get.singleton : key -> a -> Get key a Get.addList : key -> List a -> Get key (List a) -> Get key (List a) Get.map : (a -> b) -> Get key a -> Get key b Get.mapKey : (key2 -> Maybe key1) -> Get key1 a -> Get key2 a Get.mapByKey : (key -> a -> b) -> Get key a -> Get key b Get.values : List key -> Get key a -> List a Get.concatCustom : (List a -> a) -> List (Get key a) -> Get key a Get.mutation : { current : Get key a, previous : Maybe (Get key a) } -> Get key (Mutation a) Get.update : key -> (a -> a) -> Get key a -> Get key a Get.append : Get key (List a) -> Get key (List a) -> Get key (List a) Get.empty : Get key a

[upsiflu]

https://github.com/erlandsona/assoc-set/

• much simpler than KeysSet
• Dict with key type that doesn't require comparability but equality
• worse performance with many keys (but that will never happen)

[upsiflu]

4c3faa8e233cca01ee997a65e46192e9e19cf74b