
В прошлой главе мы подключили 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.

Комментарии 0