c++执行器的循环依赖

原地址

元<型名 S>
概念 发送器=/*省略原子限制*/&&!要求{
        型名 发送器特征<移除常易引用型<S>>::__非特化;
    };
//发送器特征
元<型名 S,型名 R>
概念 发送到=发送器<S>&&接收器<R>&&
    要求(移除常易引用型<S>&&s,移除常易引用型<R>&&r)
    {
        执行::连接(移动(s),移动(r));
    };
元<型名 R,型名 E=异常针>
概念 接收器=/*省略原子限制*/&&
    要求(移除常易引用型<R>&&r,移除常易引用型<E>&&e)
    {
        {执行::置错误(移动(r),移动(e))}无异;
        {执行::置完成(移动(r))}无异;
    };
元<型名 R,型名...实参>
概念 的接收器=接收器<R>&&
    要求(移除常易引用型<R>&&r,实参&&...实参)
    {
        执行::置值(移动(r),前向<实参>(实参)...);
    };
构 可调用架构{
    ~可调用架构()=删;
    空 符号()()常 无异;
};//用于破解循环依赖.
元<型名 E,型名 函数>
概念 实现的执行器=/*省略原子限制*/&&
    要求(移除常易引用型<E>&&e,移除常易引用型<函数>&&f)
    {
        执行::执行(移动(e),移动(f))
    };
元<型名 E>
概念 执行器=实现的执行器<E,可调用架构>;
元<型名 S>
概念 调度器=/*省略原子限制*/&&
    要求(移除常易引用型<S>&&s)
    {
        执行::调度(移动(s));
    };
aaaaaaaaaaaaaaaaaaaaaaaa
//概念引用符号,下面为cpo对象
名字空间 自点对
{//自点对
    构 连接自点对型
    {
        元<型名 E,型名 R>要求( 实现的执行器<E,按可调用<移除常易引用型<R>,E>>&&/*省略原子限制*/)
        动 符号()(E&&e,R&&r)常 无异
        {
            中 _按操作操作{前向<E>(e),前向<R>(r)};
        }
    };
    构 调度自点对型
    {
        元<型名 E>要求(发送器<E>&&/*省略原子限制*/)
        动 符号()(E&&e)常 无异
        {
            中 按发送器{前向<E>(e)};
        }
    };
    构 执行自点对型
    {
        元<型名 S,型名 F>要求( 发送到<S,按接收器<移除常易引用型<F>,S>>&& 可调用左值<F>&&/*省略原子限制*/)
        动 符号()(S&&s,F&&f)常
        {
            用 按接收器型=按接收器<移除常易引用型<F>,S>;
            中 执行::提交(前向<S>,按接收器型{前向<F>(f)});
        }
    };
    构 提交自点对型
    {
        元<型名 S,型名 R>要求(发送到<S,R>)
        动 符号()(S&&s,R&&r)常
        {
            中 执行器::开始();
        }
    };
}
内联 常式 自点对::连接自点对型 连接{};
内联 常式 自点对::调度自点对型 调度{};
内联 常式 自点对::执行自点对型 执行{};
内联 常式 自点对::提交自点对型 提交{};
//代码隐藏了实现,这里是声明四个类型
aaaaaaaaaaaaaaaaaaaaaaaa
元<型名 S>
构 发送器特征
{
    用 __非特化=空;
};//特化.
元<型名 S>要求(有发送器类型<S>)
构 发送器特征<S>{};
元<型名 S>要求(!有发送器类型<S>&&执行器<S>)
构 发送器特征<S>{};
//上面有个依赖环.概念与自点对循环依赖,表层依赖.
//概念与原子有隐藏依赖.
aaaaaaaaaaaaaaaaaaaaaaaa
外 构 自点对::连接自点对型 常 连接;
外 构 自点对::提交自点对型 常 提交;
外 构 自点对::执行自点对型 常 执行;
aaaaaaaaaaaaaaaaaaaaaaaa
名字空间 执行
{
    名字空间 自点对{构 连接自点对型;}
    //前向声明
    外 构 自点对::连接自点对型 常 连接;
    名字空间 自点对//定义
    {
        构 连接自点对型
        {
            元<型名 S,型名 R>要求(
                要求(S&&s,R&&r){连接(前向<S>(s),前向<R>(r));})
            动 符号()(S&&s,R&&r)常 无异()
            {
                中 连接(前向<S>(s),前向<R>(r));
            }
            元<型名 E,型名 R>要求(
                实现的执行器<E,按可调用<移除常易引用型<R>,E>>&&
                )
            动 符号()(E&&e,R&&r)常 无异
            {
                中 _按操作操作{前向<E>(e),前向<R>(r)};
            }
        };
    }
    自点对::连接自点对型 常 连接{};
}
aaaaaaaaaaaaaaaaaaaaaaaa
//概念无法前向,但元函数可以
元<型名 S,型名 R>
构 是连接可调用:假型{};
//通用
元<型名 S,型名 R>
内联 常式 极 是连接可调用值=是连接可调用<S,R>::值;
//下面为概念
元<型名 S,型名 R>
概念 发送到= 发送器<S>&& 接收器<R>&& 是连接可调用值<S,R>;

名字空间 自点对{构 连接自点对型{};}
//定义连接,省略实现
内联 常式 自点对::连接自点对型 连接{};
//定义实例
//原子限制实现.
元<型名 S,型名 R>要求(要求(S&&s,R&&r){
    {执行::连接(前向<S>(s),前向<R>(r))}->操作状态;})//这是限制.
构 是连接可调用<S,R>:真型{};
//这里完成循环依赖,看先后声明.
aaaaaaaaaaaaaaaaaaaaaaaa
//调整编译器求值顺序解决`原子限制`循环依赖.
名字空间 自点对
{
    构 执行自点对型
    {
        元<型名 S,型名 F>要求(
            发送到<S,按接收器<移除常易引用型<F>,S>>&&可调用左值<F>&&/*省略原子限制*/)
        动 符号()(S&&s,F&&f)常
        {//f为可调用.还得是左值
            用 按接收器型=按接收器<移除常易引用型<F>,S>;//
            中 执行::提交(前向<S>,按接收器型{前向<F>(f)});
        }//发送器特征依赖`执行器`概念
    };
}
内联 常式 自点对::执行自点对型 执行{};
元<型名 S>要求(!有发送器类型<S>&&执行器<S>)
构 发送器特征<S>{};
//执行器.
aaaaaaaaaaaaaaaaaaaaaaaa
名字空间 自点对
{
    构 执行自点对型
    {
        元<型名 S,型名 F>要求(
            可调用左值<F>&&//交换位置
            发送到<S,按接收器<移除常易引用型<F>,S>>&&/*省略原子限制*/)
        动 符号()(S&&s,F&&f)常
        {
            用 按接收器型=按接收器<移除常易引用型<F>,S>;
            中 执行::提交(前向<S>,按接收器型{前向<F>(f)});
        }
    };
}
//可调用左值,不满足`左值`约束.因为`无析构函数`
//由其来断开循环依赖.在`可调用左值`为假时,断开
//这种设计,使执行器少了许多`概念与接口`.
//并不没有
//改变编辑器求值结果.当无法求值时`不报错`,继续求值.