Ejemplo de definición de función en el constructor de datos de un nuevo tipo

Question

Podemos usar sinónimo de tipo para definiciones de funciones, p. Ej.

type FuncDef = Int -> Int -> Int 

Esto nos evita escribir una definición de función larga cada vez.

Uso:

someFunc :: FuncDef -> Int 

En lugar de

someFunc :: (Int -> Int -> Int) -> Int 

que es más fácil de leer y menos código.

Los tipos de datos algebraicos simples son simples y directos, etc.

data AType = X | Y | Z Int 
matchType :: AType -> Bool 
matchType X = .. 
matchType Y = .. 
matchType (Z _) = .. 

Al mirar más en tipos de datos de Haskell, descubrí que podemos tener en la definición de la función constructor de datos en la definición de nuevo tipo.

data MyType a b = X | Y (a -> b) 

Esto me desconcierta un poco y no he visto muchos ejemplos de esto. En cierto modo, la idea de función de orden superior en la que una función puede tomar otra función como argumento es similar a esta situación, excepto que aquí se aplica al tipo de datos. La wiki de Haskell no dice mucho sobre "definición de tipos de datos de alto orden". Me doy cuenta de que puedo estar equivocando todos estos términos, así que por favor corrígeme, y apúntame a leer más. Realmente quiero ver un uso concreto de esto. ¡Gracias!

matchMyType :: (MyType a b) -> Bool 
matchMyType X = .. 
matchMyType Y ?? = .. 

Answer 1

Puede usar este tipo de patrón en muchas situaciones. Por ejemplo, si desea una función que transforma las cadenas de diversas maneras, es posible que tenga un tipo de datos como esto (Esto es sólo un ejemplo que demuestra el principio - no escribir código como este!):

data StringTransformation = 
    -- | Doesn't transform the string at all 
    NoTransformation | 
    -- | Takes the string and generates a suffix that should be appended 
    Append (String -> String) | 
    -- | Takes the string and generates a prefix that should be prepended 
    Prepend (String -> String) | 
    -- | Takes the string and transforms it arbitrarily to a new string 
    Map (String -> String) 

Entonces, un programa que utiliza esto podría verse así:

-- | Returns 'True' if the name is male 
isMaleName :: String -> Bool 
isMaleName = ... 

-- | Adds a title to a name, for example "John Smith" -> "Mr. John Smith" 
addTitle :: StringTransformation 
addTitle = 
    PrependTransformation $ \ name -> 
    if isMaleName name 
    then "Mr. " 
    else "Mrs. " 

-- Applies a string transformation to a 'String'. 
transformString :: StringTransformation -> String -> String 
transformString NoTransformation str = str 
transformString (Append f) str  = str ++ f str 
transformString (Prepend f) str  = f str ++ str 
transformString (Map f) str   = f str 

Answer 2

data Thingy a b = A b 
       | B (a -> b) 

really :: Thingy a b -> a -> b 
really (A x) _ = x    -- x :: b 
really (B f) y = f y   -- f :: a -> b, y :: a, f y :: b 

Como dice C.A.McCann, no hay nada especial acerca de las funciones de verdad.