## mark a section (Learn more)

module Actor eigenmodule def new case function(:loop).arity when 0 spawn { self::loop } when 1 spawn { self::loop(self::initial_state) } else spawn { self::loop(*self::initial_state) } end end end end # Actor.new produces a basic actor that endlessly loops, # but a new definition can always be assigned to the actor's eigenmodule def loop loop end # for convenience, default implementation returns empty hash def initial_state {} end def call(actor, name, *args) cast(actor, name, *args) receive reply end end end module Server eigenmodule set_callable? = true set_castable? = false callable_functions = Set.new castable_functions = Set.new def public callable castable end def private uncallable uncastable end def callable set_callable = true end def callable(name) callable_functions.add(name) end def uncallable set_callable = false end def castable set_castable = true end def castable(name) castable_functions.add(name) end def uncastable set_castable = false end def function_added(name, function) callable_functions.add(name) if set_callable? castable_functions.add(name) if set_castable? end end def loop(state) receive sender:call(name, *arguments) handle(state, :call, sender, name, arguments) end sender:cast(name, *arguments) handle(state, :cast, sender, name, arguments) end end end def handle(state, invocation_type, sender, name, arguments) fn = function(name) sender:error("No function named #{name}.") unless fn sender:error("Function #{name} not #{type}able") unless able?(name, invocation_type) case invocation_type when :call [result, state] = fn(state, *arguments) sender:reply(result) when :cast fn(state, *arguments) end loop(state) end def function(name) module.function(name) end def able?(name, invocation_type) case invocation_type when :call module.callable_functions.has?(name) when :cast module.castable_functions.has?(name) end end end

This paste will be private.