• Chris Sokol (11/11) Aug 07 2003 What am I doing wrong?
• Chris Sokol (2/6) Aug 07 2003 Oops, I meant to say T* fooBar;
• Burton Radons (11/26) Aug 07 2003 Wrong error message, but this is the same thing as doing:
• Chris Sokol (4/5) Aug 07 2003
• Mike Wynn (32/34) Aug 07 2003 I had a play with this .....
• Mike Wynn (36/71) Aug 07 2003 and I tried a couple of other arrangements each has its own unique error
• Chris Sokol (27/49) Aug 08 2003 I have a favorite set of c++ list and tree templates that I did, which I
• Chris Sokol (2/47) Aug 08 2003

Chris Sokol <chris echosproject.org> writes:

What am I doing wrong?

template Foo(T) {
	struct Bar {
		T fooBar;
	}
}

alias instance Foo(Fu) FooT;

struct Fu {
	FooT.Bar	x;
}

no property 'Bar' for type 'instance Foo(Fu )'

Chris Sokol <chris echosproject.org> writes:

On Thu, 07 Aug 2003 23:51:32 -0400, Chris Sokol wrote:
 template Foo(T) {
 	struct Bar {
 		T fooBar;
 	}

Oops, I meant to say T* fooBar;

Burton Radons <loth users.sourceforge.net> writes:

Chris Sokol wrote:

 What am I doing wrong?
 
 template Foo(T) {
 	struct Bar {
 		T fooBar;
 	}
 }
 
 alias instance Foo(Fu) FooT;
 
 struct Fu {
 	FooT.Bar	x;
 }
 
 no property 'Bar' for type 'instance Foo(Fu )'

Wrong error message, but this is the same thing as doing:

    struct x
    {
        struct y
        {
            x xitem;
        }

        y yitem;
    }

So it has an infinite size.  Use "class" instead, or pointers.

Chris Sokol <chris echosproject.org> writes:

On Fri, 08 Aug 2003 00:35:19 -0400, Burton Radons wrote:
 So it has an infinite size.  Use "class" instead, or pointers.

 
Yeah, I meant to use a pointer.  Typo.  But that is the error that I get
with T* fooBar inside the template.

"Mike Wynn" <mike.wynn l8night.co.uk> writes:

"Chris Sokol" <chris echosproject.org> wrote in message
news:bgv6f0$1mic$1 digitaldaemon.com...
 What am I doing wrong?

 no property 'Bar' for type 'instance Foo(Fu )'

I had a play with this .....

template Foo(T) {
 struct Bar {
  T * fooBar;
 }
}

alias instance Foo(Fu).Bar FooT;
struct Fu {
 FooT x;
}

int main() {
 Fu f;
 return 0;
}

now it reports
main.d(7): size of type instance Foo(Fu ).Bar is not known

but  .................................

template Foo(T) {
 struct Bar {
  T * fooBar;
 }
}

struct Fu {
 instance Foo(Fu).Bar x;
}

int main() {
 Fu f;
 return 0;
}

WORKS

"Mike Wynn" <mike.wynn l8night.co.uk> writes:

and I tried a couple of other arrangements each has its own unique error
....

template Foo(T) {
 struct Bar {
  T * fooBar;
 }
}

instance Foo(Fu).Bar foo_bar;
struct Fu {
  foo_bar x;
}

int main() {
 Fu f;

 return 0;
}

//give the error
// test_005.d(9): foo_bar is used as a type
//

template Foo(T) {
 struct Bar {
  T * fooBar;
 }
}

instance Foo(Fu) foo_fu;
struct Fu {
  foo_fu.Bar x;
}

int main() {
 Fu f;

 return 0;
}

// gives the error
// test_004.d(9): identifier 'Bar' of 'foo_fu.Bar' is not defined
//



"Mike Wynn" <mike.wynn l8night.co.uk> wrote in message
news:bgvbr5$1rmo$1 digitaldaemon.com...
 "Chris Sokol" <chris echosproject.org> wrote in message
 news:bgv6f0$1mic$1 digitaldaemon.com...
 What am I doing wrong?

 no property 'Bar' for type 'instance Foo(Fu )'

 I had a play with this .....

 template Foo(T) {
  struct Bar {
   T * fooBar;
  }
 }

 alias instance Foo(Fu).Bar FooT;
 struct Fu {
  FooT x;
 }

 int main() {
  Fu f;
  return 0;
 }

 now it reports
 main.d(7): size of type instance Foo(Fu ).Bar is not known

 but  .................................

 template Foo(T) {
  struct Bar {
   T * fooBar;
  }
 }

 struct Fu {
  instance Foo(Fu).Bar x;
 }

 int main() {
  Fu f;
  return 0;
 }

 WORKS

Chris Sokol <chris echosproject.org> writes:

On Fri, 08 Aug 2003 01:38:41 -0400, Mike Wynn wrote:
 and I tried a couple of other arrangements each has its own unique error
 ....
 
 template Foo(T) {
  struct Bar {
   T * fooBar;
  }
  }
  }
 instance Foo(Fu).Bar foo_bar;
 struct Fu {
   foo_bar x;
 }
 }
 int main() {
  Fu f;
 
  return 0;
 }
 }
 //give the error
 // test_005.d(9): foo_bar is used as a type //

I have a favorite set of c++ list and tree templates that I did, which I
want to port to D as a learning experience.  They work without performing
any allocation; the nodes which are to be placed in the list need to have
linkage already present.  They go kind of like this:

template<typename T>
class List {
   struct Node {
      T*    prev;
      T*    next;
   };
   // all sorts of stuff
};

typedef List<struct Element> ElementList;

struct Element {
   ElementList::Node listNode;
   // blah blah blah
};

Is this the proper D-like approach?  I definitely do not want to require
the List to allocate it's own linkage; one of the things this is used for
is implementing malloc / free.

Having to do 

struct Element {
   instance ListT(Element).Node listNode;
};

feels somewhat unweildy; is there no way to something closer to my
original example or the typedef approach above?

Chris Sokol <chris echosproject.org> writes:

Ah, thank you.

On Fri, 08 Aug 2003 01:30:51 -0400, Mike Wynn wrote:


 "Chris Sokol" <chris echosproject.org> wrote in message
 news:bgv6f0$1mic$1 digitaldaemon.com...
 What am I doing wrong?

 no property 'Bar' for type 'instance Foo(Fu )'

 
 I had a play with this .....
 
 template Foo(T) {
  struct Bar {
   T * fooBar;
  }
  }
  }
 alias instance Foo(Fu).Bar FooT;
 struct Fu {
  FooT x;
 }
 }
 int main() {
  Fu f;
  return 0;
 }
 }
 now it reports
 main.d(7): size of type instance Foo(Fu ).Bar is not known
 
 but  .................................
 
 template Foo(T) {
  struct Bar {
   T * fooBar;
  }
  }
  }
 struct Fu {
  instance Foo(Fu).Bar x;
 }
 }
 int main() {
  Fu f;
  return 0;
 }
 }
 WORKS