/// <summary>
 /// Construct a <see cref="StreamSeq">StreamSeq</see> from metadata and first/rest.
 /// </summary>
 /// <param name="meta">The metadata to attach</param>
 /// <param name="first">The first item.</param>
 /// <param name="rest">The rest of the sequence.</param>
 StreamSeq(IPersistentMap meta, Object first, ISeq rest)
     : base(meta)
 {
     _first = first;
     _rest = rest;
     _stream = null;
 }

        public void VerifyISeqRestMaintainsMeta(ISeq s)
        {
            IPersistentMap meta = ((IMeta)s).meta();

            for (; s.rest() != null; s = s.rest())
                Expect(((IMeta)s.rest()).meta(), EqualTo(meta));
        }

        public void VerifyISeqCons(ISeq s, object newVal, IList<object> values)
        {
            ISeq newSeq = s.cons(newVal);

            Expect(newSeq.first(), EqualTo(newVal));
            VerifyISeqContents(newSeq.rest(), values);
        }

 public static PersistentTreeSet create(IComparer comp, ISeq init)
 {
     PersistentTreeSet ret = new PersistentTreeSet(null, new PersistentTreeMap(null, comp));
     for (ISeq s = init; s != null; s = s.next())
         ret = (PersistentTreeSet)ret.cons(s.first());
     return ret;
 }

 /// <summary>
 /// Create a <see cref="PersistentVector">PersistentVector</see> from an <see cref="ISeq">ISeq</see>.
 /// </summary>
 /// <param name="items">A sequence of items.</param>
 /// <returns>An initialized vector.</returns>
 public static PersistentVector create(ISeq items)
 {
     IPersistentVector ret = EMPTY;
     for (; items != null; items = items.next())
         ret = ret.cons(items.first());
     return (PersistentVector)ret;
 }

 protected MemberDef(IImSeq<Annotation> annotations, ISeq<CustomAttribute> customAttributes, string name, bool isStatic)
 {
     Annotations = annotations ?? Constants.EmptyAnnotations;
     CustomAttributes = customAttributes ?? new Seq<CustomAttribute>();
     Name = name;
     IsStatic = isStatic;
 }

        // This naming convention drawn from the Java code.
        internal void ComputeNames(ISeq form, string name)
        {
            ObjMethod enclosingMethod = (ObjMethod)Compiler.MethodVar.deref();

            string baseName = enclosingMethod != null
                ? enclosingMethod.Objx.Name
                : Compiler.munge(Compiler.CurrentNamespace.Name.Name) + "$";

            Symbol nm = RT.second(form) as Symbol;

            if (nm != null )
            {
                name = nm.Name + "__" + RT.nextID();
            }
            else
            {
                if (name == null)
                    name = "fn__" + RT.nextID();
                else if (enclosingMethod != null)
                    name += "__" + RT.nextID();
            }

            string simpleName = Compiler.munge(name).Replace(".", "_DOT_");

            Name = baseName + simpleName;
            InternalName = Name.Replace('.', '/');
        }

 /// <summary>
 /// Create a <see cref="PersistentHashSet">PersistentHashSet</see> initialized from an <see cref="ISeq">ISeq</see> of items.
 /// </summary>
 /// <param name="items">An <see cref="ISeq">ISeq</see> of items</param>
 /// <returns>A <see cref="PersistentHashSet">PersistentHashSet</see>.</returns>
 public static PersistentHashSet create(ISeq items)
 {
     PersistentHashSet ret = EMPTY;
     for (; items != null; items = items.next())
         ret = (PersistentHashSet)ret.cons(items.first());
     return ret;
 }

 public static PersistentHashSet create(ISeq items)
 {
     ITransientSet ret = (ITransientSet)EMPTY.asTransient(); 
     for (; items != null; items = items.next())
         ret = (ITransientSet)ret.conj(items.first());
     return (PersistentHashSet)ret.persistent();
 }

 /// <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 static Type GenerateInterface(string iName, ISeq extends, ISeq methods)
        {
            GenContext context = new GenContext(iName, CompilerMode.File);

            //            GenContext context = (GenContext)Compiler.COMPILER_CONTEXT.deref();
            //            if (context == null)
            //            {
            //#if DEBUG
            //                context = new GenContext(iName, CompilerMode.File);
            //#else
            //                throw new InvalidOperationException("No compiler context on the stack.");
            //#endif
            //            }

            Type[] interfaceTypes = GenClass.CreateTypeArray(extends == null ? null : extends.seq());

            TypeBuilder proxyTB = context.ModuleBldr.DefineType(
                iName,
                TypeAttributes.Interface | TypeAttributes.Public | TypeAttributes.Abstract,
                null,
                interfaceTypes);

            DefineMethods(proxyTB, methods);

            Type t = proxyTB.CreateType();
            context.AssyBldr.Save(iName  + ".dll");
            return t;
        }

        public static Type GenerateProxyClass(Type superclass, ISeq interfaces, string className)
        {
            //Console.WriteLine("Defining proxy class {0} with base {1}", className, superclass);

            // define the class
            List<Type> interfaceTypes = new List<Type>();
            interfaceTypes.Add(typeof(IProxy));

            for (ISeq s = interfaces; s != null; s = s.next())
                interfaceTypes.Add((Type)s.first());

            TypeBuilder proxyTB = _context.ModuleBldr.DefineType(
                className,
                TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed,
                superclass,
                interfaceTypes.ToArray());

            DefineCtors(proxyTB, superclass);
            FieldBuilder mapField = AddIProxyMethods(proxyTB);

            HashSet<Type> allInterfaces = GetAllInterfaces(interfaces);
            HashSet<MethodBuilder> specialMethods = new HashSet<MethodBuilder>();

            AddInterfaceMethods(proxyTB, mapField, superclass, allInterfaces, specialMethods);
            AddInterfaceProperties(proxyTB, superclass, allInterfaces, specialMethods ); // Must follow AddInterfaceMethods

            return proxyTB.CreateType();
        }

 private Cycle(IPersistentMap meta, ISeq all, ISeq prev, ISeq current, ISeq next)
     :base(meta)
 {
     _all = all;
     _prev = prev;
     _current = current;
     _next = next;
 }

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

 public static Expr Parse(ISeq form)
 {
     Expr fexpr = Compiler.GenerateAST(form.first());
     IPersistentVector args = PersistentVector.EMPTY;
     for ( ISeq s = RT.seq(form.next()); s != null; s = s.next())
         args = args.cons(Compiler.GenerateAST(s.first()));
     return new InvokeExpr(Compiler.TagOf(form),fexpr,args);
 }

 public static Expr Parse(ISeq form)
 {
     Expr fexpr = Compiler.GenerateAST(form.first(),false);
     IPersistentVector args = PersistentVector.EMPTY;
     for ( ISeq s = RT.seq(form.next()); s != null; s = s.next())
         args = args.cons(Compiler.GenerateAST(s.first(),false));
     return new InvokeExpr((string)Compiler.SOURCE.deref(),(int)Compiler.LINE.deref(),Compiler.TagOf(form),fexpr,args);
 }

 public override ISeq next()
 {
     if (_next == null)
     {
         _next = new Iterate(_f, first(), UNREALIZED_SEED);
     }
     return _next;
 }

 public ISeq sequence()
 {
     if (_sequence == NO_SEQ)
     {
         tap();
         _sequence = makeSequence(_tap);
     }
     return _sequence;
 }

        public void VerifyISeqContents(ISeq s, IList<object> values)
        {
            int i=0;

            for (; s != null; s = s.rest(), i++)
                Expect(s.first(), EqualTo(values[i]));

            Expect(i, EqualTo(values.Count));
        }

 // realization for use of current
 ISeq Current()
 {
     if (_current == null)
     {
         ISeq c = _prev.next();
         _current = (c == null) ? _all : c;
     }
     return _current;
 }