https://github.com/cotag/celluloid-promise

A promise/deferred implementation for Celluloid
https://github.com/cotag/celluloid-promise

Last synced: 9 months ago
JSON representation

A promise/deferred implementation for Celluloid

• Host: GitHub
• URL: https://github.com/cotag/celluloid-promise
• Owner: cotag
• License: mit
• Created: 2013-03-20T01:30:15.000Z (over 13 years ago)
• Default Branch: master
• Last Pushed: 2013-04-06T01:03:18.000Z (about 13 years ago)
• Last Synced: 2025-10-07T14:21:49.735Z (9 months ago)
• Language: Ruby
• Size: 133 KB
• Stars: 9
• Watchers: 3
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.textile
  • License: MIT-LICENSE

Awesome Lists containing this project

README

          
h1. Celluloid Promise

!https://secure.travis-ci.org/cotag/celluloid-promise.png(Build Status)!:https://travis-ci.org/cotag/celluloid-promise

A promise / deferred implementation for Celluloid inspired by "AngularJS":http://docs.angularjs.org/api/ng.$q / "Kris Kowal's Q.":https://github.com/kriskowal/q

From the perspective of dealing with error handling, deferred and promise apis are to asynchronous programing what try, catch and throw keywords are to synchronous programming.



require 'rubygems'

require 'celluloid-promise'


def asyncGreet(name)

	deferred = Celluloid::Q.defer

	

	Thread.new do

		sleep 10

		deferred.resolve("Hello #{name}")

	end

	

	deferred.promise

end

asyncGreet('Robin Hood').then(proc { |greeting|

	p "Success: #{greeting}"

}, proc { |reason|

	p "Failed: #{reason}"

})

asyncGreet('The Dude').then do |greeting|

	p "Jeff '#{greeting}' Lebowski"

end



As that example is pretty terrible here is a decent write up on the "uses for promises":http://blog.jcoglan.com/2013/03/30/callbacks-are-imperative-promises-are-functional-nodes-biggest-missed-opportunity/

h2. Start using it now

# Read the "Documentation":http://rubydoc.info/gems/celluloid-promise/Celluloid/Promise

# Then @gem install celluloid-promise@

h2. Use case

Celluloid provides a toolkit for building concurrent applications however coordinating complex chains of concurrent events can be difficult.

Celluloid-Promise provides the following:

* allows you to track a mash up of events across Actors

* guarantees serial execution of callbacks

* callback chains are spread across multiple threads

** So multiple promise chains can be executed concurrently

Of course passing blocks around is a fairly "dangerous exercise":https://github.com/celluloid/celluloid/wiki/Blocks#proposal-for-fixing-blocks, so do the following and you'll be safe

* use Celluloid-Promise for flow control

* resolve and reject promises with locally scoped variables

* call Actor methods to change state or instance variables