Gérer les variables qui ne sont pas dans le type de données

Question

Ce que je souhaite accomplir est de passer des chaînes et des booléens dans une liste. L'opérateur 'switch' commute les deux premiers éléments de type input, l'opérateur 'and' et les deux premiers éléments.

Cependant, comment ajouter une chaîne d'erreur à la liste ("erreur") si je voulais 'et' un booléen et une chaîne? En outre, SMl n'accepte pas x::y::xs que devrais-je mettre à la place puisque je voudrais changer quel que soit le type.

datatype input = Bool_value of bool | String_Value of string | Exp_value of string 
datatype bin_op = switch | and 

fun helper(switch, x::y::xs) = y::x::stack 
    | helper(and, Bool_value(x)::Bool_value(y)::xs) = Bool_value(x and y)::xs 

Toute aide sera appréciée, merci.

Answer 1

and est un mot-clé, donc vous modifiez le bin_op à switch | and_op. x::y::zs est parfaitement valide sml. Dans la première ligne de la fonction d'assistance stack n'est pas définie. Enfin, le mot-clé "et" deux booléens ensemble dans sml est andalso.

Voici le code qui compile:

datatype input = Bool_value of bool | String_Value of string | Exp_value of string 
datatype bin_op = switch | and_op 

fun helper(switch, x::y::xs) = y::x::xs 
| helper(and_op, Bool_value(x)::Bool_value(y)::xs) = Bool_value(x andalso y)::xs 

Il existe des modèles inégalés, mais je suppose que vous soit les ai laissés ou les mettrez plus tard.

Answer 2

Il semble que vous construisiez un interpréteur pour un langage dynamiquement typé. Si cela est vrai, je distinguerais entre la syntaxe abstraite de votre programme et le traitement des erreurs de l'interpréteur, indépendamment de que vous utilisiez des exceptions ou des valeurs pour indiquer une erreur. Par exemple,

datatype value = Int of int 
       | Bool of bool 
       | String of string 

datatype exp = Plus of Exp * Exp 
      | And of Exp * Exp 
      | Concat of Exp * Exp 
      | Literal of value 

exception TypeError of value * value 

fun eval (Plus (e1, e2)) = (case (eval e1, eval e2) of 
           (Int i, Int j) => Int (i+j) 
           | bogus => raise TypeError bogus) 
    | eval (And (e1, e2)) = (case eval e1 of 
           Bool a => if a 
             then ... 
             else ... 
          | bogus => ...) 
    | eval (Concat (e1, e2)) = (case (eval e1, eval e2) of 
            (String s, String t) => String (s^t) 
           | bogus => raise TypeError bogus)