public IType CheckApp(IType type1, IKind kind, IType type2)
{
/*
(TApp (TCPoly kind2) (TAbs unique type6)) = type1;
return CheckPolymorphicTypeApp(kind2, kind, unique, type6, type2);
*/
if (type1 is TApp)
{
IType type4 = ((TApp)type1).Function;
IType type5 = ((TApp)type1).Argument;
if (type4 is TCPoly)
{
IKind kind2 = ((TCPoly)type4).Kind;
if (type5 is TAbs)
{
Unique unique = ((TAbs)type5).Parameter;
IType type6 = ((TAbs)type5).Body;
return CheckPolymorphicTypeApp(
kind2, kind, unique, type6, type2
);
}
}
}
throw new ArgumentException(
string.Format(
"{0} doesn't have a polymorphic type", mValueExpr.Show()
)
);
}
public IKind <OptionF, TB> Ap <TA, TB>(IKind <OptionF, Func <TA, TB> > ff, IKind <OptionF, TA> fa)
{
var f = ff.Fix();
var a = fa.Fix();
return(f.IsSome && a.IsSome
? (IKind <OptionF, TB>) new Some <TB>(f.Get()(a.Get()))
: new None <TB>());
}
public VETypeAbs(
string typeVarName,
IKind kind,
IValueExpr valueExpr
)
{
mTypeVarName = typeVarName;
mKind = kind;
mValueExpr = valueExpr;
}
public bool Equals(IKind kind)
{
if (!(kind is KArrow))
{
return false;
}
IKind kind1 = ((KArrow)kind).mKind1;
IKind kind2 = ((KArrow)kind).mKind2;
return mKind1.Equals(kind1) && mKind2.Equals(kind2);
}
public TEAbs(
string typeVarName,
IKind kind,
ITypeExpr typeExpr
)
{
mTypeVarName = typeVarName;
mKind = kind;
mTypeExpr = typeExpr;
}
private IKind CheckFuncKindApp(
IKind parameterKind,
IKind returnKind,
IKind argumentKind
)
{
if (!argumentKind.Equals(parameterKind))
{
throw new ArgumentException(
string.Format(
"unexpected {0}, expected {1}",
argumentKind.Show(),
parameterKind.Show()
)
);
}
return returnKind;
}
private IKind CheckApp(IKind kind1, IKind kind2)
{
/*
(KArrow kind3 kind4) = kind1;
return CheckFuncKindApp(kind3, kind4, kind2);
*/
if (kind1 is KArrow)
{
IKind kind3 = ((KArrow)kind1).Left;
IKind kind4 = ((KArrow)kind1).Right;
return CheckFuncKindApp(kind3, kind4, kind2);
}
throw new InvalidOperationException(
string.Format(
"{0} doesn't have a function kind", mTypeExpr1.Show()
)
);
}
public IType CheckPolymorphicTypeApp(
IKind parameterKind,
IKind argumentKind,
Unique parameter,
IType body,
IType argument
)
{
if (!argumentKind.Equals(parameterKind))
{
throw new ArgumentException(
string.Format(
"unexpected {0}, expected {1}",
argumentKind.Show(),
parameterKind.Show()
)
);
}
return body.Eval(parameter, argument);
}
public bool EqK <T>(IKind <OptionF, T> x, IKind <OptionF, T> y, IEq <T> eq) => OptionK.Eq(eq).Eqv(x.Fix(), y.Fix());
public static Try <T> Fix <T>(this IKind <TryF, T> self) => (Try <T>)self;
public TEPoly(IKind kind)
{
mKind = kind;
}
public IKind <ResultOkF <TError>, TB> FlatMap <TA, TB>(
IKind <ResultOkF <TError>, TA> fa, Func <TA, IKind <ResultOkF <TError>, TB> > f) =>
fa.Fix().FlatMap(x => f(x).Fix());
public IKind <ResultOkF <TError>, TB> Ap <TA, TB>(IKind <ResultOkF <TError>, Func <TA, TB> > ff,
IKind <ResultOkF <TError>, TA> fa) =>
ff.Fix().FlatMap(fa.Fix().Map);
public IKind <OptionF, TB> Map <TA, TB>(IKind <OptionF, TA> fa, Func <TA, TB> f) => fa.Fix().Map(f);
public static Result <TOk, TError> Fix <TOk, TError>(this IKind <ResultOkF <TError>, TOk> self) => (Result <TOk, TError>)self;
public IKind <ResultOkF <TError>, TB> Map <TA, TB>(IKind <ResultOkF <TError>, TA> fa, Func <TA, TB> f) => fa.Fix().Map(f);
public void Add(string valueVarName, IKind kind)
{
mDictionary.Add(valueVarName, kind);
}
public bool Equals(IKind kind)
{
return this == kind;
}
public TypeVariableIntro(string name, IKind kind)
{
this.Name = name;
this.Kind = kind;
}
public static List <T> Fix <T>(this IKind <ListF, T> self) => ((ListK <T>)self).List;
public static Option <T> Fix <T>(this IKind <OptionF, T> self) => (Option <T>)self;
public static IType MakePolymorphicType(
Unique unique, IKind kind, IType type
)
{
return new TApp(new TCPoly(kind), new TAbs(unique, type));
}
public IKind <OptionF, TB> XMap <TA, TB>(IKind <OptionF, TA> fa, Func <TA, TB> f, Func <TB, TA> g) => fa.Fix().Map(f);
public bool TryGetValue(string valueVarName, out IKind result)
{
return mDictionary.TryGetValue(valueVarName, out result)
|| mParent.TryGetValue(valueVarName, out result);
}
public IKind <TreeF, TB> Map <TA, TB>(IKind <TreeF, TA> fa, Func <TA, TB> f) =>
fa.Fix() switch
{
public ArrowKind(IKind left, IKind right)
{
this.Func = left;
this.Arg = right;
}
public IKind <OptionF, TB> FlatMap <TA, TB>(IKind <OptionF, TA> fa, Func <TA, IKind <OptionF, TB> > f) => fa.Fix().FlatMap(x => f(x).Fix());
public KArrow(IKind kind1, IKind kind2)
{
mKind1 = kind1;
mKind2 = kind2;
}
private TypeInference AddIntro(string name, IKind kind) => new TypeInference(this._state.Push(new TypeVariableIntro(name, kind)));
public IKind <TryF, TB> Ap <TA, TB>(IKind <TryF, Func <TA, TB> > ff, IKind <TryF, TA> fa) => ff.Fix().FlatMap(fa.Fix().Map);
