public void TypeInference_Test()
{
var testData = "10:00/25-12-2008/1097.63/-1/hello world/(1)/(2)/1.0/JA/Nee/false/true/Y/N/30 December 2019";
var result = "";
foreach (var inference in testData.Split('/'))
{
result += TypeInference.Infer(inference).Type.ToString();
}
Assert.True(result == "TimeSpanDateTimeDoubleDoubleStringStringStringDoubleBooleanBooleanBooleanBooleanBooleanBooleanDateTime");
}
public void TestTypeclasses()
{
var initialState = new InferenceState(new FreshVariableStream(),
new TypeclassDeclaration("Eq",
new TypeScheme(new TypeConstructor("int", new DataKind())),
new TypeScheme(new QualifiedType(
new TypeApplication(new TypeConstructor("[]", new ArrowKind(new DataKind(), new DataKind())),
new TypeVariable("a", new DataKind())),
new Predicate("Eq", new TypeVariable("a", new DataKind()))), ("a", new DataKind()))),
new TypeclassDeclaration("Ord"),
new TypeclassDeclaration("Show"),
new TypeclassDeclaration("Read"),
new TypeclassDeclaration("Bounded"),
new TypeclassDeclaration("Enum"),
new TypeclassDeclaration("Functor"),
new TypeclassDeclaration("Monad"),
new TermVariableBinding("eq", new TypeScheme(new QualifiedType(
PrimType.Fun(new TypeVariable("a", new DataKind()), new TypeVariable("a", new DataKind()), new TypeConstructor("bool", new DataKind())),
new Predicate("Eq", new TypeVariable("a", new DataKind()))),
("a", new DataKind()))),
new TermVariableBinding("zero", new TypeScheme(new QualifiedType(new TypeConstructor("int", new DataKind())))),
new TermVariableBinding("true", new TypeScheme(new QualifiedType(new TypeConstructor("bool", new DataKind())))),
new TermVariableBinding("show", new TypeScheme(new QualifiedType(
PrimType.Fun(new TypeVariable("a", new DataKind()), new TypeConstructor("string", new DataKind())),
new Predicate("Show", new TypeVariable("a", new DataKind()))),
("a", new DataKind()))),
new TermVariableBinding("read", new TypeScheme(new QualifiedType(
PrimType.Fun(new TypeConstructor("string", new DataKind()), new TypeVariable("a", new DataKind())),
new Predicate("Read", new TypeVariable("a", new DataKind()))),
("a", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(initialState, new TermVariable("eq")),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t0", new DataKind()), new TypeConstructor("bool", new DataKind())),
new Predicate("Eq", new TypeVariable("t0", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(initialState, new Application(new TermVariable("eq"), new TermVariable("zero"))),
new QualifiedType(PrimType.Fun(new TypeConstructor("int", new DataKind()), new TypeConstructor("bool", new DataKind()))));
Assert.ThrowsException <Exception>(() =>
TypeInference.Infer(initialState, new Application(new TermVariable("eq"), new TermVariable("true"))));
Assert.ThrowsException <Exception>(() =>
TypeInference.Infer(initialState, new LambdaAbstraction("x", new Application(new TermVariable("show"), new Application(new TermVariable("read"), new TermVariable("x"))))));
}
public Table(DebugInfo debugInfo, string name, List <ColumnType> columnTypes, List <Row> rows, IEnumerable <ISituation> situations = null)
{
DebugInfo = debugInfo ?? throw new ArgumentNullException(nameof(debugInfo));
Name = name ?? throw new ArgumentNullException(nameof(name));
ColumnTypes = columnTypes ?? throw new ArgumentNullException(nameof(columnTypes));
Rows = rows ?? throw new ArgumentNullException(nameof(rows));
Situations = situations;
if (Rows.Count == 0)
{
throw new ArgumentNullException(nameof(rows));
}
for (int i = 0; i < ColumnTypes.Count; i++)
{
ColumnTypes[i].Index = i;
// evaluate one row for type inference
ColumnTypes[i].Type = TypeInference.Infer(Rows[0].Columns[i].Value.ToString()).Type;
}
}
public void CoreHindleyMilnerTests()
{
var InitialState = new InferenceState(new FreshVariableStream());
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new TermVariable("x"))),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t0", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new LambdaAbstraction("y", new TermVariable("y")))),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t1", new DataKind()), new TypeVariable("t1", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new LambdaAbstraction("y", new TermVariable("x")))),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t1", new DataKind()), new TypeVariable("t0", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new Application(new LambdaAbstraction("y", new TermVariable("y")), new TermVariable("x")))),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t0", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new Application(new LambdaAbstraction("y", new TermVariable("x")), new TermVariable("x")))),
new QualifiedType(PrimType.Fun(new TypeVariable("t0", new DataKind()), new TypeVariable("t0", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LetBinding("m", new LambdaAbstraction("a", new TermVariable("a")), new Application(new TermVariable("m"), new TermVariable("m")))),
new QualifiedType(PrimType.Fun(new TypeVariable("t2", new DataKind()), new TypeVariable("t2", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState,
new LetBinding("s", new LetBinding("m", new LambdaAbstraction("a", new TermVariable("a")), new Application(new TermVariable("m"), new TermVariable("m"))), new TermVariable("s"))),
new QualifiedType(PrimType.Fun(new TypeVariable("t4", new DataKind()), new TypeVariable("t4", new DataKind()))));
Assert.AreEqual(
TypeInference.Infer(InitialState, new LambdaAbstraction("x", new LambdaAbstraction("y", new Application(new TermVariable("x"), new TermVariable("y"))))),
new QualifiedType(PrimType.Fun(PrimType.Fun(new TypeVariable("t1", new DataKind()), new TypeVariable("t2", new DataKind())), new TypeVariable("t1", new DataKind()), new TypeVariable("t2", new DataKind()))));
}
public Parameter(string name, object value, TypeEnum?type, ref Model model)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("message", nameof(name));
}
Name = name;
if (type == TypeEnum.Step)
{
_value = null;
Type = TypeEnum.Step;
return;
}
var woonlanden = new List <object>();
// Check if woonland can be found in a table
foreach (var table in model.Tables)
{
foreach (var column in table.ColumnTypes)
{
if (column.Name == name)
{
// Give back a column list value of column woonland
foreach (var row in table.Rows)
{
woonlanden.Add(row.Columns[column.Index].Value);
}
_value = woonlanden;
Type = TypeEnum.List;
return;
}
}
}
if (value == null && type == TypeEnum.Double)
{
_value = double.Parse("0");
Type = type.Value;
return;
}
if (value == null && type == TypeEnum.Boolean)
{
_value = false;
Type = TypeEnum.Boolean;
return;
}
if (type == TypeEnum.Boolean)
{
Type = TypeEnum.Boolean;
_value = value.Infer();
}
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
_value = value.Infer();
if (type == null)
{
Type = value is double?
TypeEnum.Double:
TypeInference.Infer(value.ToString()).Type;
}
}
public void InferFloatTests()
{
var FloatTestInitialContext = new InferenceState(new FreshVariableStream(),
new TermVariableBinding("zero", new TypeScheme(new FloatType(new UnitPower(new TypeVariable("x"), 1)), ("x", Kind.Unit))),
new TermVariableBinding("one", new TypeScheme(new FloatType(new UnitIdentity()))),
new TermVariableBinding("mass", new TypeScheme(new FloatType(new UnitPower(new PrimitiveUnit("kg"), 1)))),
new TermVariableBinding("time", new TypeScheme(new FloatType(new UnitPower(new PrimitiveUnit("sec"), 1)))),
new TermVariableBinding("mul", new TypeScheme(new ArrowType(
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("b"), 1)),
new FloatType(new UnitMultiply(new UnitPower(new TypeVariable("a"), 1), new UnitPower(new TypeVariable("b"), 1)))), ("a", Kind.Unit), ("b", Kind.Unit))),
new TermVariableBinding("plus", new TypeScheme(new ArrowType(
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("a"), 1))), ("a", Kind.Unit))),
new TermVariableBinding("div", new TypeScheme(new ArrowType(
new FloatType(new UnitMultiply(new UnitPower(new TypeVariable("a"), 1), new UnitPower(new TypeVariable("b"), 1))),
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("b"), 1))),
("a", Kind.Unit), ("b", Kind.Unit))),
new TermVariableBinding("pair", new TypeScheme(new ArrowType(
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("b"), 1)),
new FloatType(new UnitPower(new TypeVariable("a"), 1)),
new FloatType(new UnitPower(new TypeVariable("b"), 1))),
("a", Kind.Unit), ("b", Kind.Unit)))
);
Assert.AreEqual(
TypeInference.Infer(FloatTestInitialContext, new TermVariable("zero")),
new FloatType(new UnitPower(new TypeVariable("t0"), 1)));
Assert.AreEqual(
TypeInference.Infer(FloatTestInitialContext, new Application(new TermVariable("mul"), new TermVariable("mass"), new TermVariable("mass"))),
new FloatType(new UnitPower(new PrimitiveUnit("kg"), 2)));
Assert.AreEqual(
TypeInference.Infer(FloatTestInitialContext,
new LambdaAbstraction("a",
new LambdaAbstraction("b",
new Application(new TermVariable("plus"), new TermVariable("a"), new TermVariable("b"))))),
new ArrowType(new FloatType(new UnitPower(new TypeVariable("h0"), 1)),
new FloatType(new UnitPower(new TypeVariable("h0"), 1)),
new FloatType(new UnitPower(new TypeVariable("h0"), 1))));
Assert.AreEqual(
TypeInference.Infer(FloatTestInitialContext,
new LambdaAbstraction("x",
new LetBinding("d", new Application(new TermVariable("div"), new TermVariable("x")),
new Application(new TermVariable("pair"),
new Application(new TermVariable("d"), new TermVariable("mass")),
new Application(new TermVariable("d"), new TermVariable("time")))))),
new ArrowType(new FloatType(new UnitPower(new TypeVariable("h0"), 1)),
new FloatType(new UnitMultiply(new UnitPower(new TypeVariable("h0"), 1), new UnitPower(new PrimitiveUnit("kg"), -1))),
new FloatType(new UnitMultiply(new UnitPower(new TypeVariable("h0"), 1), new UnitPower(new PrimitiveUnit("sec"), -1)))));
Assert.AreEqual(
TypeInference.Infer(FloatTestInitialContext,
new LetBinding("recip", new Application(new TermVariable("div"), new TermVariable("one")),
new Application(new TermVariable("pair"),
new Application(new TermVariable("recip"), new TermVariable("mass")),
new Application(new TermVariable("recip"), new TermVariable("time"))))),
new ArrowType(new FloatType(new UnitPower(new PrimitiveUnit("kg"), -1)), new FloatType(new UnitPower(new PrimitiveUnit("sec"), -1))));
}
