Merge pull request #419 from ReactiveBayes/rename_deferred_msg

Fix typo in DeferredMessage

docs/src/lib/message.md

@@ -83,8 +83,8 @@ ReactiveMP.messages_prod_fn
 ```
 
 
-### [Deffered messages](@id lib-messages-deffered)
+### [Deferred messages](@id lib-messages-deferred)
 
 ```@docs 
-ReactiveMP.DefferedMessage
+ReactiveMP.DeferredMessage
 ```

src/message.jl

@@ -1,4 +1,4 @@
-export AbstractMessage, Message, DefferedMessage
+export AbstractMessage, Message, DeferredMessage
 export getdata, is_clamped, is_initial, as_message
 
 using Distributions
@@ -192,22 +192,22 @@ MacroHelpers.@proxy_methods Message getdata [
 
 Distributions.mean(fn::Function, message::Message) = mean(fn, getdata(message))
 
-## Deffered Message
+## Deferred Message
 
 """
 A special type of a message, for which the actual message is not computed immediately, but is computed later on demand (potentially never).
 To compute and get the actual message, one needs to call the `as_message` method.
 """
-mutable struct DefferedMessage{R, S, F} <: AbstractMessage
+mutable struct DeferredMessage{R, S, F} <: AbstractMessage
     const messages  :: R
     const marginals :: S
     const mappingFn :: F
     cache           :: Union{Nothing, Message}
 end
 
-DefferedMessage(messages::R, marginals::S, mappingFn::F) where {R, S, F} = DefferedMessage(messages, marginals, mappingFn, nothing)
+DeferredMessage(messages::R, marginals::S, mappingFn::F) where {R, S, F} = DeferredMessage(messages, marginals, mappingFn, nothing)
 
-function Base.show(io::IO, message::DefferedMessage)
+function Base.show(io::IO, message::DeferredMessage)
     cache = getcache(message)
     if isnothing(cache)
         print(io, "DeferredMessage([ use `as_message` to compute the message ])")
@@ -216,22 +216,22 @@ function Base.show(io::IO, message::DefferedMessage)
     end
 end
 
-getcache(message::DefferedMessage) = message.cache
-setcache!(message::DefferedMessage, cache::Message) = message.cache = cache
+getcache(message::DeferredMessage) = message.cache
+setcache!(message::DeferredMessage, cache::Message) = message.cache = cache
 
-function as_message(message::DefferedMessage)::Message
+function as_message(message::DeferredMessage)::Message
     return as_message(message, getcache(message))
 end
 
-function as_message(message::DefferedMessage, cache::Message)::Message
+function as_message(message::DeferredMessage, cache::Message)::Message
     return cache
 end
 
-function as_message(message::DefferedMessage, cache::Nothing)::Message
+function as_message(message::DeferredMessage, cache::Nothing)::Message
     return as_message(message, cache, getrecent(message.messages), getrecent(message.marginals))
 end
 
-function as_message(message::DefferedMessage, cache::Nothing, messages, marginals)::Message
+function as_message(message::DeferredMessage, cache::Nothing, messages, marginals)::Message
     computed = message.mappingFn(messages, marginals)
     setcache!(message, computed)
     return computed

src/nodes/dependencies.jl

@@ -33,7 +33,7 @@ function activate!(dependencies::FunctionalDependencies, factornode, options)
                 vmessageout = combineLatest((messages, marginals), PushNew())
 
                 mapping = let messagemap = MessageMapping(fform, vtag, vconstraint, messagestag, marginalstag, meta, addons, node_if_required(fform, factornode), rulefallback)
-                    (dependencies) -> DefferedMessage(dependencies[1], dependencies[2], messagemap)
+                    (dependencies) -> DeferredMessage(dependencies[1], dependencies[2], messagemap)
                 end
 
                 vmessageout = vmessageout |> map(AbstractMessage, mapping)

src/nodes/predefined/delta/layouts/cvi.jl

@@ -44,7 +44,7 @@ function deltafn_apply_layout(::CVIApproximationDeltaFnRuleLayout, ::Val{:m_out}
         vmessageout = combineLatest((msgs_observable, marginals_observable), PushNew())
 
         mapping = let messagemap = MessageMapping(fform, vtag, vconstraint, msgs_names, marginal_names, meta, addons, factornode, rulefallback)
-            (dependencies) -> DefferedMessage(dependencies[1], dependencies[2], messagemap)
+            (dependencies) -> DeferredMessage(dependencies[1], dependencies[2], messagemap)
         end
 
         vmessageout = with_statics(factornode, vmessageout)

src/nodes/predefined/delta/layouts/default.jl

@@ -86,7 +86,7 @@ function deltafn_apply_layout(::DeltaFnDefaultRuleLayout, ::Val{:m_out}, factorn
         vmessageout = combineLatest((msgs_observable, marginals_observable), PushNew())
 
         mapping = let messagemap = MessageMapping(fform, vtag, vconstraint, msgs_names, marginal_names, meta, addons, factornode, rulefallback)
-            (dependencies) -> DefferedMessage(dependencies[1], dependencies[2], messagemap)
+            (dependencies) -> DeferredMessage(dependencies[1], dependencies[2], messagemap)
         end
 
         vmessageout = with_statics(factornode, vmessageout)
@@ -116,7 +116,7 @@ function deltafn_apply_layout(::DeltaFnDefaultRuleLayout, ::Val{:m_in}, factorno
         vmessageout = combineLatest((msgs_observable, marginals_observable), PushNew())
 
         mapping = let messagemap = MessageMapping(fform, vtag, vconstraint, msgs_names, marginal_names, meta, addons, factornode, rulefallback)
-            (dependencies) -> DefferedMessage(dependencies[1], dependencies[2], messagemap)
+            (dependencies) -> DeferredMessage(dependencies[1], dependencies[2], messagemap)
         end
 
         vmessageout = with_statics(factornode, vmessageout)
@@ -184,7 +184,7 @@ function deltafn_apply_layout(::DeltaFnDefaultKnownInverseRuleLayout, ::Val{:m_i
         vmessageout = combineLatest((msgs_observable, marginals_observable), PushNew())
 
         mapping = let messagemap = MessageMapping(fform, vtag, vconstraint, msgs_names, marginal_names, meta, addons, factornode, rulefallback)
-            (dependencies) -> DefferedMessage(dependencies[1], dependencies[2], messagemap)
+            (dependencies) -> DeferredMessage(dependencies[1], dependencies[2], messagemap)
         end
 
         vmessageout = with_statics(factornode, vmessageout)

test/message_tests.jl

@@ -160,15 +160,15 @@
     end
 end
 
-@testitem "Deffered message" begin
+@testitem "Deferred message" begin
     using Rocket
-    import ReactiveMP: DefferedMessage, as_message, getdata
+    import ReactiveMP: DeferredMessage, as_message, getdata
 
     for a in rand(3), b in rand(3)
         messages_stream = RecentSubject(Float64)
         marginals_stream = RecentSubject(Float64)
 
-        dmessage = DefferedMessage(messages_stream, marginals_stream, (a, b) -> Message(a + b, false, false, nothing))
+        dmessage = DeferredMessage(messages_stream, marginals_stream, (a, b) -> Message(a + b, false, false, nothing))
 
         # The data cannot be computed since no values were provided yet
         @test_throws MethodError as_message(dmessage)