/// <summary> /// If str represents a function name (no quotes, letters only), make a FuncArg. Otherwise, return null. /// In a declaration, function names can have a type, such as int n. /// </summary> /// <param name="str"></param> /// <returns></returns> public static FunctionArg TryParseArg(string str) { string functionName; FluencyType declType = FluencyType.Any; string[] halves = str.Split(_spliton, 2, StringSplitOptions.RemoveEmptyEntries); if (halves.Length == 1) { functionName = halves[0]; } else { functionName = halves[1]; declType = PickType(halves[0]); } if (functionName.All(c => char.IsLetter(c)) || functionName == "...") { return(new FunctionArg(functionName) { DeclaredType = declType }); } return(null); }
public void CanParseFunctionsWithTypenames(string toparse, FluencyType expectedType, string expectedName) { if (Argument.TryParse(toparse, out var argument)) { Assert.IsInstanceOfType(argument, typeof(FunctionArg)); Assert.AreEqual(FluencyType.Function, argument.Type); Assert.AreEqual(expectedName, argument.GetAs <string>()); FunctionArg arg = (FunctionArg)argument; Assert.AreEqual(expectedType, arg.DeclaredType); } else { Assert.Fail("Could not parse {0}.", toparse); } }
public WrapBinaryFold(Func <TReal, TReal, TReal> function, FluencyType returnType, string name, Value[] arguments, Value shortCircuitOn = null) { this.function = function; this.type = returnType; this.shortCircuitOn = shortCircuitOn; Name = name; if (arguments.Length == 1) { stored = arguments[0]; if (returnType != FluencyType.Any && stored.Type != returnType) { throw new ExecutionException("Function {0} takes a {1}. You supplied a {2}: {3}", name, returnType, stored.Type, stored.ToString()); } } else if (arguments.Length > 1) { throw new ExecutionException("Function {0} takes either zero or one parameters. You supplied {1}: {2}", name, arguments.Length, string.Join(", ", arguments.Select(x => x.ToString()))); } }
public WrapBinaryStreamOutput(Func <TRealTop, TRealBottom, IEnumerable <TRealOut> > function, FluencyType returnType, FluencyType inputType, string name, Value[] arguments) { this.function = function; this.returnType = returnType; Name = name; if (arguments.Length == 1) { stored = arguments[0]; if (inputType != FluencyType.Any && stored.Type != inputType) { throw new ExecutionException("Function {0} takes a {1}. You supplied a {2}: {3}", name, inputType, stored.Type, stored.ToString()); } } else if (arguments.Length > 1) { throw new ExecutionException("Function {0} takes either zero or one parameters. You supplied {1}: {2}", name, arguments.Length, string.Join(", ", arguments.Select(x => x.ToString()))); } }
private bool ValidateArgs(Value[] arguments, FluencyType argType, string name) { if (arguments.Length == 1) { if (argType != FluencyType.Any && arguments[0].Type != argType) { throw new ExecutionException("Function {0} takes a {1}. You supplied a {2}: {3}", name, argType, stored.Type, stored.ToString()); } else { return(true); } } else if (arguments.Length > 1) { throw new ExecutionException("Function {0} takes either zero or one top parameters. You supplied {1}: {2}", name, arguments.Length, string.Join(", ", arguments.Select(x => x.ToString()))); } // if no arguments, don't store this one return(false); }
public WrapBinary(Func <TRealTop, TRealBottom, TRealOut> function, FluencyType argType, FluencyType returnType, string name, Value[] topArguments, Value[] bottomArguments = null) { this.function = function; this.type = returnType; Name = name; bottomArguments = bottomArguments ?? new Value[0]; if (topArguments.Length > 0 && bottomArguments.Length > 0) { throw new ExecutionException("You must pass either one top argument, one bottom argument, or neither to {0}, not both.", Name); } if (ValidateArgs(topArguments, argType, name)) { stored = topArguments[0]; topStored = true; } if (ValidateArgs(bottomArguments, argType, name)) { stored = bottomArguments[0]; topStored = false; } }
public WrapUnary(Func <TRealIn, TRealOut> function, FluencyType returnType, string name) { this.function = function; this.type = returnType; Name = name; }
/// <summary> /// Construct a value from a C# value and a type. /// </summary> /// <param name="value"></param> /// <param name="type"></param> public Value(object value, FluencyType type) { _value = value; Type = type; Done = false; }
/// <summary> /// Construct a value from a parsed function argument. /// </summary> /// <param name="arg"></param> public Value(Argument arg) { Type = arg.Type; _value = arg.GetAs <object>(); Done = false; }