public IfDotted() : base("if_then_else_dotted", true,
new[]
{
Curry.ConstructFrom(a,
new Curry(b, Typs.Bool),
new Curry(b, a),
b),
Curry.ConstructFrom(a,
new Curry(b, Typs.String),
new Curry(b, a),
b),
Curry.ConstructFrom(a,
new Curry(b, Typs.Bool),
new Curry(b, a),
new Curry(b, a),
b),
Curry.ConstructFrom(a,
new Curry(b, Typs.String),
new Curry(b, a),
new Curry(b, a),
b)
}
)
{
Funcs.AddBuiltin(this, "ifdotted");
Funcs.AddBuiltin(this, "ifDotted");
}
public Default() : base("default", true,
new[]
{
Curry.ConstructFrom(a, a, new Curry(b, a), b)
})
{
}
public Concat() : base("concat", true,
new[]
{
Curry.ConstructFrom(Typs.String, Typs.String, Typs.String)
})
{
}
public Eq() : base("eq", true,
new[]
{
Curry.ConstructFrom(Typs.Bool, new Var("a"), new Var("a")),
Curry.ConstructFrom(Typs.String, new Var("a"), new Var("a"))
})
{
}
public ConstRight() : base("constRight", true,
new[]
{
Curry.ConstructFrom(new Var("b"), new Var("a"), new Var("b"))
}
)
{
}
public Const() : base("firstArg", true,
new[]
{
Curry.ConstructFrom(new Var("a"), new Var("a"), new Var("b"))
}
)
{
Funcs.AddBuiltin(this, "const");
}
public void Fresh_SomeType_NewVarName()
{
Assert.Equal("$d", Var.Fresh(
Curry.ConstructFrom(new Var("a"),
new Var("b"),
new Var("b"),
new Var("c"),
new Var("aa"))).Name);
}
public AtLeast() : base("atleast", true,
new[]
{
Curry.ConstructFrom(a,
Typs.Double,
new Curry(b, Typs.Double),
a, a, b),
})
{
}
public NotEq() : base("notEq", true,
new[]
{
Curry.ConstructFrom(Typs.Bool, new Var("a"), new Var("a")),
Curry.ConstructFrom(Typs.String, new Var("a"), new Var("a")),
new Curry(Typs.Bool, Typs.Bool),
})
{
Funcs.AddBuiltin(this, "not");
}
public Dot() : base("dot", true, new[]
{
// (.) : (b -> c) -> (a -> b) -> a -> c
Curry.ConstructFrom(C,
new Curry(B, C),
new Curry(A, B),
A
)
})
{
}
public If() : base("if_then_else", true,
new[]
{
Curry.ConstructFrom(a, Typs.Bool, a, a),
Curry.ConstructFrom(a, Typs.Bool, a),
Curry.ConstructFrom(a, Typs.String, a, a),
Curry.ConstructFrom(a, Typs.String, a)
}
)
{
Funcs.AddBuiltin(this, "if");
}
public MustMatch() : base("must_match", true,
new[] {
// [String] -> (Tags -> [string]) -> Tags -> bool
Curry.ConstructFrom(Typs.Bool, // Result type on top!
new ListType(Typs.String), // List of keys to check for
new Curry(Typs.Tags, new ListType(Typs.String)), // The function to execute on every key
Typs.Tags // The tags to apply this on
)
})
{
Funcs.AddBuiltin(this, "mustMatch");
}
public FirstMatchOf() : base("first_match_of", true,
new[]
{
// [String] -> (Tags -> [a]) -> Tags -> a
Curry.ConstructFrom(new Var("a"), // Result type on top!
new ListType(Typs.String),
new Curry(Typs.Tags, new ListType(new Var("a"))),
Typs.Tags
)
})
{
Funcs.AddBuiltin(this, "firstMatchOf");
}
public void TypeInference_EitherIdConstConst_CorrectType()
{
/*
* id : a -> a
* dot: (b -> c) -> (a -> b) -> a -> c
* const - throw away b: a -> b -> a
* eitherFunc: (a -> b) -> (c -> d) -> (a -> b)
* eitherFunc: (a -> b) -> (c -> d) -> (c -> d)
*
*
* All with free vars:
* id: a -> a
* dot: (b -> c) -> (x -> b) -> x -> c
* const: y -> z -> y
* eitherfunc: (d -> e) -> (f -> g) -> (d -> e)
* (d -> e) -> (f -> g) -> (f -> g)
*/
/*
* (((eitherfunc id) dot) const)
*
* (eitherfunc id)
* [(d -> e) -> (f -> g) -> (d -> e)] (a -> a)
* [(d -> e) -> (f -> g) -> (f -> g)] (a -> a)
*
* Gives:
* d ~ a
* e ~ a
* thus:
* (f -> g) -> (a -> a)
* (f -> g) -> (f -> g)
*
* ((eitherfunc id) dot)
* [(f -> g) -> (a -> a)] ((b -> c) -> (x -> b) -> x -> c)
* [(f -> g) -> (f -> g)] (b -> c) -> (x -> b) -> (x -> c)
*
* Thus: (f -> g) ~ (b -> c) -> ((x -> b) -> x -> c)
* thus: f ~ (b -> c)
* g ~ ((x -> b) -> (x -> c))
* thus:
* (a -> a)
* (b -> c) -> ((x -> b) -> (x -> c))
*
*
*
* (((eitherfunc id) dot) const):
* [(a -> a)] (y -> (z -> y))
* [(b -> c) -> ((x -> b) -> (x -> c))] (y -> (z -> y))
*
* Thus: case 1:
* a ~ (y -> (z -> y)
* Type is: (y -> z -> y) === typeof(const)
* case2:
* (b -> c) ~ (y -> (z -> y))
* thus: b ~ y
* c ~ (z -> y)
* ((x -> y) -> (x -> (z -> y))))
* = ((x -> y) -> x -> z -> y === mix of dot and const
*
*/
var a = new Var("a");
var c = new Var("c");
var d = new Var("d");
var e = Funcs.Either(Funcs.Id, Funcs.Dot, Funcs.Const);
var types = e.Types.ToList();
Assert.Equal(Curry.ConstructFrom(c, c, d), types[0]);
Assert.Equal(Curry.ConstructFrom(
c, // RESULT TYPE
new Curry(a, c),
a, d
), types[1]);
}