{-#LANGUAGE派生数据类型#-}
{-#LANGUAGE派生通用#-}
{-#LANGUAGE通用新类型派生#-}
{-#LANGUAGE重载字符串#-}
{-#LANGUAGE记录通配符#-}
模块 系统。克罗恩。类型
    ( 克朗时间表(..)
    , 定时任务(..)
    , Crontab条目(..)
    , 分钟规格
    , CronCommand公司(..)
    , 分钟规格
    , mk分钟规范
    , 小时规格
    , 小时规格
    , mk小时规格
    , MonthSpec公司
    , 月份规格
    , mk月份规格
    , 月份规范中的日期
    , 月份规范中的日期
    , mkDayOfMonthSpec
    , DayOfWeekSpec（星期规范）
    , 星期几规范
    , mkDayOfWeek规范
    , 基本字段(..)
    , 特定字段
    , specific字段
    , mk特定字段
    , 范围字段
    , rf开始
    , rf结束
    , mk范围字段
    , 克朗菲尔德(..)
    , StepField（步长字段）
    , sfField（sf字段）
    , sf步进
    , mkStepField（mkStep字段）
    --*常用时间表
    , 每年的
    , 月刊
    , 每日的
    , 每周的
    , 每小时
    , 每一分钟
    --*渲染
    , 序列化CronSchedule
    , 序列化Crontab

    --*转换为可读字符串
    --，显示CronField
    --，显示（..）
    ) 哪里


-------------------------------------------------------------------------------
进口           控制。适用 作为 A类
进口           数据。数据           (数据)
进口 有资格的 数据。可折叠的       作为 英尺
进口           数据。Ix公司
进口           数据。列表。非空  (非空 (..))
进口 有资格的 数据。列表。非空  作为 氖
进口           数据。单体         作为 单体
进口           数据。文本           (文本)
进口 有资格的 数据。文本           作为 T型
进口           数据。可输入       (可输入)
进口           全球总部。通用        (通用)
-------------------------------------------------------------------------------


-------------------------------------------------------------------------------
--速记时间表
-------------------------------------------------------------------------------


--|每年1月1日午夜的速记。用\@yearly解析，0 0 1 1*
每年的 :: 克朗时间表
年度：：CronSchedule每年的 = 克朗时间表月刊 { 月 = 月 (字段 (特定字段' (特定字段 1))) }


--|每月1号午夜的速记。用\@monthly解析，0 0 1**
月刊 :: 克朗时间表
每月：：CronSchedule月刊 = 克朗时间表每日的 { 每月第几天 = 每月的天数 (字段 (特定字段' (特定字段 1))) }


--|每个星期天午夜的人手短缺。用\@weekly解析，0 0**0
每周的 :: 克朗时间表
每周：：CronSchedule每周的 = 克朗时间表每日的 { 星期几 = 星期几（DaysOfWeek） (字段 (特定字段' (特定字段 0))) }


--|每天午夜的速记。用\@daily，0 0**解析*
每日的 :: 克朗时间表
每日：：CronSchedule每日的 = 克朗时间表每小时 { 小时 = 小时 (字段 (特定字段' (特定字段 0))) }


--|每小时的速记。用\@hourly，0***解析*
每小时 :: 克朗时间表
每小时：：CronSchedule每小时 = 克朗时间表每一分钟 { 分钟 = 会议记录 (字段 (特定字段' (特定字段 0))) }


--|总是匹配的表达式的缩写。用****解析*
每一分钟 :: 克朗时间表
每分钟：：CronSchedule每一分钟 = 克朗时间表 {
      分钟：：MinuteSpec分钟     = CronField->MinuteSpec会议记录 (基本字段->CronField字段 基本字段星星)
    , 小时：：小时规格小时       = CronField->小时规格小时 (基本字段->CronField字段 基本字段星星)
    , dayOfMonth:：DayOf MonthSpec每月第几天 = CronField->DayOfMonthSpec每月的天数 (基本字段->CronField字段 基本字段星星)
    , 月份：：MonthSpec月      = CronField->MonthSpec月 (基本字段->CronField字段 基本字段星星)
    , 星期几：：星期几规范星期几  = CronField->DayOfWeekSpec星期几（DaysOfWeek） (BaseField->CronField字段 基本字段星星)
    }


-------------------------------------------------------------------------------
--类型
-------------------------------------------------------------------------------


班 显示T 一 哪里
  表演 :: 一 -> 文本


实例 显示T 文本 哪里
  showT:：文本->文本表演 = 文本->文本对于所有a.a->a身份证件


实例 显示T 国际 哪里
  显示T：：Int->文本表演 = 字符串->文本T.pack系列 （字符串->文本）->（Int->字符串）->Int->文本对于所有的b c a。（b->c）->（a->b）->a->c. Int->字符串for all a.显示a=>a->String显示


--| cron表达式规范
数据 克朗时间表 = 克朗时间表 {
      CronSchedule->MinuteSpec分钟     :: 分钟规格     --^跑几分钟。cron规范中的第一个字段。
    , CronSchedule->小时规格小时       :: 小时规格       --^运行时间。cron规范中的第二个字段。
    , CronSchedule->DayOfMonthSpec日期每月第几天 :: 月份规范中的日期 --^每月的哪几天运行。cron规范中的第三个字段。
    , CronSchedule->MonthSpec月      :: MonthSpec公司      --^要运行的月份。cron规范中的第四个字段。
    , CronSchedule->DayOfWeekSpec星期几  :: DayOfWeekSpec（星期规范）  --^一周中的哪几天跑步。cron规范中的第五个字段。
    } 衍生 (CronSchedule->CronSched->布尔（CronSchedule->CronSched->Bool）->（Cron时间表->Cron时间表->Bool）->Eq Cron时间表对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：CronSchedule->CronSchledule->Bool==：：CronSchedule->CronSchledule->Bool$c/=：：CronSchedule->CronSchledule->Bool/=：：CronSchedule->CronSchledule->Bool等式, （对于所有x.CronSchedule->Rep CronSchedule x）->（针对所有x代表CronSchedule x->CronSched）->通用CronSchedule对于所有x代表CronSchedule x->CronSched对于所有x.CronSchedule->Rep CronSchedule x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.CronSchedule->Rep CronSchedule x来自：：对于所有x.CronSchedule->Rep CronSchedule x$cto:：针对所有x代表CronSchedule x->CronSched发送至：：forall x.Rep CronSchedule x->CronSchedule通用, 可打印CronSchedule可键入CronSchedule=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronSchedule->c CronSched）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronSchedule）->（CronSchedule->Constr）->（CronSchedule->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c CronSchedule））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronSchedule）->（对于所有b.数据b=>b->b）->CronSchedule->CronSched）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronSchedule->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronSchedule->r）->（对于所有u.（对于所有d.数据d=>d->u）->CronSchedule->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->CronSchedule->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched）->数据CronScheduleCronSchedule->Constr（CronSchedule->Constr）CronSchedule->数据类型（对于所有b.数据b=>b->b）->CronSchedule->CronSched对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->a->m a）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->CronSchedule->u对于所有u.（对于所有d.数据d=>d->u）->CronSchedule->[u]对于所有r’。（r->r'->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->r所有r’。（r'->r->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronSchedule所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronSchedule->c CronSched对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronSchedule）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronSchedule）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronSchedule->c CronSchedgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronSchedule->c CronSched$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronSchedule枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronSchedule$ctoConstr:：CronSchedule->施工toConstr:：CronSchedule->Constr$cdataTypeOf:：CronSchedule->数据类型dataTypeOf:：CronSchedule->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronSchedule）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronSchedule）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronSchedule）dataCast2:：用于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronSchedule）$cgmapT:：（对于所有b.数据b=>b->b）->CronSchedule->CronSchedgmapT:：（对于所有b.数据b=>b->b）->CronSchedule->CronSched$cgmapQl:：针对所有r r’。（r->r'->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->rgmapQl:：针对所有r r’。（r->r'->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->rgmapQr：：用于所有r’。（r'->r->r）->r->（针对所有d.数据d=>d->r'）->CronSchedule->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CronSchedule->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CronSchedule->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronSchedule->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronSchedule->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSchedgmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSchedgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSchedgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronSchedule->m CronSched数据, 可输入)


实例 显示 克朗时间表 哪里
  显示：：CronSchedule->String显示 克朗时间表反恐精英 = 字符串“CronSchedule” 字符串->显示对于所有a.半群a=>a->a->a单倍体。<> 文本->字符串T.拆包 (CronSchedule->文本对于所有a.显示a=>a->Text表演 克朗时间表反恐精英)


实例 显示T 克朗时间表 哪里
  showT:：CronSchedule->文本显示T 克朗时间表 {DayOfWeekSpec（星期规范）MonthSpec公司月份规范中的日期小时规格分钟规格月：：CronSchedule->MonthSpecdayOfMonth:：CronSchedule->DayOf MonthSpecdayOfWeek:：CronSchedule->DayOfWeekSpec小时：：CronSchedule->HourSpec分钟：：CronSchedule->MinuteSpec分钟：：MinuteSpec小时：：小时规格dayOfMonth:：DayOf MonthSpec月份：：MonthSpec星期几：：星期几规格..} = [文本]->文本T.unwords公司 [ MinuteSpec->文本对于所有a.显示a=>a->Text表演 分钟规格分钟
                                      , 小时规格->文本对于所有a.显示a=>a->Text表演 小时规格小时
                                      , DayOfMonthSpec->文本对于所有a.显示a=>a->Text表演 月份规范中的日期每月第几天
                                      , MonthSpec->文本对于所有a.显示T a=>a->文本表演 MonthSpec公司月
                                      , DayOfWeekSpec->文本对于所有a.显示a=>a->Text表演 DayOfWeekSpec（星期规范）星期几
                                      ]

序列化CronSchedule :: 克朗时间表 -> 文本
序列化CronSchedule:：CronSched->文本序列化CronSchedule = CronSchedule->文本对于所有a.显示a=>a->Text表演


-------------------------------------------------------------------------------
--| Crontab文件，忽略注释。
新类型 定时任务 = 定时任务 {
      Crontab->[Crontab条目]crontabEntries（crontabEntries） :: [Crontab条目]
    } 衍生 (Crontab->Crontab->布尔（Crontab->Crontab->Bool）->（克伦塔布->克伦塔布->布尔）->克伦塔布等式对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：Crontab->Crontab->布尔==：：Crontab->Crontab->Bool$c/=：：Crontab->Crontab->Bool/=：：Crontab->Crontab->Bool等式, （针对所有x.Crontab->Rep Crontabx）->（针对所有x.Rep Crontab x->Crontab）->通用Crontabfor all x.代表Crontab x->Crontab对于所有x.Crontab->代表Crontab x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.Crontab->Rep Crontab x来自：：对于所有x.Crontab->Rep Crontabx$cto：：针对所有x.Rep Crontab x->Crontab收件人：：针对所有x.Rep Crontab x->Crontab通用, 可输入的Crontab可输入的Crontab=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有克/克->克/克）->克龙塔布->克龙塔布）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c Crontab）->（Crontab->Constr）->（Crontab->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（所有d.数据d=>c（t d））->可能（c Crontab））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c Crontab））->（对于所有b.数据b=>b->b）->克伦塔布->克伦塔布）->（对于所有r’。（r->r'->r）->r->（所有d.数据d=>d->r'）->Crontab->r）->（适用于所有r’。（r'->r->r）->r->（所有d.数据d=>d->r'）->Crontab->r）->（对于所有u。（对于所有d。数据d=>d->u）->Crontab->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->Crontab->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->克伦塔布->m克伦塔伯）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->Crontab->m Crontab）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->克伦塔布->m克伦塔伯）->数据Crontab克伦塔布->ConstrCrontab->数据类型（对于所有b.数据b=>b->b）->Crontab->Crontab对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->Crontab->u对于所有u.（对于所有d.数据d=>d->u）->克伦塔布->[u]所有r’。（r->r'->r）->r->（所有d.数据d=>d->r'）->Crontab->r所有r’。（r'->r->r）->r->（所有d.数据d=>d->r'）->Crontab->r所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->Crontab->m Crontab所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->Crontab->m Crontab所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c Crontab所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有克/克->克/克）->克龙塔布->克龙塔布对于所有（t:：*->*）（c:：*->*）。可输入t=>（所有d.数据d=>c（t d））->可能（c Crontab）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c Crontab）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有克/克->克/克）->克龙塔布->克龙塔布gfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有克/克->克/克）->克龙塔布->克龙塔布$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c Crontab枪口：：用于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c Crontab$ctoConstr:：Crontab->施工至Constr:：Crontab->Constr$cdataTypeOf:：Crontab->数据类型dataTypeOf:：Crontab->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（所有d.数据d=>c（t d））->可能（c Crontab）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（所有d.数据d=>c（t d））->可能（c Crontab）$cdataCast2:：for all（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c Crontab）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c Crontab）$cgmapT:：（对于所有b.数据b=>b->b）->Crontab->CrontabgmapT:：（对于所有b.数据b=>b->b）->Crontab->Crontab$cgmapQl:：针对所有r r’。（r->r'->r）->r->（所有d.数据d=>d->r'）->Crontab->rgmapQl:：针对所有r r’。（r->r'->r）->r->（所有d.数据d=>d->r'）->Crontab->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（所有d.数据d=>d->r'）->Crontab->rgmapQr：：针对所有r r’。（r'->r->r）->r->（所有d.数据d=>d->r'）->Crontab->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->Crontab->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->Crontab->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->Crontab->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->Crontab->u$cgmapM:：针对所有（m:：*->*）。莫纳德m=>（对于所有d.数据d=>d->m d）->Crontab->m CrontabgmapM:：对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->Crontab->m Crontab$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->Crontab->m CrontabgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->Crontab->m Crontab$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->Crontab->m CrontabgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->Crontab->m Crontab数据, 可输入)


实例 显示T 定时任务 哪里
  showT:：Crontab->文本表演 (定时任务 [Crontab条目]条目) = 文本->[文本]->文本T.夹层 文本“\n” (CrontabEntry->文本对于所有a.显示a=>a->Text表演 （CrontabEntry->文本）->【CrontabEntry】->【文本】对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fbA.<$> [Crontab条目]条目)


实例 显示 定时任务 哪里
  显示：：Crontab->字符串显示 = 文本->字符串T.拆包 （文本->字符串）->（Crontab->文本）->Crontab->String对于所有的b c a。（b->c）->（a->b）->a->c. Crontab->文本对于所有a.显示T a=>a->文本表演


序列化Crontab :: 定时任务 -> 文本
序列化Crontab:：Crontab->文本序列化Crontab = Crontab->文本对于所有a.显示a=>a->Text表演


-------------------------------------------------------------------------------
新类型 CronCommand公司 = CronCommand公司 {
      CronCommand->文本cron命令 :: 文本
    } 衍生 (Int->CronCommand->显示S[CronCommand]->显示CronCommand->String命令->字符串（Int->CronCommand->ShowS）->（CronCommand->String）->（[CronCommand]->显示）->显示CronCommand对于所有a。（Int->a->ShowS）->（a->String）->（[a]->ShowS）->显示$cshowsPrec:：Int->CronCommand->ShowSshowsPrec:：Int->CronCommand->ShowS$cs显示：：CronCommand->String显示：：CronCommand->String$cshowList:：[CronCommand]->显示showList:：[CronCommand]->显示显示, CronCommand->CronCommand->Bool（CronCommand->CronCommond->Bool）->（Cron命令->Cron命令->Bool）->等式Cron命令对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：CronCommand->CronCommond->Bool==：：CronCommand->CronCommond->Bool$c/=：：CronCommand->CronCommond->Bool/=：：CronCommand->CronCommond->Bool等式, 等式CronCommand等式CronCommand=>（CronCommand->CronCommand->Ordering）->（CronCommand->CronCommond->Bool）->（CronCommand->CronCommond->Bool）->（CronCommand->CronCommond->Bool）->（CronCommand->CronCommond->Bool）->（CronCommand->CronCommond->CronCommand）->（CronCommand->CronCommond->CronCommand）->克罗恩命令克罗恩命令->克罗恩命令->BoolCronCommand->CronComman->排序CronCommand->CronComman->CronCom命令对于所有a。等式a=>（a->a->订购）->（a->a->Bool）->（a->a->Bool）->（a->a->Bool）->（a->a->Bool）->（a->a->a）->（a->a->a）->命令a$ccompare:：CronCommand->CronComman->排序比较：：CronCommand->CronComman->排序$c<：：CronCommand->CronCommond->Bool<：：CronCommand->CronCommond->Bool$c<=：：CronCommand->CronCommond->Bool<=：：CronCommand->CronCommond->Bool$c>：：CronCommand->CronComman->Bool>：：CronCommand->CronCommand->Bool$c>=：：CronCommand->CronCommond->Bool>=：：CronCommand->CronCommond->Bool$cmax:：CronCommand->CronCommond->CronCommand最大值：：CronCommand->CronComman->CronCom$cmin:：CronCommand->CronCommond->CronCommand分钟：：CronCommand->CronComman->CronCom订单, CronCommand->文本（CronCommand->Text）->显示CronComman对于所有a.（a->文本）->ShowT$cshowT:：CronCommand->文本showT:：CronCommand->文本显示T, （对于所有x.CronCommand->Rep CronCom x）->（对于所有x代表CronCommand x->CronComman）->通用CronCommand对于所有x代表CronCommand x->CronComman对于所有x.CronCommand->Rep CronCom x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.CronCommand->Rep CronCom x来自：：对于所有x.CronCommand->Rep CronCom x$cto:：针对所有x.代表CronCommand x->CronComman至：：forall x.Rep CronCommand x->CronCommand通用, 可键入CronCommand可键入CronCommand=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronCommand->c CronComman）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronCommand）->（CronCommand->Constr）->（CronCommand->DataType）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronCommand））->（对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronCommand）->（对于所有b.数据b=>b->b）->CronCommand->CronComman）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r）->（对于所有u.（对于所有d.数据d=>d->u）->CronCommand->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->CronCommand->u->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman）->数据CronCommandCronCommand->Constr公司CronCommand->数据类型（对于所有b.数据b=>b->b）->CronCommand->CronComman对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->CronCommand->u对于所有u.（对于所有d.数据d=>d->u）->CronCommand->[u]对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronCommand对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronCommand->c CronComman对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronCommand）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronCommand）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronCommand->c CronCommangfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CronCommand->c CronComman$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronCommand枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronCommand$ctoConstr:：CronCommand->ConstrtoConstr:：CronCommand->Constr$cdataTypeOf:：CronCommand->DataTypedataTypeOf:：CronCommand->DataType$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronCommand）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronCommand）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronCommand）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CronCommand）$cgmapT:：（对于所有b.数据b=>b->b）->CronCommand->CronCommangmapT:：（对于所有b.数据b=>b->b）->CronCommand->CronComman$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r$cgmapQr:：用于所有r'。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronCommand->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CronCommand->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CronCommand->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronCommand->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronCommand->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronCommangmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronCommangmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronCommangmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CronCommand->m CronComman数据, 可打字的)


-------------------------------------------------------------------------------
--|本质上是crontab文件中的一行。它要么是带有
--命令或设置环境变量（例如FOO=BAR）
数据 Crontab条目 = 命令条目 克朗时间表 CronCommand公司
                  | 环境变量 文本 文本
                  衍生 (CrontabEntry->CrontabEntry->Bool（CrontabEntry->CrontabEntry->Bool）->（CrontabEntry->CrontabEntry->Bool）->等式CrontabEntry对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：CrontabEntry->CrontabEntry->Bool=：：CrontabEntry->CrontabEntry->布尔$c/=：：CrontabEntry->CrontabEntry->Bool/=：：CrontabEntry->CrontabEntry->Bool等式, （对于所有x.CrontabEntry->Rep Crontab Entry x）->（对于所有x个Rep CrontabEntry x->CrontabEntry）->通用CrontabEntry对于所有x个Rep CrontabEntry x->CrontabEntry对于所有x.CrontabEntry->Rep Crontab Entry x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.CrontabEntry->Rep Crontab Entry x来自：：对于所有x.CrontabEntry->Rep Crontab Entry x$cto：：针对所有x个Rep CrontabEntry x->CrontabEntry发送至：：forall x.Rep CrontabEntry x->CrontabEntry通用, 可键入的CrontabEntry可键入的CrontabEntry=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CrontabEntry->c CrontabEntry）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CrontabEntry）->（Crontab条目->Constr）->（CrontabEntry->DataType）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CrontabEntry））->（对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CrontabEntry）->（对于所有b.数据b=>b->b）->CrontabEntry->Crontab条目）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r）->（对于所有u。（对于所有d。数据d=>d->u）->CrontabEntry->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->CrontabEntry->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry）->数据CrontabEntryCrontabEntry->构造CrontabEntry->数据类型（对于所有b.数据b=>b->b）->CrontabEntry->Crontab Entry对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->CrontabEntry->u对于所有u.（对于所有d.数据d=>d->u）->CrontabEntry->[u]对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CrontabEntry对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CrontabEntry->c CrontabEntry对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CrontabEntry）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CrontabEntry）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CrontabEntry->c CrontabEntrygfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->CrontabEntry->c CrontabEntry$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CrontabEntry枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CrontabEntry$ctoConstr:：CrontabEntry->Constr到Constr:：CrontabEntry->Constr$cdataTypeOf:：CrontabEntry->数据类型dataTypeOf:：CrontabEntry->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CrontabEntry）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CrontabEntry）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CrontabEntry）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c CrontabEntry）$cgmapT:：（对于所有b.数据b=>b->b）->CrontabEntry->Crontab条目gmapT:：（对于所有b.数据b=>b->b）->CrontabEntry->Crontab条目$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r$cgmapQr:：用于所有r'。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CrontabEntry->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CrontabEntry->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CrontabEntry->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CrontabEntry->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CrontabEntry->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntrygmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntrygmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntrygmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->CrontabEntry->m CrontabEntry数据, 可打字的)


实例 显示T Crontab条目 哪里
  showT:：CrontabEntry->文本表演 (命令条目 克朗时间表秒 CronCommand公司c（c）) = CronSchedule->文本对于所有a.显示a=>a->Text表演 克朗时间表秒 文本->文本->文本对于所有a.半群a=>a->a->a<> 文本" " 文本->文本->文本对于所有a.半群a=>a->a->a<> CronCommand->文本对于所有a.显示a=>a->Text表演 CronCommand公司c（c）
  表演 (环境变量 文本n个 文本v（v）)  = 文本->文本对于所有a.显示a=>a->Text表演 文本n个 文本->文本->文本对于所有a.半群a=>a->a->a<> 文本"=" 文本->文本->文本对于所有a.半群a=>a->a->a<> 文本->文本对于所有a.显示a=>a->Text表演 文本v（v）


实例 显示 Crontab条目 哪里
  show:：CrontabEntry->字符串显示 = 文本->字符串T.拆包 （文本->字符串）->（CrontabEntry->文本）->CrontabEntry->字符串对于所有的b c a。（b->c）->（a->b）->a->c. CrontabEntry->文本对于所有a.显示a=>a->Text表演

-------------------------------------------------------------------------------
--| cron表达式的分钟字段
新类型 分钟规格 = 会议记录 {
      MinuteSpec->CronField分钟规格 :: 克朗菲尔德
    } 衍生 (MinuteSpec->MinuteSpec->布尔（MinuteSpec->MinuteSpec->Bool）->（MinuteSpec->MinuteSpec->Bool）->等式MinuteSpec对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：MinuteSpec->MinuteSpec->布尔==：：MinuteSpec->MinuteSpec->布尔$c/=：：MinuteSpec->MinuteSpec->布尔/=：：分钟规格->分钟规格->布尔等式, MinuteSpec->文本（MinuteSpec->文本）->显示MinuteSpec对于所有a.（a->文本）->ShowT$cshowT:：MinuteSpec->文本showT:：MinuteSpec->文本显示T, （对于所有x.MinuteSpec->Rep MinuteSpec x）->（对于所有x.Rep MinuteSpec x->MinuteSpec）->通用MinuteSpec对于所有x.Rep MinuteSpec x->MinuteSpec对于所有x.MinuteSpec->Rep MinuteSpec x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：for all x.分钟规格->代表分钟规格x来自：：对于所有x.MinuteSpec->Rep MinuteSpec x$cto:：对于所有x.Rep MinuteSpec x->MinuteSpec到：：对于所有x.Rep MinuteSpec x->MinuteSpec通用, 可键入的MinuteSpec可键入的MinuteSpec=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MinuteSpec->c MinuteSpec）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MinuteSpec）->（MinuteSpec->Constr）->（MinuteSpec->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可打字t=>（对于所有d.数据d=>c（t d））->可能（c MinuteSpec））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c MinuteSpec）->（对于所有b.数据b=>b->b）->MinuteSpec->MinuteSpec）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r）->（适用于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r）->（对于所有u.（对于所有d.数据d=>d->u）->MinuteSpec->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->MinuteSpec->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec）->数据分钟规范MinuteSpec->常量MinuteSpec->数据类型（对于所有b.数据b=>b->b）->MinuteSpec->MinuteSpec对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（适用于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->MinuteSpec->u对于所有u.（对于所有d.数据d=>d->u）->MinuteSpec->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MinuteSpec所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MinuteSpec->c MinuteSpec对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MinuteSpec）对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c MinuteSpec）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MinuteSpec->c MinuteSpecgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MinuteSpec->c MinuteSpec$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MinuteSpec枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（适用于所有r.r->c r）->Constr->c MinuteSpec$ctoConstr:：MinuteSpec->Constr到Constr:：MinuteSpec->Constr$cdataTypeOf:：MinuteSpec->数据类型dataTypeOf:：MinuteSpec->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MinuteSpec）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MinuteSpec）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c MinuteSpec）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c MinuteSpec）$cgmapT:：（对于所有b.数据b=>b->b）->MinuteSpec->MinuteSpecgmapT:：（对于所有b.数据b=>b->b）->MinuteSpec->MinuteSpec$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r$cgmapQr:：用于所有r'。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MinuteSpec->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->MinuteSpec->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->MinuteSpec->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->MinuteSpec->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->MinuteSpec->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpecgmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpecgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpecgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MinuteSpec->m MinuteSpec数据, 可打字的)


实例 显示 分钟规格 哪里
  显示：：MinuteSpec->字符串显示 (会议记录 克朗菲尔德囊性纤维变性) = CronField->字符串for all a.显示a=>a->String显示 克朗菲尔德囊性纤维变性


--TODO:qc所有这些
mk分钟规范 :: 克朗菲尔德 -> 也许 吧 分钟规格
mkMinuteSpec:：CronField->可能是MinuteSpecmk分钟规范 克朗菲尔德囊性纤维变性
  | 克罗恩菲尔德->国际->国际->布尔有效CF 克朗菲尔德囊性纤维变性 国际0 国际59 = MinuteSpec->也许MinuteSpec对于所有a.a->可能是只是 (CronField->MinuteSpec会议记录 克朗菲尔德囊性纤维变性)
  | 布尔否则       = 可能是MinuteSpec对所有人来说。也许是没有什么


-------------------------------------------------------------------------------
--| cron表达式的小时字段
新类型 小时规格 = 小时 {
      小时规格->CronField小时规格 :: 克朗菲尔德
    } 衍生 (小时规格->小时规格->布尔（小时规格->小时规格->Bool）->（小时规格->小时规格->Bool）->Eq小时规格对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c=：：小时规格->小时规格->Bool==：：小时规格->小时规格->布尔$c/=：：小时规格->小时规格->布尔/=：：小时规格->小时规格->布尔等式, 小时规格->文本（小时规格->文本）->显示小时规格对于所有a.（a->文本）->ShowT$cshowT:：小时规格->文本showT:：小时规格->文本显示T, （对于所有x.小时规格->Rep小时规格x）->（适用于所有x.Rep小时规格x->小时规格）->通用小时规格对于所有x代表小时规格x->小时规格对于所有x小时规格->代表小时规格x对于所有a。（对于所有x.a->Rep a x）->（对于所有x.Rep a x->a）->Generic a$cfrom:：对于所有x.小时规格->Rep小时规格x来自：：对于所有x小时规格->代表小时规格x$cto：：针对所有x代表小时规格x->小时规格至：：所有x代表小时规格x->小时规格通用, 可键入的小时规格可键入小时规格=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->小时规格->c小时规格）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（所有r.r->c r）->Constr->c HourSpec）->（小时规格->施工）->（小时规格->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c小时规格））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c小时规格））->（对于所有b.数据b=>b->b）->小时规格->小时规格）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->小时规格->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->小时规格->r）->（对于所有u.（对于所有d.数据d=>d->u）->小时规格->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->小时规格->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->HourSpec->m HourSpec）->数据小时规格小时规格->施工小时规范->数据类型（对于所有b.数据b=>b->b）->小时规格->小时规格对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->HourSpec->u对于所有u.（对于所有d.数据d=>d->u）->小时规格->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->小时规格->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->小时规格->r所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->HourSpec->m HourSpec所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（所有r.r->c r）->施工->c小时规范所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->小时规格->c小时规格对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c小时规格）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c小时规格）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->小时规格->c小时规格gfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->小时规格->c小时规格$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（所有r.r->c r）->施工->c小时规范枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（所有r.r->c r）->施工->c小时规范$ctoCnstr:：HourSpec->构造toConstr:：小时规格->Constr$cdataTypeOf:：小时规范->数据类型dataTypeOf:：小时规格->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c小时规格）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c小时规格）$cdataCast2:：for all（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c小时规格）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c小时规格）$cgmapT:：（对于所有b.数据b=>b->b）->小时规格->小时规格gmapT:：（对于所有b.数据b=>b->b）->小时规格->小时规格$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->小时规格->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->HourSpec->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->小时规格->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->小时规格->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->小时规范->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->小时规格->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->小时规格->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->小时规范->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格gmapM:：对于所有（m:：*->*）。莫纳德m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格gmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->HourSpec->m HourSpecgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->小时规格->m小时规格数据, 可键入)


实例 显示 小时规格 哪里
  show:：HourSpec->字符串显示 (小时 克朗菲尔德囊性纤维变性) = CronField->字符串for all a.显示a=>a->String显示 克朗菲尔德囊性纤维变性


mk小时规格 :: 克朗菲尔德 -> 也许 吧 小时规格
mkHourSpec:：CronField->可能是HourSpecmk小时规格 克朗菲尔德囊性纤维变性
  | 克罗恩菲尔德->国际->国际->布尔有效CF 克朗菲尔德囊性纤维变性 国际0 国际23 = HourSpec->也许是HourSpec对于所有a.a->可能是只是 (CronField->小时规格小时 克朗菲尔德囊性纤维变性)
  | 布尔否则       = 也许是HourSpec对所有人来说。也许是没有什么


-------------------------------------------------------------------------------
--| cron表达式的Day of month字段
新类型 月份规范中的日期 = 每月的天数 {
      DayOfMonthSpec->CronField日月份规范中的日期 :: 克朗菲尔德
    } 衍生 (DayOfMonthSpec->DayOf MonthSpec->Bool（DayOfMonthSpec->DayOf MonthSpec->Bool）->（DayOfMonthSpec->DayOf MonthSpec->Bool）->公式DayOf-MonthSpec对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：DayOfMonthSpec->DayOf MonthSpec->Bool=：：月规格日->月规格日->布尔$c/=：：月规格日->月规格日->布尔/=：：DayOfMonthSpec->DayOf MonthSpec->Bool等式, DayOfMonthSpec->文本（DayOfMonthSpec->文本）->显示DayOf MonthSpec对于所有a.（a->文本）->ShowT$cshowT:：DayOfMonthSpec->文本showT:：DayOfMonthSpec->文本显示T, （对于所有x.DayOfMonthSpec->Rep DayOf MonthSpec x）->（适用于所有x个Rep DayOfMonthSpec x->DayOf Month Spec）->通用日期月规格对于所有x.Rep DayOfMonthSpec x->DayOf MonthSpec对于所有x.DayOfMonthSpec->Rep DayOf MonthSpec x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.DayOfMonthSpec->Rep DayOf MonthSpecx来自：：对于所有x.DayOfMonthSpec->Rep DayOf MonthSpec x$cto:：对于所有x.Rep DayOfMonthSpec x->DayOf MonthSpec至：：对于所有x。Rep DayOfMonthSpec x->DayOf MonthSpec通用, 可键入DayOfMonthSpec可键入DayOfMonthSpec=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（适用于所有g->c g）->月日规格->月日规格）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfMonthSpec）->（DayOfMonthSpec->Constr）->（DayOfMonthSpec->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfMonthSpec））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfMonthSpec）->（对于所有b.数据b=>b->b）->DayOfMonthSpec->DayOf MonthSpec）->（适用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r）->（对于所有u。（对于所有d.数据d=>d->u）->DayOfMonthSpec->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->DayOfMonthSpec->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec）->数据DayOfMonthSpec月份规格->施工日期DayOfMonthSpec->数据类型（对于所有b.数据b=>b->b）->DayOfMonthSpec->DayOf MonthSpec对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u。Int->（对于所有d.数据d=>d->u）->DayOfMonthSpec->ufor all u.（for all d.数据d=>d->u）->DayOfMonthSpec->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfMonthSpec所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfMonthSpec->c DayOf MonthSpec对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfMonthSpec）对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfMonthSpec）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfMonthSpec->c DayOf MonthSpecgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfMonthSpec->c DayOf MonthSpec$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfMonthSpec枪口折叠：：所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfMonthSpec$ctoConstr:：DayOfMonthSpec->Constr到Constr:：DayOfMonthSpec->Constr$cdataTypeOf:：DayOfMonthSpec->数据类型dataTypeOf:：DayOfMonthSpec->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfMonthSpec）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfMonthSpec）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c DayOfMonthSpec）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfMonthSpec）$cgmapT:：（对于所有b.数据b=>b->b）->DayOfMonthSpec->DayOf MonthSpecgmapT:：（对于所有b.数据b=>b->b）->DayOfMonthSpec->DayOf MonthSpec$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->rgmapQl:：用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfMonthSpec->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->DayOfMonthSpec->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->DayOfMonthSpec->[u]$cgmapQi:：对于所有您。Int->（对于所有d.数据d=>d->u）->DayOfMonthSpec->ugmapQi:：针对所有u。Int->（对于所有d.数据d=>d->u）->DayOfMonthSpec->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpecgmapM:：对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpecgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpec$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfMonthSpec->m DayOf MonthSpecgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->月规格日->月规格日数据, 可输入)


实例 显示 月份规范中的日期 哪里
  show:：DayOfMonthSpec->字符串显示 (每月的天数 克朗菲尔德囊性纤维变性) = CronField->字符串for all a.显示a=>a->String显示 克朗菲尔德囊性纤维变性


mkDayOfMonthSpec :: 克朗菲尔德 -> 也许 吧 月份规范中的日期
mkDayOfMonthSpec:：CronField->可能是DayOf MonthSpecmkDayOfMonthSpec 克朗菲尔德囊性纤维变性
  | 克罗恩菲尔德->国际->国际->布尔有效CF 克朗菲尔德囊性纤维变性 国际1 国际31 = DayOfMonthSpec->可能DayOf MonthSpec对于所有a.a->可能是只是 (CronField->DayOfMonthSpec每月的天数 克朗菲尔德囊性纤维变性)
  | 布尔否则       = 也许是DayOfMonthSpec对所有人来说。也许是没有什么


-------------------------------------------------------------------------------
--| cron表达式的Month字段
新类型 MonthSpec公司 = 月 {
      MonthSpec->CronField公司月份规格 :: 克朗菲尔德
    } 衍生 (MonthSpec->MonthSpec->Bool（MonthSpec->MonthSpec->Bool）->（MonthSpec->MonthSpec->Bool）->Eq MonthSpec对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：MonthSpec->MonthSpec->Bool==：：MonthSpec->MonthSpec->Bool$c/=：：MonthSpec->MonthSpec->Bool/=：：MonthSpec->MonthSpec->Bool等式, MonthSpec->文本（MonthSpec->文本）->显示MonthSpec对于所有a.（a->文本）->ShowT$cshowT:：MonthSpec->文本showT:：MonthSpec->文本显示T, （对于所有x.MonthSpec->Rep MonthSpec x）->（适用于所有x.Rep MonthSpec x->MonthSpec）->通用MonthSpec对于所有x.Rep MonthSpec x->MonthSpec对于所有x.MonthSpec->Rep MonthSpec x对于所有a。（对于所有x.a->Rep a x）->（对于所有x.Rep a x->a）->Generic a$cfrom:：对于所有x.MonthSpec->Rep MonthSpec x来自：：对于所有x.MonthSpec->Rep MonthSpec x$cto:：针对所有x个代表MonthSpec x->MonthSpec至：：针对所有x。Rep MonthSpec x->MonthSpec通用, 可键入的MonthSpec可键入的MonthSpec=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MonthSpec->c MonthSpec）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MonthSpec）->（MonthSpec->施工）->（MonthSpec->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MonthSpec））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e.（数据d，数据e）=>c（t d e））->可能（c MonthSpec））->（对于所有b.数据b=>b->b）->MonthSpec->MonthSpec）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r）->（对于所有u.（对于所有d.数据d=>d->u）->MonthSpec->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->MonthSpec->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec）->数据月规范MonthSpec->施工MonthSpec->数据类型（对于所有b.数据b=>b->b）->MonthSpec->MonthSpec对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（适用于所有r->c r）->施工->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->MonthSpec->u对于所有u.（对于所有d.数据d=>d->u）->MonthSpec->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MonthSpec对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MonthSpec->c MonthSpec对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MonthSpec）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e.（Data d，Data e）=>c（t d e））->可能（c MonthSpec）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MonthSpec->c MonthSpecgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->MonthSpec->c MonthSpec$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c MonthSpec枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（适用于所有r.r->cr）->Constr->c MonthSpec$ctoConstr:：MonthSpec->Constr至施工：：MonthSpec->施工$cdataTypeOf:：MonthSpec->数据类型dataTypeOf:：MonthSpec->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MonthSpec）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c MonthSpec）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c MonthSpec）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e.（Data d，Data e）=>c（t d e））->可能（c MonthSpec）$cgmapT:：（对于所有b.数据b=>b->b）->MonthSpec->MonthSpecgmapT:：（对于所有b.数据b=>b->b）->MonthSpec->MonthSpec$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->rgmapQr：：用于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->MonthSpec->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->MonthSpec->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->MonthSpec->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->MonthSpec->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->MonthSpec->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpecgmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpecgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpecgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->MonthSpec->m MonthSpec数据, 可输入)


实例 显示 MonthSpec公司 哪里
  显示：：MonthSpec->字符串显示 (月 克朗菲尔德囊性纤维变性) = CronField->字符串for all a.显示a=>a->String显示 克朗菲尔德囊性纤维变性


mk月份规格 :: 克朗菲尔德 -> 也许 吧 MonthSpec公司
mkMonthSpec:：CronField->可能是MonthSpecmk月份规格 克朗菲尔德囊性纤维变性
  | 克罗恩菲尔德->国际->国际->布尔有效CF 克朗菲尔德囊性纤维变性 国际1 国际12 = MonthSpec->可能是MonthSpec对于所有a.a->可能是只是 (CronField->MonthSpec月 克朗菲尔德囊性纤维变性)
  | 布尔否则       = 可能是MonthSpecfor all a.也许是没有什么


-------------------------------------------------------------------------------
--| cron表达式的Day of week字段
新类型 DayOfWeekSpec（星期规范） = 星期几（DaysOfWeek） {
      DayOfWeekSpec->CronField日规范星期几规范 :: 克朗菲尔德
    } 衍生 (DayOfWeekSpec->DayOf WeekSpec->Bool（DayOfWeekSpec->DayOf WeekSpec->Bool）->（DayOfWeekSpec->DayOf WeekSpec->Bool）->公式DayOf-WeekSpec对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：DayOfWeekSpec->DayOf WeekSpec->Bool=：：工作日规格->工作日规格->Bool$c/=：：DayOfWeekSpec->DayOf WeekSpec->Bool/=：：DayOfWeekSpec->DayOf WeekSpec->Bool等式, DayOfWeekSpec->文本（DayOfWeekSpec->文本）->显示DayOf WeekSpec对于所有a.（a->文本）->ShowT$cshowT:：DayOfWeekSpec->文本showT:：DayOfWeekSpec->文本显示T, （对于所有x.DayOfWeekSpec->Rep DayOf WeekSpec x）->（对于所有x个Rep DayOfWeekSpec x->DayOf WeekSpec.）->通用DayOfWeekSpec对于所有x.Rep DayOfWeekSpec x->DayOf WeekSpec对于所有x.工作日规格->代表工作日规格x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.DayOfWeekSpec->Rep DayOf WeekSpec x来自：：对于所有x.DayOfWeekSpec->Rep DayOf WeekSpec x$cto：：对于所有x.Rep DayOfWeekSpec x->DayOf WeekSpec至：：对于所有x。Rep DayOfWeekSpec x->DayOf WeekSpec通用, 可键入的DayOfWeekSpec可键入的DayOfWeekSpec=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfWeekSpec->c DayOf WeekSpec）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfWeekSpec）->（工作日规格->施工）->（DayOfWeekSpec->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfWeekSpec））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfWeekSpec）->（对于所有b.Data b=>b->b）->DayOfWeekSpec->DayOf WeekSpec）->（适用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r）->（对于所有u.（对于所有d.数据d=>d->u）->DayOfWeekSpec->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->DayOfWeekSpec->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec）->数据工作日规范DayOfWeekSpec->施工DayOfWeekSpec->数据类型（对于所有b.数据b=>b->b）->DayOfWeekSpec->DayOf WeekSpec对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->DayOfWeekSpec->u对于所有u.（对于所有d.数据d=>d->u）->DayOfWeekSpec->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfWeekSpec所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfWeekSpec->c DayOf WeekSpec对于所有（t:：*->*）（c:：*->*）。可打字t=>（对于所有d.数据d=>c（t d））->可能（c DayOfWeekSpec）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfWeekSpec）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfWeekSpec->c DayOf WeekSpecgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->DayOfWeekSpec->c DayOf WeekSpec$cgflow:：for all（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfWeekSpec枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c DayOfWeekSpec$ctoConstr:：DayOfWeekSpec->Constr到Constr:：DayOfWeekSpec->Constr$cdataTypeOf:：DayOfWeekSpec->数据类型dataTypeOf:：DayOfWeekSpec->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfWeekSpec）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c DayOfWeekSpec）$cdataCast2:：for all（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfWeekSpec）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c DayOfWeekSpec）$cgmapT:：（对于所有b.数据b=>b->b）->DayOfWeekSpec->DayOf WeekSpecgmapT:：（对于所有b.数据b=>b->b）->DayOfWeekSpec->DayOf WeekSpec$cgmapQl:：用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->DayOfWeekSpec->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->DayOfWeekSpec->[u]gmapQ:：对于所有u.（对于所有d.数据d=>d->u）->DayOfWeekSpec->[u]$cgmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->DayOfWeekSpec->ugmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->DayOfWeekSpec->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpecgmapM:：对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpecgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpecgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->DayOfWeekSpec->m DayOf WeekSpec数据, 可输入)


实例 显示 DayOfWeekSpec（星期规范） 哪里
  显示：：DayOfWeekSpec->字符串显示 (星期几（DaysOfWeek） 克朗菲尔德囊性纤维变性) = CronField->字符串for all a.显示a=>a->String显示 克朗菲尔德囊性纤维变性


mk工作日规格 :: 克朗菲尔德 -> 也许 吧 DayOfWeekSpec（星期规范）
mkDayOfWeekSpec:：CronField->可能是DayOf WeekSpecmkDayOfWeek规范 克朗菲尔德囊性纤维变性
  --0-7是一个有争议的问题，但我们在这里是自由的
  | 克罗恩菲尔德->国际->国际->布尔有效CF 克朗菲尔德囊性纤维变性 国际0 国际7  = DayOfWeekSpec->Maybe DayOf WeekSpec对于所有a.a->可能是只是 (CronField->DayOfWeekSpec星期几（DaysOfWeek） 克朗菲尔德囊性纤维变性)
  | 布尔否则       = 也许是DayOfWeekSpec对所有人来说。也许是没有什么


-------------------------------------------------------------------------------
有效CF
    :: 克朗菲尔德
    -> 国际
    --^最小值
    -> 国际
    --^最大值
    -> 布尔
有效CF:：CronField->Int->Int->Bool有效CF (字段 基本字段高炉) 国际锰 国际mx（百万倍）          = 基本字段->Int->Int->Bool有效BF 基本字段高炉 国际锰 国际mx（百万倍）
有效CF (列表字段 非空基字段高炉煤气) 国际锰 国际mx（百万倍）     = （BaseField->Bool）->非空BaseField->Bool对于所有（t:：*->*）a.可折叠t=>（a->Bool）->ta->BoolFT.所有 (\基本字段高炉 -> 基本字段->Int->Int->Bool有效BF 基本字段高炉 国际锰 国际mx（百万倍）) 非空基字段高炉煤气
有效CF (步骤字段' (StepField（步长字段） 基本字段高炉 国际步)) 国际锰 国际mx（百万倍） = 基本字段->Int->Int->Bool有效BF 基本字段高炉 国际锰 国际mx（百万倍） Bool->Bool->Bool&& （国际、国际）->国际->布尔对于所有a.Ix a=>（a，a）->a->Bool英寸范围 (国际锰, 国际mx（百万倍）) 国际步


-------------------------------------------------------------------------------
有效BF
    :: 基本字段
    -> 国际
    --^最小值
    -> 国际
    --^最大值
    -> 布尔
有效BF:：BaseField->Int->Int->Bool有效F 基本字段星星 国际_ 国际_ = 布尔真的
有效BF (特定字段' (特定字段 国际n个)) 国际锰 国际mx（百万倍） =
  （国际、国际）->国际->布尔对于所有a.Ix a=>（a，a）->a->Bool英寸范围 (国际锰, 国际mx（百万倍）) 国际n个
有效BF (范围字段' (范围字段 国际n1个 国际氮气)) 国际锰 国际mx（百万倍） =
  （国际、国际）->国际->布尔对于所有a.Ix a=>（a，a）->a->Bool英寸范围 (国际锰, 国际mx（百万倍）) 国际n1个 布尔->布尔->布尔&& （国际、国际）->国际->布尔对于所有a.Ix a=>（a，a）->a->布尔英寸范围 (国际锰, 国际mx（百万倍）) 国际氮气


-------------------------------------------------------------------------------
--| cron表达式的单个字段。
数据 基本字段 = 星星                         --^匹配任何内容
               | 特定字段' 特定字段 --^匹配特定值（例如1）
               | 范围字段' 范围字段       --^匹配一系列值（例如1-3）
               衍生 (BaseField->BaseField->Bool（BaseField->BaseField->Bool）->（BaseField->BaseField->Bool）->Eq BaseField对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：BaseField->BaseField->Bool==：：BaseField->BaseField->Bool$c/=：：基本字段->基本字段->布尔/=：：BaseField->BaseField->Bool等式, （对于所有x.BaseField->Rep BaseFild x）->（对于所有x.Rep BaseField x->BaseFields）->通用BaseField对于所有x个Rep BaseField x->BaseFields对于所有x.BaseField->Rep BaseFild x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.BaseField->Rep BaseFild x来自：：对于所有x.BaseField->Rep BaseFild x$cto:：for all x.代表基本字段x->基本字段收件人：：对于所有x个Rep BaseField x->BaseFields通用, 可键入的BaseField可键入的BaseField=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->BaseField->c BaseField）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c BaseField）->（基本字段->常量）->（基本字段->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可打字t=>（对于所有d.数据d=>c（t d））->可能（c BaseField））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c BaseField））->（对于所有b.Data b=>b->b）->BaseField->BaseField）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r）->（对于所有u.（对于所有d.数据d=>d->u）->BaseField->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->BaseField->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField）->数据库字段基本字段->常量基本字段->数据类型（对于所有b.数据b=>b->b）->基本字段->基本字段对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->a->m a）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.Data d=>d->u）->BaseField->u对于所有u.（对于所有d.数据d=>d->u）->BaseField->[u]对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c BaseField所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->BaseField->c BaseField对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c BaseField）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c BaseField）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->BaseField->c BaseFieldgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->BaseField->c BaseField$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c BaseField枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c BaseField$ctoConstr:：基本字段->Constr到Constr:：BaseField->Constr$cdataTypeOf:：BaseField->数据类型dataTypeOf:：BaseField->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c BaseField）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c BaseField）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c BaseField）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c BaseField）$cgmapT:：（对于所有b.Data b=>b->b）->BaseField->BaseFieldgmapT:：（对于所有b.数据b=>b->b）->基本字段->基本字段$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->BaseField->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->BaseField->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->BaseField->r$cgmapQ:：for all u.（for all d.数据d=>d->u）->BaseField->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->BaseField->[u]$cgmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->BaseField->ugmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->BaseField->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseFieldgmapM:：对于所有（m:：*->*）。莫纳德m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField$cgmapMp:：用于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseFieldgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseFieldgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->BaseField->m BaseField数据, 可输入)


实例 显示T 基本字段 哪里
  showT:：BaseField->文本表演 基本字段星星               = 文本"*"
  表演 (特定字段' 特定字段（f）) = SpecificField->文本对于所有a.显示T a=>a->文本表演 特定字段（f）
  表演 (范围字段' 范围字段射频)   = RangeField->文本对于所有a.显示a=>a->Text表演 范围字段射频


实例 显示 基本字段 哪里
  show：：BaseField->字符串显示 = 文本->字符串T.打开包装 （文本->字符串）->（BaseField->文本）->BaseField->String对于所有的b c a。（b->c）->（a->b）->a->c. BaseField->文本对于所有a.显示a=>a->Text表演


-------------------------------------------------------------------------------
新类型 特定字段 = 特定字段 {
      特定字段->Intspecific字段 :: 国际
    } 衍生 (SpecificField->SpecificField->Bool（特定字段->特定字段->Bool）->（SpecificField->Specific字段->Bool）->Eq SpecificField对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：SpecificField->SpecificField->Bool==：：SpecificField->SpecificField->Bool$c/=：：SpecificField->SpecificField->Bool/=：：SpecificField->SpecificField->Bool等式, SpecificField->文本（SpecificField->Text）->显示特定字段对于所有a.（a->文本）->ShowT$cshowT:：SpecificField->文本showT:：SpecificField->文本显示T, （对于所有x.SpecificField->Rep SpecificField x）->（对于所有x.Rep SpecificField x->SpecificField）->通用特定字段对于所有x.Rep SpecificField x->SpecificField对于所有x.SpecificField->Rep Specific Field x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：for all x.SpecificField->Rep Specific Field x来自：：对于所有x.SpecificField->Rep SpecificField x$cto:：对于所有x.代表SpecificField x->SpecificField收件人：：对于所有x.Rep SpecificField x->SpecificField通用, 可键入的特定字段可键入的SpecificField=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g->c g）->特定字段->c特定字段）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c SpecificField）->（SpecificField->Constr）->（SpecificField->DataType）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c特定字段））->（对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c SpecificField）->（对于所有b.Data b=>b->b）->SpecificField->Specific Field）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r）->（对于所有u.（对于所有d.数据d=>d->u）->SpecificField->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->SpecificField->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField）->数据特定字段特定字段->ConstrSpecificField->数据类型（对于所有b.数据b=>b->b）->特定字段->特定字段对于所有a。可键入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->a->m a）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.Data d=>d->u）->SpecificField->u对于所有u.（对于所有d.数据d=>d->u）->SpecificField->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c SpecificField对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->SpecificField->c SpecificField对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c SpecificField）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c SpecificField）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->SpecificField->c SpecificFieldgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->SpecificField->c SpecificField$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c SpecificField枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c SpecificField$ctoConstr:：SpecificField->Constr到Constr:：SpecificField->Constr$cdataTypeOf:：SpecificField->数据类型dataTypeOf:：SpecificField->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c特定字段）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c SpecificField）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c SpecificField）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c SpecificField）$cgmapT:：（对于所有b.数据b=>b->b）->特定字段->特定字段gmapT:：（对于所有b.Data b=>b->b）->SpecificField->Specific Field$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->rgmapQr：：用于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->SpecificField->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->SpecificField->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->SpecificField->[u]$cgmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->SpecificField->ugmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->SpecificField->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificFieldgmapM:：用于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->SpecificField->m SpecificFieldgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificFieldgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->SpecificField->m SpecificField数据, 可打字的)


实例 显示 特定字段 哪里
  show:：SpecificField->字符串显示 = 文本->字符串T.拆包 （文本->字符串）->（SpecificField->Text）->SpecificField->字符串对于所有的b c a。（b->c）->（a->b）->a->c. SpecificField->文本对于所有a.显示a=>a->Text表演


mk特定字段 :: 国际 -> 也许 吧 特定字段
mkSpecificField:：Int->可能是SpecificFieldmk特定字段 国际n个
  | 国际n个 Int->Int->布尔对于所有a.订单a=>a->a->Bool>= 国际0 = SpecificField->可能是SpecificField对于所有a.a->可能是只是 (Int->SpecificField（内部->特定字段）特定字段 国际n个)
  | 布尔否则 = 也许是特定字段对所有人来说。也许是没有什么


-------------------------------------------------------------------------------
数据 范围字段 = 范围字段 {
      范围字段->Intrf开始 :: 国际
    , 范围字段->Intrf结束   :: 国际
    } 衍生 (范围字段->范围字段->布尔（RangeField->RangeFild->Bool）->（范围字段->范围字段->布尔）->等式范围字段对于所有a.（a->a->Bool）->（a->a->Bool）->方程a$c==：：RangeField->RangeFiield->Bool==：：RangeField->RangeFiield->Bool$c/=：：RangeField->RangeFiield->Bool/=：：RangeField->RangeFiield->Bool等式, （对于所有x.RangeField->Rep RangeFild x）->（对于所有x.Rep RangeField x->RangeFild）->Generic RangeFiield对于所有x.Rep RangeField x->RangeFild对于所有x.RangeField->Rep RangeFild x对于所有a。（对于所有x.a->Rep a x）->（对于所有x.Rep a x->a）->Generic a$cfrom:：对于所有x.RangeField->Rep RangeFild x来自：：对于所有x.RangeField->Rep RangeFild x$cto:：对于所有x.代表RangeField x->RangeFild到：：对于所有x。Rep RangeField x->RangeFild通用, 可键入的范围字段可键入的RangeField=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->RangeField->c RangeFild）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c RangeField）->（范围字段->常量）->（RangeField->DataType）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c RangeField））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->也许（c RangeField）->（对于所有b.数据b=>b->b）->范围字段->范围字段）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r）->（对于所有u.（对于所有d.数据d=>d->u）->RangeField->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->RangeField->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild）->数据范围字段范围字段->常量RangeField->数据类型（对于所有b.数据b=>b->b）->范围字段->范围字段对于所有a。可键入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u（对于所有d。数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->a->m a）->数据a对于所有u.Int->（对于所有d.Data d=>d->u）->RangeField->u对于所有u.（对于所有d.数据d=>d->u）->范围字段->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c RangeField所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->RangeField->c RangeFild对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c RangeField）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c RangeField）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->RangeField->c RangeFildgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->RangeField->c RangeFild$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c RangeField枪口折叠：：所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c RangeField$ctoConstr:：RangeField->Constr到Constr:：RangeField->Constr$cdataTypeOf:：RangeField->数据类型dataTypeOf:：RangeField->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c RangeField）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c RangeField）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可打字t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c RangeField）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c RangeField）$cgmapT:：（对于所有b.数据b=>b->b）->范围字段->范围字段gmapT:：（对于所有b.数据b=>b->b）->范围字段->范围字段$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->RangeField->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->RangeField->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->RangeField->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->范围字段->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->范围字段->[u]$cgmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->RangeField->ugmapQi:：对于所有u.Int->（对于所有d.Data d=>d->u）->RangeField->u$cgmapM:：针对所有（m:：*->*）。莫纳德m=>（对于所有d。数据d=>d->m d）->RangeField->m RangeFieldgmapM:：对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFildgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFildgmapMo:：用于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->RangeField->m RangeFild数据, 可输入)


实例 显示T 范围字段 哪里
  showT:：RangeField->文本表演 (范围字段 国际x 国际年) = Int->文本对于所有a.显示a=>a->Text表演 国际x 文本->文本->文本对于所有a.半群a=>a->a->a<> 文本"-" 文本->文本->文本对于所有a.半群a=>a->a->a<> Int->文本对于所有a.显示a=>a->Text表演 国际年


实例 显示 范围字段 哪里
  显示：：RangeField->字符串显示 = 文本->字符串T.拆包 （文本->字符串）->（范围字段->文本）->范围字段->字符串对于所有的b c a。（b->c）->（a->b）->a->c. RangeField->文本对于所有a.显示T a=>a->文本显示T


mk范围字段 :: 国际 -> 国际 -> 也许 吧 范围字段
mkRangeField:：Int->Int->可能是RangeFildmk范围字段 国际x 国际年
  | 国际x 国际->国际->布尔对于所有a.订单a=>a->a->Bool<= 国际年    = RangeField->可能是RangeFild对于所有a.a->可能是只是 (Int->Int->RangeField（内部->内部->范围字段）范围字段 国际x 国际年)
  | 布尔否则 = 也许是RangeField对所有人来说。也许是没有什么



-------------------------------------------------------------------------------
数据 克朗菲尔德 = 字段 基本字段
               | 列表字段 (非空 基本字段) --^匹配表达式列表。
               | 步骤字段' StepField（步长字段）           --^匹配阶梯式表达式，例如（*/2）。
               衍生 (（对于所有x.CronField->Rep CronField x）->（对于所有x.Rep CronField x->CronFiield）->通用CronFild对于所有x代表CronField x->CronFild对于所有x.CronField->Rep CronField x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：for all x.CronField->代表CronFild x来自：：for all x.CronField->Rep CronField x$cto:：针对所有x.Rep CronField x->CronFild收件人：：for all x.Rep CronField x->CronFild通用, 可键入的CronField可键入的CronField=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g g->c g）->克朗菲尔德->c克朗菲尔德）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronField）->（CronField->Constr）->（CronField->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronField））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c CronField））->（对于所有b.数据b=>b->b）->CronField->CronFild）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronField->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronField->r）->（对于所有u.（对于所有d.数据d=>d->u）->CronField->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->CronField->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德）->数据CronFieldCronField->Constr公司CronField->数据类型（对于所有b.数据b=>b->b）->CronField->CronFild对于所有a。可键入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d。数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->a->m a）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->CronField->u对于所有u.（对于所有d.数据d=>d->u）->CronField->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronField->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronField->r所有（m:：*->*）。单体m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德所有（m:：*->*）。MonadPlus m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronField对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g g->c g）->克朗菲尔德->c克朗菲尔德对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronField）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（Data d，Data e）=>c（t d e））->可能（c CronField）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g g->c g）->克朗菲尔德->c克朗菲尔德gfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g g->c g）->克朗菲尔德->c克朗菲尔德$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronField枪口折叠：：所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c CronField$ctoConstr:：CronField->Constr至Constr:：CronField->Constr$cdataTypeOf:：CronField->数据类型dataTypeOf:：CronField->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronField）dataCast1:：用于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c CronField）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（Data d，Data e）=>c（t d e））->可能（c CronField）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（Data d，Data e）=>c（t d e））->可能（c CronField）$cgmapT:：（对于所有b.数据b=>b->b）->CronField->CronFildgmapT:：（对于所有b.数据b=>b->b）->CronField->CronField$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronField->rgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->CronField->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronField->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->CronField->r$cgmapQ:：for all u.（for all d.数据d=>d->u）->CronField->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->CronField->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronField->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->CronField->u$cgmapM:：针对所有（m:：*->*）。单体m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德gmapM:：对于所有（m:：*->*）。单体m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德gmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->CronField->m CronField$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德gmapMo:：针对所有（m:：*->*）。MonadPlus m=>（针对所有d.数据d=>d->m d）->克朗菲尔德->m克朗菲尔德数据, 可键入)


实例 等式 克朗菲尔德 哪里
  字段 基本字段一 ==：：CronField->CronFild->Bool== 字段 基本字段b条 = 基本字段一 BaseField->BaseField->Bool对于所有a.方程a=>a->a->Bool== 基本字段b条
  字段 基本字段一 == 列表字段 (基本字段b条 :| []) = 基本字段一 BaseField->BaseField->Bool对于所有a.等式a=>a->a->Bool== 基本字段b条
  列表字段 非空基字段作为 == 列表字段 非空基字段英国标准 = 非空基字段作为 非空BaseField->NonEmpty BaseField->Bool对于所有a.等式a=>a->a->Bool== 非空基字段英国标准
  列表字段 (基本字段一 :| []) == 字段 基本字段b条 = 基本字段一 BaseField->BaseField->Bool对于所有a.等式a=>a->a->Bool== 基本字段b条
  步骤字段' StepField（步长字段）一 == 步骤字段' StepField（步长字段）b条 = StepField（步长字段）一 步骤字段->步骤字段->布尔对于所有a.等式a=>a->a->Bool== StepField（步长字段）b条
  克朗菲尔德_ == 克朗菲尔德_ = 布尔False（错误）


实例 显示T 克朗菲尔德 哪里
  showT:：CronField->文本显示T (字段 基本字段（f）)       = BaseField->文本对于所有a.显示a=>a->Text表演 基本字段（f）
  表演 (列表字段 非空基字段X轴)  = 文本->[文本]->文本T.夹层 文本"," (非空文本->[文本]对于所有a.非空a->[a]NE.to列表 (BaseField->文本对于所有a.显示a=>a->Text表演 （基本字段->文本）->非空基本字段->非空文本对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb<$> 非空基字段X轴))
  表演 (步骤字段' StepField（步长字段）平方英尺) = 步骤字段->文本对于所有a.显示a=>a->Text表演 StepField（步长字段）平方英尺


实例 显示 克朗菲尔德 哪里
  显示：：CronField->String显示 = 文本->字符串T.拆包 （文本->字符串）->（CronField->文本）->CronFiield->String对于所有的b c a。（b->c）->（a->b）->a->c. CronField->文本对于所有a.显示a=>a->Text表演


-------------------------------------------------------------------------------
数据 StepField（步长字段） = StepField（步长字段） { StepField->基本字段sf字段    :: 基本字段
                           , 步骤字段->Intsf步进 :: 国际
                           } 衍生 (步骤字段->步骤字段->布尔（StepField->StepFilter->Bool）->（StepField->StepFiield->Bool）->Eq StepFild对于所有a.（a->a->Bool）->（a->a->Bool）->等式a$c==：：StepField->StepFiield->Bool==：：StepField->StepFild->Bool$c/=：：StepField->StepFiield->Bool/=：：StepField->StepFild->Bool等式, （对于所有x.StepField->Rep StepFild x）->（对于所有x.Rep StepField x->StepFild）->通用StepFiield对于所有x.Rep StepField x->StepFild对于所有x.StepField->Rep StepFild x对于所有a。（对于所有x.a->Rep a x）->（对于所有x。Rep a x->a）->通用$cfrom:：对于所有x.StepField->Rep StepFild x来自：：对于所有x。StepField->Rep StepFild x$cto:：对于所有x.Rep StepField x->StepFild到：：对于所有x。Rep StepField x->StepFild通用, 可键入的StepField可键入的StepField=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g->c g）->StepField->c StepField）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c StepField）->（StepField->Constr）->（步骤字段->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c StepField））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（数据d，数据e）=>c（t d e））->可能（c StepField））->（对于所有b.数据b=>b->b）->StepField->StepFild）->（适用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->StepField->r）->（适用于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->StepField->r）->（对于所有u.（对于所有d.数据d=>d->u）->StepField->[u]）->（对于所有u。Int->（对于所有d.数据d=>d->u）->StepField->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild）->数据StepFieldStepField->常量StepField->数据类型（对于所有b.数据b=>b->b）->StepField->StepFild对于所有a。可输入a=>（对于所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->cg）->a->ca）->（对于所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r r->c r）->Constr->c a）->（a->施工图）->（a->数据类型）->（对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c a））->（对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有数据e（数据d，数据e）=>c（t d e））->可能（c a））->（（对于所有b.数据b=>b->b）->a->a）->（对于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->a->r）->（对于所有u.（对于所有d.数据d=>d->u）->a->[u]）->（对于所有u.Int->（对于所有d.数据d=>d->u）->a->u）->（对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->md）->a->ma）->（对于所有（m:：*->*）。MonadPlus m=>（对于所有d。数据d=>d->m d）->a->m a）->数据a对于所有u.Int->（对于所有d.数据d=>d->u）->StepField->u对于所有u.（对于所有d.数据d=>d->u）->StepField->[u]所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->StepField->r所有r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->StepField->r对于所有（m:：*->*）。单体m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild所有（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c StepField所有（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->StepField->c StepFild对于所有（t:：*->*）（c:：*->*）。可打字t=>（对于所有d.数据d=>c（t d））->可能（c StepField）对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c StepField）$cgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->StepField->c StepFildgfoldl:：for all（c:：*->*）。（对于所有d b，数据d=>c（d->b）->d->c b）->（对于所有g.g->c g）->StepField->c StepFild$cgflow:：for all（c:：*->*）。（对于所有br.数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c StepField枪口折叠：：所有（c:：*->*）。（对于所有b r。数据b=>c（b->r）->c r）->（对于所有r.r->c r）->Constr->c StepField$ctoCostr:：StepField->构造到Constr:：StepField->Constr$cdataTypeOf:：StepField->数据类型dataTypeOf:：StepField->数据类型$cdataCast1:：对于所有（t:：*->*）（c:：*->*）。可输入t=>（对于所有d.数据d=>c（t d））->可能（c StepField）数据广播1：：针对所有（t:：*->*）（c:：*->*）。可打字t=>（对于所有d.数据d=>c（t d））->可能（c StepField）$cdataCast2:：对于所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c StepField）dataCast2:：针对所有（t:：*->*->*）（c:：*->*）。可输入t=>（对于所有d e.（Data d，Data e）=>c（t d e））->可能（c StepField）$cgmapT:：（对于所有b.数据b=>b->b）->StepField->StepFildgmapT:：（对于所有b.数据b=>b->b）->StepField->StepFild$cgmapQl:：针对所有r r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->StepField->rgmapQl:：用于所有r’。（r->r'->r）->r->（对于所有d.数据d=>d->r'）->StepField->r$cgmapQr:：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->StepField->rgmapQr：：针对所有r r’。（r'->r->r）->r->（对于所有d.数据d=>d->r'）->StepField->r$cgmapQ:：对于所有u。（对于所有d。数据d=>d->u）->StepField->[u]gmapQ:：对于所有u。（对于所有d。数据d=>d->u）->StepField->[u]$cgmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->StepField->ugmapQi:：对于所有u.Int->（对于所有d.数据d=>d->u）->StepField->u$cgmapM:：针对所有（m:：*->*）。单体m=>（对于所有d。数据d=>d->m d）->StepField->m StepFieldgmapM:：对于所有（m:：*->*）。莫纳德m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild$cgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFildgmapMp:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild$cgmapMo:：for all（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFildgmapMo:：针对所有（m:：*->*）。MonadPlus m=>（对于所有d.数据d=>d->m d）->StepField->m StepFild数据, 可输入)


实例 显示T StepField（步长字段） 哪里
  showT:：StepField->文本表演 (StepField（步长字段） 基本字段（f） 国际步) = BaseField->文本对于所有a.显示a=>a->Text表演 基本字段（f） 文本->文本->文本对于所有a.半群a=>a->a->a<> 文本"/" 文本->文本->文本对于所有a.半群a=>a->a->a<> Int->文本对于所有a.显示a=>a->Text表演 国际步


实例 显示 StepField（步长字段） 哪里
  显示：：StepField->String显示 = 文本->字符串T.拆包 （文本->字符串）->（步骤字段->文本）->步骤字段->字符串对于所有的b c a。（b->c）->（a->b）->a->c. StepField->文本对于所有a.显示a=>a->Text表演


mkStep字段 :: 基本字段 -> 国际 -> 也许 吧 StepField（步长字段）
mkStepField:：BaseField->Int->Maybe StepFildmkStepField（mkStep字段） 基本字段高炉 国际n个
  | 国际n个 国际->国际->布尔对于所有a.订单a=>a->a->Bool> 国际0     = StepField->可能是StepFild对于所有a.a->可能是只是 (基本字段->Int->StepFieldStepField（步长字段） 基本字段高炉 国际n个)
  | 布尔否则 = 也许是StepField对所有人来说。也许是没有什么