CSC/ECE 517 Spring 2014/ch1 1w1l m: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
Line 59: Line 59:


In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.
In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.
<code>
count = 0
commands = []
(1..10).each do |i|
  commands << proc { count +=i }
end
puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>


== See Also ==
== See Also ==
== References ==
== References ==
<references />
<references />

Revision as of 01:37, 24 February 2014

Design Patterns Involving Closures

Background

Explanation of Closures

Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

def closure_builder(message="Default"):
    def closure():
        # Message is in-scope here
        print message
    return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure()  # Amazingly, prints "Default"
custom_closure()  # Amazingly, prints "Custom"

Examples

Decorators

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

#!/usr/bin/env python

def decorate(func):
    def decorated_func():
        print "About to call func"
        func()
        print "Back from calling func"
    return decorated_func

@decorate
def func_to_decorate():
    print "In func_to_decorate"

func_to_decorate()

[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func


Command Pattern

The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

count = 0

commands = [] (1..10).each do |i|

  commands << proc { count +=i }

end

puts "Count is initially #{count}" commands.each { |cmd| cmd.call } puts "Performed all commands. count is #{count}"

See Also

References

<references />