type statique vérification conditionals

Question

Ce qui suit est le code pour le type StaticCharme vérificateur:

je besoin d'aide pour définir la méthode typeConditional (expr, env). Il doit vérifier que toutes les expressions de prédicat évaluent une valeur booléenne. Pour qu'une expression conditionnelle soit correcte, les expressions correspondantes de chaque clause produisent des valeurs du même type. Le type d'une expression conditionnelle est le type de toutes les expressions conséquentes.

J'ai déjà un typcheck (expr, env) Méthode:

def typecheck(expr, env): 
if isPrimitive(expr): 
    return typePrimitive(expr) 
elif isConditional(expr): 
    return typeConditional(expr, env) 
elif isLambda(expr): 
    return typeLambda(expr, env) 
elif isDefinition(expr): 
    typeDefinition(expr, env) 
elif isName(expr): 
    return typeName(expr, env) 
elif isApplication(expr): 
    return typeApplication(expr, env) 
else: evalError ("Unknown expression: " + str(expr)) 

Answer 1

Pour un cas comme cela, j'essaie généralement de commencer par les expressions simples puis construire à d'autres plus compliquées:

def typeConditional(expr, env): 
    # handle a literal 
    # handle a variable 

alors pensez à la façon de briser les cas plus compliqués dans une composition des cas les plus simples ...

aussi, quand vous écrivez des tests, vous pouvez les commander de simple à compliqué afin que vous puissiez simplement les parcourir à leur tour.

Answer 2

Veuillez indiquer très précisément quelles sont les entrées que vos fonctions reçoivent et quelles sont les sorties qu'elles doivent générer. C'est très important! Puisque vous n'étiez pas spécifique, toute personne essayant de vous aider devra deviner ce que vous voulez faire.

---

À partir de votre déclaration:

In order for a conditional expression to be type correct: 
    a) All predicates must be boolean 
    b) All consequents must have the same type 
If it typechecks: 
    The type of the conditional expression 
    is the type of the consequent expressions. 

Cela se traduit presque directement (pseudo) code:

def typeConditional(condition, env): 
    #receives a conditional expression, and an execution environment 
    # returns the expression's type if it is well typed 
    # or None otherwise 

    predicates = get_predicate_expressions(condition) 
    if any predicate has a type that is not Bool: 
     return None 
    else: 
     consequents = consequent_expressions(consition) 
     the_type = typcheck(first consequent, env)  
     if all consequents have type the_type: 
      return the_type 
     else: 
      return None