public void With_equal_referent_are_equal()
{
var type1 = new OptionalType(new ObjectType(Namespace("foo", "bar"), "Baz", true, ReferenceCapability.Borrowed));
var type2 = new OptionalType(new ObjectType(Namespace("foo", "bar"), "Baz", true, ReferenceCapability.Borrowed));
Assert.Equal(type1, type2);
}
/// <summary>
/// To none
/// </summary>
/// <param name="value"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IOptional <T> None <T>(this T value,
OptionalType type = OptionalType.ReferenceType)
{
return(type == OptionalType.ReferenceType
? Optional.Wrapped.None <T>()
: Optional.None <T>() as IOptional <T>);
}
/// <summary>
/// To none
/// </summary>
/// <param name="value"></param>
/// <param name="exception"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
public static IOptional <T, TException> None <T, TException>(this T value, TException exception,
OptionalType type = OptionalType.ReferenceType)
{
return(type == OptionalType.ReferenceType
? Optional.Wrapped.None <T, TException>(exception)
: Optional.None <T, TException>(exception) as IOptional <T, TException>);
}
public OptionalFactor(OptionalType type, string postiveanswer, string negativeanswer)
{
TypeOfFactor = FactorTypes.Optional;
TypeOfOptional = type;
Positive = postiveanswer;
Negative = negativeanswer;
}
/// <summary>
/// To some
/// </summary>
/// <param name="value"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
public static IOptional <T, TException> Some <T, TException>(this T value,
OptionalType type = OptionalType.ReferenceType)
{
return(type == OptionalType.ReferenceType
? Optional.Wrapped.Some <T, TException>(value)
: Optional.Some <T, TException>(value) as IOptional <T, TException>);
}
public void No_underlying_reference_type_for_optional_value_type()
{
var optionalType = new OptionalType(DataType.Bool);
var underlyingType = optionalType.UnderlyingReferenceType();
Assert.Null(underlyingType);
}
public ImplicitNoneConversionExpression(
IExpressionSyntax expression,
OptionalType convertToType)
// We can always copy the `none` literal
: base(expression.Span, convertToType, expression, ExpressionSemantics.Copy)
{
ConvertToType = convertToType;
}
/// <summary>
/// To none
/// </summary>
/// <param name="value"></param>
/// <param name="predicate"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IOptional <T> None <T>(this T value, Func <T, bool> predicate,
OptionalType type = OptionalType.ReferenceType)
{
if (predicate is null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(value.Some(val => !predicate(val), type));
}
/// <summary>
/// To some not null
/// </summary>
/// <param name="value"></param>
/// <param name="exceptionFactory"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IOptional <T, TException> SomeNotNull <T, TException>(this T value, Func <T, TException> exceptionFactory,
OptionalType type = OptionalType.ReferenceType)
{
if (exceptionFactory is null)
{
throw new ArgumentNullException(nameof(exceptionFactory));
}
return(value.Some(val => val != null, exceptionFactory, type));
}
/// <summary>
/// To some
/// </summary>
/// <param name="value"></param>
/// <param name="predicate"></param>
/// <param name="exception"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IOptional <T, TException> Some <T, TException>(this T value, Func <T, bool> predicate, TException exception,
OptionalType type = OptionalType.ReferenceType)
{
if (predicate is null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(predicate(value) ? value.Some <T, TException>(type) : value.None(exception, type));
}
public void Underlying_reference_type_of_optional_reference_type_is_reference_type()
{
var referenceType = new ObjectType("Foo", "Bar", true, ReferenceCapability.Borrowed);
var optionalType = new OptionalType(referenceType);
var underlyingType = optionalType.UnderlyingReferenceType();
Assert.Same(referenceType, underlyingType);
}
public ImplicitNoneConversionExpression(
TextSpan span,
DataType dataType,
ExpressionSemantics semantics,
IExpression expression,
OptionalType convertToType)
: base(span, dataType, semantics, expression)
{
ConvertToType = convertToType;
}
/// <summary>
/// To optional
/// </summary>
/// <param name="value"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IOptional <T> ToOptional <T>(this T?value,
OptionalType type = OptionalType.ReferenceType) where T : struct
{
return(value.HasValue
? type == OptionalType.ReferenceType
? Optional.Wrapped.Some(value.Value)
: Optional.Some(value.Value) as IOptional <T>
: type == OptionalType.ReferenceType
? Optional.Wrapped.None <T>()
: Optional.None <T>() as IOptional <T>);
}
/// <summary>
/// To optional
/// </summary>
/// <param name="value"></param>
/// <param name="exception"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
public static IOptional <T, TException> ToOptional <T, TException>(this T?value, TException exception,
OptionalType type = OptionalType.ReferenceType) where T : struct
{
return(value.HasValue
? type == OptionalType.ReferenceType
? Optional.Wrapped.Some <T, TException>(value.Value)
: Optional.Some <T, TException>(value.Value) as IOptional <T, TException>
: type == OptionalType.ReferenceType
? Optional.Wrapped.None <T, TException>(exception)
: Optional.None <T, TException>(exception) as IOptional <T, TException>);
}
/// <summary>
/// To optional
/// </summary>
/// <param name="value"></param>
/// <param name="exceptionFactory"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IOptional <T, TException> ToOptional <T, TException>(this T?value, Func <TException> exceptionFactory,
OptionalType type = OptionalType.ReferenceType) where T : struct
{
if (exceptionFactory is null)
{
throw new ArgumentNullException(nameof(exceptionFactory));
}
return(value.HasValue
? type == OptionalType.ReferenceType
? Optional.Wrapped.Some <T, TException>(value.Value)
: Optional.Some <T, TException>(value.Value) as IOptional <T, TException>
: type == OptionalType.ReferenceType
? Optional.Wrapped.None <T, TException>(exceptionFactory())
: Optional.None <T, TException>(exceptionFactory()) as IOptional <T, TException>);
}
public GameObject(GameObject OtherObject)
{
TemplateIndex = OtherObject.TemplateIndex;
X = OtherObject.X;
Y = OtherObject.Y;
Color = OtherObject.Color;
Speed = OtherObject.Speed;
MoveBorderLeft = OtherObject.MoveBorderLeft;
MoveBorderRight = OtherObject.MoveBorderRight;
MoveBorderBottom = OtherObject.MoveBorderBottom;
MoveBorderTop = OtherObject.MoveBorderTop;
OptionalValue = OtherObject.OptionalValue;
Optional = OtherObject.Optional;
SpriteImage = new GR.Image.MemoryImage(OtherObject.SpriteImage);
}
public void RenderForFilterPlan(StringBuilder stringBuilder)
{
stringBuilder.Append("substitution parameter");
if (OptionalName != null) {
stringBuilder
.Append(" name '")
.Append(OptionalName)
.Append("'");
}
if (OptionalType != null) {
stringBuilder
.Append(" type '")
.Append(OptionalType.ToEPL())
.Append("'");
}
}
public ShenzhenTypes(ModuleDefinition module)
{
Module = module;
BuiltIn = module.TypeSystem;
GameLogic = new GameLogicType(module);
Globals = new GlobalsType(module);
Index2 = new Index2Type(module);
L = new LType(module);
MessageThread = new MessageThreadType(module);
MessageThreads = new MessageThreadsType(module);
Optional = new OptionalType(module);
Puzzle = new PuzzleType(module);
Puzzles = new PuzzlesType(module);
Terminal = new TerminalType(module);
TextureManager = new TextureManagerType(module);
Traces = new TracesType(module);
Solution = new SolutionType(module, Traces);
}
public LoadNoneInstruction(Place resultPlace, OptionalType type, TextSpan span, Scope scope)
: base(resultPlace, span, scope)
{
Type = type;
}
public void Optional_unknown_type_has_copy_semantics()
{
var optionalNever = new OptionalType(DataType.Unknown);
Assert.Equal(TypeSemantics.Copy, optionalNever.Semantics);
}
/// <summary>
/// To some not null
/// </summary>
/// <param name="value"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IOptional <T> SomeNotNull <T>(this T value,
OptionalType type = OptionalType.ReferenceType)
{
return(value.Some(val => val != null, type));
}
public void Optional_copy_type_has_copy_semantics()
{
var optionalBool = new OptionalType(DataType.Bool);
Assert.Equal(TypeSemantics.Copy, optionalBool.Semantics);
}
public void Optional_reference_has_reference_semantics()
{
var optionalAny = new OptionalType(new AnyType(ReferenceCapability.Isolated));
Assert.Equal(TypeSemantics.Reference, optionalAny.Semantics);
}
/// <summary>
/// To some not null
/// </summary>
/// <param name="value"></param>
/// <param name="exception"></param>
/// <param name="type"></param>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TException"></typeparam>
/// <returns></returns>
public static IOptional <T, TException> SomeNotNull <T, TException>(this T value, TException exception,
OptionalType type = OptionalType.ReferenceType)
{
return(value.Some(val => val != null, exception, type));
}
public SomeInstruction(Place resultPlace, OptionalType type, Operand operand, TextSpan span, Scope scope)
: base(resultPlace, span, scope)
{
Type = type;
Operand = operand;
}
/// <summary>
/// Returns the value associated with the specified key if such exists.
/// A dictionary lookup will be used if available, otherwise falling
/// back to a linear scan of the enumerable.
/// </summary>
/// <param name="source"></param>
/// <param name="key"></param>
/// <param name="type"></param>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IOptional <T> FindOrNone <TKey, T>(this IEnumerable <KeyValuePair <TKey, T> > source, TKey key, OptionalType type = OptionalType.ReferenceType)
{
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
if (source is IDictionary <TKey, T> dictionary)
{
return(dictionary.TryGetValue(key, out var value) ? value.Some(type) : value.None(type));
}
if (source is IReadOnlyDictionary <TKey, T> readOnlyDictionary)
{
return(readOnlyDictionary.TryGetValue(key, out var value) ? value.Some(type) : value.None(type));
}
return(source
.FirstOrNone(pair => EqualityComparer <TKey> .Default.Equals(pair.Key, key))
.Map(pair => pair.Value));
}
