假设我有一个不可变的包装器:
template<class T>
struct immut {
T const& get() const {return *state;}
immut modify( std::function<T(T)> f ) const { return immut{f(*state)}; }
immut(T in):state(std::make_shared<T>(std::move(in))){}
private:
std::shared_ptr<T const> state;
};
如果我有immut<Bob> b
,则可以将Bob(Bob)
的操作转换为可以代替b
的内容。
template<class T>
std::function<immut<T>(immut<T>)> on_immut( std::function<void(T&)> f ){
return [=](auto&&in){ return in.modify( [&](auto t){ f(t); return t; } ); };
}
因此,如果Bob
是int x,y;
,我可以将朴素的可变代码[](auto& b){ b.x++; }
变成immut<Bob>
更新程序。
现在,如果Bob
依次具有immut<Alice>
个成员,而该成员又具有immut<Charlie>
个成员,该怎么办。
假设我有一个Charlie
更新程序void(Charlie&)
。而且我知道我要更新的Charlie
在哪里。在可变的土地上,它看起来像是:
void update( Bob& b ){
modify_charlie(b.a.c[77]);
}
我可能将其拆分为:
template<class S, class M>
using get=std::function<M&(S&)>;
template<class X>
using update=std::function<void(X&)>;
template<class X>
using produce=std::function<X&()>;
void update( produce<Bob> b, get<Bob, Alice> a, get<Alice, Charlie> c, update<Charlie> u ){
u(c(a(b())));
}
甚至代数并拥有(伪代码):
get<A,C> operator|(get<A,B>,get<B,C>);
update<A> operator|(get<A,B>,update<B>);
produce<B> operator|(produce<A>,get<A,B>);
void operator|(produce<A>, update<A>);
让我们根据需要将操作链接在一起。
void update( produce<Bob> b, get<Bob, Alice> a, get<Alice, Charlie> c, update<Charlie> u ){std::
u(c(a(b())));
}
成为
b|a|c|u;
在任何需要的地方都可以将这些步骤缝合在一起。
immuts等效于什么,它有名称吗?理想情况下,我希望这些步骤像可变情况一样孤立且可组合,并且朴素的“叶子代码”位于可变状态结构上。
答案 0 :(得分:6)
immuts的等效含义是什么?
IDK是否存在用于子状态操纵的通用名称。但是在Haskell中,有一个Lens
可以提供您想要的东西。
在C ++中,您可以将lens
视为一对getter和setter函数,这两个函数仅专注于其直接子部分。然后是一个作曲家,将两个镜头组合在一起,以专注于结构的更深部分。
// lens for `A` field in `D`
template<class D, class A>
using get = std::function<A const &(D const &)>;
template<class D, class A>
using set = std::function<D(D const &, A)>;
template<class D, class A>
using lens = std::pair<get<D, A>, set<D, A>>;
// compose (D, A) lens with an inner (A, B) lens,
// return a (D, B) lens
template<class D, class A, class B>
lens<D, B>
lens_composer(lens<D, A> da, lens<A, B> ab) {
auto abgetter = ab.first;
auto absetter = ab.second;
auto dagetter = da.first;
auto dasetter = da.second;
get<D, B> getter = [abgetter, dagetter]
(D const &d) -> B const&
{
return abgetter(dagetter(d));
};
set<D, B> setter = [dagetter, absetter, dasetter]
(D const &d, B newb) -> D
{
A const &a = dagetter(d);
A newa = absetter(a, newb);
return dasetter(d, newa);
};
return {getter, setter};
};
您可以像这样编写基本镜头:
struct Bob {
immut<Alice> alice;
immut<Anna> anna;
};
auto bob_alice_lens
= lens<Bob, Alice> {
[] (Bob const& b) -> Alice const & {
return b.alice.get();
},
[] (Bob const& b, Alice newAlice) -> Bob {
return { immut{newAlice}, b.anna };
}
};
请注意,此过程可以通过宏自动执行。
然后,如果Bob
包含immut<Alice>
,Alice
包含immut<Charlie>
,则可以写2个镜头(Bob
到Alice
和{{1 }}到Alice
),Charlie
到Bob
的镜头可以由以下组成:
Charlie
注意:
Below是一个更完整的示例,其线性存储器增长深度,没有类型擦除开销(auto bob_charlie_lens =
lens_composer(bob_alice_lens, alice_charlie_lens);
),并且具有完整的编译时类型检查。它还使用宏来生成基本镜头。
std::function