// do these really need to be IBox? they seeme to generally be filled...
// mayble IPossibly...
public IBox <WeakObjectDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var finalElements = nextElements.Select(x => x.SwitchReturns <IOrType <IBox <WeakAssignOperation>, IError> >(
y => {
var res = y.Run(context, stack.Add(myScope)).GetValue();
if (res is WeakAssignOperation weakAssign)
{
return(OrType.Make <IBox <WeakAssignOperation>, IError>(new Box <WeakAssignOperation>(weakAssign)));
}
else
{
return(OrType.Make <IBox <WeakAssignOperation>, IError>(Error.Other("lines in an object must me assignments")));
}
},
y => OrType.Make <IBox <WeakAssignOperation>, IError>(y))).ToArray();
box.Fill(finalElements);
var objectOr = myScope.Converter.Convert(context, myScope, stack);//; context.GetObject(myScope);
if (objectOr.Is1(out var v1))
{
return(new Box <WeakObjectDefinition>(v1));
}
throw new Exception("wrong or");
}
public IBox <WeakImplementationDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
linesBox.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(outer).Add(inner)))).ToArray());
var res = outer.Converter.Convert(context, outer, stack);
if (res.Is2(out var v2))
{
return(new Box <WeakImplementationDefinition>(v2));
}
throw new Exception("wrong!");
}
public IBox <WeakMethodDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
box.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(method)))).ToArray());
var res = method.Converter.Convert(context, method, stack);
if (res.Is1(out var v1))
{
return(new Box <WeakMethodDefinition>(v1));
}
throw new Exception("wrong!");
}
public IBox <WeakEntryPointDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var finalForm = converted.Select(x => x.TransformInner(y => y.Run(context, stack.Add(scope)))).ToArray();
box.Fill(finalForm);
var res = scope.Converter.Convert(context, scope, stack);
if (res.Is3(out var v3))
{
return(new Box <WeakEntryPointDefinition>(v3));
}
throw new Exception("wrong!");
}
public ISetUpResult <IBox <WeakImplementationDefinition>, Tpn.IValue> Run(Tpn.IStaticScope scope, ISetUpContext context)
{
scope = scope.EnterInitizaionScopeIfNessisary();
if (!(scope is Tpn.IScope runtimeScope))
{
throw new NotImplementedException("this should be an IError");
}
// TODO this is so painful, I think I need to look in to implementations having special treatment...
// maybe they need to be a generic on the tpn
// altho to the tpn they really are not special
// but here they might maybe convert to an implementation not a method that returns a method
// idk! 🤷😭
IIsPossibly <(IOrType <TypeProblem2.TypeReference, IError>, IOrType <TypeProblem2.TypeReference, IError>, IOrType <TypeProblem2.TypeReference, IError>)> pair =
Possibly.IsNot <(IOrType <TypeProblem2.TypeReference, IError>, IOrType <TypeProblem2.TypeReference, IError>, IOrType <TypeProblem2.TypeReference, IError>)>();
var innerBox = new Box <Tpn.TypeProblem2.Method>();
Tpn.TypeProblem2.Method?myInner = null;
var linesBox = new Box <IReadOnlyList <IOrType <IBox <IFrontendCodeElement>, IError> > >();
IOrType <IKey, IError>?realizedInputKey = null;
IOrType <IKey, IError>?realizedOutputKey = null;
IOrType <IResolve <IBox <IFrontendCodeElement> >, IError>[]? nextElements = null;
var(outer, realizeContext, _) = context.TypeProblem.CreateMethod(
scope,
x => parameterDefinition.Run(x, context.CreateChildContext(this)).SetUpSideNode,
x => {
var(inner, realizedInput, realizedOutput) = context.TypeProblem.CreateMethod(
x,
y => parameterDefinition.Run(y, context.CreateChildContext(this)).SetUpSideNode,
y => output.Run(y, context.CreateChildContext(this)).SetUpSideNode,
parameterName,
new WeakMethodDefinitionConverter(
linesBox));
myInner = inner;
innerBox.Fill(inner);
nextElements = elements.Select(z => z.TransformInner(w => w.Run(inner, context.CreateChildContext(this)).Resolve)).ToArray();
realizedInputKey = realizedInput.TransformInner(y => y.Key());
realizedOutputKey = realizedOutput.TransformInner(y => y.Key());
var outputTypeRef = context.TypeProblem.CreateTypeReference(scope, new GenericNameKey(new NameKey("method"), new[] {
realizedInputKey,
realizedOutputKey,
}), new WeakTypeReferenceConverter());
return(OrType.Make <TypeProblem2.TypeReference, IError>(outputTypeRef));
},
contextName,
new WeakImplementationDefinitionConverter(
new Box <IReadOnlyList <IOrType <IBox <IFrontendCodeElement>, IError> > >(Array.Empty <IOrType <IBox <IFrontendCodeElement>, IError> >()),
innerBox));
if (realizedInputKey == null)
{
throw new NullReferenceException(nameof(realizedInputKey));
}
if (realizedOutputKey == null)
{
throw new NullReferenceException(nameof(realizedOutputKey));
}
if (nextElements == null)
{
throw new NullReferenceException(nameof(nextElements));
}
if (myInner == null)
{
throw new NullReferenceException(nameof(myInner));
}
var innerValue = context.TypeProblem.CreateValue(outer,
new GenericNameKey(new NameKey("method"), new[] {
realizedInputKey,
realizedOutputKey,
}));
innerValue.AssignTo(outer.Returns());
var value = context.TypeProblem.CreateValue(runtimeScope, new GenericNameKey(new NameKey("method"), new[] {
realizeContext.TransformInner(x => x.Key()),
OrType.Make <IKey, IError>(new GenericNameKey(new NameKey("method"), new[] {
realizedInputKey,
realizedOutputKey,
})),
}));
return(new SetUpResult <IBox <WeakImplementationDefinition>, Tpn.IValue>(new ImplementationDefinitionResolveReferance(
outer, myInner, nextElements, linesBox), OrType.Make <Tpn.IValue, IError>(value)));
}
public IBox <WeakBlockDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
box.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray());
return(new Box <WeakBlockDefinition>(myScope.Converter.Convert(context, myScope, stack).Is1OrThrow()));
}
