public void Test()
{
var testCase = new MirrorPointImplementation();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, res) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var implementation = scope.GetMember(new NameKey("mirror")).Value.Has <IInterpetedMethod>();
var context = TypeManager.InstanceScope(
(new NameKey("x"), TypeManager.AnyMember(TypeManager.Double(5))),
(new NameKey("y"), TypeManager.AnyMember(TypeManager.Double(7))));
{
Assert.False(implementation.Invoke(TypeManager.Member(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method !.Value.Has <IInterpetedMethod>().Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(7, context.GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.Equal(5, context.GetMember(new NameKey("y")).Value.Has <IBoxedDouble>().Value);
{
Assert.False(implementation.Invoke(TypeManager.Member(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method !.Value.Has <IInterpetedMethod>().Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(5, context.GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.Equal(7, context.GetMember(new NameKey("y")).Value.Has <IBoxedDouble>().Value);
}
public void Test()
{
var testCase = new MirrorPointImplementation();
var conversionContext = new Definitions();
var module = testCase.Module.Convert(conversionContext);
var res = module.Interpet(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var scope = value.Value.Cast <IInterpetedScope>();
var implementation = scope.GetMember <IInterpetedAnyType>(new NameKey("mirror")).Value.Cast <IInterpetedImplementation <IInterpetedScope, IInterpedEmpty, IInterpedEmpty> >();
var context = TypeManager.InstanceScope(
(new NameKey("x"), TypeManager.AnyMember(TypeManager.Double(5))),
(new NameKey("y"), TypeManager.AnyMember(TypeManager.Double(7))));
{
Assert.False(implementation.Invoke(TypeManager.Member <IInterpetedScope>(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method.Value.Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(7, context.GetMember <IInterpetedAnyType>(new NameKey("x")).Value.Cast <IBoxedDouble>().Value);
Assert.Equal(5, context.GetMember <IInterpetedAnyType>(new NameKey("y")).Value.Cast <IBoxedDouble>().Value);
{
Assert.False(implementation.Invoke(TypeManager.Member <IInterpetedScope>(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method.Value.Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(5, context.GetMember <IInterpetedAnyType>(new NameKey("x")).Value.Cast <IBoxedDouble>().Value);
Assert.Equal(7, context.GetMember <IInterpetedAnyType>(new NameKey("y")).Value.Cast <IBoxedDouble>().Value);
}
public void Test()
{
var testCase = new OrTypeSample();
var conversionContext = new Definitions();
Assert.False(testCase.Module.Convert(conversionContext).Interpet(InterpetedContext.Root()).IsReturn(out var _, out var res));
Assert.Equal(5, res.Value.Cast <IInterpetedScope>().GetMember <IInterpetedAnyType>(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.False(res.Value.Cast <IInterpetedScope>().GetMember <IInterpetedAnyType>(new NameKey("y")).Value.Has <IBoxedBool>().Value);
}
public void Test()
{
var testCase = new Arithmetic();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, _) = module.InterpetWithExposedScope(InterpetedContext.Root());
var x = scope.GetMember(new NameKey("x"));
Assert.Equal(63.0, x.Value.CastTo <IBoxedDouble>().Value);
}
public void Test()
{
var testCase = new PointObject();
var conversionContext = new Definitions();
Assert.False(testCase.Module.Convert(conversionContext).Interpet(InterpetedContext.Root()).IsReturn(out var _, out var res));
var scope = res.Value.Cast <IInterpetedScope>().GetMember <IInterpetedAnyType>(new NameKey("point")).Value;
Assert.True(scope.Cast <IInterpetedScope>().ContainsMember(new NameKey("x")));
Assert.True(scope.Cast <IInterpetedScope>().ContainsMember(new NameKey("y")));
}
public void Test()
{
var testCase = new OrTypeSample();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, value) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(value.IsReturn(out var _, out var res));
Assert.Equal(5, scope.GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.False(scope.GetMember(new NameKey("y")).Value.Has <IBoxedBool>().Value);
}
public void Test()
{
var testCase = new Arithmetic();
var conversionContext = new Definitions();
var module = testCase.Module.Convert(conversionContext);
var res = module.Interpet(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var member));
var scope = member.Value.Cast <IInterpetedScope>();
var x = scope.GetMember <IInterpetedAnyType>(new NameKey("x"));
Assert.Equal(63.0, x.Value.Cast <IBoxedDouble>().Value);
}
public void Test()
{
var testCase = new PointObject();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, value) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(value.IsReturn(out var _, out var res));
var pointScope = scope.GetMember(new NameKey("point")).Value;
Assert.True(pointScope.CastTo <IInterpetedScope>().ContainsMember(new NameKey("x")));
Assert.True(pointScope.CastTo <IInterpetedScope>().ContainsMember(new NameKey("y")));
}
public static void Run(IProject <IAssembly <InterpetedAssemblyBacking>, InterpetedAssemblyBacking> moduleDefinition)
{
var conversionContext = new Definitions();
var interpetedContext = InterpetedContext.Root();
foreach (var reference in moduleDefinition.References)
{
interpetedContext.TryAddMember(reference.Key, reference.Backing.CreateMember(interpetedContext));
}
if (conversionContext.RootScope(moduleDefinition.RootScope).Interpet(interpetedContext).IsReturn(out var _, out var _))
{
throw new Exception("this should not really return");
}
}
private double Fac(double d)
{
var testCase = new Factorial();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, res) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
// no way this cast works...
var method = scope.GetMember(new NameKey("fac"));
Assert.False(method.Value.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(d))).IsReturn(out var _, out var methodReturn));
return(methodReturn !.Value.CastTo <IBoxedDouble>().Value);
}
private double Fac(double d)
{
var testCase = new Factorial();
var conversionContext = new Definitions();
var module = testCase.Module.Convert(conversionContext);
var res = module.Interpet(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var scope = value.Value.Cast <IInterpetedScope>();
// no way this cast works...
var method = scope.GetMember <IInterpetedMethod <IBoxedDouble, IBoxedDouble> >(new NameKey("fac"));
Assert.False(method.Value.Invoke(TypeManager.NumberMember(TypeManager.Double(d))).IsReturn(out var _, out var methodReturn));
return(methodReturn.Value.Cast <IBoxedDouble>().Value);
}
private void Pairify(double d)
{
var testCase = new PairType();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, res) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var method = scope.GetMember(new NameKey("pairify"));
Assert.False(method.Value.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(d))).IsReturn(out var _, out var methodResult));
Assert.Equal(d, methodResult !.Value.Has <IInterpetedScope>().GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.Equal(d, methodResult !.Value.Has <IInterpetedScope>().GetMember(new NameKey("y")).Value.Has <IBoxedDouble>().Value);
}
public static void Run(IProject <InterpetedAssemblyBacking> moduleDefinition)
{
var conversionContext = new Definitions();
var interpetedContext = InterpetedContext.Root();
foreach (var reference in moduleDefinition.References)
{
interpetedContext.TryAddMember(reference.Key, reference.Backing.CreateMember(interpetedContext));
}
if (conversionContext.ModuleDefinition(moduleDefinition.ModuleDefinition).Interpet(interpetedContext).IsReturn(out var _, out var _))
{
throw new Exception("this should not really return");
}
if (conversionContext.EntryPoint.Interpet(interpetedContext).IsReturn(out var _, out var value))
{
throw new Exception("this should not really return");
}
value.Value.Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
public void Test()
{
var testCase = new Closoure();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, res) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var method = scope.GetMember(new NameKey("create-accululator")).Value;
Assert.False(method.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(1))).IsReturn(out var _, out var innerMethod));
Assert.False(innerMethod !.Value.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(2))).IsReturn(out var _, out var res1));
Assert.Equal(3, res1 !.Value.Has <IBoxedDouble>().Value);
Assert.False(innerMethod.Value.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(3))).IsReturn(out var _, out var res2));
Assert.Equal(6, res2 !.Value.Has <IBoxedDouble>().Value);
Assert.False(innerMethod.Value.Has <IInterpetedMethod>().Invoke(TypeManager.NumberMember(TypeManager.Double(4))).IsReturn(out var _, out var res3));
Assert.Equal(10, res3 !.Value.Has <IBoxedDouble>().Value);
}
public void Test()
{
var testCase = new Closoure();
var conversionContext = new Definitions();
var module = testCase.Module.Convert(conversionContext);
var res = module.Interpet(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var scope = value.Value.Cast <IInterpetedScope>();
var method = scope.GetMember <IInterpetedAnyType>(new NameKey("create-accululator")).Value.Cast <IInterpetedMethod <IBoxedDouble, IInterpetedMethod <IBoxedDouble, IBoxedDouble> > >();
Assert.False(method.Invoke(TypeManager.NumberMember(TypeManager.Double(1))).IsReturn(out var _, out var innerMethod));
Assert.False(innerMethod.Value.Invoke(TypeManager.NumberMember(TypeManager.Double(2))).IsReturn(out var _, out var res1));
Assert.Equal(3, res1.Value.Value);
Assert.False(innerMethod.Value.Invoke(TypeManager.NumberMember(TypeManager.Double(3))).IsReturn(out var _, out var res2));
Assert.Equal(6, res2.Value.Value);
Assert.False(innerMethod.Value.Invoke(TypeManager.NumberMember(TypeManager.Double(4))).IsReturn(out var _, out var res3));
Assert.Equal(10, res3.Value.Value);
}
public IInterpetedResult <IInterpetedMember <IInterpedEmpty> > Interpet(InterpetedContext interpetedContext)
{
return(InterpetedResult.Create(TypeManager.EmptyMember(TypeManager.Empty())));
}
public IInterpetedResult <IInterpetedMember <IInterpetedMethod <TIn, TOut> > > Interpet(InterpetedContext interpetedContext)
{
var thing = TypeManager.ExternalMethod(Backing, MethodType);
return(InterpetedResult.Create(TypeManager.Member(thing.Convert(TransformerExtensions.NewConversionContext()), thing)));
}
