coincidencia de patrón donde el patrón se basa en un (función) parámetro

Question

me gustaría escribir una función que toma tanto

• un constructor valor para un determinado tipo de datos algebraico, y
• un valor real de ese mismo tipo,

y determina si el valor dado está "hecho de" el constructor dado. La coincidencia de patrones parece un ajuste natural para esto, pero el patrón para hacer coincidir tendría que ser un parámetro de función en lugar de un nombre de constructor codificado.

El código siguiente es lo que he intentado, pero GHC informa un error de análisis en la línea indicada.

¿Hay alguna manera de lograr esto?

data FooBar = Foo Int | Bar String 

-- Imagine that these are useful functions. 
processInt :: Int -> String 
processInt = show 
processString :: String -> String 
processString = id 

-- This should take one of the above functions and adapt it to operate on 
-- FooBar values of compatible "type". Values that match the given FooBar 
-- constructor should be "unwrapped" and passed to the given function. 
typeCheck :: (a -> FooBar) -> (a -> String) -> (FooBar -> Maybe String) 
typeCheck constructor func fooBar = case fooBar of 
    (constructor x) -> Just (func x) -- GHC says "Parse error in pattern: constructor" 
    _ -> Nothing 

-- Define processing functions that operate on FooBars. 
processFoo :: FooBar -> Maybe String 
processFoo = typeCheck Foo processInt 
processBar :: FooBar -> Maybe String 
processBar = typeCheck Bar processString 

Answer 1

Idea interesante. Me pregunto qué estás tratando de hacer, ya que este es un problema de coincidencia de patrones bastante inusual.

Por supuesto que puede hacerlo si se puede:

• enumerar los constructores del tipo
• tener igualdad en los elementos del tipo

Al igual que (rompo a cabo la aplicación de f parte, ya que es ortogonal):

wasBuilt :: Eq t => (t -> Either t t) --^the constructor 
       -> Either t t   --^a value 
       -> Maybe t    --^the transformed result 

wasBuilt k v = case v of 
    Left x | v == k x -> Just x 
    Right x | v == k x -> Just x 
    _      -> Nothing 

Pero el Hay un montón de repetición. Este problema grita "genéricos" en mí. Pruebe con un enfoque diferente, y refleje el constructor en los datos, luego haga coincidir genéricamente esos datos, tal vez. Esto le permitirá tratar a los constructores como valores, en lugar de funciones.

---

Esto es más o menos lo que estaba pensando, pero tenga en cuenta que esta es una técnica avanzada. explícita patrón correspondiente de una AST regular es mucho, mucho más idiomática:

import Generics.SYB 

-- only works for unary constructors 
sameConstructor :: (Data a, Data b) => (a -> b) -> b -> Bool 
sameConstructor k v = toConstr v == toConstr (k undefined) 

> sameConstructor (Left :: Char -> Either Char Char) (Right 'x') 
False 

> sameConstructor (Left :: Char -> Either Char Char) (Left 'x') 
True 

> sameConstructor (:[]) "haskell" 
True 

Answer 2

Es posible que desee ver en Type-safe pattern combinators perla funcional. Si bien no se combina tan bien con la sintaxis de concordancia de patrones de Haskell, sí le permite tener la modularidad de patrones compostables de primera clase, si eso es lo que necesita (es decir, si la capacidad de compilación adicional supera las molestias sintácticas).