javascript - Agrupar sin puntos por múltiples propiedades

Estoy teniendo un poco de dificultad con la implementación de una variante groupBy que permita agrupar por múltiples propiedades en un estilo point-free. (Estoy usando TypeScript y Ramda).

Quiero agrupar algunos elementos, digamos del tipo A, por propiedades devueltas por la función getProperties :: A a -> [b]. En el paradigma imperativo, la implementación podría verse así:

const getProperties = (item: Item): Array<keyof Item> => [item.x, item.y.z];

const groupByMany = (items: Item[]): Dictionary<Item[]> => {
  let groupped: Dictionary<Item[]> = {};
  for (let item of items) {
    for (let key of getProperties(item)) {
      if (groupped[key]) {
        groupped[key].push(item);
      } else {
        groupped[key] = [item];
      }
    }
  }
}

Ejemplo :

const items = [
  { i: 1, x: 'A', y: { z: 'B' } },
  { i: 2, x: 'A' },
  { i: 3, x: 'B', y: { z: 'B' } },
];
const expectedOutput = {
  A: [ { i: 1, ... }, { i: 2, ... }],
  B: [ { i: 1, ... }, { i: 3, ... }],
};

Respuesta #1

Te daré un comienzo -

const reduce = (f, init, xs) =>
  xs .reduce (f, init)

const upsert = (m, k, v) =>
  m .has (k)
    ? m .get (k) .push (v)
    : m .set (k, [ v ])

const groupByMany = (f, xs) =>
  reduce
    ( (m, x) =>
        ( f (x) .forEach (k => k && upsert (m, k, x))
        , m
        )
    , new Map
    , xs
    )
    
const items =
  [ { i: 1, x: 'A', y: { z: 'B' } }
  , { i: 2, x: 'A' }
  , { i: 3, x: 'B', y: { z: 'B' } }
  ]

const result =
  groupByMany
    ( item => [ item.x, item.y && item.y.z ]
    , items
    )
    
console.log(Object.fromEntries(result.entries()))

Observa cómo el último elemento tiene una B para .x y .y.z por lo que se inserta en el grupo B dos veces. Cambiamos upsert para que no inserte un valor duplicado -

const upsert = (m, k, v) =>
  m .has (k)
    ? m .get (k) .includes (v)
      ? m
      : m .get (k) .push (v)
    : m .set (k, [ v ])

Expande el fragmento a continuación para ver el resultado final en tu propio navegador -

const reduce = (f, init, xs) =>
  xs .reduce (f, init)

const upsert = (m, k, v) =>
  m .has (k)
    ? m .get (k) .includes (v)
      ? m
      : m .get (k) .push (v)
    : m .set (k, [ v ])

const groupByMany = (f, xs) =>
  reduce
    ( (m, x) =>
        ( f (x) .forEach (k => k && upsert (m, k, x))
        , m
        )
    , new Map
    , xs
    )
    
const items =
  [ { i: 1, x: 'A', y: { z: 'B' } }
  , { i: 2, x: 'A' }
  , { i: 3, x: 'B', y: { z: 'B' } }
  ]

const result =
  groupByMany
    ( item => [ item.x, item.y && item.y.z ]
    , items
    )
    
console.log(Object.fromEntries(result.entries()))

Una nota sobre la salida peculiar de SO: SO no mostrará el mismo objeto dos veces, en su lugar le dará al objeto una referencia, y mostrará esa referencia donde aparecería el objeto duplicado. Por ejemplo /**id:3**/ en la salida del programa -

{
  "A": [
    {
      /**id:3**/
      "i": 1,
      "x": "A",
      "y": {
        "z": "B"
      }
    },
    {
      "i": 2,
      "x": "A"
    }
  ],
  "B": [
    /**ref:3**/,
    {
      "i": 3,
      "x": "B",
      "y": {
        "z": "B"
      }
    }
  ]
}

Lo cual coincide con tu salida esperada -

const expectedOutput = {
  A: [ { i: 1, ... }, { i: 2, ... }],
  B: [ { i: 1, ... }, { i: 3, ... }],
};

No es sin puntos como pediste, pero solo dije que te daría un inicio...

Respuesta #2

No podía decir por la pregunta si querías algo que facilitara programar sin puntos o si, por alguna razón, estabas buscando una implementación sin puntos real. Si es lo último, me temo que esto no será de ayuda. Pero es bastante simple

const groupByMany = (fn) => (xs) => 
  xs .reduce 
    ( (a, x) => [...new Set ( fn(x) )] . reduce 
      ( (a, k) => k ? {...a, [k]: [... (a [k] || []), x ] } : a 
      , a
      )
    , {}
    )

// const getProperties = (item) => [path(['x'], item), path(['y', 'z'], item)]
const getProperties = juxt ( [path (['x']), path (['y', 'z']) ] )

const items = [{ i: 1, x: 'A', y: { z: 'B' } }, { i: 2, x: 'A'}, { i: 3, x: 'B', y: { z: 'B' } }]

console .log 
  ( groupByMany (getProperties) (items)
  )

<script src="https://bundle.run/[email "></script></script>
<script>const { juxt, path } = ramda                   </script>

Pasar las claves a través de [... new Set ( fn(x) ) ] es solo una forma rápida de eliminar duplicados del arreglo devuelto por fn (x). El resto de la función debería ser bastante claro.