模块 PGF公司。生成 
         ( 生成全部,         生成所有深度
         , 生成自,        从深度生成
         , 生成随机,      生成随机深度
         , 生成随机来自,  从深度生成随机数
         , 生成本体,    生成OntologyDepth
         , 证明
         ) 哪里

进口 PGF。CId代码
进口 PGF公司。数据
进口 PGF公司。类型检查
进口 控制。莫纳德
进口 控制。莫纳德。州
进口 控制。莫纳德。身份
进口 系统。随机
进口 数据。也许 吧(什么都不是)

------------------------------------------------------------------------------
--API

--|生成一个详尽的可能无限的列表
--抽象语法表达式。
生成全部 :: 前列腺素F -> 类型 -> [实验]
生成全部：：PGF->类型->[表达式]生成全部 前列腺素F前列腺素f 类型第y天 = PGF->类型->可能Int->[Expr]生成所有深度 前列腺素F前列腺素f 类型第y天 也许是Int对所有人来说。也许是没有什么

--|“generateAll”的变体，它也接受作为参数
--生成的表达式深度的上限。
生成所有深度 :: 前列腺素F -> 类型 -> 也许 吧 国际 -> [实验]
generateAllDepth:：PGF->类型->可能Int->[Expr]生成所有深度 前列腺素F前列腺素f 类型第y天 也许是Int数据处理程序 = （）->PGF->类型->可能是Int->[Expr]对于所有sel。选择器选择=>sel->PGF->类型->可能是Int->[Expr]生成 () 前列腺素F前列腺素f 类型第y天 也许是Int数据处理程序

--|生成抽象语法表达式列表
--以类似于“generateAll”的方式，但不是
--生成给定类型的所有实例，这
--函数使用模板。
生成自 :: 前列腺素F -> 实验 -> [实验]
生成自：：PGF->Expr->[Expr]生成自 前列腺素F前列腺素f 实验前任 = PGF->Expr->可能是Int->[Expr]从深度生成 前列腺素F前列腺素f 实验前任 也许是Intfor all a.也许是没有什么

--|“generateFrom”的一个变体，它也作为参数
--生成的子表达式深度的上限。
从深度生成 :: 前列腺素F -> 实验 -> 也许 吧 国际 -> [实验]
generateFromDepth:：PGF->Expr->Maybe Int->[Expr]从深度生成 前列腺素F前列腺素f 实验e（电子） 也许是Int数据处理程序 = 
  [实验e（电子） | (MetaStore（）_,()_,实验e（电子）) <- （[（），TcError）]，[（MetaStore（），（），Expr）]）->[（MetaStore（），（），Expr）]对于所有a b.（a，b）->b信噪比 （（[（），TcError）]，[（MetaStore（），（），Expr）]）->[（MetaStore（），（），Expr）]）->（[（），TcError）]，[（MetaStore（），（），Expr）]）->[（MetaStore（），（），Expr）]对于所有a b（a->b）->a->b$ 文章摘要->TcM（）实验->MetaStore（）-> ()->（[（），TcError）]，[（MetaStore（），（），Expr）]）对于所有s a。文章摘要->TcM系统a->MetaStore->秒->（[（s，TcError）]，[（MetaStore s，s，a）]）运行TCM (PGF->摘要摘要 前列腺素F前列腺素f)
                               (（范围->TType->TcM（）Expr）->Expr->TcM（）Expr对于所有s。选择器=>（范围->TType->TcM s Expr）->Expr->TcMs Expr生成元数据 (可能是Int->Scope->TType->TcM（）Expr对于所有sel。选择器选择=>也许Int->Scope->TType->TcM sel Expr证明 也许是Int数据处理程序) 实验e（电子）)
                               MetaStore（）针对所有s.MetaStore空MetaStore ()]

--|生成随机抽象语法表达式的无限列表。
--这对于生成树库很有用，之后可以使用
--用于语法测试。
生成随机 :: 随机生成 克 => 克 -> 前列腺素F -> 类型 -> [实验]
generateRandom:：g->PGF->类型->[Expr]生成随机 克克 前列腺素F前列腺素f 类型第y天 = g->PGF->类型->可能是Int->[Expr]对于所有g。RandomGen g=>g->PGF->类型->可能Int->[Expr]生成随机深度 克克 前列腺素F前列腺素f 类型第y天 也许是Int对所有人来说。也许是没有什么

--|“generateRandom”的一个变体，它也作为参数
--生成的表达式深度的上限。
生成随机深度 :: 随机生成 克 => 克 -> 前列腺素F -> 类型 -> 也许 吧 国际 -> [实验]
生成随机深度：：g->PGF->Type->Maybe Int->[Expr]生成随机深度 克克 前列腺素F前列腺素f 类型第y天 也许是Int数据处理程序 = g->（g->[出口]）->[出口]对于所有g a.RandomGen g=>g->（g->[a]）->[a]重新启动 克克 (\克克 -> 身份g->PGF->类型->可能是Int->[Expr]对于所有sel。选择器选择=>sel->PGF->类型->可能是Int->[Expr]生成 (g->标识g对于所有a.a->Identity标识身份 克克) 前列腺素F前列腺素f 类型第y天 也许是Int数据处理程序)

--|基于模板随机生成
生成随机来自 :: 随机生成 克 => 克 -> 前列腺素F -> 实验 -> [实验]
生成随机源：：g->PGF->Expr->[Expr]生成随机来自 克克 前列腺素F前列腺素f 实验e（电子） = g->PGF->Expr->可能是Int->[Expr]对于所有g，随机生成g=>g->PGF->Expr->也许Int->[Expr]从深度生成随机数 克克 PGF公司前列腺素f 实验e（电子） 也许是Int对所有人来说。也许是没有什么

--|基于深度有限的模板随机生成。
从深度生成随机数 :: 随机生成 克 => 克 -> 前列腺素F -> 实验 -> 也许 吧 国际 -> [实验]
generateRandomFromDepth:：g->PGF->Expr->Maybe Int->[Expr]从深度生成随机数 克克 前列腺素F前列腺素f 实验e（电子） 也许是Int数据处理程序 = 
  g->（g->[出口]）->[出口]对于所有g a.RandomGen g=>g->（g->[a]）->[a]重新启动 克克 (\克克 -> [实验e（电子） | (MetaStore（标识g）_,标识g毫秒,实验e（电子）) <- （[（标识g，TcError）]，[（MetaStore（标识g）、标识g、Expr）]）->[（MetaStore（标识g）、标识g、Expr）]对于所有a b.（a，b）->b信噪比 （[（标识g，TcError）]，[（MetaStore（标识g）、标识g、Expr）]）->[（MetaStore（标识g）、标识g、Expr）]）->（[（标识g，TcError）]，[（MetaStore（标识g）、标识g、Expr）]）->[（MetaStore（标识g）、标识g、Expr）]对于所有a b（a->b）->a->b$ 文章摘要->TcM（标识g）Expr->MetaStore（标识g）->标识g->（[（标识g，TcError）]，[（MetaStore（标识g）、标识g、Expr）]）对于所有s a。文章摘要->TcM系统a->MetaStore->秒->（[（s，TcError）]，[（MetaStore s，s，a）]）运行TcM (PGF->摘要摘要 PGF公司前列腺素f)
                                                 (（范围->T类型->TcM（标识g）表达式）->Expr->TcM（标识g）Expr对于所有s。选择器=>（范围->TType->TcM s Expr）->Expr->TcMs Expr生成元数据 (可能是Int->Scope->TType->TcM（标识g）Expr对于所有sel。选择器选择=>可能是Int->Scope->TType->TcM sel Expr证明 也许是Int数据处理程序) 实验e（电子）)
                                                 MetaStore（标识g）针对所有s.MetaStore空MetaStore (g->标识g对于所有a.a->Identity标识身份 克克)])

生成本体 :: 随机生成 克 => 克 -> 前列腺素F -> 类型 -> [(也许 吧 实验, 类型)] -> [实验]
生成本体：：g->PGF->Type->[（可能是Expr，Type）]->[Expr]生成本体 克克 前列腺素F前列腺素f 类型第y天 [（可能是Expr，类型）]参数 = g->PGF->类型->[（可能是Expr，类型）]->可能是Int->[Expr]对于所有g。随机生成g=>g->PGF->Type->[（可能是Expr，Type）]->可能是Int->[Expr]生成OntologyDepth 克克 前列腺素F前列腺素f 类型第y天 [（可能是Expr，类型）]参数 也许是Int对所有人来说。也许是没有什么

生成OntologyDepth :: 随机生成 克 => 克 -> 前列腺素F -> 类型 -> [(也许 吧 实验, 类型)] -> 也许 吧 国际 -> [实验]
生成生物学深度：：g->PGF->Type->[（可能是Expr，Type）]->可能是Int->[Expr]生成OntologyDepth 克克 PGF公司前列腺素f 类型第y天 [（可能是Expr，类型）]参数 也许是Int数据处理程序 =
  g->（g->[出口]）->[出口]对于所有g a.RandomGen g=>g->（g->[a]）->[a]重新启动 克克 (\克克 -> [实验e（电子） | (MetaStore（本体g）_,(本体论 [（可能是Expr，类型）]参数' 克_),实验e（电子）) <- （[（本体g，TcError）]，[（MetaStore（本体g）、本体g、Expr）]）->[（MetaStore（本体g）、本体g、Expr）]对于所有a b.（a，b）->b信噪比 （（[（本体g，TcError）]，[（MetaStore（本体g）、本体g、Expr）]）->[（MetaStore（本体g）、本体g、Expr）]）->（[（本体g，TcError）]，[（MetaStore（本体g）、本体g、Expr）]）->[（MetaStore（本体g）、本体g、Expr）]对于所有a b（a->b）->a->b$ 文章摘要->TcM（本体g）Expr->MetaStore（本体g）->本体g->（[（本体g，TcError）]，[（MetaStore（本体g）、本体g、Expr）]）对于所有s a。文章摘要->TcM系统a->MetaStore->秒->（[（s，TcError）]，[（MetaStore s，s，a）]）运行TCM (PGF->摘要摘要 前列腺素F前列腺素f)
                                                                 (可能是Int->Scope->TType->TcM（本体g）Expr对于所有sel。选择器选择=>可能是Int->Scope->TType->TcM sel Expr证明 也许是Int数据处理程序 范围清空范围 (环境->类型->TTypeT类型 [] 类型第y天) TcM（本体g）Expr->（Expr->TcM（本体g）Expr）->TcM对于所有（m:：*->*）a b.Monad m=>m a->（a->m b）->m b>>= 范围->表达式->TcM（本体g）表达式对于所有s.范围->Expr->TcM的ExprcheckResolvedMetaStore 范围清空范围)
                                                                 MetaStore（本体g）针对所有s.MetaStore空MetaStore
                                                                 ([（可能是Expr，类型）]->g->Ontology g对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]参数 克克),
                        （（可能是Expr，类型）->Bool）->[（可能是EXR，类型）]->Bool对于所有（t:：*->*）a.可折叠t=>（a->Bool）->ta->Bool全部的 (可能是Expr->Bool对所有人来说。也许是一个->布尔什么都不是 （可能是Expr->Bool）->（（可能Expr，类型）->可能Expr）->（可能Expr，类型）->Bool对于所有的b c a。（b->c）->（a->b）->a->c。 （可能Expr，类型）->可能Expr对于所有a b.（a，b）->a有限状态试验) [（可能是Expr，Type）]参数'])

------------------------------------------------------------------------------
--主要生成算法

生成 :: 选择器 sel（选择） => sel（选择） -> 前列腺素F -> 类型 -> 也许 吧 国际 -> [实验]
生成：：sel->PGF->类型->可能Int->[Expr]生成 sel（选择）sel（选择） 前列腺素F前列腺素f 类型第y天 也许是Int数据处理程序 =
  [实验e（电子） | (MetaStore选择_,sel（选择）毫秒,实验e（电子）) <- （[（sel，TcError）]，[（MetaStore sel，sel，Expr）]）->[（MetaStore sel，sel，Expr）]对于所有a b.（a，b）->b信噪比 （[（sel，TcError）]，[（MetaStore sel，sel，Expr）]）->[（MetaStore sel，sel，Expr）]）->（[（sel，TcError）]，[（MetaStore sel，sel，Expr）]）->[（MetaStore sel，sel，Expr）]对于所有a b（a->b）->a->b$ 文章摘要->TcM选择Expr->MetaStore选择->sel（选择）->（[（sel，TcError）]，[（MetaStore sel，sel，Expr）]）对于所有s a。文章摘要->TcM系统a->MetaStore->秒->（[（s，TcError）]，[（MetaStore s，s，a）]）运行TCM (PGF->摘要摘要 前列腺素F前列腺素f)
                                (可能是Int->Scope->TType->TcM sel Expr对于所有sel。选择器选择=>可能是Int->Scope->TType->TcM sel Expr证明 也许是Int数据处理程序 范围清空范围 (环境->类型->TTypeT类型 [] 类型第y天) TcM sel Expr->（Expr->TcM sel Expr）->TcM sel Expr对于所有（m:：*->*）a b.Monad m=>m a->（a->m b）->m b>>= 范围->Expr->TcM sel Expr对于所有s.范围->Expr->TcM的ExprcheckResolvedMetaStore 范围清空范围)
                                MetaStore选择针对所有s.MetaStore空MetaStore sel（选择）sel（选择）]


证明 :: 选择器 sel（选择） => 也许 吧 国际 -> 范围 -> T类型 -> TcM公司 sel（选择） 实验
证明：：可能是Int->Scope->TType->TcM sel Expr证明 也许是Int数据处理程序 范围范围 (T类型 环境环境v1 (D类型 [海波]hypos1型 CId代码猫 [出口]电子系统1)) = 做
  环境与1相比 <- （Expr->TcM选择值）->[Expr]->TcM-sel Env对于所有（t:：*->*）（m:：*->*）a b。（可通过t，单峰m）=>（a->m b）->t a->m（t b）地图M (环境->Expr->TcM选择值对于所有s.Env->Expr->TcM值PGF公司。类型检查.eval 环境环境v1) [出口]电子系统1
  让 范围'：：scope范围' = 范围->环境->[Hypo]->范围对于所有a.范围->环境->[（a，CId，类型）]->范围exScope公司 范围范围 环境环境v1 [海波]hypos1型
  (实验铁,T类型 环境环境v2 (D类型 [海波]hypos2型 CId代码_ [出口]es2型)) <- CId->Scope->Maybe Int->TcM sel（Expr，TType）对于所有的s。选择器=>CId->Scope->Maybe Int->TcM（Expr，TType）选择 CId代码猫 范围范围' 也许是Int数据处理程序
  案例 也许是Int数据处理程序 属于
    只是 国际0 | 布尔->布尔不 ([Hypo]->布尔对于所有（t:：*->*）a.可折叠t=>ta->Bool无效的 [海波]hypos2型) -> TcM选择（）对于所有（m:：*->*）a.MonadPlus m=>mamzero（零点）
    也许是Int_                          -> （）->TcM选择（）对于所有（m:：*->*）a.Monad m=>a->ma返回 ()
  (环境环境v2,[（BindType，或TType Expr）]参数) <- 范围->环境->[Hypo]->TcM sel（环境，[（绑定类型，任意TType Expr）]）对于所有s。范围->环境->[（a，CId，类型）]->TcM s（环境，[（a）任一TType Expr）]）mk环境 范围范围' 环境环境v2 [海波]尿道下裂2
  环境vs2（vs2） <- （Expr->TcM选择值）->[Expr]->TcM-sel Env对于所有（t:：*->*）（m:：*->*）a b。（可通过t，单峰m）=>（a->m b）->t a->m（t b）地图M (环境->Expr->TcM选择值对于所有s.Env->Expr->TcM值PGF公司。类型检查.eval 环境环境2) [出口]es2型
  [TcM选择（）]->TcM选择对于所有（t:：*->*）（m:：*->*）a。（可折叠t，单体m）=>t（毫安）->米（）顺序_ [（对于所有a.TcM sel a）->（Int->（Expr->TcM sel（））->TcM sel（））->国际->价值->价值->TcM选择（）对于所有s。（对于所有a.TcM s a）->（Int->（Expr->TcM（））->TcM（））->国际->价值->价值->TcM（）eq值 对于所有a.TcM sel a对于所有（m:：*->*）a.MonadPlus m=>mamzero（零点） Int->（Expr->TcM sel（））->TcM sel（）对于所有s.Int->（Expr->TcM s（））->TcM s（）暂停 (范围->Int范围大小 范围作用域') 价值第1版 价值第2版 | (价值第1版,价值第2版) <- 环境->环境->[（值，值）]对于所有a b.[a]->[b]->[（a，b）]拉链 环境与1相比 环境vs2（vs2）]
  [出口]锿 <- （（绑定类型，任意TType Expr）->TcM sel Expr）->[（BindType，任一TType Expr）]->TcM sel[Expr]对于所有（t:：*->*）（m:：*->*）a b。（可通过t，单峰m）=>（a->m b）->t a->m（t b）地图M (范围->（BindType，任一TType Expr）->TcM sel Expr有孔虫。选择器选择=>范围->（BindType，任一TType Expr）->TcM sel Expr下降 范围范围') [（BindType，或TType Expr）]参数
  Expr->TcM sel Expr（膨胀->TcM选择膨胀）对于所有（m:：*->*）a.Monad m=>a->ma返回 ([Hypo]->Expr->Expr对于所有c.[（BindType，CId，c）]->Expr->Expr防抱死制动系统 [海波]hypos1型 (（支出->支出->支出）->支出->[支出]->支出对于所有（t:：*->*）b a。可折叠t=>（b->a->b）->b->t a->b折叠 导出->导出->导出EApp公司 实验铁 [出口]锿))
  哪里
    挂起：：Int->（Expr->TcM s（））->TcM s（）暂停 国际我 Expr->TcM（）c（c） = 做
      元值毫伏 <- Int->TcM（元值）对于所有s.Int->TcM（元值）获取元数据 国际我
      案例 元值毫伏 属于
        MBound（绑定） 实验e（电子） -> 实验->TcM s（）c（c） 实验e（电子）
        MUnbound公司 秒x个 范围范围 T类型tty公司 [Expr->TcM（）]反恐精英 -> Int->MetaValues->TcM（）对于所有s.Int->MetaValue s->TcM s（）setMeta（设置元数据） 国际我 (s->范围->TType->[Expr->TcM s（）]->MetaValue s对于所有s.s->范围->TType->[Expr->TcM（）]->MetaValue sMUnbound公司 秒x个 范围范围 T类型tty公司 (实验->TcM s（）c（c）（Expr->TcM s（））->[Expr->TcM s（）]->[Expr->TcM s对于所有a.a->[a]->[a]:[Expr->TcM（）]反恐精英))

    abs:：[（BindType，CId，c）]->Expr->Expr防抱死制动系统 []                实验e（电子） = 实验e（电子）
    防抱死制动系统 ((绑定类型英国电信公司,CId代码x个,c（c）第y天):[（绑定类型，CId，c）]低血压) 实验e（电子） = 绑定类型->CId->Expr->ExprEAbs公司 绑定类型英国电信公司 CId代码x个 ([（绑定类型，CId，c）]->Expr->Expr防抱死制动系统 [（绑定类型，CId，c）]低血压 实验e（电子）)

    exScope:：范围->环境->[（a，CId，类型）]->范围exScope公司 范围范围 环境环境价值 []                = 范围范围
    exScope公司 范围范围 环境环境价值 ((一英国电信公司,CId代码x个,类型第y天):[（a，CId，类型）]低血压) = 
       让 环境'：：环境环境' | CId代码x个 CId->CId->Bool对于所有a.等式a=>a->a->Bool/= CId代码野生CID = Int->Env->值VGen公司 (范围->Int范围大小 范围范围) [] 价值->环境->环境对于所有a.a->[a]->[a]: 环境环境价值
                | 布尔否则    = 环境环境价值
       在里面 范围->环境->[（a，CId，Type）]->范围exScope公司 (CId->TT类型->范围->范围添加范围变量 CId代码x个 (环境->类型->TTypeT类型 环境环境价值 类型第y天) 范围范围) 环境环境' [（a，CId，类型）]低血压

    mkEnv:：范围->环境->[（a，CId，类型）]->TcM s（环境，[（a）任一TType Expr）]）mk环境 范围范围 环境环境价值 []                = （环境，[（a，任一TType Expr）]）->TcM（环境，[（a，任一TType Expr）]）对于所有（m:：*->*）a.Monad m=>a->ma返回 (环境环境价值,[])
    mk环境 范围范围 环境环境价值 ((一英国电信公司,CId代码x个,类型第y天):[（a，CId，类型）]低血压) = 做
      (环境环境价值,TType Expr之一参数) <- 如果 CId代码x个 CId->CId->Bool对于所有a.等式a=>a->a->Bool/= CId代码野生CID
                    然后 做 国际我 <- 范围->TType->TcM的Int对于所有s.范围->TType->TcM的Int新Meta 范围范围 (环境->类型->TTypeT类型 环境环境价值 类型第y天)
                            （环境，任一TType Expr）->TcM s（环境，任意TType Expr）对于所有（m:：*->*）a.Monad m=>a->ma返回 (内部->环境->环境->价值VMeta公司 国际我 (范围->环境范围环境 范围范围) [] 值->环境->环境对于所有a.a->[a]->[a]: 环境环境价值,Expr->任一TType Expr对于所有b.b->要么a b赖特 (内部->外部EMeta公司 国际我))
                    其他的 （环境，任一TType Expr）->TcM s（环境，任意TType Expr）对于所有（m:：*->*）a.Monad m=>a->ma返回 (环境环境价值,TType->任一TType Expr对于所有的b.a->要么a b左侧 (环境->类型->TTypeT类型 环境环境价值 类型第y天))
      (环境环境价值,[（a）任一TType Expr）]参数) <- 范围->环境->[（a，CId，类型）]->TcM s（环境，[（a）任一TType Expr）]）mk环境 范围范围 环境环境价值 [（a，CId，类型）]低血压
      （环境，[（a，任一TType Expr）]）->TcM（环境，[（a，任一TType Expr）]）对于所有（m:：*->*）a.Monad m=>a->ma返回 (环境环境价值,(一英国电信公司,TType Expr之一参数)（a，TType Expr之一）->[（a，任一TType Expr）]->[（a）任一TType-Expr）]对于所有a.a->[a]->[a]:[（a）任一TType Expr）]参数)

    下降：：范围->（BindType，任一TType Expr）->TcM sel Expr下降 范围范围 (绑定类型英国电信公司,TType Expr之一参数) = 做
      让 dp'：：可能是Intdp' = （智力->智力）->可能智力->可能智力对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb功能性维修计划 (（国际->国际->国际）->国际->国内->国际对于所有a到b到c（a到>b到>c）->b到>a到>c轻弹 (-) 国际1) 也许是Int数据处理程序
      实验e（电子） <- 案例 TType Expr之一参数 属于
             赖特 实验e（电子）  -> Expr->TcM sel Expr（膨胀->TcM选择膨胀）对于所有（m:：*->*）a.莫纳德m=>a->m a返回 实验e（电子）
             左侧 T类型tty公司 -> 也许Int->Scope->TType->TcM sel Expr对于所有sel。选择器选择=>可能是Int->Scope->TType->TcM sel Expr证明 也许是Intdp’ 范围范围 T类型tty公司
      实验e（电子） <- 案例 绑定类型英国电信公司 属于
             绑定类型隐性的 -> Expr->TcM sel Expr（膨胀->TcM选择膨胀）对于所有（m:：*->*）a.Monad m=>a->ma返回 (Expr->导出EImplArg公司 实验e（电子）)
             绑定类型明确的 -> Expr->TcM sel Expr（膨胀->TcM选择膨胀）对于所有（m:：*->*）a.Monad m=>a->ma返回 实验e（电子）
      Expr->TcM sel Expr（膨胀->TcM选择膨胀）对于所有（m:：*->*）a.Monad m=>a->ma返回 实验e（电子）


--用于随机生成的辅助函数。每一次之后
--成功我们必须重新开始搜索，以找到足够不同的解决方案。
重新启动 :: 随机生成 克 => 克 -> (克 -> [一]) -> [一]
重新启动：：g->（g->[a]）->[a]重新启动 克克 g->[a]（f） =
  让 (克第1组,克第二组) = g->（g，g）对于所有g.RandomGen g=>g->（g，g）分裂 克克
  在里面 案例 g->[a]（f） 克第1组 属于
       []     -> []
       (一x个:【a】X轴) -> 一x个 a->[a]->[a]对于所有a.a->[a]->[a]: g->（g->[a]）->[a]对于所有g a.RandomGen g=>g->（g->[a]）->[a]重新启动 克第二组 g->[a]（f）


------------------------------------------------------------------------------
--选择器

实例 选择器 () 哪里
  拆分选择器：：（）->（（），（））拆分选择器 ()秒 = (()秒,()秒)
  选择：：CId->Scope->Maybe Int->TcM（）（Expr，TType）选择 CId公司猫 范围范围 也许是Int数据处理程序 = 做
    [（双精度、Expr、TType）]氏族 <- 范围->CId->TcM（）[（双精度、Expr、TType）]对于所有s.范围->CId->TcM s[（双精度、Expr、TType）]类型生成器 范围范围 CId代码猫
    （对于所有b。文章摘要->（（Expr，TType）->MetaStore（）->（）->b->b）->（T错误->（）->b->b）->MetaStore（）-> ()->b条->b）->TcM（）（表达式，T类型）对于所有s a。（对于所有b。文章摘要->（a->MetaStore s->s->b->b）->（T错误->s->b->b）->MetaStore->秒->b条->b）->TcM系统a列车控制模块 (\文章摘要禁酒 （Expr，TType）->MetaStore（）->（）->b->bk个 TcError->（）->b->b小时 -> （（Expr，TType）->MetaStore（）->（）->b->b）->[（Double，Expr，TType）]->MetaStore（）->（）->b->b对于所有的b t t b a。（（a，b）->t->t->b->b）->[（a，a，biter公司 （Expr，TType）->MetaStore（）->（）->b->bk个 [（双精度、Expr、TType）]氏族)
    哪里
      iter：：（a，b）->t->t->b->b）->[（a，a，biter公司 （a，b）->t->t->b->bk个 []              t吨毫秒 t吨秒 = b->b对于所有a.a->a身份证件
      iter公司 （a，b）->t->t->b->bk个 ((一_,一e（电子）,b条tty公司):[（a、a、b）]fns公司) t吨毫秒 t吨秒 = （a，b）->t->t->b->bk个 (一e（电子）,b条tty公司) t吨毫秒 t吨秒 （b->b）->（b->b）->b->b对于所有的b c a。（b->c）->（a->b）->a->c。 （（a，b）->t->t->b->b）->[（a，a，biter公司 （a，b）->t->t->b->bk个 [（a、a、b）]fns公司 t吨毫秒 t吨秒


实例 随机生成 克 => 选择器 (身份 克) 哪里
  分割选择器：：标识g->（标识g，标识g）拆分选择器 (身份 克克) = 让 (克第1组,克第二组) = g->（g，g）对于所有g.RandomGen g=>g->（g，g）分裂 克克
                               在里面 (g->标识g对于所有a.a->Identity标识身份 克第1组, g->标识g对于所有a.a->Identity标识身份 克第二组)

  选择：：CId->Scope->Maybe Int->TcM（标识g）（Expr，TType）选择 CId代码猫 范围范围 也许是Int数据处理程序 = 做
    [（双精度、Expr、TType）]氏族 <- 作用域->CId->TcM（标识g）[（Double，Expr，TType）]对于所有s.范围->CId->TcM s[（双精度、Expr、TType）]类型生成器 范围范围 CId代码猫
    （对于所有b。文章摘要->（（Expr，T类型）->MetaStore（标识g）->标识g->b->b）->（Tc错误->标识g->b->b）->MetaStore（标识g）->标识g->b条->b）->TcM（标识g）（Expr，TType）对于所有s a。（对于所有b。文章摘要->（a->MetaStore s->s->b->b）->（T错误->s->b->b）->MetaStore->秒->b条->b）->TcM系统a列车控制模块 (\文章摘要禁酒 （Expr，TType）->MetaStore（标识g）->标识g->b->bk个 Tc错误->标识g->b->b小时 -> （（Expr，TType）->MetaStore（Identity g）->Identity g->b->b）->双精度->[（双精度、Expr、TType）]->MetaStore（标识g）->标识g->b条->b条对于所有a t b。随机生成a=>（（Expr，TType）->t->标识a->b->b）->双精度->[（双精度，Expr，TType）]->t->标识a->b->biter公司 （Expr，TType）->MetaStore（标识g）->标识g->b->bk个 双重1 [（双精度、Expr、TType）]氏族)
    哪里
      iter:：（（Expr，TType）->t->标识a->b->b）->双精度->[（双精度，Expr，TType）]->t->标识a->b->biter公司 （Expr，TType）->t->标识a->b->bk个 双重对 []   t吨毫秒 (身份 一克) = b->b对于所有a.a->a身份证件
      iter公司 （Expr，TType）->t->标识a->b->bk个 双重对 [（双精度、Expr、TType）]氏族 t吨毫秒 (身份 一克) = 让 (双重d日,一g’)    = （Double，Double）->a->（Doubler，a）对于所有a g（随机a，随机生成g）=>（a，a）->g->（a，g）随机数R (双重0,双重对) 一克
                                          (一第1组,一第二组)   = a->（a，a）对于所有g.RandomGen g=>g->（g，g）分裂 一g’
                                          (双重p’,（Expr，T类型）（_ty）,[（双精度、Expr、TType）]氏族') = 双重->[（双精度、Expr、TType）]->（双精度，（Expr，TType），[（双精度、Expr，T类型）]）打 双重d日 [（双精度、Expr、TType）]氏族
                                      在里面 （Expr，TType）->t->标识a->b->bk个 （Expr，T类型）（_ty） t吨毫秒 (a->Identity标识对于所有a.a->Identity标识身份 一第1组) （b->b）->（b->b）->b->b对于所有的b c a。（b->c）->（a->b）->a->c。 （（Expr，TType）->t->标识a->b->b）->双精度->[（双精度，Expr，TType）]->t->标识a->b->biter公司 （Expr，TType）->t->标识a->b->bk个 (双重对双->双->双对于所有a.数字a=>a->a->a-双重p’) [（Double、Expr、TType）]氏族' t吨毫秒 (a->Identity标识对于所有a.a->Identity标识身份 一第二组)

      打 :: 双重 -> [(双重,实验,T类型)] -> (双重,(实验,T类型),[(双重,实验,T类型)])
      命中：：加倍->[（双精度、Expr、TType）]->（Double，（Expr，TType），[（Double，Expr，TType）]）打 双重d日 (gen:：（双精度、Expr、TType）消息@(双重对,实验e（电子）,T类型第y天):[（双精度、Expr、TType）]氏族)
        | 双重d日 双->双->Bool对于所有a.订单a=>a->a->Bool< 双重对 布尔->布尔->布尔|| [（Double，Expr，TType）]->布尔对于所有（t:：*->*）a.可折叠t=>ta->Bool无效的 [（双精度、Expr、TType）]氏族 = (双重对,(实验e（电子）,T类型第y天),[（双精度、Expr、TType）]氏族)
        | 布尔否则 = 让 (双重p’,（Expr，T类型）（_ty）',[（双精度、Expr、TType）]氏族') = 双重->[（双精度、Expr、TType）]->（双精度，（Expr，TType），[（双精度、Expr，T类型）]）打 (双重d日双->双->双对于所有a.数字a=>a->a->a-双重对) [（双精度、Expr、TType）]氏族
                      在里面 (双重p’,（Expr，T类型）（_ty）',（双精度、Expr、TType）消息（双精度、Expr、TType）->[（Double，Expr，TType）]->[（Double，Expr，TType）]对于所有a.a->[a]->[a]:[（双精度、Expr、TType）]氏族')


数据 本体论 一 = 本体论 [(也许 吧 实验, 类型)] 一

实例 随机生成 克 => 选择器 (本体论 克) 哪里
  splitSelector:：本体g->（本体g，本体g）拆分选择器 (本体论 [（可能是Expr，类型）]参数 克克) = 让 (克第1组,克第二组) = g->（g，g）对于所有g.RandomGen g=>g->（g，g）分裂 克克
                                    在里面 ([（可能是表达式，类型）]->g->Ontology g对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]参数 克第1组, [（可能是Expr，类型）]->g->Ontology g对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]参数 克第二组)

  选择：：CId->Scope->Maybe Int->TcM（本体g）（Expr，TType）选择 CId代码猫 范围范围 也许是Int数据处理程序 = 做
    本体论 [（可能是Expr，类型）]参数 克克 <- TcM（本体g）对于所有s（m:：*->*）。MonadStates s m=>m s（单数状态）得到
    案例 [（可能是Expr，类型）]->CId代码->[（可能是Expr，类型）]->[（可能Expr，类型，[（可能Expr，类型）]）]对于所有a。[（a，类型）]->CId->[（a、类型）]->[（a），类型，[（a；类型）]）]pickArg（选择参数） [] CId代码猫 [（可能是Expr，类型）]参数 属于
      []   -> 做 [（双精度、Expr、TType）]氏族 <- 范围->CId->TcM（本体g）[（Double、Expr、TType）]对于所有s.范围->CId->TcM s[（双精度、Expr、TType）]类型生成器 范围范围 CId代码猫
                 （对于所有b。文章摘要->（（Expr，T类型）->MetaStore（本体g）->本体g->b->b）->（TcError->Ontology g->b->b）->MetaStore（本体g）->本体g->b条->b）->TcM（本体g）（Expr，TType）对于所有的a。（对于所有b。文章摘要->（a->MetaStore s->s->b->b）->（T错误->s->b->b）->MetaStore->秒->b条->b）->TcM系统a列车控制模块 (\文章摘要禁酒 （Expr，TType）->MetaStore（本体g）->本体g->b->bk个 TcError->Ontology g->b->b小时 -> （（Expr，TType）->MetaStore（本体g）->本体g->b->b）->双精度->[（双精度、Expr、TType）]->MetaStore（本体g）->本体g->b条->b条对于所有a t b。随机生成a=>（（Expr，TType）->t->本体a->b->b）->Double->[（Double，Expr，TType）]->t->本体a->b->biter公司 （Expr，TType）->MetaStore（本体g）->本体g->b->bk个 双重1 [（双精度、Expr、TType）]氏族)
      [（可能Expr，类型，[（可能Expr，类型）]）]alts公司 -> [TcM（本体g）（Expr，TType）]->TcM（Ontology g）（Expr，TTtype）对于所有（t:：*->*）（m:：*->*）a。（可折叠t，MonadPlus m）=>t（毫安）->毫安毫秒 [  案例 可能是Exprmb（e） 属于
                        只是 实验e（电子）  -> 做 本体g->TcM（本体g）（）对于所有s（m:：*->*）。MonadStates s m=>s->m（）放 ([（可能是表达式，类型）]->g->Ontology g对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]参数 克克)
                                      （Expr，TType）->TcM（Ontology g）（Expr，TTtype）对于所有（m:：*->*）a.Monad m=>a->ma返回 (实验e（电子）, 环境->类型->TTypeT类型 [] 类型第y天)
                        可能是Expr没有什么 -> TcM（本体g）（Expr，TType）对于所有（m:：*->*）a.MonadPlus m=>mamzero（零点）
                    | (可能是Exprmb（e）,类型第y天,[（可能是Expr，类型）]参数) <- [（可能Expr，类型，[（可能Expr，类型）]）]备选方案]
    哪里
      iter：：（（Expr，TType）->t->本体a->b->b）->Double->[（Double，Expr，TType）]->t->本体a->b->biter公司 （Expr，TType）->t->本体a->b->bk个 双重对 []   t吨毫秒 (本体论 [（可能是Expr，类型）]总工程师 一克) = b->b对于所有a.a->a身份证件
      iter公司 （Expr，TType）->t->本体a->b->bk个 双重对 [（双精度、Expr、TType）]氏族 t吨毫秒 (本体论 [（可能是Expr，类型）]总工程师 一克) =
        让 (双重d日,一g’)    = （双人间，双人间）->a->（双人间，a）对于所有g（Random a，RandomGen g）=>（a，a）->g->（a，g）随机数R (双重0,双重对) 一克
            (一第1组,一第二组)   = a->（a，a）对于所有g.RandomGen g=>g->（g，g）分裂 一g’
            (双重p’,（Expr，T类型）（_ty）,[（Double、Expr、TType）]氏族') = 双重->[（Double、Expr、TType）]->（双精度，（Expr，TType），[（双精度、Expr，T类型）]）打 双重d日 [（双精度、Expr、TType）]氏族
        在里面 （Expr，TType）->t->本体a->b->bk个 （Expr，T类型）（_ty） t吨毫秒 ([（可能是Expr，类型）]->a->Ontology a对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]总工程师 一第1组) （b->b）->（b->b）->b->b对于所有的b c a。（b->c）->（a->b）->a->c。 （（Expr，TType）->t->本体a->b->b）->Double->[（Double，Expr，TType）]->t->本体a->b->biter公司 （Expr，TType）->t->本体a->b->bk个 (双重对双->双->双对于所有a.数字a=>a->a->a-双重p’) [（双精度、Expr、TType）]氏族' t吨毫秒 ([（可能是Expr，类型）]->a->Ontology a对于所有a.[（可能是Expr，Type）]->a->Ontology a本体论 [（可能是Expr，类型）]总工程师 一第二组)

      打 :: 双重 -> [(双重,实验,T类型)] -> (双重,(实验,T类型),[(双重,实验,T类型)])
      命中：：加倍->[（Double、Expr、TType）]->（双精度，（Expr，TType），[（双精度、Expr，T类型）]）打 双重d日 (gen:：（双精度、Expr、TType）消息@(双重对,实验e（电子）,T类型第y天):[（双精度、Expr、TType）]氏族) | 双重d日 双->双->Bool对于所有a.订单a=>a->a->Bool< 双重对 布尔->布尔->布尔|| [（Double，Expr，TType）]->布尔对于所有（t:：*->*）a.可折叠t=>ta->Bool无效的 [（Double、Expr、TType）]氏族 = (双重对,(实验e（电子）,T类型第y天),[（双精度、Expr、TType）]氏族)
                                | 布尔否则          = 让 (双重p’,（Expr，T类型）（_ty）',[（双精度、Expr、TType）]氏族') = 双重->[（双精度、Expr、TType）]->（双精度，（Expr，TType），[（双精度、Expr，T类型）]）打 (双重d日双->双->双对于所有a.数字a=>a->a->a-双重对) [（双精度、Expr、TType）]氏族
                                                       在里面 (双重p’,（Expr，T类型）（_ty）',（双精度、Expr、TType）消息（双精度、Expr、TType）->[（Double，Expr，TType）]->[（Douple，Expr，TType]对于所有a.a->[a]->[a]:[（双精度、Expr、TType）]氏族')

      pickArg:：[（a，类型）]->CId->[（a、类型）]->[（a），类型，[（a；类型）]）]pickArg（选择参数） [（a，类型）]参数' CId公司猫' [] = []
      pickArg（选择参数） [（a，类型）]参数' CId代码猫' (arg:：（a，类型）参数@(一mb（e）,ty：：类型第y天@(D类型 [海波]_ CId代码猫 [出口]_)):[（a，类型）]参数)
        | CId代码猫' CId->CId->Bool对于所有a.等式a=>a->a->Bool== CId代码猫 = (一mb（e）, 类型第y天, （[（a，类型）]->（a，型号）->[（a、类型）]）->[（a，类型）]->[（a、类型）]->[（a），类型）]对于所有（t:：*->*）b a。可折叠t=>（b->a->b）->b->t a->b折叠 (（（a，类型）->[（a，型号）]->[（b，类型）]）->[（a，类型）]->（a，型号）->[（a），类型）]对于所有a到b到c（a到>b到>c）->b到>a到>c轻弹 (:)) [（a，类型）]参数 [（a，类型）]参数') （a，类型，[（a，型号）]）->[（a，类型，[对于所有a.a->[a]->[a]: 
                        [（a，类型）]->CId->[（a、类型）]->[（a），类型，[（a；类型）]）]pickArg（选择参数） (（a，类型）参数（a，类型）->[（a，型号）]->[（b，型号）]对于所有a.a->[a]->[a]:[（a，类型）]参数') CId代码猫' [（a，类型）]参数
        | 布尔否则   = [（a，类型）]->CId->[（a、类型）]->[（a），类型，[（a；类型）]）]pickArg (（a，类型）参数（a，类型）->[（a，类型）]->[（a，类型）]对于所有a.a->[a]->[a]:[（a，类型）]参数') CId代码猫' [（a，类型）]参数