public GenericImplementationType(IFrontendType input, IFrontendType output, IFrontendType context)
{
this.input = input ?? throw new ArgumentNullException(nameof(input));
this.output = output ?? throw new ArgumentNullException(nameof(output));
this.context = context ?? throw new ArgumentNullException(nameof(context));
TypeParameterDefinitions = new[] { input, output, context }.OfType <IGenericTypeParameterPlacholder>().Select(x => Possibly.Is(x)).ToArray();
}
public static IVerifiableType ConvertTypeOrThrow(this IFrontendType self, IConversionContext context)
{
if (self is IConvertableFrontendType <IVerifiableType> convertable)
{
return(convertable.Convert(context));
}
throw new Exception("could not be converted");
}
public IFrontendType Convert(IFrontendType type)
{
if (type.Is <IWeakTypeDefinition>(out var typeDef))
{
return(new OverlayTypeDefinition(typeDef, this));
}
if (type is IGenericTypeParameterPlacholder generic && map.TryGetValue(generic, out var value))
{
return(value);
}
return(type);
}
public void PrimitivesAreThemselves()
{
var left = new IFrontendType <IVerifiableType>[] { new NumberType(), new StringType(), new BooleanType() };
var right = new IFrontendType <IVerifiableType>[] { new NumberType(), new StringType(), new BooleanType() };
for (int i = 0; i < left.Length; i++)
{
for (int j = 0; j < right.Length; j++)
{
if (i == j)
{
Assert.True(left[i].TheyAreUs(left[j], new List <(IFrontendType <IVerifiableType>, IFrontendType <IVerifiableType>)>()).Is1OrThrow());
}
else
{
Assert.False(left[i].TheyAreUs(left[j], new List <(IFrontendType <IVerifiableType>, IFrontendType <IVerifiableType>)>()).Is1OrThrow());
}
}
}
}
//public IIsPossibly<IFrontendType<IVerifiableType>> Returns()
//{
// return Possibly.Is(TypeDefinition.GetValue());
//}
public IOrType <bool, IError> TheyAreUs(IFrontendType <IVerifiableType> they, List <(IFrontendType <IVerifiableType>, IFrontendType <IVerifiableType>)> assumeTrue)
public static IEnumerable <IError> TypeCheck(this IOrType <IBox <IFrontendCodeElement>, IError> self, IFrontendType <IVerifiableType> targetType)
{
return(ReturnsTypeOrErrors(self).SwitchReturns <IEnumerable <IError> >(
x =>
{
if (!x.TheyAreUs(targetType, new List <(IFrontendType <IVerifiableType>, IFrontendType <IVerifiableType>)>()).SwitchReturns(x => x, x => false))
{
return new[] { Error.Other($"left cannot be {x}") };
}
return System.Array.Empty <IError>();
},
x => new[] { x }));
}
// Is1OrThrow is sloppy here
// probably this interface should entertain the possiblity that a type doesn't know it's members because the code is jibberish
//public IReadOnlyList<WeakMemberDefinition> GetMembers() => members.Is1OrThrow();
private static IIsPossibly <(IOrType <IFrontendType <IVerifiableType>, IError> fromLeft, IOrType <IFrontendType <IVerifiableType>, IError> fromRight)> IsOrType(IFrontendType <IVerifiableType> them)
{
if (them.SafeIs(out FrontEndOrType orType))
{
return(Possibly.Is <(IOrType <IFrontendType <IVerifiableType>, IError> fromLeft, IOrType <IFrontendType <IVerifiableType>, IError> fromRight)>((orType.left.GetValue(), orType.right.GetValue())));
}
return(Possibly.IsNot <(IOrType <IFrontendType <IVerifiableType>, IError> fromLeft, IOrType <IFrontendType <IVerifiableType>, IError> fromRight)>());
}
public static IOrType <IFrontendType <IVerifiableType>, IError> UnwrapRefrence(this IFrontendType <IVerifiableType> frontendType)
{
if (frontendType is RefType refType)
{
return(refType.inner);
}
return(OrType.Make <IFrontendType <IVerifiableType>, IError>(frontendType));
}
public TypeParameter(IGenericTypeParameterPlacholder parameterDefinition, IFrontendType frontendType)
{
this.parameterDefinition = parameterDefinition;
this.frontendType = frontendType ?? throw new ArgumentNullException(nameof(frontendType));
}