# Multiple constructors?

**URL:** <https://rubytalk.org/t/multiple-constructors/3022>\
**Category:** ruby-talk\
**Created:** [21 November 2002 15:06 UTC](https://rubytalk.org/t/multiple-constructors/3022 "2002-11-21T15:06:36Z")\
**Posts on this page:** 18\
**Page:** 1

<div class="post-metadata">

**Author:** ![Christopher\_J\_Meisen](https://avatars.discourse-cdn.com/v4/letter/c/f0a364/32.png) [@Christopher\_J\_Meisen](https://rubytalk.org/u/Christopher_J_Meisen)\
**Post date:** [21 November 2002 15:06 UTC](https://rubytalk.org/t/multiple-constructors/3022/1 "2002-11-21T15:06:36Z")

</div>

I’ve seen how Ruby uses an initialize() method as a constructor.

Can this method be overloaded? After playing with IRB I’m assuming it can’t?

Thanks very much again; Ruby and this list are great.

Christopher J. Meisenzahl CPS, CSTE  
Senior Software Testing Consultant  
Spherion  
[christopher.j.meisenzahl@citicorp.com](mailto:christopher.j.meisenzahl@citicorp.com)

---

<div class="post-metadata">

**Author:** ![Austin\_Ziegler2](https://avatars.discourse-cdn.com/v4/letter/a/ad7895/32.png) [@Austin\_Ziegler2](https://rubytalk.org/u/Austin_Ziegler2)\
**Post date:** [21 November 2002 15:20 UTC](https://rubytalk.org/t/multiple-constructors/3022/2 "2002-11-21T15:20:10Z")

</div>

Actually, so far as I can tell, no method in Ruby can be overloaded.  
(What looks like overloading is redefinition.)

Inasmuch as I’ve cared about overloading by type, I’ve handled the  
dispatching myself. For good examples of this, look at my  
initializers in Text::Format and MIME::Types. In all of these, I  
handle a “copy constructor” case, a Hash case, and a NilClass case;  
I also handle other types as appropriate.

-austin  
– Austin Ziegler, austin@halostatue.ca on 2002.11.21 at 10.16.15

> **···**
>
> On Fri, 22 Nov 2002 00:06:36 +0900, [christopher.j.meisenzahl@citicorp.com](mailto:christopher.j.meisenzahl@citicorp.com) wrote:
> 
> > I’ve seen how Ruby uses an initialize() method as a constructor.
> > 
> > Can this method be overloaded? After playing with IRB I’m assuming  
> > it can’t?
> > 
> > Thanks very much again; Ruby and this list are great.

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [21 November 2002 15:27 UTC](https://rubytalk.org/t/multiple-constructors/3022/3 "2002-11-21T15:27:31Z")

</div>

> I’ve seen how Ruby uses an initialize() method as a constructor.
> 
> Can this method be overloaded? After playing with IRB I’m assuming it can’t?
> 
> Thanks very much again; Ruby and this list are great.

For better or worse, no method can be overloaded, unless you ask Guy for his  
modified Ruby 🙂

If you need to branch on type, you can do this

def initialize(value)  
case value  
when String then …  
when Regexp then …  
else …  
end

If you need variable arguments, you can do

def initialize (value, \*values)  
process(value)  
values.each do |v|  
…  
end  
end

Then, of course, there’s default arguments:

def initialize(size=5, shape=SQUARE, colour=nil, params={})  
@colour = nil || @colour || DEFAULT\_COLOUR  
…  
end

Finally, if your method expects a String, do the following:

def initialize(s)  
process(s.to\_s) # Now it can handle numbers, etc, too.  
end

(This doesn’t always feel right. Use your judgement in each case.)

So there are ways to handle the need for varying parameter lists (a la  
overloaded methods). None of them are a perfect fit from the point of view of  
some other languages, but it’s pretty rare that the above approaches can’t  
provide a decent solution.

Note to FAQ maintainer: this proposed FAQ entry is in response to  
ruby-talk:56440. Please examine any other responses if/when entering this.

Gavin

> **···**
>
> From: [christopher.j.meisenzahl@citicorp.com](mailto:christopher.j.meisenzahl@citicorp.com)

---

<div class="post-metadata">

**Author:** ![Paul\_Brannan](https://avatars.discourse-cdn.com/v4/letter/p/76d3ee/32.png) [@Paul\_Brannan](https://rubytalk.org/u/Paul_Brannan)\
**Post date:** [21 November 2002 15:37 UTC](https://rubytalk.org/t/multiple-constructors/3022/4 "2002-11-21T15:37:47Z")

</div>

Ruby does not have overloading. As an alternative, you can do one of  
the following:

1. Define initialize() like this:  
class Foo  
def initialize(\*args)  
@host = @port = @filename = nil  
if args.length == 2 then  
@host = args[0]  
@port = args[1]  
elsif args.length == 1 then  
@filename = args[0]  
else  
raise ArgumentError, “Invalid number of arguments”  
end  
end  
end  
You can interpret args however you wish; it’s an array containing all  
the arguments to your method. You can also do your own type checking  
if you wish.

2. Define multiple constructors with different names:

Hope this gives you some ideas,

Paul

> **···**
>
> On Fri, Nov 22, 2002 at 12:06:36AM +0900, [christopher.j.meisenzahl@citicorp.com](mailto:christopher.j.meisenzahl@citicorp.com) wrote:
> 
> > I’ve seen how Ruby uses an initialize() method as a constructor.
> > 
> > Can this method be overloaded? After playing with IRB I’m assuming it can’t?

---

<div class="post-metadata">

**Author:** ![Nat\_Pryce](https://avatars.discourse-cdn.com/v4/letter/n/b38774/32.png) [@Nat\_Pryce](https://rubytalk.org/u/Nat_Pryce)\
**Post date:** [21 November 2002 15:52 UTC](https://rubytalk.org/t/multiple-constructors/3022/5 "2002-11-21T15:52:51Z")

</div>

In Ruby there are actually _two_ methods that act as a constructor, the  
new method of the class and the initialize method of the object. The new  
method allocates a new object and then calls initialize on it.

If you want to define multiple constructors, define multiple “new”  
methods on your class and have those call different “initialize” methods  
on the object.

For example the following code will print:

“initialize 1”  
“initialize 2”

class C  
def C.new\_1()  
c = C.new()  
c.initialize\_1()  
c  
end

```
def C.new_2()
    c = C.new()
    c.initialize_2()
    c
end

def initialize_1()
    p "initialize 1"
end

def initialize_2()
    p "initialize 2"
end

```

end

c1 = C.new\_1()  
c2 = C.new\_2()

Cheers,  
Nat.

> **···**
>
> On Thu, 2002-11-21 at 15:06, [christopher.j.meisenzahl@citicorp.com](mailto:christopher.j.meisenzahl@citicorp.com) wrote:
> 
> > I’ve seen how Ruby uses an initialize() method as a constructor.
> > 
> > Can this method be overloaded? After playing with IRB I’m assuming it can’t
> 
> –  
> Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com)  
> B13media

---

<div class="post-metadata">

**Author:** ![Bulat\_Ziganshin](https://avatars.discourse-cdn.com/v4/letter/b/ba8739/32.png) [@Bulat\_Ziganshin](https://rubytalk.org/u/Bulat_Ziganshin)\
**Post date:** [22 November 2002 05:35 UTC](https://rubytalk.org/t/multiple-constructors/3022/6 "2002-11-22T05:35:38Z")

</div>

Hello christopher,

Thursday, November 21, 2002, 6:06:36 PM, you wrote:

> Can this method be overloaded?

you can overload yourself:

def initialize (\*args)

case true  
when args.size==1 then …  
when args.size==2 and Array===args[1] then …  
…  
end  
end

or use overload.rb, which autocreates this ‘case’ statement for you  
automagically

> **···**
>
> –  
> Best regards,  
> Bulat [mailto:bulatz@integ.ru](mailto:bulatz@integ.ru)

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [21 November 2002 15:47 UTC](https://rubytalk.org/t/multiple-constructors/3022/7 "2002-11-21T15:47:32Z")

</div>

Hi –

> 1. Define multiple constructors with different names:

Maybe you could do:

def self.my\_new  
obj = new  
class \<\< obj; public :other\_initialize; end  
obj.other\_initialize  
class \<\< obj; private :other\_initialize; end  
obj  
end

def other\_initialize  
# …  
end  
private :other\_initialize

(give or take any hidden pitfalls I haven’t spotted 🙂

David

> **···**
>
> On Fri, 22 Nov 2002, Paul Brannan wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![Nat\_Pryce](https://avatars.discourse-cdn.com/v4/letter/n/b38774/32.png) [@Nat\_Pryce](https://rubytalk.org/u/Nat_Pryce)\
**Post date:** [21 November 2002 16:01 UTC](https://rubytalk.org/t/multiple-constructors/3022/8 "2002-11-21T16:01:24Z")

</div>

I would avoid this because it is not branching on type, but instead  
branching on how an object _implements_ its type, which should be of no  
concern to other objects. For example, this code would break if I passed  
it an object that acted exactly like a Regexp but was not an instance of  
the Regexp class. That object would have the same _type_ as objects of  
class Regexp, but would have a different _implementation_. See  
[http://www.rubygarden.org/ruby?TypesInRuby](http://www.rubygarden.org/ruby?TypesInRuby) for a more detailed  
explanation.

If you want to have different constructors for different argument types,  
define different constructors on your class. Your code will then be  
both more flexible and more readable. E.g. If you had a class that  
could be created with either a String and a Regexp you would define  
constructors new\_from\_string(a\_string) and new\_from\_regexp(a\_regexp).

Cheers,  
Nat.

> **···**
>
> On Thu, 2002-11-21 at 15:27, Gavin Sinclair wrote:
> 
> > If you need to branch on type, you can do this
> > 
> > def initialize(value)  
> > case value  
> > when String then …  
> > when Regexp then …  
> > else …  
> > end
> 
> –  
> Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com)  
> B13media

---

<div class="post-metadata">

**Author:** ![Paul\_Brannan](https://avatars.discourse-cdn.com/v4/letter/p/76d3ee/32.png) [@Paul\_Brannan](https://rubytalk.org/u/Paul_Brannan)\
**Post date:** [21 November 2002 17:46 UTC](https://rubytalk.org/t/multiple-constructors/3022/9 "2002-11-21T17:46:38Z")

</div>

I just thought of a solution:

class Foo  
public  
def self.new\_with\_socket(host, port)  
return new(:initialize\_with\_host\_and\_port, host, port)  
return obj  
end

```
def self.new_with_filename(filename)
  return new(:initialize_with_filename, filename)
end

```

private  
private\_class\_method :new

```
def initialize(init_method, *args, &block)
  @host = @port = @filename = nil
  self.send(init_method, *args, &block)
end

def initialize_with_filename(filename)
  @filename = filename
end

def initialize_with_host_and_port(host, port)
  @host = host
  @port = port
end

```

end

Paul

> **···**
>
> On Fri, Nov 22, 2002 at 12:37:47AM +0900, Paul Brannan wrote:
> 
> > the only thing I don’t like about this second method is that  
> > initialize\_with\_filename and initialize\_with\_host\_and\_port are both  
> > public methods; I don’t know any way to make them private  
> > (initialize() is always a private method).

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [21 November 2002 16:21 UTC](https://rubytalk.org/t/multiple-constructors/3022/10 "2002-11-21T16:21:12Z")

</div>

> > If you need to branch on type, you can do this
> > 
> > def initialize(value)  
> > case value  
> > when String then …  
> > when Regexp then …  
> > else …  
> > end
> 
> I would avoid this because it is not branching on type, but instead  
> branching on how an object _implements_ its type, which should be of no  
> concern to other objects. For example, this code would break if I passed  
> it an object that acted exactly like a Regexp but was not an instance of  
> the Regexp class. That object would have the same _type_ as objects of  
> class Regexp, but would have a different _implementation_. See  
> [http://www.rubygarden.org/ruby?TypesInRuby](http://www.rubygarden.org/ruby?TypesInRuby) for a more detailed  
> explanation.

That’s fair enough - like I say, none of these approaches is a perfect fit -  
but sometimes you can be pretty sure what you’re dealing with. It sort of  
depends how far and wide your code is going to spread.

For better or worse, code like that above is seen in widely used libraries.  
Even though most experienced rubyists would agree that it’s to be avoided,  
sometimes it makes the most sense.

> If you want to have different constructors for different argument types,  
> define different constructors on your class. Your code will then be  
> both more flexible and more readable. E.g. If you had a class that  
> could be created with either a String and a Regexp you would define  
> constructors new\_from\_string(a\_string) and new\_from\_regexp(a\_regexp).

I have an aesthetic problem with that, but again, sometimes it’s the most  
desirable solution.

At the end of the day, if I find myself _really needing_ Java-style overloaded  
methods, I question my design.

> **···**
>
> From: “Nat Pryce” [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com)
> 
> > On Thu, 2002-11-21 at 15:27, Gavin Sinclair wrote:
> 
> > Cheers,  
> > Nat.

---

<div class="post-metadata">

**Author:** ![Austin\_Ziegler2](https://avatars.discourse-cdn.com/v4/letter/a/ad7895/32.png) [@Austin\_Ziegler2](https://rubytalk.org/u/Austin_Ziegler2)\
**Post date:** [21 November 2002 17:06 UTC](https://rubytalk.org/t/multiple-constructors/3022/11 "2002-11-21T17:06:11Z")

</div>

> > If you need to branch on type, you can do this
> > 
> > def initialize(value)  
> > case value  
> > when String then …  
> > when Regexp then …  
> > else …  
> > end

> I would avoid this because it is not branching on type, but  
> instead branching on how an object _implements_ its type, which  
> should be of no concern to other objects.  
> […]

> If you want to have different constructors for different argument  
> types, define different constructors on your class. Your code will  
> then be both more flexible and more readable. E.g. If you had a  
> class that could be created with either a String and a Regexp you  
> would define constructors new\_from\_string(a\_string) and  
> new\_from\_regexp(a\_regexp).

Mmmm. No. That unnecessarily exposes producer implementation details  
to the consumer class. If the behaviours are what are important,  
then the producer class should use #respond\_to? and not the type. In  
my cases where I respond to multiple _types_, I have done so because  
I explicitly care about the types used because my code responds  
slightly differently to different types in constructors, but only  
internally. It should never matter to the consumer that the  
responses are internally different – only that the outputs are the  
same.

-austin  
– Austin Ziegler, austin@halostatue.ca on 2002.11.21 at 12.01.45

> **···**
>
> On Fri, 22 Nov 2002 01:01:24 +0900, Nat Pryce wrote:
> 
> > On Thu, 2002-11-21 at 15:27, Gavin Sinclair wrote:

---

<div class="post-metadata">

**Author:** ![Paul\_Brannan](https://avatars.discourse-cdn.com/v4/letter/p/76d3ee/32.png) [@Paul\_Brannan](https://rubytalk.org/u/Paul_Brannan)\
**Post date:** [21 November 2002 17:40 UTC](https://rubytalk.org/t/multiple-constructors/3022/12 "2002-11-21T17:40:04Z")

</div>

This isn’t thread-safe. Consider:

1. I create two objects
2. The first constructor makes other\_initialize public
3. The second constructor makes other\_initialize public
4. The first constructor calls other\_initialize
5. The first constructor makes other\_initialize private
6. The second constructor will fail when it calls other\_initialize

It’s also possible to call other\_initialize from one thread while  
another thread is constructing one of these objects.

Paul

> **···**
>
> On Fri, Nov 22, 2002 at 12:47:32AM +0900, [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> 
> > def self.my\_new  
> > obj = new  
> > class \<\< obj; public :other\_initialize; end  
> > obj.other\_initialize  
> > class \<\< obj; private :other\_initialize; end  
> > obj  
> > end

---

<div class="post-metadata">

**Author:** ![Martin\_DeMello1](https://avatars.discourse-cdn.com/v4/letter/m/3be4f8/32.png) [@Martin\_DeMello1](https://rubytalk.org/u/Martin_DeMello1)\
**Post date:** [22 November 2002 10:17 UTC](https://rubytalk.org/t/multiple-constructors/3022/13 "2002-11-22T10:17:18Z")

</div>

This won’t let me do something like

my\_objs = input\_objs.map {|i| MyClass.new(i)}

martin

> **···**
>
> Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com) wrote:
> 
> > If you want to have different constructors for different argument types,  
> > define different constructors on your class. Your code will then be  
> > both more flexible and more readable. E.g. If you had a class that  
> > could be created with either a String and a Regexp you would define  
> > constructors new\_from\_string(a\_string) and new\_from\_regexp(a\_regexp).

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [21 November 2002 20:18 UTC](https://rubytalk.org/t/multiple-constructors/3022/14 "2002-11-21T20:18:14Z")

</div>

Hi –

> > def self.my\_new  
> > obj = new  
> > class \<\< obj; public :other\_initialize; end  
> > obj.other\_initialize  
> > class \<\< obj; private :other\_initialize; end  
> > obj  
> > end
> 
> This isn’t thread-safe. Consider:
> 
> 1. I create two objects
> 2. The first constructor makes other\_initialize public
> 3. The second constructor makes other\_initialize public
> 4. The first constructor calls other\_initialize
> 5. The first constructor makes other\_initialize private
> 6. The second constructor will fail when it calls other\_initialize
> 
> It’s also possible to call other\_initialize from one thread while  
> another thread is constructing one of these objects.

I think the privacy is gate-kept separately by each object’s singleton  
class:

class A  
def talk; puts “hi”; end  
private :talk  
end

a = A.new  
class \<\< a; public :talk; end  
a.talk # hi  
b = A.new  
b.talk # error: private method called

so the manipulation of the privacy should itself be private and  
atomic.

David

> **···**
>
> On Fri, 22 Nov 2002, Paul Brannan wrote:
> 
> > On Fri, Nov 22, 2002 at 12:47:32AM +0900, [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![Nat\_Pryce](https://avatars.discourse-cdn.com/v4/letter/n/b38774/32.png) [@Nat\_Pryce](https://rubytalk.org/u/Nat_Pryce)\
**Post date:** [22 November 2002 10:55 UTC](https://rubytalk.org/t/multiple-constructors/3022/15 "2002-11-22T10:55:08Z")

</div>

That’s true but how often does one put arbitrary objects into a  
collection and then use them to create something? And if you do, you  
can easily put different types of objects into different collections.

Cheers,  
Nat.

> **···**
>
> On Fri, 2002-11-22 at 10:17, Martin DeMello wrote:
> 
> > Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com) wrote:
> > 
> > > If you want to have different constructors for different argument types,  
> > > define different constructors on your class. Your code will then be  
> > > both more flexible and more readable. E.g. If you had a class that  
> > > could be created with either a String and a Regexp you would define  
> > > constructors new\_from\_string(a\_string) and new\_from\_regexp(a\_regexp).
> > 
> > This won’t let me do something like
> > 
> > my\_objs = input\_objs.map {|i| MyClass.new(i)}
> 
> –  
> Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com)  
> B13media

---

<div class="post-metadata">

**Author:** ![Paul\_Brannan](https://avatars.discourse-cdn.com/v4/letter/p/76d3ee/32.png) [@Paul\_Brannan](https://rubytalk.org/u/Paul_Brannan)\
**Post date:** [21 November 2002 21:42 UTC](https://rubytalk.org/t/multiple-constructors/3022/16 "2002-11-21T21:42:14Z")

</div>

Oh, good point.

This discussion inspired me to go rewrite some code I wrote the day I  
started learning Ruby. I decided to use instance\_eval to call the  
private initialize\_with\_xxx methods. Do you think that’s a reasonable  
alternative?

Paul

> **···**
>
> On Fri, Nov 22, 2002 at 05:18:14AM +0900, [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> 
> > I think the privacy is gate-kept separately by each object’s singleton  
> > class:

---

<div class="post-metadata">

**Author:** ![Martin\_DeMello1](https://avatars.discourse-cdn.com/v4/letter/m/3be4f8/32.png) [@Martin\_DeMello1](https://rubytalk.org/u/Martin_DeMello1)\
**Post date:** [22 November 2002 20:38 UTC](https://rubytalk.org/t/multiple-constructors/3022/17 "2002-11-22T20:38:44Z")

</div>

Well, in general, I think that if you have to select on type at some  
point in your code, it’s neater to have it bundled into the constructor.  
But now that you mention it, a better way to code the above might be  
to have your class extend each object type it accepts with a method to  
return the appropriately initialised instance, and avoid explicit type  
dispatching altogether. Something like

my\_objs = input\_objs.map {|i| i.newmyclass}

as you suggested I do with the generators.

martin

> **···**
>
> Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com) wrote:
> 
> > On Fri, 2002-11-22 at 10:17, Martin DeMello wrote:
> > 
> > > Nat Pryce [nat.pryce@b13media.com](mailto:nat.pryce@b13media.com) wrote:
> > > 
> > > > If you want to have different constructors for different argument types,  
> > > > define different constructors on your class. Your code will then be  
> > > > both more flexible and more readable. E.g. If you had a class that  
> > > > could be created with either a String and a Regexp you would define  
> > > > constructors new\_from\_string(a\_string) and new\_from\_regexp(a\_regexp).
> > > 
> > > This won’t let me do something like
> > > 
> > > my\_objs = input\_objs.map {|i| MyClass.new(i)}
> > 
> > That’s true but how often does one put arbitrary objects into a  
> > collection and then use them to create something? And if you do, you  
> > can easily put different types of objects into different collections.

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [21 November 2002 22:42 UTC](https://rubytalk.org/t/multiple-constructors/3022/18 "2002-11-21T22:42:49Z")

</div>

Hi –

> **···**
>
> On Fri, 22 Nov 2002, Paul Brannan wrote:
> 
> > On Fri, Nov 22, 2002 at 05:18:14AM +0900, [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> > 
> > > I think the privacy is gate-kept separately by each object’s singleton  
> > > class:
> > 
> > Oh, good point.
> > 
> > This discussion inspired me to go rewrite some code I wrote the day I  
> > started learning Ruby. I decided to use instance\_eval to call the  
> > private initialize\_with\_xxx methods. Do you think that’s a reasonable  
> > alternative?
> 
> It does seem more streamlined.
> 
> David
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)
