Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Ruby > Supplying multiple procs to initialization

Reply
Thread Tools

Supplying multiple procs to initialization

 
 
Phrogz
Guest
Posts: n/a
 
      11-25-2007
One of my libraries previously required code like this:

# Convert markup to HTML, doing something
# useless with links and commands
owl = OWLScribble.new( markup )
owl.wiki_links.each{ |link|
# do something useful to the link
}
owl.wiki_commands.each{ |command|
# do something useful with the command
}
html = owl.to_html

I have changed it so that the user can instead describe how to handle
links and commands in general, so that during initialization the
library doesn't waste time or code lines doing something useless:

owl = OWLScribble.new( markup ) do |owl|
owl.handle_wiki_link do |tag, page, link_text|
# do something useful to the link
end
owl.handle_wiki_command do |tag, command, params|
# do something useful to the command
end
end
puts owl.to_html

The syntax you see above is my current favorite choice for specifying
these two procs. Alternatives that I have rejected as less elegant:

# Deferred initialization
owl = OWLScribble.new( markup )
owl.handle_wiki_link{ ... }
owl.handle_wiki_command{ ... }
owl.run
puts owl.to_html

# proc params
do_link = proc{ ... }
do_command = proc{ ... }
owl = OWLScribble.new(
markup,
:handle_wiki_link=>do_link,
:handle_wiki_command=>do_command
)
puts owl.to_html

Can anyone suggest a more elegant way of supplying multiple processing
procs that should be used during initialization, on a per-instance
basis?
 
Reply With Quote
 
 
 
 
Robert Klemme
Guest
Posts: n/a
 
      11-25-2007
On 25.11.2007 19:36, Phrogz wrote:
> One of my libraries previously required code like this:
>
> # Convert markup to HTML, doing something
> # useless with links and commands
> owl = OWLScribble.new( markup )
> owl.wiki_links.each{ |link|
> # do something useful to the link
> }
> owl.wiki_commands.each{ |command|
> # do something useful with the command
> }
> html = owl.to_html
>
> I have changed it so that the user can instead describe how to handle
> links and commands in general, so that during initialization the
> library doesn't waste time or code lines doing something useless:
>
> owl = OWLScribble.new( markup ) do |owl|
> owl.handle_wiki_link do |tag, page, link_text|
> # do something useful to the link
> end
> owl.handle_wiki_command do |tag, command, params|
> # do something useful to the command
> end
> end
> puts owl.to_html
>
> The syntax you see above is my current favorite choice for specifying
> these two procs. Alternatives that I have rejected as less elegant:
>
> # Deferred initialization
> owl = OWLScribble.new( markup )
> owl.handle_wiki_link{ ... }
> owl.handle_wiki_command{ ... }
> owl.run
> puts owl.to_html
>
> # proc params
> do_link = proc{ ... }
> do_command = proc{ ... }
> owl = OWLScribble.new(
> markup,
> :handle_wiki_link=>do_link,
> :handle_wiki_command=>do_command
> )
> puts owl.to_html
>
> Can anyone suggest a more elegant way of supplying multiple processing
> procs that should be used during initialization, on a per-instance
> basis?


Why not just

owl = OWLScribble.new(
markup,
:handle_wiki_link => lambda {...},
:handle_wiki_command => lambda {...}
)

Kind regards

robert
 
Reply With Quote
 
 
 
 
Phrogz
Guest
Posts: n/a
 
      11-25-2007
On Nov 25, 12:42 pm, Robert Klemme <(E-Mail Removed)> wrote:
> On 25.11.2007 19:36, Phrogz wrote:
>
>
>
> > One of my libraries previously required code like this:

>
> > # Convert markup to HTML, doing something
> > # useless with links and commands
> > owl = OWLScribble.new( markup )
> > owl.wiki_links.each{ |link|
> > # do something useful to the link
> > }
> > owl.wiki_commands.each{ |command|
> > # do something useful with the command
> > }
> > html = owl.to_html

>
> > I have changed it so that the user can instead describe how to handle
> > links and commands in general, so that during initialization the
> > library doesn't waste time or code lines doing something useless:

>
> > owl = OWLScribble.new( markup ) do |owl|
> > owl.handle_wiki_link do |tag, page, link_text|
> > # do something useful to the link
> > end
> > owl.handle_wiki_command do |tag, command, params|
> > # do something useful to the command
> > end
> > end
> > puts owl.to_html

>
> > The syntax you see above is my current favorite choice for specifying
> > these two procs. Alternatives that I have rejected as less elegant:

>
> > # Deferred initialization
> > owl = OWLScribble.new( markup )
> > owl.handle_wiki_link{ ... }
> > owl.handle_wiki_command{ ... }
> > owl.run
> > puts owl.to_html

>
> > # proc params
> > do_link = proc{ ... }
> > do_command = proc{ ... }
> > owl = OWLScribble.new(
> > markup,
> > :handle_wiki_link=>do_link,
> > :handle_wiki_command=>do_command
> > )
> > puts owl.to_html

>
> > Can anyone suggest a more elegant way of supplying multiple processing
> > procs that should be used during initialization, on a per-instance
> > basis?

>
> Why not just
>
> owl = OWLScribble.new(
> markup,
> :handle_wiki_link => lambda {...},
> :handle_wiki_command => lambda {...}
> )


I personally lump that in with the other option that happens to create
the procs outside the function call. As you show it, with a single
ellipsis for each proc's content, it feels clean. I expect
handle_wiki_link to be on the order of 20 lines, and
handle_wiki_command to take 50-100 lines. That seems excessive to
inline into a method call.
 
Reply With Quote
 
Robert Klemme
Guest
Posts: n/a
 
      11-26-2007
2007/11/25, Phrogz <(E-Mail Removed)>:
> On Nov 25, 12:42 pm, Robert Klemme <(E-Mail Removed)> wrote:
> > On 25.11.2007 19:36, Phrogz wrote:
> >
> >
> >
> > > One of my libraries previously required code like this:

> >
> > > # Convert markup to HTML, doing something
> > > # useless with links and commands
> > > owl = OWLScribble.new( markup )
> > > owl.wiki_links.each{ |link|
> > > # do something useful to the link
> > > }
> > > owl.wiki_commands.each{ |command|
> > > # do something useful with the command
> > > }
> > > html = owl.to_html

> >
> > > I have changed it so that the user can instead describe how to handle
> > > links and commands in general, so that during initialization the
> > > library doesn't waste time or code lines doing something useless:

> >
> > > owl = OWLScribble.new( markup ) do |owl|
> > > owl.handle_wiki_link do |tag, page, link_text|
> > > # do something useful to the link
> > > end
> > > owl.handle_wiki_command do |tag, command, params|
> > > # do something useful to the command
> > > end
> > > end
> > > puts owl.to_html

> >
> > > The syntax you see above is my current favorite choice for specifying
> > > these two procs. Alternatives that I have rejected as less elegant:

> >
> > > # Deferred initialization
> > > owl = OWLScribble.new( markup )
> > > owl.handle_wiki_link{ ... }
> > > owl.handle_wiki_command{ ... }
> > > owl.run
> > > puts owl.to_html

> >
> > > # proc params
> > > do_link = proc{ ... }
> > > do_command = proc{ ... }
> > > owl = OWLScribble.new(
> > > markup,
> > > :handle_wiki_link=>do_link,
> > > :handle_wiki_command=>do_command
> > > )
> > > puts owl.to_html

> >
> > > Can anyone suggest a more elegant way of supplying multiple processing
> > > procs that should be used during initialization, on a per-instance
> > > basis?

> >
> > Why not just
> >
> > owl = OWLScribble.new(
> > markup,
> > :handle_wiki_link => lambda {...},
> > :handle_wiki_command => lambda {...}
> > )

>
> I personally lump that in with the other option that happens to create
> the procs outside the function call. As you show it, with a single
> ellipsis for each proc's content, it feels clean. I expect
> handle_wiki_link to be on the order of 20 lines, and
> handle_wiki_command to take 50-100 lines. That seems excessive to
> inline into a method call.


Good point. I did not know that they would become that complex. In
that case it's a reasonable option to define them elsewhere. But in
that case I'd probably even define them as constants - unless you need
the local binding.

Kind regards

robert

--
use.inject do |as, often| as.you_can - without end

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
supplying runtime parameter sp XML 3 01-27-2006 08:42 AM
Problem writing cookie when supplying Path property =?Utf-8?B?U3llZCBHaGF5YXM=?= ASP .Net 2 05-06-2005 03:55 PM
Multiple stored procs for dataadapter =?Utf-8?B?QUtKVFI=?= ASP .Net 1 12-21-2004 11:58 AM
procs/blocks - blocks with procs, blocks with blocks? matt Ruby 1 08-06-2004 01:33 AM
Making function private/ not supplying declaration in header file Daniel Nichols C Programming 6 06-15-2004 05:03 AM



Advertisments