Behaviour / Behavior implementation

clinuxrulz 2020-05-11 05:32:16 UTC #1

Just chasing a summary of functions available to Behavior. Or what makes it different from Cell.

clinuxrulz 2020-05-11 06:46:29 UTC #2

I think I found my answer:

Just what is in here:

SodiumFRP/sodium/blob/master/dotnet/src/Sodium/CSharp/Sodium.Frp/BehaviorExtensionMethods.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace Sodium.Frp
{
    public static class BehaviorExtensionMethods
    {
        /// <summary>
        ///     Sample the current value of the behavior.
        /// </summary>
        /// <typeparam name="T">The type of the behavior.</typeparam>
        /// <param name="b">The behavior.</param>
        /// <returns>The current value of the behavior.</returns>
        /// <remarks>
        ///     <para>
        ///         This method may be used inside the functions passed to primitives that apply them to streams,
        ///         including <see cref="StreamExtensionMethods.Map{T, TResult}(Stream{T}, Func{T, TResult})" /> in which case it is equivalent to
        ///         snapshotting the behavior,
        ///         <see cref=" StreamExtensionMethods.Snapshot{T, T2, TResult}(Stream{T}, Behavior{T2}, Func{T, T2, TResult})" />,

This file has been truncated. show original

And stream should be able to snapshot against both Behavior and Cell.

clinuxrulz 2020-05-11 07:36:55 UTC #3

I strongly feel a Behavior should simply be implemented as a side effecting cached thunk, that clears its cache at the end of transaction. It would still allow all the API to be implemented for a Behavior.

And would allow us to do this: (Java)

Behavior<Long> timeMs = Behavior.fromEffect(System::currentTimeMillis);

Which feels very clean to me.

It also significantly reduces noise in the network as apposed to being implemented like a Cell with a few less methods.

Now Cell to Behavior, not a problem:

Behavior<String> ba = Behavior.fromEffect(ca::sample);

The rationale behind this implementation is:

To losslessly push a true continuous value requires infinite CPU. However it takes finite CPU to just poll/sample that continuous value every now and again.