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)); }