//Symbol referenced by this function. protected override Expression GetBody( Dictionary <INode, string> symbols, Dictionary <INode, List <INode> > letEntries, HashSet <string> initializedIds, HashSet <string> conditionalIds) { return(Expression.NewId(Symbol)); }
//Function used to construct our expression. This is used to properly create a curried function call, which will be //able to support partial function application. protected Expression ToExpression( Expression function, IEnumerable <string> parameters, int expectedArgs, Dictionary <INode, string> symbols, Dictionary <INode, List <INode> > letEntries, HashSet <string> initializedIds, HashSet <string> conditionalIds) { //If no arguments have been supplied and if we are expecting arguments, simply return the function. if (arguments.Keys.Count == 0 && expectedArgs > 0) { return(function); } //If the number of expected arguments is greater than how many arguments have been supplied, we perform a partial //application, returning a function which takes the remaining arguments. if (arguments.Keys.Count < expectedArgs) { //Get all of the missing arguments. IEnumerable <string> missingArgs = parameters.Where( input => !arguments.ContainsKey(input) ); //Return a function that... return(Utils.MakeAnon( //...takes all of the missing arguments... missingArgs.ToList(), Expression.NewList_E( FSharpList <Expression> .Cons( //...and calls this function... function, Utils.SequenceToFSharpList( //...with the arguments which were supplied. parameters.Select( input => missingArgs.Contains(input) ? Expression.NewId(input) : arguments[input].compile( symbols, letEntries, initializedIds, conditionalIds))))))); } //If all the arguments were supplied, just return a standard function call expression. else { return(Expression.NewList_E( FSharpList <Expression> .Cons( function, Utils.SequenceToFSharpList( parameters.Select( input => arguments[input].compile( symbols, letEntries, initializedIds, conditionalIds)) ) ) )); } }
/// <summary> /// Looks up the value associated with the given symbol in this environment. /// </summary> /// <param name="p"></param> /// <returns></returns> public Value LookupSymbol(string p) { //try //{ // return this.frozenEnv.Value[p]; //} //catch (Exception) //{ // throw new Exception("Could not find key " + p + " in environment"); //} //return env.Lookup(p); return(Evaluate(Expression.NewId(p))); }
private Expression __compileBody( Dictionary <INode, string> symbols, Dictionary <INode, List <INode> > letEntries, HashSet <string> initializedIds, HashSet <string> conditionalIds) { string symbol; if (symbols.TryGetValue(this, out symbol)) { var body = Expression.NewId(symbol); if (conditionalIds.Contains(symbol)) { symbols.Remove(this); var binding = compile(symbols, letEntries, initializedIds, conditionalIds); symbols[this] = symbol; body = Expression.NewIf( Expression.NewId(symbol + "-init"), body, Expression.NewBegin( Utils.MakeFSharpList( Expression.NewSetId(symbol, binding), Expression.NewSetId(symbol + "-init", Expression.NewNumber_E(1)), body))); } else if (!initializedIds.Contains(symbol)) { symbols.Remove(this); var binding = compile(symbols, letEntries, initializedIds, conditionalIds); symbols[this] = symbol; body = Expression.NewBegin( Utils.MakeFSharpList( Expression.NewSetId(symbol, binding), Expression.NewSetId(symbol + "-init", Expression.NewNumber_E(1)), body)); initializedIds.Add(symbol); } return(body); } else { return(compileBody(symbols, letEntries, initializedIds, conditionalIds)); } }
protected override Expression compileBody( Dictionary <INode, string> symbols, Dictionary <INode, List <INode> > letEntries, HashSet <string> initializedIds, HashSet <string> conditionalIds) { var arg = arguments.First().Value.compile( symbols, letEntries, initializedIds, conditionalIds); //idle :: (() -> A) -> A //Evaluates the given function in the Revit Idle thread. var idle = Expression.NewFunction_E( FSharpFunc <FSharpList <Value>, Value> .FromConverter( args => { var f = (args[0] as Value.Function).Item; if (dynSettings.Controller.DynamoViewModel.RunInDebug) { return(f.Invoke(FSharpList <Value> .Empty)); } return(IdlePromise <Value> .ExecuteOnIdle( () => f.Invoke(FSharpList <Value> .Empty))); })); //startTransaction :: () -> () //Starts a Dynamo Transaction. var startTransaction = Expression.NewFunction_E( FSharpFunc <FSharpList <Value>, Value> .FromConverter( _ => { if (_node.Controller.RunCancelled) { throw new CancelEvaluationException(false); } if (!dynSettings.Controller.DynamoViewModel.RunInDebug) { dynRevitSettings.Controller.InIdleThread = true; dynRevitSettings.Controller.InitTransaction(); } return(Value.NewDummy("started transaction")); })); //endTransaction :: () -> () //Ends a Dynamo Transaction. var endTransaction = Expression.NewFunction_E( FSharpFunc <FSharpList <Value>, Value> .FromConverter( _ => { if (!dynRevitSettings.Controller.DynamoViewModel.RunInDebug) { dynRevitSettings.Controller.EndTransaction(); dynRevitSettings.Controller.InIdleThread = false; dynSettings.Controller.DynamoViewModel.OnRequestLayoutUpdate(this, EventArgs.Empty); _node.ValidateConnections(); } else { _node.setDirty(false); } return(Value.NewDummy("ended transaction")); })); /* (define (idleArg) * (startTransaction) * (let ((a <arg>)) * (endTransaction) * a)) */ var idleArg = Expression.NewFun( FSharpList <FScheme.Parameter> .Empty, Expression.NewBegin( Utils.SequenceToFSharpList(new List <Expression> { Expression.NewList_E( Utils.SequenceToFSharpList( new List <Expression> { startTransaction })), Expression.NewLet( Utils.SequenceToFSharpList( new List <string> { "__result" }), Utils.SequenceToFSharpList( new List <Expression> { arg }), Expression.NewBegin( Utils.SequenceToFSharpList( new List <Expression> { Expression.NewList_E( Utils.SequenceToFSharpList( new List <Expression> { endTransaction })), Expression.NewId("__result") }))) }))); // (idle idleArg) return(Expression.NewList_E( Utils.SequenceToFSharpList(new List <Expression> { idle, idleArg }))); }