D中日历写法与组件式编程

女爷i 2022-09-11 10:15 130阅读 0赞

/*D日历用带区间的组件式编程,来简化复杂任务为可管理片段示例.任务是,给定`年`,生成代表该年日历的行.展示如何清晰易读读写易重用复杂组件.*/
    
    导入 标.算法;
    导入 标.转换;
    导入 标.日期时间;
    导入 标.函数;
    导入 标.区间;
    导入 标.标io:写行,写格式行,标错误;
    导入 标.串;
    
    
    /*返回:N个空格串.*/
    串 空格()(整 n)
    {
       
        导入 标.数组:重复;
        中 重复(" ",n);
    }
    
    
    /*返回:给定年中的日期区间.*/
    动 年中日期()(整 年)
    {
       
        中 日期(年,1,1)
            .再现!((a,n)=>a[n-1]+1.天)
            .直到!(a=>a.年>年);
    }
    
    单元测试
    {
       
        动 日期=年中日期(2013);
        断定(!日期.空的);
        断定(日期.前==日期(2013,1,1));
    
        //检查增量
        日期.弹前();
        断定(日期.前==日期(2013,1,2));
    
        //检查按月
        每一(i;2..31){
       
            断定(!日期.空的);
            日期.弹前();
        }
        断定(!日期.空的);
        断定(日期.前==日期(2013,1,31));
        日期.弹前();
    
        断定(!日期.空的);
        断定(日期.前==日期(2013,2,1));
    }
    
    单元测试
    {
       
        //检查年长
        动 日期=年中日期(2013);
        每一(i;0..365){
       
            断定(!日期.空的);
            日期.弹前();
        }
        断定(日期.空的);
    }
    
    
    /*验证给定区间日期输入区间的便捷模板.*/
    元 是日期区间(R)
    {
       
        枚 是日期区间=是输入区间!R&&是(元素类型!R:日期);
    }
    
    静 断定(是日期区间!(的型(年中日期(1))));
    
    
    /*按等价元素分块输入区间.函数以输入区间为参,拆分为(`函数属性`值一样的)等价相邻元素子区间.
    请注意,中间不等价元素分隔的等价元素在单独子区间中;本函数只考虑相邻等价.类似`std.algorithm.group`,但当每个组中元素在结果中必须`可迭代`时,不能用后者.
    参数:G=F.
    返回值,必须能用==进行比较.
    r=待分块区间.返回:区间的相同属性值区间*/
    动 块按(别名 F,区间)(区间 r)
        如(是输入区间!区间&&
            是(的型(
                F(元素类型!区间.初化)==F(元素类型!区间.初化)
            ))//有==,F为属性函数
        )
    {
       
        别名 G=一元函数!F;
        别名 属性类型=的型(属性(r.前));//类型
    
        静 构 块
        {
       //C为当前属性,P为上个属性
            私 区间 r;私 属性类型 C;
            @属性 极 空的()
            {
       
                中 r.空的||!(C==G(r.前));
            }
            @属性 元素类型!区间 前(){
       中 r.前;}
            空 弹前()
            {
       
                断定(!r.空的);
                r.弹前();
            }
        }
    
        静 构 块按
        {
       
            私 区间 r;私 属性类型 P;
            本(区间 _r)
            {
       
                r=_r;
                如(!空的)P=G(r.前);
            }
            @属性 极 空的(){
       中 r.空的;}
            @属性 动 前()
            {
       
                断定(!r.空的);中 块(r,P);
            }
            空 弹前()
            {
       
                断定(!r.空的);
                当(!r.空的&&G(r.前)==P)
                {
       
                    r.弹前();
                }
                如(!r.空的)P=G(r.前);
            }
            静 如(是前向区间!区间)
            {
       
                @属性 块按 保存()
                {
       //可保存
                    块按 复制=本;
                    复制.r=r.保存;中 复制;
                }
            }
        }
        中 块按(r);
    }//满足某个属性的分组区间.
    
    ///
    单元测试
    {
       
        动 区间=[ [1,1], [1,1], [1,2], [2,2], [2,3], [2,3], [3,3] ];
    
        动 按X=块按!(a=>a[0])(区间);
        动 期望1=[
            [[1,1],[1,1],[1,2]],
            [[2,2],[2,3],[2,3]],[[3,3]]
        ];//3,3,1
        每一(e;按X)
        {
       
            断定(!期望1.空的);
            断定(e.相等(期望1.前));
            期望1.弹前();
        }
    
        动 按Y=块按!(a=>a[1])(区间);
        动 期望2=[
            [[1,1],[1,1]],
            [[1,2],[2,2]],
            [[2,3],[2,3],[3,3]]
        ];//两个期望不一样.//2,2,3
        每一(e;按Y)
        {
       
            断定(!期望2.空的);
            断定(e.相等(期望2.前));
            期望2.弹前();
        }
    }
    
    
    /*按月分块日期的给定输入区间.
    返回:其中每个子区间为同月日期的`系列`区间*/
    动 按月(I)(I 日期)
        如(是日期区间!I)
    {
       
        中 日期.块按!(a=>a.月());
    }
    
    单元测试
    {
       
        动 月=年中日期(2013).按月();
        整 月=1;
        干{
       
            断定(!月.空的);
            断定(月.前.前==日期(2013,月,1));
            月.弹前();//每月的前为月的1号.
        }当(++月<=12);
    
        断定(月.空的);
    }
    
    
    /*按周分块日期的给定输入区间.
    返回:其中每个子区间为同星期日期的`系列`区间,从星期天开始.*/
    动 按星期(I)(I 日期)如(是日期区间!I)
    {
       //是可复用的.
        静 构 按星期
        {
       
            I r;
            @属性 极 空的(){
       中 r.空的;}
            @属性 动 前()
            {
       
                中 直到!((日期 a)=>a.星期中天==星期中天.星期六)(r,打开右.no);//不要右边.
            }//非常强大.处理了部分周的问题
            空 弹前()
            {
       
                断定(!r.空的);r.弹前();
                当(!r.空的&&r.前.星期中天!=星期中天.太阳)r.弹前();
            }
        }
        中 按星期(日期);
    }
    
    单元测试
    {
       
        动 周=年中日期(2013).按星期();
        断定(!周.空的);
        断定(相等(周.前,[
            日期(2013,1,1), //星期二
            日期(2013,1,2), //星期三
            日期(2013,1,3), //星期四
            日期(2013,1,4), //星期五
            日期(2013,1,5), //星期六
        ]));
        周.弹前();
    
        断定(!周.空的);
        断定(相等(周.前,[
            日期(2013,1,6), //星期日
            日期(2013,1,7), //星期一
            日期(2013,1,8), //星期二
            日期(2013,1,9), //星期三
            日期(2013,1,10),//星期四
            日期(2013,1,11),//星期五
            日期(2013,1,12),//星期六
        ]));
        周.弹前();
    
        断定(!周.空的);
        断定(周.前.前==日期(2013,1,13));
    }
    
    
    ///格式化输出中每天列数.
    枚 每天列=3;
    ///格式化输出中每周列数.
    枚 每星期列=7*每天列;
    
    /*格式化`周区间`为`串区间`.
    格式化每一天为月中数字表示,用3空格填充.
    参数:周=(周中连续日期的)日期区间的区间*/
    动 格式星期(区间)(区间 周)纯 不抛
        如(是输入区间!区间&&是输入区间!(元素类型!区间)&&是(元素类型!(元素类型!区间)==日期))
    {
       
        构 星期串
        {
       
            区间 r;
            @属性 极 空的(){
       中 r.空的;}
    
            串 前()
            出(s){
       断定(s.长度==每星期列);}
            体
            {
       
                动 缓冲=附加器!串();
    
                //插入足够空隙将第一天与其各自的
                //星期几对齐.
                断定(!r.前.空的);
                动 开始天=r.前.前.星期中天;
                缓冲.放(空格(每天列*开始天));
    
                //格式化每天为自身单元并附加到目标串.
                串[]天=映射!((日期 d)=>" %2d".格式(d.天))(r.前).数组;
                断定(天.长度<=7-开始天);
                天.复制(缓冲);
    
                //如是短星期,在尾插入更多空格来填充
                //(如在月底).
                如(天.长度<7-开始天)
                    缓冲.放(空格(每天列*(7-开始天-天.长度)));
    
                中 缓冲.数据;
            }//格式星期
    
            空 弹前(){
       r.弹前();}
        }
        中 星期串(周);
    }
    
    单元测试
    {
       
        动 一月2013=年中日期(2013)
            .按月().前 //选择2013年1月来测试
            .按星期()
            .格式星期()
            .合并("\n");
    
        断定(一月2013==
            "        1  2  3  4  5\n"~
            "  6  7  8  9 10 11 12\n"~
            " 13 14 15 16 17 18 19\n"~
            " 20 21 22 23 24 25 26\n"~
            " 27 28 29 30 31"
        );
    }
    
    
    /*按每周列居中格式化月份名称.*/
    串 月标题()(月 月)
    {
       
        静 不变 串[]月名=[
            "一月","二月","三月","四月","五月","六月",
            "七月","八月","九月","十月","11月","12月"
        ];
        静 断定(月名.长度==12);
    
        //确定需要月份名前后空格数
        //在格式周上按月居中
        动 名=月名[月-1];
        断定(名.长度<每星期列);
        动 在前=(每星期列-名.长度)/2;
        动 在后=每星期列-名.长度-在前;
    
        中 空格(在前)~名~空格(在后);
    }
    
    单元测试
    {
       
        断定(月标题(月.一月).长度==每星期列);
    }
    
    
    /*编译时辅助函数,创建包含星期几缩写名称的串,可用作有中星期标头.与每日列对齐.*/
    动 造工作日头()()
    {
       
        动 工作日名=["Su","Mo","Tu","We","Th","Fr","Sa"];
        中 工作日名
            .映射!(s=>格式(" %.*s",每天列,s))
            .合并();
    }
    
    /*包含周缩写名标题,用作每月头.用D的`CTFE`功能编译时计算的串.*/
    静 工作日头=造工作日头();
    
    单元测试
    {
       
        断定(工作日头.长度==每星期列);
        断定(工作日头==" Su Mo Tu We Th Fr Sa");
    }
    
    
    /*格式化月.
    参数:月天=月中连续日期区间.
    返回:格式化后月份每行串区间.*/
    动 格式月(区间)(区间 月天)
        如(是输入区间!区间&&是(元素类型!区间==日期))
    在
    {
       
        断定(!月天.空的);
        断定(月天.前.天==1);
    }
    体
    {
       
        中 链(
            [月标题(月天.前.月)],
            [工作日头],
            月天.按星期().格式星期());
    }
    
    单元测试
    {
       
        动 月格式=年中日期(2013)
            .按月().前   //选择`一月`作为测试用例
            .格式月()
            .合并("\n");
    
        断定(月格式==
            "         一月        \n"~
            " Su Mo Tu We Th Fr Sa\n"~
            "        1  2  3  4  5\n"~
            "  6  7  8  9 10 11 12\n"~
            " 13 14 15 16 17 18 19\n"~
            " 20 21 22 23 24 25 26\n"~
            " 27 28 29 30 31"
        );
    }
    
    
    /*格式化月区间.
    参数:月=月中日期区间的区间.
    返回:每月的格式化行区间的区间.*/
    动 格式月(区间)(区间 月)纯 不抛
        如(是输入区间!区间&&是(元素类型!(元素类型!区间)==日期))
    {
       
        中 月.映射!格式月;
    }
    
    
    /*水平粘贴矩形字符块的前向区间.每个矩形块按固定宽度区间串表示.如果块比其他块长,用空格填充.
    参数:R=固定宽串区间区间.
    分隔宽度=每月间插入的空格数.
    返回:每月格式化区间区间.*/
    动 粘贴块(区间)(区间 R,整 分隔宽度)
        如(是前向区间!区间&&是(元素类型!(元素类型!区间):串))
    {
       
        构 行
        {
       
            区间 R;串 分隔;整[]列宽;极 _空的;
    
            本(区间 _R,串 _分隔)
            {
       
                R=_R;分隔=_分隔;_空的=R.空的;
    
                //存储每列宽,以便子区间数据不够时填充空格
                每一(r;R.保存)
                {
       
                    列宽~=r.空的?0:r.前.长度;
                }
            }
    
            @属性 极 空的(){
       中 _空的;}
            @属性 动 前()
            {
       
                中
                    //同时迭代R和列宽
                    压缩(R.保存,列宽)
    
                    //映射每个子区间到它的`前`元素,或如已空了,则用空格填充
                    .映射!(a=>a[0].空的?空格(a[1]):a[0].前)
                    //合并成一条线
                    .合并(分隔);
            }
    
            ///从每个子区间弹出一个元素.
            空 弹前()
            {
       
                断定(!空的);
                _空的=真;//假设弹后无更多数据(我们很懒)
                每一(引用 r;R)
                {
       
                    如(!r.空的)
                    {
       
                        r.弹前();
                        如(!r.空的)_空的=假;
                        //好吧,毕竟还有数据
                    }
                }
            }
        }
        静 断定(是输入区间!行);
    
        串 分割器=空格(分隔宽度);
        中 行(R,分割器);
    }
    
    单元测试
    {
       
        //做漂亮的月历.单元测试怎么样?:)
        动 行=年中日期(2013).按月().带(3)
                  .格式月()
                  .数组()
                  .粘贴块(1)
                  .合并("\n");
        断定(行==
            "       January              February                March        \n"~
            " Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa\n"~
            "        1  2  3  4  5                  1  2                  1  2\n"~
            "  6  7  8  9 10 11 12   3  4  5  6  7  8  9   3  4  5  6  7  8  9\n"~
            " 13 14 15 16 17 18 19  10 11 12 13 14 15 16  10 11 12 13 14 15 16\n"~
            " 20 21 22 23 24 25 26  17 18 19 20 21 22 23  17 18 19 20 21 22 23\n"~
            " 27 28 29 30 31        24 25 26 27 28        24 25 26 27 28 29 30\n"~
            "                                             31"
        );
    }
    
    
    //下面块是简单替换std.range.chunks
    //早先限制
    //不允许其与不可切片区间一起用.
    //在2.064中解除,
    静 如(__版本__<2064L)
    {
       
        动 块(区间)(区间 r,整 n)
        {
       
            构 块
            {
       
                区间 r;
                整 n;
    
                @属性 极 空的(){
       中 r.空的;}
                @属性 动 前(){
       中 r.保存.带(n);}
                空 弹前()
                {
       
                    整 数=n;
                    当(数-->0&&!r.空的)r.弹前();
                }
            }
            中 块(r,n);
        }
    
        单元测试
        {
       
            动 r=[1,2,3,4,5,6,7];
            动 c=r.块(3);
            断定(c.相等([[1,2,3],[4,5,6],[7]]));
        }
    }
    
    
    /*格式化年.
    参数:year=显示日历年.
    monthsPerRow=每行多少月.
    返回:表示格式化年的串区间.*/
    动 格式年()(整 年,整 每行月)
    {
       
        枚 空间列=1;
    
        中
            //首先生成给定年所有日期
            年中日期(年)
    
            //按月分组
            .按月()
    
            //分组月为水平行
            .块(每行月)
    
            //格式化每行
            .映射!(r=>
                    //格式化每月
                    r.格式月()
                     //在行缓冲区中存储每月格式
                     .数组()
                     //水平粘贴每月行在一起
                     .粘贴块(空间列)
                     .合并("\n"))
            //每行间插入空行
            .合并("\n\n");
    }
    
    整 主(串[]实参)
    {
       
        //默认年从当前系统时钟获取.
        整 年=(转换(日期)钟.当前时间).年;
        //很简单:从命令行解析年:
        如(实参.长度==2)
        {
       
            年=到!整(实参[1]);
        }
    
        //打印日历
        枚 每行月=3;写行(格式年(年,每行月));
    
        中 0;
    }