Haskell función que toma un tipo y un valor y comprueba si el valor tiene ese tipo

Question

Estoy tratando de hacer un simple intérprete de esquema en Haskell. Como parte de esto, ¿estoy implementando algunos operadores primitivos como number ?, string? etc.

tengo código como este:

isNumber :: [LispVal] -> LispVal 
isNumber ([Number n]) = Bool True 
isNumber   _ = Bool False 

isString :: [LispVal] -> LispVal 
isString ([String n]) = Bool True 
isString   _ = Bool False 

Y lo que me gustaría es algo así como

isType :: ?? -> [LispVal] -> LispVal 
isType (typeName [typeName n]) = Bool True 
isType      _ = Bool False 

En otras palabras, me gustaría crear el equivalente de ISNUMBER por diciendo "isType Number". ¿Es esto posible de alguna manera? Estoy luchando por encontrar algo similar en Google, tal vez porque no sé cómo llamar a la situación.

Answer 1

Estoy suponiendo que tiene un tipo algo como esto:

data LispVal = String String | Number Double -- &c.... 

... y desea una función que comprueba si un valor LispVal es un constructor en particular (String, Number, & c.) basado en algún argumento

Desafortunadamente, no existe una forma sencilla y genérica de hacerlo.

Se podría recurrir a las comparaciones de cadenas:

getTypeName :: LispVal -> String 
getTypeName (String _) = "String" 
getTypeName (Number _) = "Number" 

isType :: String -> [LispVal] -> LispVal 
isType name [val] = Bool (name == getTypeName val) 
isType _ _ = Bool False 

O puede comparar los dos tipos de LispVal s:

sameType :: LispVal -> LispVal -> LispVal 
sameType (String _) (String _) = Bool True 
sameType (Number _) (Number _) = Bool True 
sameType _ _ = Bool False 

... y luego crear un valor ficticio de comparar por isType .

También puede hacer que un valor "tipo" y poner en práctica una especie de reflexión sobre LispVal s, a continuación, comparar basan en las que:

data LispType = LispString | LispNumber | LispType 

getType :: LispVal -> LispVal 
getType (String _) = Type LispString 
getType (Number _) = Type LispNumber 
getType (Type _) = Type LispType 

isType :: LispVal -> [LispVal] -> LsipVal 
isType t [v] = isEqual t (getType v) 
isType _ _ = Bool False 

alguna variación en uno de estos enfoques es probablemente su mejor opción. Hay otras maneras, basadas en funciones más avanzadas de Haskell, pero probablemente no valen la pena a menos que los tipos de lenguaje interpretado se vinculen mucho más estrechamente con los tipos de Haskell.