Haskell: Typeclass vs pasar una función

Para mí, parece que siempre puedes pasar argumentos de función en lugar de usar una clase de tipos. Por ejemplo, en lugar de definir la clase de tipo de igualdad:

class Eq a where 
  (==)                  :: a -> a -> Bool

Y usarlo en otras funciones para indicar el argumento de tipo debe ser una instancia de Eq:

elem                    :: (Eq a) => a -> [a] -> Bool

¿No podemos simplemente definir nuestra elemfunción sin usar una clase de tipos y en su lugar pasar un argumento de función que haga el trabajo?

Si. Esto se llama "estilo de aprobación de diccionario". A veces, cuando estoy haciendo algunas cosas especialmente difíciles, necesito desechar una clase de texto y convertirla en un diccionario, porque la aprobación del diccionario es más potente ¹ , pero a menudo bastante engorrosa, lo que hace que el código conceptual simple parezca bastante complicado. A veces uso el estilo de aprobación de diccionario en idiomas que no son Haskell para simular clases de tipos (pero he aprendido que, por lo general, no es una idea tan buena como parece).

Por supuesto, cada vez que hay una diferencia en el poder expresivo, hay una compensación. Si bien puede usar una API determinada de más maneras si está escrita con DPS, la API obtiene más información si no puede. Una forma en que esto aparece en la práctica es en Data.Set, que se basa en el hecho de que solo hay un Orddiccionario por tipo. Las Settiendas de sus elementos ordenados según Ord, y si se construye un conjunto con un diccionario, y luego inserta un elemento utilizando una diferente, ya que sería posible con DPS, se podría romper Set's invariante y hacer que se caiga. Este problema de singularidad puede mitigarse utilizando un fantasma existencialescriba para marcar el diccionario, pero, una vez más, a costa de una complejidad bastante molesta en la API. Esto también se muestra más o menos de la misma manera en la TypeableAPI.

El bit de singularidad no aparece muy a menudo. En qué clases de tipos es excelente escribir código para usted. Por ejemplo,

catProcs :: (i -> Maybe String) -> (i -> Maybe String) -> (i -> Maybe String)
catProcs f g = f <> g

que toma dos "procesadores" que toman una entrada y pueden dar una salida, y los concatena, aplanándolos Nothing, tendría que escribirse en DPS algo como esto:

catProcs f g = (<>) (funcSemi (maybeSemi listSemi)) f g

Esencialmente tuvimos que deletrear el tipo en el que lo estamos usando nuevamente, a pesar de que ya lo deletreamos en la firma de tipo, e incluso eso era redundante porque el compilador ya conoce todos los tipos. Debido a que solo hay una forma de construir un determinado Semigroupen un tipo, el compilador puede hacerlo por usted. Esto tiene un efecto de tipo "interés compuesto" cuando comienzas a definir muchas instancias paramétricas y a usar la estructura de tus tipos para calcular por ti, como en los Data.Functor.*combinadores, y esto se usa para un gran efecto con el deriving viaque esencialmente puedes obtener todos los estructura algebraica "estándar" de su tipo escrita para usted.

Y ni siquiera me hagas comenzar con MPTC y fundeps, que retroalimentan la información en la verificación de tipos e inferencia. Nunca he intentado convertir tal cosa a DPS; sospecho que implicaría pasar muchas pruebas de igualdad de tipos, pero en cualquier caso, estoy seguro de que sería mucho más trabajo para mi cerebro de lo que estaría cómodo con.

-

¹ U alvo que utilizar reflectionen cuyo caso se convierten en equivalente en potencia - pero reflectiontambién puede ser complicado de usar.

Si. Eso (llamado pasar de diccionario) es básicamente lo que hace el compilador para escribir clases de todos modos. Para esa función, hecha literalmente, se vería un poco así:

elemBy :: (a -> a -> Bool) -> a -> [a] -> Bool
elemBy _ _ [] = False
elemBy eq x (y:ys) = eq x y || elemBy eq x ys

Llamar elemBy (==) x xsahora es equivalente a elem x xs. Y en este caso específico, puede ir un paso más allá: eqtiene el mismo primer argumento cada vez, por lo que puede hacer que la responsabilidad de la persona que llama aplique eso y termine con esto:

elemBy2 :: (a -> Bool) -> [a] -> Bool
elemBy2 _ [] = False
elemBy2 eqx (y:ys) = eqx y || elemBy2 eqx ys

Llamar elemBy2 (x ==) xsahora es equivalente a elem x xs.

...Oh espera. Eso es justo any. (Y, de hecho, en la biblioteca estándar,.elem = any . (==) )