Viene desde la perspectiva de big data. Básicamente, muchos frameworks (como Apache Spark) "compensan" la falta de operaciones relacionales al proporcionar interfaces similares a Functor / Monad y hay un movimiento similar hacia las conversiones de gatos a SQL (Slick in Scala). Por ejemplo, necesitamos una unión natural (suponiendo que no haya repeticiones en los índices) para la multiplicación de vectores de elementos desde la perspectiva SQL, que podría considerarse como zip + map(multiply)
(el MLib de Spark, sin embargo, ya lo tiene ElementwiseProduct
) en las aplicaciones de la teoría de la categoría.
Simplemente diciendo (los siguientes ejemplos están en Scala):
El subcase de referencia de join se puede considerar como un aplicador (sobre una colección ordenada), que a su vez nos da
zip
:List(1,2,3).ap(List(2,4,8).map(a => (b: Int) => a * b))
->(List(1,2,3) zip List(2,4,8)).map(x => x._1 * x._2)
. Además, podemos inducirlo a otras uniones, suponiendo algún preprocesamiento (groupBy
operador o simplemente surjection, o en general, un epimorfismo).otras uniones y selecciones pueden considerarse mónadas. Por ejemplo,
WHERE
es solo:List(1,2,2,4).flatMap(x => if (x < 3) List(x) else List.empty)
->List(1,2,2,4).filter(_ < 3)
los datos en sí mismos son solo ADT (¿GADT también?), que a su vez se parece a una simple categoría Set (o más en general, cerrada cartesiana), por lo que debería (supongo) cubrir las operaciones basadas en Set (debido a Curry- Howard-Lambek en sí) y también operaciones como
RENAME
(al menos en la práctica).la agregación corresponde a
fold/reduce
(catamorfismo)
Entonces, lo que estoy preguntando es si podemos construir un isomorfismo entre (quizás un subconjunto de) teoría de categorías y (el todo) álgebra relacional o ¿hay algo descubierto? Si funciona, ¿qué "subconjunto" exacto de categorías es isomorfo a relalgebra?
Puede ver que mis propias suposiciones son bastante amplias, mientras que las soluciones formales como la correspondencia de Curry-Howard-Lambek para logic-cats-lambda son más precisas, por lo que en realidad, estoy pidiendo una referencia a un estudio realizado (que muestra una relación directa ) con más ejemplos en Scala / Haskell.
Editar : la respuesta aceptada me hizo pensar que fui demasiado lejos al representar uniones y condiciones como una mónada (especialmente usando un valor vacío que crea instancias de manera FALSA), creo que los retrocesos deberían ser suficientes al menos para el subconjunto relalgebra de SQL. Las mónadas son mejores para cosas de orden superior (anidamiento) como GROUP BY, que no forma parte de relalgebra.