[<DomainType>]
type Thing<'a> = { value : 'a; name : string }


[<AutoOpen>]
module Mutable =
    [<AbstractClass>]
    type MThing<'ma>() =
        abstract member value: 'ma
        abstract member name : IMod<string>

    type private MThingV<'a>(__initial : Thing<'a>) =
        inherit MThing<IMod<'a>>()

        let mutable __current = __initial

        let _value = ResetMod(__initial.value)
        let _name = ResetMod(__initial.name)

        override x.value = _value :> IMod<_>
        override x.name = _name :> IMod<_>

        member x.Update(v : Thing<'a>) =
            if not (System.Object.ReferenceEquals(__current, v)) then
                __current <- v
                _value.Update(v.value)
                _name.Update(v.name)

        interface IUpdatable<Thing<'a>> with
            member x.Update v = x.Update v

    type private MThingD<'a, 'ma>(__initial : Thing<'a>, init : 'a -> 'ma, update : 'ma * 'a -> unit) =
        inherit MThing<'ma>()

        let mutable __current = __initial

        let _value = init(__initial.value)
        let _name = ResetMod(__initial.name)

        override x.value = _value
        override x.name = _name :> IMod<_>

        member x.Update(v : Thing<'a>) =
            if not (System.Object.ReferenceEquals(__current, v)) then
                __current <- v
                update(_value, v.value)
                _name.Update(v.name)

        interface IUpdatable<Thing<'a>> with
            member x.Update v = x.Update v

    [<AbstractClass; Sealed; Extension>]
    type MThing private() =
        static member CreateV(v : Thing<'a>) =
            MThingV<'a>(v) :> MThing<_>

        static member CreateD(v : Thing<'a>, init : 'a -> 'ma, update : 'ma * 'a -> unit) =
            MThingD(v, init, update) :> MThing<_>

        [<Extension>]
        static member Update(m : MThing<'ma>, v : Thing<'a>) =
            match m :> obj with
                | :? IUpdatable<Thing<'a>> as m -> m.Update(v)
                | _ -> failwith "asdasds"