我试图让我周围的类型推断是如何实现的头。 在特别的，我不太看到/为什么“统一”的繁重进场。
我给的“伪C＃”，以帮助澄清一个例子：
用简单的方式做这将是这样的：
假设你用“解析”你的程序到一个表达式树，使得它可以与执行：
interface IEnvironment
{
object lookup(string name);
}
interface IExpression
{
// Evaluate this program in this environment
object Evaluate(IEnvironment e);
}
因此，像“乘法”可能会实现：
class Multiply : IExpression
{
IExpression lhs;
IExpression rhs;
// etc.
public object Evaluate(IEnvironment e)
{
// assume for the moment C# has polymorphic multiplication
return lhs.Evaluate(e) * rhs.Evaluate(e);
}
}
然后以“落实”式的推理，你可能只是这样做：
interface ITypeEnvironment
{
Type getType(string name);
}
interface IExpression
{
//as before
object Evaluate(IEnvironment e);
// infer type
Type inferType(ITypeEnvironment typeEnvironment);
}
然后，“乘法”的类型推断可能仅仅是这样的：
class Multiply : IExpression
{
IExpression lhs;
IExpression rhs;
// ...
public Type inferType(ITypeEnvironment typeEnvironment)
{
Type lhsType = lhs.inferType(typeEnvironment);
Type rhsType = rhs.inferType(typeEnvironment);
if(lhsType != rhsType)
throw new Exception("lhs and rhs types do not match");
// you could also check here that lhs/rhs are one of double/int/float etc.
return lhsType;
}
}
LHS和RHS可能很简单的常量，或者在环境中抬头“变量”：
class Constant : IExpression
{
object value;
public Type inferType(ITypeEnvironment typeEnvironment)
{
return value.GetType(); // The type of the value;
}
public object Evaluate(IEnvironment environment)
{
return value;
}
}
class Variable : IExpression
{
string name;
public Type inferType(ITypeEnvironment typeEnvironment)
{
return typeEnvironment.getType(name);
}
public object Evaluate(IEnvironment environment)
{
return environment.lookup(name);
}
}
但无处在做这我们最终需要一个“统一”的算法。
因此，很明显，我的例子是不是足够复杂。 是否需要更高阶的功能呢？ 我们需要“参数多态性”？
什么是最简单的可能的例子，其中“统一”实际需要正确地推断表达式的类型。
在方案的一个例子是理想的（即，在那里你需要统一正确推断s表达式的类型的非常小的方案程序的例子）。
