[{"data":1,"prerenderedAt":1180},["ShallowReactive",2],{"navigation":3,"-design-generics-system":239,"-design-generics-system-surround":1177},[4,159],{"title":5,"path":6,"stem":7,"children":8,"icon":10},"指南","\u002Fguide","00.guide\u002F00.index",[9,11,16,21,53,84,116,142],{"title":5,"path":6,"stem":7,"icon":10},"lucide:book",{"title":12,"path":13,"stem":14,"icon":15},"快速开始","\u002Fguide\u002Fgetting-started","00.guide\u002F01.getting-started","lucide:rocket",{"title":17,"path":18,"stem":19,"icon":20},"基础语法","\u002Fguide\u002Fbasic-syntax","00.guide\u002F02.basic-syntax","lucide:code-2",{"title":22,"path":23,"stem":24,"children":25,"icon":27},"数据类型","\u002Fguide\u002Fdata-types","00.guide\u002F03.data-types\u002F00.index",[26,28,33,38,43,48],{"title":22,"path":23,"stem":24,"icon":27},"lucide:database",{"title":29,"path":30,"stem":31,"icon":32},"基本类型","\u002Fguide\u002Fdata-types\u002Fbasic_types","00.guide\u002F03.data-types\u002F01.basic_types","lucide:type",{"title":34,"path":35,"stem":36,"icon":37},"复合类型","\u002Fguide\u002Fdata-types\u002Fcomposite_types","00.guide\u002F03.data-types\u002F02.composite_types","lucide:layers",{"title":39,"path":40,"stem":41,"icon":42},"类型推导","\u002Fguide\u002Fdata-types\u002Ftype_inference","00.guide\u002F03.data-types\u002F03.type_inference","lucide:brain-circuit",{"title":44,"path":45,"stem":46,"icon":47},"结构体","\u002Fguide\u002Fdata-types\u002Fstruct","00.guide\u002F03.data-types\u002F04.struct","lucide:box-select",{"title":49,"path":50,"stem":51,"icon":52},"内建类型表面","\u002Fguide\u002Fdata-types\u002Fbuilt-in-surface","00.guide\u002F03.data-types\u002F05.built-in-surface","lucide:wrench",{"title":54,"path":55,"stem":56,"children":57,"icon":59},"流程控制","\u002Fguide\u002Fcontrol-flow","00.guide\u002F04.control-flow\u002F00.index",[58,60,64,69,74,79],{"title":54,"path":55,"stem":56,"icon":59},"lucide:git-branch",{"title":61,"path":62,"stem":63,"icon":59},"if 表达式","\u002Fguide\u002Fcontrol-flow\u002Fif-expressions","00.guide\u002F04.control-flow\u002F01.if-expressions",{"title":65,"path":66,"stem":67,"icon":68},"for 循环","\u002Fguide\u002Fcontrol-flow\u002Ffor-loops","00.guide\u002F04.control-flow\u002F02.for-loops","lucide:repeat",{"title":70,"path":71,"stem":72,"icon":73},"break 和 continue","\u002Fguide\u002Fcontrol-flow\u002Fbreak-continue","00.guide\u002F04.control-flow\u002F03.break-continue","lucide:skip-forward",{"title":75,"path":76,"stem":77,"icon":78},"return","\u002Fguide\u002Fcontrol-flow\u002Freturn","00.guide\u002F04.control-flow\u002F04.return","lucide:corner-up-left",{"title":80,"path":81,"stem":82,"icon":83},"注意事项","\u002Fguide\u002Fcontrol-flow\u002Fnotes","00.guide\u002F04.control-flow\u002F05.notes","lucide:alert-triangle",{"title":85,"path":86,"stem":87,"children":88,"icon":90},"函数","\u002Fguide\u002Ffunctions","00.guide\u002F05.functions\u002F00.index",[89,91,96,101,106,111],{"title":85,"path":86,"stem":87,"icon":90},"lucide:braces",{"title":92,"path":93,"stem":94,"icon":95},"基础函数","\u002Fguide\u002Ffunctions\u002Fbasic-functions","00.guide\u002F05.functions\u002F01.basic-functions","lucide:function-square",{"title":97,"path":98,"stem":99,"icon":100},"参数与默认值","\u002Fguide\u002Ffunctions\u002Fadvanced-parameters","00.guide\u002F05.functions\u002F02.advanced-parameters","lucide:settings-2",{"title":102,"path":103,"stem":104,"icon":105},"匿名函数","\u002Fguide\u002Ffunctions\u002Fclosures","00.guide\u002F05.functions\u002F03.closures","lucide:curly-braces",{"title":107,"path":108,"stem":109,"icon":110},"内建函数","\u002Fguide\u002Ffunctions\u002Fbuiltin-functions","00.guide\u002F05.functions\u002F04.builtin-functions","lucide:box",{"title":112,"path":113,"stem":114,"icon":115},"main 函数","\u002Fguide\u002Ffunctions\u002Fmain-function","00.guide\u002F05.functions\u002F05.main-function","lucide:play",{"title":117,"path":118,"stem":119,"children":120,"icon":37},"模块化","\u002Fguide\u002Fmodules","00.guide\u002F06.modules\u002F00.index",[121,122,127,132,137],{"title":117,"path":118,"stem":119,"icon":37},{"title":123,"path":124,"stem":125,"icon":126},"导出","\u002Fguide\u002Fmodules\u002Fexport","00.guide\u002F06.modules\u002F01.export","lucide:upload",{"title":128,"path":129,"stem":130,"icon":131},"导入","\u002Fguide\u002Fmodules\u002Fimport","00.guide\u002F06.modules\u002F02.import","lucide:download",{"title":133,"path":134,"stem":135,"icon":136},"最佳实践","\u002Fguide\u002Fmodules\u002Fbest-practices","00.guide\u002F06.modules\u002F03.best-practices","lucide:check-circle-2",{"title":138,"path":139,"stem":140,"icon":141},"完整示例","\u002Fguide\u002Fmodules\u002Fcomplete-example","00.guide\u002F06.modules\u002F04.complete-example","lucide:file-code-2",{"title":143,"path":144,"stem":145,"children":146,"icon":148},"高级特性概述","\u002Fguide\u002Fadvanced","00.guide\u002F07.advanced\u002F00.index",[147,149,154],{"title":143,"path":144,"stem":145,"icon":148},"lucide:zap",{"title":150,"path":151,"stem":152,"icon":153},"泛型","\u002Fguide\u002Fadvanced\u002Fgenerics","00.guide\u002F07.advanced\u002F05.generics","lucide:git-merge",{"title":155,"path":156,"stem":157,"icon":158},"类型转换","\u002Fguide\u002Fadvanced\u002Ftype-conversion","00.guide\u002F07.advanced\u002F06.type-conversion","lucide:refresh-cw",{"title":160,"path":161,"stem":162,"children":163,"icon":15},"设计","\u002Fdesign","01.design\u002F00.index",[164,165,169,173,177,181,185,189,193,197,201,205,209,213,217,221,225,229,232,235],{"title":160,"path":161,"stem":162,"icon":15},{"title":166,"path":167,"stem":168},"CST 特性","\u002Fdesign\u002Fcst-features","01.design\u002F01.cst-features",{"title":170,"path":171,"stem":172},"注释关联规则","\u002Fdesign\u002Fcomment-association","01.design\u002F02.comment-association",{"title":174,"path":175,"stem":176},"错误处理","\u002Fdesign\u002Ferror-handling","01.design\u002F03.error-handling",{"title":178,"path":179,"stem":180},"代码优化","\u002Fdesign\u002Foptimization","01.design\u002F04.optimization",{"title":182,"path":183,"stem":184},"注释保留","\u002Fdesign\u002Fcomments","01.design\u002F05.comments",{"title":186,"path":187,"stem":188},"结构体设计","\u002Fdesign\u002Fstruct-design","01.design\u002F06.struct-design",{"title":190,"path":191,"stem":192},"comparable 约束设计","\u002Fdesign\u002Fcomparable-constraint","01.design\u002F07.comparable-constraint",{"title":194,"path":195,"stem":196},"文档分层约定","\u002Fdesign\u002Fdocumentation-convention","01.design\u002F08.documentation-convention",{"title":198,"path":199,"stem":200},"类型系统总纲","\u002Fdesign\u002Ftype-system","01.design\u002F09.type-system",{"title":202,"path":203,"stem":204},"泛型系统","\u002Fdesign\u002Fgenerics-system","01.design\u002F10.generics-system",{"title":206,"path":207,"stem":208},"值语义与共享语义","\u002Fdesign\u002Fvalue-and-sharing-semantics","01.design\u002F11.value-and-sharing-semantics",{"title":210,"path":211,"stem":212},"函数与调用","\u002Fdesign\u002Ffunctions-and-calls","01.design\u002F12.functions-and-calls",{"title":214,"path":215,"stem":216},"表达式与语句","\u002Fdesign\u002Fexpressions-and-statements","01.design\u002F13.expressions-and-statements",{"title":218,"path":219,"stem":220},"模块系统","\u002Fdesign\u002Fmodule-system","01.design\u002F14.module-system",{"title":222,"path":223,"stem":224},"渲染内建","\u002Fdesign\u002Frender-intrinsics","01.design\u002F15.render-intrinsics",{"title":226,"path":227,"stem":228},"Any 设计","\u002Fdesign\u002Fany-design","01.design\u002F16.any-design",{"title":49,"path":230,"stem":231},"\u002Fdesign\u002Fbuilt-in-types-surface","01.design\u002F17.built-in-types-surface",{"title":107,"path":233,"stem":234},"\u002Fdesign\u002Fbuilt-in-functions","01.design\u002F18.built-in-functions",{"title":236,"path":237,"stem":238},"内建结构体与运行时类型","\u002Fdesign\u002Fbuilt-in-structs-and-runtime-types","01.design\u002F19.built-in-structs-and-runtime-types",{"id":240,"title":202,"body":241,"description":326,"extension":1172,"meta":1173,"navigation":1174,"path":203,"seo":1175,"stem":204,"__hash__":1176},"content\u002F01.design\u002F10.generics-system.md",{"type":242,"value":243,"toc":1148},"minimark",[244,248,251,255,274,277,297,300,303,317,320,373,376,390,393,396,439,442,450,453,456,458,473,476,484,487,490,492,507,510,519,523,526,537,539,548,559,568,571,574,594,596,611,614,617,620,623,626,646,653,660,665,667,698,701,703,712,715,724,727,730,733,752,754,768,775,783,789,811,813,837,840,843,865,868,874,877,888,890,913,916,919,936,939,942,945,947,955,957,977,980,1007,1010,1013,1016,1042,1045,1056,1059,1065,1068,1085,1088,1091,1094,1108,1111,1114,1117,1144],[245,246,247],"p",{},"本文档收敛 Dujie 第一阶段的简单泛型系统。",[245,249,250],{},"目标不是建立复杂的类型参数体系，而是提供足够支撑通用容器、简单复用和少量约束检查的最小泛型能力。",[252,253,254],"h2",{"id":254},"设计目标",[256,257,258,262,265,268,271],"ul",{},[259,260,261],"li",{},"只提供最小可用的泛型能力",[259,263,264],{},"语法简单",[259,266,267],{},"推导边界清楚",[259,269,270],{},"不引入复杂子类型、trait 系统或高阶类型",[259,272,273],{},"不让实现细节反推语言语义",[252,275,276],{"id":276},"总体原则",[278,279,281,285,288,291,294],"steps",{"level":280},"4",[282,283,284],"h4",{},"泛型系统保持简单",[282,286,287],{},"类型位置优先显式",[282,289,290],{},"函数调用位置只做局部、可解释的推导",[282,292,293],{},"第一阶段只支持极小的约束集合",[282,295,296],{},"不做复杂的跨表达式反向推导",[252,298,299],{"id":299},"支持范围",[245,301,302],{},"第一阶段泛型只允许出现在：",[256,304,305,312],{},[259,306,307,308],{},"顶层 ",[309,310,311],"code",{},"func",[259,313,307,314],{},[309,315,316],{},"struct",[245,318,319],{},"例如：",[321,322,327],"pre",{"className":323,"code":324,"language":325,"meta":326,"style":326},"language-dj shiki shiki-themes github-light github-dark github-dark","func id\u003CT>(x: T) -> T {\n    x\n}\n\nstruct Box\u003CT> {\n    value: T,\n}\n","dj","",[309,328,329,337,343,349,356,362,368],{"__ignoreMap":326},[330,331,334],"span",{"class":332,"line":333},"line",1,[330,335,336],{},"func id\u003CT>(x: T) -> T {\n",[330,338,340],{"class":332,"line":339},2,[330,341,342],{},"    x\n",[330,344,346],{"class":332,"line":345},3,[330,347,348],{},"}\n",[330,350,352],{"class":332,"line":351},4,[330,353,355],{"emptyLinePlaceholder":354},true,"\n",[330,357,359],{"class":332,"line":358},5,[330,360,361],{},"struct Box\u003CT> {\n",[330,363,365],{"class":332,"line":364},6,[330,366,367],{},"    value: T,\n",[330,369,371],{"class":332,"line":370},7,[330,372,348],{},[245,374,375],{},"当前不支持：",[256,377,378,381,384,387],{},[259,379,380],{},"方法级泛型",[259,382,383],{},"局部函数泛型",[259,385,386],{},"模块级泛型",[259,388,389],{},"高阶类型参数",[252,391,392],{"id":392},"语法",[245,394,395],{},"泛型参数列表使用尖括号：",[321,397,399],{"className":323,"code":398,"language":325,"meta":326,"style":326},"func pair\u003CA, B>(a: A, b: B) -> Pair\u003CA, B> {\n    Pair { first: a, second: b }\n}\n\nstruct Pair\u003CA, B> {\n    first: A,\n    second: B,\n}\n",[309,400,401,406,411,415,419,424,429,434],{"__ignoreMap":326},[330,402,403],{"class":332,"line":333},[330,404,405],{},"func pair\u003CA, B>(a: A, b: B) -> Pair\u003CA, B> {\n",[330,407,408],{"class":332,"line":339},[330,409,410],{},"    Pair { first: a, second: b }\n",[330,412,413],{"class":332,"line":345},[330,414,348],{},[330,416,417],{"class":332,"line":351},[330,418,355],{"emptyLinePlaceholder":354},[330,420,421],{"class":332,"line":358},[330,422,423],{},"struct Pair\u003CA, B> {\n",[330,425,426],{"class":332,"line":364},[330,427,428],{},"    first: A,\n",[330,430,431],{"class":332,"line":370},[330,432,433],{},"    second: B,\n",[330,435,437],{"class":332,"line":436},8,[330,438,348],{},[245,440,441],{},"规则：",[256,443,444,447],{},[259,445,446],{},"多个类型参数使用逗号分隔",[259,448,449],{},"类型参数作用域仅限当前声明",[252,451,452],{"id":452},"类型位置的实参",[245,454,455],{},"类型位置必须显式写出类型实参。",[245,457,319],{},[321,459,461],{"className":323,"code":460,"language":325,"meta":326,"style":326},"let a: Box\u003Cstring>\nlet b: Pair\u003Cint, string>\n",[309,462,463,468],{"__ignoreMap":326},[330,464,465],{"class":332,"line":333},[330,466,467],{},"let a: Box\u003Cstring>\n",[330,469,470],{"class":332,"line":339},[330,471,472],{},"let b: Pair\u003Cint, string>\n",[245,474,475],{},"第一阶段不支持：",[256,477,478,481],{},[259,479,480],{},"类型位置的省略实参",[259,482,483],{},"部分类型参数推导",[252,485,486],{"id":486},"泛型函数调用推导",[245,488,489],{},"泛型函数调用优先从普通实参做局部推导。",[245,491,319],{},[321,493,495],{"className":323,"code":494,"language":325,"meta":326,"style":326},"id(1)          \u002F\u002F T = int\npair(1, \"a\")   \u002F\u002F A = int, B = string\n",[309,496,497,502],{"__ignoreMap":326},[330,498,499],{"class":332,"line":333},[330,500,501],{},"id(1)          \u002F\u002F T = int\n",[330,503,504],{"class":332,"line":339},[330,505,506],{},"pair(1, \"a\")   \u002F\u002F A = int, B = string\n",[245,508,509],{},"如果调用点无法唯一推导类型参数，则必须显式写出类型实参：",[321,511,513],{"className":323,"code":512,"language":325,"meta":326,"style":326},"id\u003Cint>(1)\n",[309,514,515],{"__ignoreMap":326},[330,516,517],{"class":332,"line":333},[330,518,512],{},[520,521,522],"h3",{"id":522},"当前不做的推导",[245,524,525],{},"第一阶段不做这些推导：",[256,527,528,531,534],{},[259,529,530],{},"从赋值目标反推函数泛型实参",[259,532,533],{},"从返回类型单独反推函数泛型实参",[259,535,536],{},"跨表达式的复杂联立求解",[245,538,319],{},[321,540,542],{"className":323,"code":541,"language":325,"meta":326,"style":326},"let x: Box\u003Cstring> = make_box()\n",[309,543,544],{"__ignoreMap":326},[330,545,546],{"class":332,"line":333},[330,547,541],{},[245,549,550,551,554,555,558],{},"这里不依赖左侧目标类型去反推 ",[309,552,553],{},"make_box\u003CT>()"," 的 ",[309,556,557],{},"T","。如果普通实参推不出来，就必须显式写：",[321,560,562],{"className":323,"code":561,"language":325,"meta":326,"style":326},"make_box\u003Cstring>()\n",[309,563,564],{"__ignoreMap":326},[330,565,566],{"class":332,"line":333},[330,567,561],{},[520,569,570],{"id":570},"必须显式写类型实参的典型情况",[245,572,573],{},"这些值本身不能唯一推出类型参数：",[256,575,576,581,586,591],{},[259,577,578],{},[309,579,580],{},"none",[259,582,583],{},[309,584,585],{},"[]",[259,587,588],{},[309,589,590],{},"{}",[259,592,593],{},"仅出现在返回类型中的类型参数",[245,595,319],{},[321,597,599],{"className":323,"code":598,"language":325,"meta":326,"style":326},"id(none)\nmake_list()\n",[309,600,601,606],{"__ignoreMap":326},[330,602,603],{"class":332,"line":333},[330,604,605],{},"id(none)\n",[330,607,608],{"class":332,"line":339},[330,609,610],{},"make_list()\n",[245,612,613],{},"都不应自动推导成功，除非有显式类型实参。",[252,615,616],{"id":616},"匿名函数与泛型",[245,618,619],{},"第一阶段支持匿名函数，但匿名函数自己不声明泛型参数。",[245,621,622],{},"匿名函数可以参与泛型调用，只要其参数类型和返回类型与目标位置要求一致。",[245,624,625],{},"例如在内建泛型方法中：",[321,627,629],{"className":323,"code":628,"language":325,"meta":326,"style":326},"items.map(func(x: int) -> string {\n    `#${x}`\n})\n",[309,630,631,636,641],{"__ignoreMap":326},[330,632,633],{"class":332,"line":333},[330,634,635],{},"items.map(func(x: int) -> string {\n",[330,637,638],{"class":332,"line":339},[330,639,640],{},"    `#${x}`\n",[330,642,643],{"class":332,"line":345},[330,644,645],{},"})\n",[245,647,648,649,652],{},"这里匿名函数的参数类型必须与 ",[309,650,651],{},"map"," 当前实例的元素类型一致，返回类型必须与推导出的目标元素类型一致。",[252,654,656,657,659],{"id":655},"泛型-struct-构造推导","泛型 ",[309,658,316],{}," 构造推导",[245,661,656,662,664],{},[309,663,316],{}," 在构造时允许从字段值推导类型参数，只要能唯一确定。",[245,666,319],{},[321,668,670],{"className":323,"code":669,"language":325,"meta":326,"style":326},"struct Box\u003CT> {\n    value: T,\n}\n\nlet a = Box { value: \"x\" }   \u002F\u002F Box\u003Cstring>\nlet b = Box { value: 1 }     \u002F\u002F Box\u003Cint>\n",[309,671,672,676,680,684,688,693],{"__ignoreMap":326},[330,673,674],{"class":332,"line":333},[330,675,361],{},[330,677,678],{"class":332,"line":339},[330,679,367],{},[330,681,682],{"class":332,"line":345},[330,683,348],{},[330,685,686],{"class":332,"line":351},[330,687,355],{"emptyLinePlaceholder":354},[330,689,690],{"class":332,"line":358},[330,691,692],{},"let a = Box { value: \"x\" }   \u002F\u002F Box\u003Cstring>\n",[330,694,695],{"class":332,"line":364},[330,696,697],{},"let b = Box { value: 1 }     \u002F\u002F Box\u003Cint>\n",[245,699,700],{},"如果字段值不能唯一推出类型参数，则必须使用显式类型标注。",[245,702,319],{},[321,704,706],{"className":323,"code":705,"language":325,"meta":326,"style":326},"let x: Box\u003Copt\u003Cstring>> = Box { value: none }\n",[309,707,708],{"__ignoreMap":326},[330,709,710],{"class":332,"line":333},[330,711,705],{},[245,713,714],{},"第一阶段先不引入值构造位置的显式类型实参语法，因此不写：",[321,716,718],{"className":323,"code":717,"language":325,"meta":326,"style":326},"Box\u003Cstring> { value: \"x\" }\n",[309,719,720],{"__ignoreMap":326},[330,721,722],{"class":332,"line":333},[330,723,717],{},[252,725,726],{"id":726},"约束",[245,728,729],{},"第一阶段支持约束语法，但只支持极小集合。",[245,731,732],{},"语法：",[321,734,736],{"className":323,"code":735,"language":325,"meta":326,"style":326},"func has_key\u003CK: key, V>(m: map\u003CK, V>, k: K) -> bool {\n    m.contains(k)\n}\n",[309,737,738,743,748],{"__ignoreMap":326},[330,739,740],{"class":332,"line":333},[330,741,742],{},"func has_key\u003CK: key, V>(m: map\u003CK, V>, k: K) -> bool {\n",[330,744,745],{"class":332,"line":339},[330,746,747],{},"    m.contains(k)\n",[330,749,750],{"class":332,"line":345},[330,751,348],{},[245,753,441],{},[256,755,756,759,765],{},[259,757,758],{},"约束只允许出现在泛型参数声明上",[259,760,761,762],{},"语法形式为 ",[309,763,764],{},"T: constraint",[259,766,767],{},"多个类型参数各自独立声明约束",[520,769,771,772],{"id":770},"当前唯一内建约束key","当前唯一内建约束：",[309,773,774],{},"key",[245,776,777,779,780,782],{},[309,778,774],{}," 用于表示“可作为 ",[309,781,651],{}," 键”的类型能力。",[245,784,785,786,788],{},"当前满足 ",[309,787,774],{}," 的类型只有：",[256,790,791,796,801,806],{},[259,792,793],{},[309,794,795],{},"int",[259,797,798],{},[309,799,800],{},"bool",[259,802,803],{},[309,804,805],{},"rune",[259,807,808],{},[309,809,810],{},"string",[245,812,475],{},[256,814,815,818,824,827,830],{},[259,816,817],{},"多重约束",[259,819,820,823],{},[309,821,822],{},"where"," 子句",[259,825,826],{},"用户自定义约束",[259,828,829],{},"基于方法集的复杂约束系统",[259,831,832,833,836],{},"恢复旧的 ",[309,834,835],{},"comparable"," 设计作为通用约束",[252,838,839],{"id":839},"与参数化容器类型的关系",[245,841,842],{},"内建参数化类型：",[256,844,845,850,855,860],{},[259,846,847],{},[309,848,849],{},"list\u003CT>",[259,851,852],{},[309,853,854],{},"map\u003CK, V>",[259,856,857],{},[309,858,859],{},"opt\u003CT>",[259,861,862],{},[309,863,864],{},"iter\u003CT>",[245,866,867],{},"和用户定义泛型共用同一套类型参数语法，但它们的具体语义仍由各自的专题文档定义，不由本文件重复展开。",[245,869,870,871,873],{},"这些内建参数化类型不是用户代码定义出来的普通泛型 ",[309,872,316],{},"，而是语言内建类型。",[245,875,876],{},"因此：",[256,878,879,882,885],{},[259,880,881],{},"语法一致",[259,883,884],{},"类型参数写法一致",[259,886,887],{},"但具体操作语义由各自专题定义",[245,889,319],{},[256,891,892,899,906],{},[259,893,894,554,896],{},[309,895,849],{},[309,897,898],{},"push\u002Fpop\u002Fremove",[259,900,901,554,903],{},[309,902,859],{},[309,904,905],{},"none\u002Fsome\u002Fis",[259,907,908,554,910],{},[309,909,864],{},[309,911,912],{},"map\u002Ffilter\u002Fcollect",[245,914,915],{},"都属于内建语义，不代表所有用户泛型类型自动拥有类似能力。",[245,917,918],{},"语言内建方法可以带泛型语义，例如：",[256,920,921,926,931],{},[259,922,923],{},[309,924,925],{},"iter\u003CT>.map\u003CU>(...) -> iter\u003CU>",[259,927,928],{},[309,929,930],{},"iter\u003CT>.filter(...) -> iter\u003CT>",[259,932,933],{},[309,934,935],{},"iter\u003CT>.collect() -> list\u003CT>",[245,937,938],{},"但这不代表当前语言已经开放“用户自定义方法”或“用户自定义方法泛型”。",[252,940,941],{"id":941},"泛型类型相等性",[245,943,944],{},"泛型类型采用名义相等。",[245,946,441],{},[256,948,949,952],{},[259,950,951],{},"同一个泛型声明，类型实参逐个完全相同，类型才相等",[259,953,954],{},"不同声明即使字段形状相同，也不是同一类型",[245,956,319],{},[321,958,960],{"className":323,"code":959,"language":325,"meta":326,"style":326},"Box\u003Cstring>\nBox\u003Cint>\nPair\u003Cint, string>\n",[309,961,962,967,972],{"__ignoreMap":326},[330,963,964],{"class":332,"line":333},[330,965,966],{},"Box\u003Cstring>\n",[330,968,969],{"class":332,"line":339},[330,970,971],{},"Box\u003Cint>\n",[330,973,974],{"class":332,"line":345},[330,975,976],{},"Pair\u003Cint, string>\n",[245,978,979],{},"其中：",[256,981,982,991,999],{},[259,983,984,987,988,990],{},[309,985,986],{},"Box\u003Cstring>"," 与 ",[309,989,986],{}," 是同一类型",[259,992,993,987,995,998],{},[309,994,986],{},[309,996,997],{},"Box\u003Cint>"," 不是同一类型",[259,1000,1001,987,1004,998],{},[309,1002,1003],{},"Pair\u003Cint, string>",[309,1005,1006],{},"Pair\u003Cstring, int>",[252,1008,1009],{"id":1009},"泛型实例兼容性",[245,1011,1012],{},"第一阶段参数化类型统一按不变处理。",[245,1014,1015],{},"也就是说：",[256,1017,1018,1026,1034],{},[259,1019,1020,1022,1023],{},[309,1021,986],{}," 不是 ",[309,1024,1025],{},"Box\u003Cany>",[259,1027,1028,1022,1031],{},[309,1029,1030],{},"list\u003Cstring>",[309,1032,1033],{},"list\u003Cany>",[259,1035,1036,1022,1039],{},[309,1037,1038],{},"opt\u003Cstring>",[309,1040,1041],{},"opt\u003Cany>",[245,1043,1044],{},"第一阶段不引入：",[256,1046,1047,1050,1053],{},[259,1048,1049],{},"协变",[259,1051,1052],{},"逆变",[259,1054,1055],{},"基于子类型关系的参数化兼容",[252,1057,1058],{"id":1058},"用户泛型类型的能力边界",[245,1060,1061,1062,1064],{},"用户定义的泛型 ",[309,1063,316],{}," 不会因为“是泛型”而自动获得额外能力。",[245,1066,1067],{},"例如，泛型本身不会自动决定：",[256,1069,1070,1073,1079,1082],{},[259,1071,1072],{},"是否可比较",[259,1074,1075,1076,1078],{},"是否可作 ",[309,1077,651],{}," key",[259,1080,1081],{},"是否可迭代",[259,1083,1084],{},"是否具有特殊内建方法",[245,1086,1087],{},"这些能力仍由语言内建规则或显式约束单独定义。",[252,1089,1090],{"id":1090},"当前不讨论的实现问题",[245,1092,1093],{},"本文不规定：",[256,1095,1096,1099,1102,1105],{},[259,1097,1098],{},"单态化还是共享实现",[259,1100,1101],{},"Rust 代码生成的具体映射方式",[259,1103,1104],{},"运行时表示",[259,1106,1107],{},"trait\u002Fobject 风格的底层实现策略",[245,1109,1110],{},"这些属于编译器实现问题，不能反向决定语言语义。",[252,1112,1113],{"id":1113},"当前结论",[245,1115,1116],{},"Dujie 第一阶段的泛型系统可以概括为：",[256,1118,1119,1128,1131,1134,1139],{},[259,1120,1121,1122,1124,1125,1127],{},"只支持顶层 ",[309,1123,311],{}," 和顶层 ",[309,1126,316],{}," 泛型",[259,1129,1130],{},"类型位置显式写实参",[259,1132,1133],{},"函数调用位置做局部推导",[259,1135,656,1136,1138],{},[309,1137,316],{}," 构造可从字段值局部推导",[259,1140,1141,1142],{},"约束系统只保留最小的 ",[309,1143,774],{},[1145,1146,1147],"style",{},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":326,"searchDepth":339,"depth":339,"links":1149},[1150,1151,1152,1153,1154,1155,1159,1160,1162,1166,1167,1168,1169,1170,1171],{"id":254,"depth":339,"text":254},{"id":276,"depth":339,"text":276},{"id":299,"depth":339,"text":299},{"id":392,"depth":339,"text":392},{"id":452,"depth":339,"text":452},{"id":486,"depth":339,"text":486,"children":1156},[1157,1158],{"id":522,"depth":345,"text":522},{"id":570,"depth":345,"text":570},{"id":616,"depth":339,"text":616},{"id":655,"depth":339,"text":1161},"泛型 struct 构造推导",{"id":726,"depth":339,"text":726,"children":1163},[1164],{"id":770,"depth":345,"text":1165},"当前唯一内建约束：key",{"id":839,"depth":339,"text":839},{"id":941,"depth":339,"text":941},{"id":1009,"depth":339,"text":1009},{"id":1058,"depth":339,"text":1058},{"id":1090,"depth":339,"text":1090},{"id":1113,"depth":339,"text":1113},"md",{},{},{"title":202,"description":326},"Jwm2BMbEcOSkiFXxM8DoLRK6sXF26uMFkP12bGvFESU",[1178,1179],{"title":198,"path":199,"stem":200,"description":326,"children":-1},{"title":206,"path":207,"stem":208,"description":326,"children":-1},1776981319057]