public IFn tap()
        {
            if (_tap != null)
            throw new InvalidOperationException("Stream already tapped");

            return _tap = makeTap(_xform, _src);
        }

        public static Delegate Create(Type delegateType, IFn fn)
        {
            MethodInfo invokeMI = delegateType.GetMethod("Invoke");
            Type returnType = invokeMI.ReturnType;

            ParameterInfo[] delParams = invokeMI.GetParameters();

            List<ParameterExpression> parms = new List<ParameterExpression>();
            List<Expression> callArgs = new List<Expression>();

            foreach (ParameterInfo pi in delParams)
            {
                ParameterExpression pe = Expression.Parameter(pi.ParameterType, pi.Name);
                parms.Add(pe);
                callArgs.Add(MaybeBox(pe));
            }

            Expression call =                    
                Expression.Call(
                    Expression.Constant(fn),
                    Compiler.Methods_IFn_invoke[parms.Count], 
                    callArgs);

            Expression body =  returnType == typeof(void)
                ? (Expression)Expression.Block(call,Expression.Default(typeof(void)))
                : (Expression)Expression.Convert(call, returnType);

            LambdaExpression lambda = Expression.Lambda(delegateType, body, true, parms);

            return lambda.Compile();
        }

        public void UpdateSettings(DataSource_ClojureFunction_Config sender)
        {
            minXVal = sender.MinX;
            maxXVal = sender.MaxX;
            minYVal = sender.MinY;
            maxYVal = sender.MaxY;
            precision = sender.Precision;

            clojureFunctionText1 = sender.ClojureFunction1.Trim();
            clojureFunctionText2 = sender.ClojureFunction2.Trim();

            clojureFunction1 = null;
            clojureFunction2 = null;

            if (clojureFunctionText1 != "")
            {
                try { clojureFunction1 = (IFn)ClojureEngine.EvalRaw("(fn [x y z t] " + clojureFunctionText1 + ")"); }
                catch { }
            }

            if (clojureFunctionText2 != "")
            {
                try { clojureFunction2 = (IFn)ClojureEngine.EvalRaw("(fn [x y z t] " + clojureFunctionText2 + ")"); }
                catch { }
            }
        }

 public object reduce(IFn f, object start)
 {
     object ret = f.invoke(start, _array[_off]);
     for (int x = _off + 1; x < _end; x++)
         ret = f.invoke(ret, _array[x]);
     return ret;
 }

 /// <summary>
 /// Initialize from given metatadata, plus first, restFn, rest.
 /// </summary>
 /// <param name="meta">The metadata to attach</param>
 /// <param name="first">The first of the sequence.</param>
 /// <param name="restFn">The function to generate the next value.</param>
 /// <param name="rest">The rest of the sequence..</param>
 FnSeq(IPersistentMap meta, object first, IFn restFn, ISeq rest)
     : base(meta)
 {
     _first = first;
     _restFn = restFn;
     _rest = rest;
 }

 public Future(IFn fn)
 {
     // TODO: Use a cached thread pool when agents have one.
     _t = new Thread(new ParameterizedThreadStart(ComputeFuture));
     _t.Name = "Future";
     _t.Start(fn);
 }

 private Iterate(IPersistentMap meta, IFn f, Object prevSeed, Object seed, ISeq next)
     :base(meta)
 {
     _f = f;
     _prevSeed = prevSeed;
     _seed = seed;
     _next = next;
 }

 /// Construct a multifunction.
 /// </summary>
 /// <param name="name">The name</param>
 /// <param name="dispatchFn">The dispatch function.</param>
 /// <param name="defaultDispatchVal">The default dispatch value.</param>
 /// <param name="hierarchy">The hierarchy for this multifunction</param>
 public MultiFn(string name, IFn dispatchFn, object defaultDispatchVal, IRef hierarchy)
 {
     _name = name;
     _dispatchFn = dispatchFn;
     _defaultDispatchVal = defaultDispatchVal;
     _methodTable = PersistentHashMap.EMPTY;
     _methodCache = MethodTable;
     _preferTable = PersistentHashMap.EMPTY;
     _hierarchy = hierarchy;
     _cachedHierarchy = null;
 }

 public object reduce(IFn f, object start)
 {
     object ret = f.invoke(start, _array[_off]);
     if (RT.isReduced(ret))
         return ret;
     for (int x = _off + 1; x < _end; x++)
     {
         ret = f.invoke(ret, _array[x]);
         if (RT.isReduced(ret))
             return ((IDeref)ret).deref();
     }
     return ret;
 }

 public object swap(IFn f)
 {
     for (; ; )
     {
         object v = deref();
         object newv = f.invoke(v);
         Validate(newv);
         if (_state.CompareAndSet(v, newv))
         {
             NotifyWatches(v,newv);
             return newv;
         }
     }
 }

        /// <summary>
        /// Invoke an <see cref="IFn">IFn</see> on a value to validate it.
        /// </summary>
        /// <param name="vf">The <see cref="IFn">IFn</see> to invoke.</param>
        /// <param name="val">The value to validate.</param>
        /// <remarks>Uneventful return marks a successful validation.  
        /// To indicate a failed validation, the validation function should return <value>false</value> or throw an exception.
        /// <para>This appears in multiple places.  Should find it a common home?</para></remarks>
        protected internal static void Validate(IFn vf, object val)
        {
            if (vf == null)
                return;

            bool ret = false;

            try
            {
               ret = RT.booleanCast(vf.invoke(val));
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Invalid reference state", e);
            }

            if ( ! ret )
                throw new InvalidOperationException("Invalid reference state");
        }

        public static void AddClojureDropDownBox(string labelText, Var variable, PersistentVector vals, IFn func)
        {
            string variableSymbolName = null;

            if(variable != null)
                variableSymbolName = variable.sym.Name;

            Label label = new Label();
            label.AutoSize = true;
            label.Text = labelText;

            Dictionary<string, object> labelCodeAssoc = new Dictionary<string, object>();

            ComboBox comboBox = new ComboBox();
            for (int i = 0; i < vals.Count; i += 2)
            {
                labelCodeAssoc.Add(vals[i].ToString(), vals[i + 1]);
                comboBox.Items.Add(vals[i]);
            }

            comboBox.SelectedIndex = 0;
            comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
            comboBox.SelectedIndexChanged += (s, e) =>
                {
                    if (comboBox.SelectedItem == null)
                        return;

                    object code = labelCodeAssoc[comboBox.SelectedItem.ToString()];

                     if(variableSymbolName != null)
                    {
                        string newVal = code.ToString();
                        ClojureEngine.Eval("(def " + variableSymbolName + " " + newVal + ")");
                    }

                    if (func != null)
                        ClojureEngine.Log(func.invoke());
                };

            self.AddNewClojureControls(new Control[] { label, comboBox });
        }

 public IRef addWatch(Agent watcher, IFn action, bool sendOff)
 {
     _watchers = _watchers.assoc(watcher, new object[] { action, sendOff });
      return this;
 }

 /// <summary>
 /// Sets the validator.
 /// </summary>
 /// <param name="vf">The new validtor</param>
 /// <remarks>The current value must validate in order for this validator to be accepted.  If not, an exception will be thrown.</remarks>
 public virtual void setValidator(IFn vf)
 {
     Validate(vf, deref());
     _validator = vf;
 }

 /// <summary>
 /// Sets the validator.
 /// </summary>
 /// <param name="vf">The new validtor</param>
 public override void setValidator(IFn vf)
 {
     if (hasRoot())
         Validate(vf, _root);
     _validator = vf;
 }

 public object alterRoot(IFn fn, ISeq args)
 {
     object newRoot = fn.applyTo(RT.cons(_root, args));
     Validate(getValidator(), newRoot);
     object oldroot = _root;
     _root = newRoot;
     ++_rev;
     NotifyWatches(oldroot,newRoot);
     return newRoot;
 }

 public object alter(IFn fn, ISeq args)
 {
     set(fn.applyTo(RT.cons(deref(), args)));
     return this;
 }

 void CommuteRoot(IFn fn)
 {
     object newRoot = fn.invoke(_root);
     Validate(getValidator(), newRoot);
     object oldRoot = _root;
     _root = newRoot;
     ++_rev;
     NotifyWatches(oldRoot, newRoot);
 }

 public object reduce(IFn f, object start)
 {
     int step = 0;
     for (int i = 0; i < _cnt; i += step)
     {
         Object[] array = ArrayFor(i);
         for (int j = 0; j < array.Length; ++j)
         {
             start = f.invoke(start, array[j]);
             if (RT.isReduced(start))
                 return ((IDeref)start).deref();
         }
         step = array.Length;
     }
     return start;
 }

 public static object ApplyToHelper(IFn fn, ISeq argList)
 {
     switch (RT.BoundedLength(argList, 20))
     {
         case 0:
             argList = null;
             return fn.invoke();
         case 1:
             return fn.invoke(Util.Ret1(argList.first(),argList=null));
         case 2:
             return fn.invoke(argList.first()
                     , Util.Ret1((argList = argList.next()).first(),argList = null)
             );
         case 3:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 4:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 5:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 6:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 7:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 8:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 9:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 10:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 11:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , Util.Ret1((argList = argList.next()).first(), argList = null)
             );
         case 12:
             return fn.invoke(argList.first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
                     , (argList = argList.next()).first()
//.........这里部分代码省略.........