В прошлой главе мы подключили System.Reactive к Godot и, претерпев соответствующие муки, почти добрались до изобретения реактивных свойств. Сегодня мы их наконец-то изобретём и за несколько шагов доведём до ума.

Я говорил об этом в прошлом заключении и повторю сейчас: всё, что я предлагаю, не является единственно верным решением. Возможны альтернативы, которые я здесь не затрагиваю. В первой главе их можно было спокойно игнорировать, потому что их объём совпадал со свободным пространством в надетом сапоге. Но к концу этой главы мы будем держать в руках ложку, которой надо выскоблить самые ценные куски из бабушкиного зур бэлиша. В такой ситуации стоит хорошо понимать, чего именно мы хотим. Ну или хотя бы чего хочу я.

Когда-то я начинал экспериментировать с DSL лишь потому, что мне нравился сам процесс построения нового языка. Однако со временем обнаружилось, что DSL — это отличный способ снять часть груза ответственности с пользователей и возложить его на плечи автора DSL, то есть меня. За это мне неоднократно припоминали бас-фактор. Но так получилось, что большую часть времени мне надо было работать ещё и с людьми, чьи возможности были значительно ниже моих. Они не были тупыми (иначе бы я их не привлекал), но они чисто исторически не могли быть подготовлены на моём уровне. Обилие DSL в таком сценарии позволяло успешно для обеих сторон грузить отважных дилетантов задачами, которыми, по формальным признакам, их грузить было нельзя.

Сейчас развитие технологий и общая экономическая ситуация в сочетании с моей любовью к DSL внезапно вылились в забавный выверт. До подведения его итогов мне ещё далеко, поэтому я оставлю этот «анонс» в скомканном виде в расчёте на то, что он зацепит лишь человека со сходным предчувствием. Если же описать мои хотелки без этого крайне мутного «выверта», то они заключаются в стремлении избавить рядового пользователя от рисков и беспокойства сделать что-либо не так.

Устройство проекта

Здесь всё устроено по той же схеме, что и в прошлый раз.

Почти все примеры можно найти в этом проекте, собранный из него .exe лежит в архиве здесь. Это проект из прошлой главы, который был скопирован, переименован, сохранён отдельно и дополнен свежими примерами. Их снова 9 штук (включая неправильные), и они расположены в хронологическом порядке. Нумерация в статье и в проекте совпадает.

Всего одна.tscn-сцена (не считая EntryPoint.tscn), которая конфигурируется через аргументы при запуске. Новый профиль Sample 2-All загрузит в неё Chapter2/AllSamples.fs. Этот же профиль настроен для запуска из редактора или .exe.

Общий профиль для всех примеров из обеих глав я не заводил. Можете собрать его самостоятельно по образу и подобию.

Тонна типов и их расширений из первой главы была оставлена в местах своего определения. То, что было признано полезным, было продублировано в Chapter2/Utils.fs и улучшено без упоминания в тексте.

За 9 шагов мы создадим 5 версий реактивных свойств. Они неустранимо конфликтуют между собой, поэтому в этот раз переносить их из примера в пример придётся руками.

There is only Var

1. Var

Мы закончили на том, что 'a Observable.CachePrevious очень сильно похож на «реактивное свойство». Здесь я кавычу этот термин, потому что не смог убедить себя в том, что он действительно существует. Однако все мои предыдущие собеседники хорошо понимали, что это некая ячейка данных, которая умеет сообщать о своих изменениях вовне.

Правда, есть серьёзные расхождения по поводу того, кто именно должен сообщать об изменениях. Владелец свойства или оно само? В MVVM-фреймворках это почти всегда владелец, то есть ViewModel (INotifyPropertyChanged) или DependencyObject.

Однако в экосистеме F# всё существует и ощущается несколько иначе, поэтому под реактивным свойством я буду подразумевать самостоятельный автономный объект, которым можно кидаться отдельно от его владельца. Людям из геймдева такая абстракция может напоминать Component из ECS. Hopac-оводы знакомы с аналогами этой штуки под именами 'a Stream.Var или 'a Stream.Property, и именно эти типы можно считать прообразом того, что обсуждается в этой главе. Пользователи System.Reactive первое время могут ассоциировать эту штуку с 'a SubjectBehavior, которым мы воспользуемся в первой версии, но очень быстро вынуждены будем отказаться от неё в пользу кастомной структуры.

Первая попытка начинается так:

module Observable =
    type 'a Var =
        inherit System.IObservable<'a>
        abstract Value : 'a

    type 'a MVar =
        inherit Var<'a>
        abstract Value : 'a with set

    module Var =
        let paranoid (var : _ Var) = {
            new Var<'a> with
                member _.Value = var.Value
            interface System.IObservable<'a> with
                override _.Subscribe observer =
                    var.Subscribe observer
        }

'a Observable.Var — это реактивное свойство, которое доступно только для чтения. Оно наблюдаемо и его содержимое доступно для извлечения в любой момент. По факту сейчас эта штука идентична несуществующему 'a ReadonlySubjectBehavior.

'a Observable.MVar — это реактивное свойство, которое доступно как для чтения, так и для записи. Сейчас оно выступает лишь фасадом над 'a SubjectBehavior. Но в отличие от него MVar не поддерживает 'a System.IObserver, так что держатель экземпляра может только кидаться в него новыми значениями (OnNext). Опции OnCompleted и OnError недоступны.

Var — это очень тонкий и безобидный клиент, поэтому Observable.Var.paranoid «сепарировался» в модуле. А вот MVar всё-таки надо уметь останавливать, что статистически проще всего делать сразу из родительского CompositeDisposable (или аналога):

type CompositeDisposable with
    member this.MVar value =
        let output = this.Behavior value
        { new Observable.MVar<'a> with
            override _.Value
                with get () = output.Value
                and set value = output.OnNext value
            override _.Subscribe observer =
                output.Subscribe observer
        }

Там же размещаем маппинги и прочие хелперы:

type CompositeDisposable with
    member this.ToVar value observable =
        let mvar = this.MVar value
        observable
        |> this.Subscribe ^ fun p -> mvar.Value <- p
        Observable.Var.paranoid mvar

    member this.MapVar mapping var =
        var
        |> Observable.tail
        |> Observable.map mapping
        |> this.ToVar ^ mapping (var : _ Observable.Var).Value

Модель на таких примитивах может определяться так:

let deltaSource = Event<_>()
let model = 
    let progress = disposables.MVar initialProgress
    deltaSource.Publish
    |> disposables.Subscribe ^ fun p ->
        progress.Value <- progress.Value + p

    let distanceToB =
        progress
        |> disposables.MapVar patrolTrack.DistanceToB
    {|
        Progress = progress
        DistanceToB = distanceToB
        Direction =
            distanceToB
            |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A
            |> Observable.distinctUntilChanged
            |> disposables.ToVar A2B
        Frame =
            progress
            |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p)
            |> Observable.distinctUntilChanged
            |> disposables.ToVar ^ props.Lines.Walk.Circledf 0f
        Position =
            distanceToB
            |> disposables.MapVar patrolTrack.PositionOf
    |}

Она мало чем отличается от версии из конца предыдущей главы, но теперь мы имеем доступ к сеттеру Model.Progress.Value. При желании его можно запараноить, но, пока он открыт, мы можем легко сбросить модель в стартовое (или любое другое) состояние:

for unit in [mason;goodspeed] do
    asNode ^ FG.Button(
        Text = sprintf "Перезапустить %sа" unit.Props.Name
        , SizeFlagsHorizontal = Control.SizeFlags.ShrinkCenter
        , FocusMode = Control.FocusModeEnum.None
        , Pressed'Handler = disposables.HandleSignal ^ fun _ () ->
            unit.Model.Progress.Value <- 0f
        , Icon = unit.Props.Icon
    )

Реактивные свойства как самостоятельные объекты — вещь не новая. Однако подавляющее большинство гайдов по RX предлагает скрывать их присутствие от стороннего наблюдателя. Дескать, мы не должны травмировать неподготовленного пользователя и так далее. Довод сам по себе слабый, а в случае инди-геймдева вообще абсурдный.

Ещё один аргумент в пользу сокрытия — возможность несанкционированно вызывать что-то ещё, кроме SetValue за пределами владельца. Торчащий наружу SubjectBehavior можно освободить или завершить, что вряд ли хорошо скажется на здоровье модели. Поэтому мы скрыли MVar.Dispose в недрах фабрики, причём сделали это радикально, хоть и не очень экономично (CompositeDisposable — временами оверкилл). Но кому действительно будет жать перфоманс, перепишет самостоятельно, как посчитает нужным.

В общем, мы не будем скрывать эти объекты, потому что Var / MVar — это автономная самодостаточная штука, которую можно использовать и таскать отдельно от владельца, шарить между несколькими владельцами или создавать в произвольной части кода, где никаких владельцев нет. Это очень серьёзное преимущество, которое хорошо откликается на склонность F# и Godot к композиции.

2. ToVarUnsafe

Метод disposables.ToVar требует от нас передачи инициирующего состояния. В случае Frame и Direction я загрузил значение от балды, потому что знал, что самый первый IObservable в пайпе — это Var (или SubjectBehavior), и он всё равно инициирует отправку в момент подписки, так что левое значение будет моментально перебито правильным. В общем случае мы могли бы воспользоваться Unchecked.defaultof, но Var в процессе эволюции кода может быть незаметно подменён обычным IObservable, и тогда наш null таки пролезет в незащищённый домен. Каким геморроем это может обернуться, я уже рассказывал.

В идеале, нам надо поймать первое сообщение, которое приходит в момент знакомства, создать из него MVar, после чего абсорбировать этим MVar весь последующий поток сообщений. При этом мы обязаны упасть, если приветственное сообщение не пришло:

type CompositeDisposable with
    member this.ToVarUnsafe observable =
        let mutable state = None
        let get () =
            state
            |> Option.defaultWith ^ fun () ->
                invalidOp "IObservable was empty!"
        observable
        |> Observable.subscribeObserver { 
            new System.IObserver<'a> with
                override _.OnNext value =
                    match state with
                    | None ->
                        let local = this.CreateChild()
                        state <- Some {|
                            MVar = local.MVar value
                            Dispose = local.Dispose
                        |}
                    | Some state ->
                        state.MVar.Value <- value
                override _.OnCompleted () =
                    get().Dispose()
                override _.OnError exn =
                    get().Dispose()
        }
        |> this.Add
        get().MVar
        |> Observable.Var.paranoid

Код сложнее, чем мог бы быть при написании { new Observable.MVar<'a> ... } с нуля, но нам надо пройти через CompositeDisposable.MVar, чтобы потом не дублировать изменения в «конструкторе» по всем хелперам. С этим методом модель можно будет описать так:

let model = 
    let progress = disposables.MVar initialProgress
    deltaSource.Publish
    |> disposables.Subscribe ^ fun p ->
        progress.Value <- progress.Value + p

    let distanceToB =
        progress
        |> disposables.MapVar patrolTrack.DistanceToB
    {|
        Progress = progress
        DistanceToB = distanceToB
        Direction =
            distanceToB
            |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A
            |> Observable.distinctUntilChanged
            |> disposables.ToVarUnsafe
        Frame =
            progress
            |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p)
            |> Observable.distinctUntilChanged
            |> disposables.ToVarUnsafe
        Position =
            distanceToB
            |> disposables.MapVar patrolTrack.PositionOf
    |}

Визуальных изменений этот код не даёт, однако на большом проекте ToVarUnsafe создает до половины всех Var.

Судьба Value

3. Value после смерти

Разобравшись с «началом» Var, впору подумать о его «конце». Например, что происходит с Value после условного MVar.Dispose? Можем ли мы подглядеть финальные значения модели после смерти юнита, чтобы заспавнить на его месте копию-духа?

let killUnit (unit : Unit) =
    let unit = unit.Core
    unit.Disposables.Dispose()
    try unit.Model.Direction.Value.Destination
        |> sprintf "%s убит в %0.3f, когда шёл в точку %s." unit.Props.Name unit.Model.Progress.Value
        |> messages.Add Colors.Green
        FG.Node2D(
            Disposables = disposables
            , Parent = center
            , Position = unit.Model.Position.Value
            , Modulate = Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f
        ).Add'Children [
            UnitLabel.text unit.Props.LastWords

            FG.Sprite2D(
                Spritesheet = unit.Props.Styles.Outlined
                , TextureFilter = CanvasItem.TextureFilterEnum.Nearest
                , Scale = Vector2.One * scale
                , Frame = unit.Model.Frame.Value
                , FlipH = unit.Model.Direction.Value.IsB2A
            )
        ]
        |> center.AddChild
    with
    | ex ->
        sprintf "Ошибка при чтении из %sа:\n%s" unit.Props.Name ex.Message
        |> messages.Add Colors.Red

Я считаю, что можем, но конструкция try ... with намекает, что нет. Мёртвый SubjectBehavior при обращении к Value бросает исключение.

Я догадываюсь, что такое поведение связано с необходимостью вовремя отпустить объект в Value. Но если мне понадобится от него гарантированно избавиться, я подберу другой инструмент. А для стандартного сценария ожидаю, что Value у меня никто не отберёт.

4. Возвращаем Value

Subject.behavior меняем на Subject.broadcast. Value сохраняем сами и потом грузим его в каждого нового подписчика:

type CompositeDisposable with
    member this.MVar value =
        let mutable value = value
        let output = this.Broadcast()

        { new Observable.MVar<'a> with
            override _.Value
                with get () = value
                and set newValue =
                    if not output.IsDisposed then
                        value <- newValue
                        output.Trigger newValue
            override _.Subscribe observer =
                observer.Trigger value
                output.Subscribe observer
        }

Всё работает, юниты умирают, духи жалуются.

Тут можно придраться к тому, что мы просто игнорируем попытки установить новое значение в Value, а могли бы бросаться исключениями. Но по моим наблюдениям, в играх этого лучше избегать. Количество перекрёстных связей огромно, и, в силу устройства движка, не всякое сообщение о смерти моментально доходит до адресата. Чаще всего загибающиеся акторы успеют один раз пнуть мёртвые Value перед тем, как сами уйдут на покой. Беспокоить нас и уж тем более игрока по такому пустяку нерационально.

Это также справедливо для падающих Dispose. Если я что-то высвободил, оно должно исчезнуть молча, однако даже в этом проекте нашлась пара мест, где мёртвые решили постучаться обратно. Я вынужденно воспользовался DisposeSafe и подозреваю, что это будет причиной, по которой я таки заменю CompositeDisposable в будущих статьях на Хабре.

Для тех редких случаев, где нам действительно необходимо падение, можно бахнуть ещё один хелпер вида:

type CompositeDisposable with
    member this.MVarBiddy value =
        let mutable value = value
        let output = this.Broadcast()

        { new Observable.MVar<'a> with
            override _.Value
                with get () = value
                and set newValue =
                    if not output.IsDisposed then
                        value <- newValue
                        output.Trigger newValue
                    else
                        invalidOp "MVar was disposed."
            override _.Subscribe observer =
                observer.Trigger value
                output.Subscribe observer
        }

Хотя с учётом столь склочного поведения, быть может, будет лучше создать отдельный тип, чтобы его можно было идентифицировать на расстоянии.

Freezable

5. Подписка после смерти

Предположим, что визуализация нашего юнита лежит в отдельной функции:

and makeView disposables props model =
    FG.Node2D(
        Disposables = disposables
        , Parent = center
        , Position'Bind = disposables.Bind model.Position
    ).Add'Children [
        FG.Sprite2D(
            Name = "Sprite"
            , Spritesheet = props.Styles.Outlined
            , TextureFilter = CanvasItem.TextureFilterEnum.Nearest
            , Scale = Vector2.One * scale
            , Frame'Bind = disposables.Bind model.Frame
            , FlipH'Bind = disposables.BindMap model.Direction ^ fun p -> p.IsB2A
        )
    ]

Мы дёргаем её при создании юнита:

let view : Node2D = makeView disposables props model
GD.Implements._process(fun _ delta -> deltaSource.Trigger ^ float32 delta).Parent <- view
Unit {|
    Disposables = disposables
    Props = props
    Model = model
    View = view
|}

И хотим дёрнуть второй раз при создании призрака:

let view = makeView disposables unit.Props unit.Model
view.Modulate <- Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f
view.AddChild ^ UnitLabel.text unit.Props.LastWords

При спавне призрака unit.Disposables уже мёртв. Соответственно мертвы и все Var в модели. Но это не должно помешать нам создать ещё одну вьюху, на базе свежего CompositeDisposable, ведь информация с последними значениями всё ещё в модели. Так звучит в теории, однако на практике System.Reactive опять стреляет нам в ногу.

Попытка подписаться на мёртвый Subject тоже вызывает исключение:

try let view = makeView disposables unit.Props unit.Model
    view.Modulate <- Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f
    view.AddChild ^ UnitLabel.text unit.Props.LastWords
with ex ->
    messages.Add Colors.Red ^ sprintf "Ошибка при спавне призрака %s:\n%s" unit.Props.Name ex.Message

6. Заморозка

Соответственно, нам надо проверять состояние output до подписки и при его смерти никого не подписывать, а сообщать observer-у о том, что с изменениями покончено:

type CompositeDisposable with
    member this.MVar value =
        let mutable value = value
        let output = this.Broadcast()
                    
        { new Observable.MVar<'a> with
            override _.Value
                with get () = value
                and set newValue =
                    if not output.IsDisposed then
                        value <- newValue
                        output.Trigger newValue
            override this.Subscribe observer =
                observer.Trigger value
                if output.IsDisposed
                then
                    observer.OnCompleted ()
                    IDisposable.empty
                else
                    output.Subscribe observer
        }

Н-ное число статей назад мы обсуждали тип Freezable из мира XAML-фреймворков. Этот тип создан для объектов, которые изначально могут наблюдаемо изменяться, но после команды Freeze становятся фиксированным слепком данных. В лице MVar мы получили нечто близкое и поэтому столкнёмся со свойственной Freezable проблемой — зафриженный MVar может попасть в контекст, который захочет его поменять. Гарантированно избежать этого не получится, но риск здорово минимизируется профилактическими средствами.

От точечной паранойи:

let view : Node2D =
    {| model with Progress = Observable.Var.paranoid model.Progress |}
    |> makeView disposables props

До изоляции в духе CQRS:

let model, commands = 
    let progress = disposables.MVar initialProgress
    deltaSource.Publish
    |> disposables.Subscribe ^ fun p ->
        progress.Value <- progress.Value + p

    let distanceToB =
        progress
        |> disposables.MapVar patrolTrack.DistanceToB
    {|
        Progress = 
            // Запараноили.
            Observable.Var.paranoid progress
        DistanceToB = distanceToB
        Direction =
            distanceToB
            |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A
            |> Observable.distinctUntilChanged
            |> disposables.ToVarUnsafe
        Frame =
            progress
            |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p)
            |> Observable.distinctUntilChanged
            |> disposables.ToVarUnsafe
        Position =
            distanceToB
            |> disposables.MapVar patrolTrack.PositionOf
    |}
    , {|
        // Вынесли команды в отдельный узел.
        ResetProgress = fun () -> progress.Value <- 0f
    |}

OnFrozen

7. Ждём смерти

Когда у нас есть доступ к полю Disposables, мы можем докинуть в него экземпляр IDisposable, который известит нас о смерти юнита. Однако F# свойственна атомизация скоупов. Вполне возможно, что нам придётся реагировать на остановку юнита, когда у нас на руках только лишь несколько Var-ов. По идее мы можем получить его окольным путём через подписку на IObservable:

for unit in [mason;goodspeed] do
    let core = unit.Core        
    // ...
    let completed () = messages.Add Colors.Gray ^ sprintf "%s прекратил движение." core.Props.Name
    core.Model.Position
    |> Observable.subscribeObserver {
        new System.IObserver<_> with
            override this.OnNext _ = ()
            override this.OnError _ = completed ()
            override this.OnCompleted () = completed ()
    }
    |> disposables.Add

Но проверка показывает, что смерть disposables не триггерит IObserver. При детальном изучении обнаружится, что output.Dispose (из недр MVar) всего лишь молча убивает Subject. Я привык мыслить категориями Hopac, и на мой взгляд, output.Dispose перед освобождением вызывать OnCompleted.

Это поведение раздражает меня в System.Reactive больше всего, потому что оно для меня абсолютно контринтуитивно и, несмотря на это, чрезвычайно распространено по всей библиотеке. Весь модуль Observable заполнен функциями, которые могут остановить обработку и ничего никому об этом не сказать. Это местный канон, и у него даже есть кое-какое объяснение, которое я проигнорирую, потому что наличие оправдания не заставит меня сменить свой канон.

8. Сообщаем о смерти

В Hopac молчаливое прерывание Hopac.Stream технически тоже возможно, но встречается очень редко, и, как правило, я к этому заранее готов. От Var-ов я хочу того же. Если Var умер, то он должен известить об этом своих подписчиков, а не просто забыть о них.

В коде это достигается через прокси между broadcast-ом и CompositeDisposable:

type CompositeDisposable with
    member this.MVar value =
        let mutable value = value
        let output = Subject.broadcast
        this.Add ^ IDisposable.create ^ fun () ->
            output.OnCompleted()
            output.Dispose()
            
        { new Observable.MVar<'a> with
            member _.Value
                with get () = value
                and set newValue =
                    if not output.IsDisposed then
                        value <- newValue
                        output.Trigger newValue
            override _.Subscribe observer =
                observer.Trigger value
                if output.IsDisposed
                then
                    observer.OnCompleted ()
                    IDisposable.empty
                else
                    output.Subscribe observer
        }

Решение работает, но оно локально. Его хочется как-то распространить на весь проект:

type CompositeDisposable with
    member this.Broadcast () =
        let broadcast = Subject.broadcast
        this.Add ^ Disposable.create ^ fun () ->
            broadcast.OnCompleted()
            broadcast.Dispose()
        broadcast

Однако и в таком виде у нас сохраняется риск, что кто-то или что-то зевнёт и создаст экземпляр в обход хелпера. Поэтому в идеальном случае нам стоит вовсе отказаться от Subject.broadcast в основном теле проекта и создать вместо него ещё один примитив:

type CompositeDisposable with
    member this.Subject () = 
        let inner = Subject.broadcast
        this.Add ^ Disposable.create ^ fun () ->
            if not inner.IsDisposed then
                inner.OnCompleted()
                inner.Dispose()
        { new Subjects.ISubject<'a> with
            override _.OnCompleted () =
                if not inner.IsDisposed then
                    inner.OnCompleted()
            override _.OnError error =
                if not inner.IsDisposed then
                    inner.OnError error
            override _.OnNext value =
                if not inner.IsDisposed then
                    inner.OnNext value
            override _.Subscribe observer =
                if inner.IsDisposed then
                    observer.OnCompleted()
                    Disposable.empty
                else
                    inner.Subscribe observer
        }

Попутно в него можно запихнуть фикс для вызовов после смерти.

Свойства

9. Property

Вместо очередной версии MVar заведём ещё один примитив:

module Observable =
    type 'a Property when 'a : equality =
        inherit Observable.Var<'a>

    type 'a MProperty when 'a : equality =
        inherit Observable.MVar<'a>
        inherit Property<'a>

    module Property =
        let paranoid (property : _ Property) = {
            new Property<'a> with
                override _.Value =
                    property.Value
                override _.Subscribe observer =
                    property.Subscribe observer
        }

type CompositeDisposable with
    member this.MProperty value =
        let mutable value = value
        let output = this.Subject ()
        { new Observable.MProperty<'a> with
            override _.Value
                with get () = value
                and set newValue =
                    if not this.IsDisposed
                        && value <> newValue
                    then
                        value <- newValue
                        output.Trigger newValue
            override _.Subscribe observer =
                observer.Trigger value
                output.Subscribe observer
        }

    member this.ToProperty value observable =
        let property = this.MProperty value
        observable
        |> this.Subscribe ^ fun p -> property.Value <- p
        Observable.Property.paranoid property

    // Вполне сознательно берём Var, а не Property.
    member this.MapProperty mapping var =
        var
        |> Observable.tail
        |> Observable.map mapping
        |> this.ToProperty ^ mapping (var : _ Observable.Var).Value

    member this.ToPropertyUnsafe observable =
        this.createFromFirst (fun p -> p.MProperty) (fun p value -> p.Value <- value) observable
        |> Observable.Property.paranoid

MProperty — это тот же MVar, но с защитой от дублей. То есть мы руками фильтруем поток подобно тому, как это происходит в distinctUntilChanged. При этом MProperty чуть строже, потому что требует от дженерика поддержки эквивалентности (в distinctUntilChanged он может быть любым).

В теории мы могли бы ожидать фильтрацию по дублям уже в MVar, что при использовании Unchecked.equals даже не ограничило бы тип дженерика. Но я предпочитаю держать такие фильтры отдельно, потому что проверка эквивалентности на некоторых типах ощутимо жрёт ресурсы. Нам нужен способ объяснить системе, что вот в этом месте не надо ничего сравнивать, потому что мы точно знаем, что пришедшее дерево хотя бы на 1%, но другое.

Промежуточное заключение

Var — это ядерный тип для выражения «реактивного свойства». Его определение завершено в этой главе, и дальше оно будет кочевать из статьи в статью без значимых изменений. По крайней мере до тех пор, пока мы не сменим Godot на что-то другое. Например, в мире WPF или Avalonia Var дополнится имплементацией INotifyPropertyChanged и, быть может, научится отправлять сообщение только в основном потоке.

Текущий Var очень примитивен и потому наиболее универсален среди всех аналогов, что я писал до этого или находил в других фреймворках. Поэтому его проще всех использовать в произвольном окружении. Однако упаковывать его в пакет я смысла не вижу. Кода мало и его легко кастомизировать под особенности конкретного ТВД.

Причём под «особенностями» я подразумеваю не новые фичи, а новые проблемы, связанные с тем, что кто-то что-то куда-то не сообщил или сообщил несвоевременно. О том, в какое адище может превратиться универсальное решение, можно судить по исходникам System.Reactive, Gjallarhorn или даже Hopac. Хотя в последнем случае картину сильно улучшает наличие Hopac.Core, в недра которого вынесено изрядное количество инфраструктурных корнер-кейсов.

В следующей главе мы поговорим о симуляции поведения юнитов на базе реактивных потоков. С синтаксическими особенностями, разумеется.


НЛО прилетело и оставило здесь промокод для читателей нашего блога: -15% на заказ нового VDS — HABRFIRSTVDS.

Положение об акции