stanford-oval/wikipedia huggingface dataset:
錫爾弗蓋特 (蒙大拿州)
歷史

錫爾弗蓋特的郵局於1937年設立，1942年關閉後於1948年重啟，營運至今。
氣候

| 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 月份 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 1月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 2月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 3月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 4月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 5月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 6月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 7月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 8月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 9月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 10月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 11月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 12月 | 錫爾弗蓋特 (蒙大拿州)，1991–2020年正常值，1991–2020年降雨量> 全年 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 平均高温 °F（°C） | 26.7 (−2.9) | 30.2 (−1.0) | 38.6 (3.7) | 44.3 (6.8) | 55.3 (12.9) | 64.8 (18.2) | 73.8 (23.2) | 72.8 (22.7) | 63.8 (17.7) | 49.6 (9.8) | 33.0 (0.6) | 24.3 (−4.3) | 48.1 (9.0) |
| 日均气温 °F（°C） | 14.8 (−9.6) | 17.7 (−7.9) | 25.4 (−3.7) | 32.1 (0.1) | 42.0 (5.6) | 49.7 (9.8) | 56.8 (13.8) | 54.7 (12.6) | 46.9 (8.3) | 36.2 (2.3) | 22.5 (−5.3) | 13.1 (−10.5) | 34.3 (1.3) |
| 平均低温 °F（°C） | 2.9 (−16.2) | 5.1 (−14.9) | 12.2 (−11.0) | 19.9 (−6.7) | 28.6 (−1.9) | 34.5 (1.4) | 39.8 (4.3) | 36.6 (2.6) | 30.0 (−1.1) | 22.8 (−5.1) | 12.0 (−11.1) | 1.8 (−16.8) | 20.5 (−6.4) |
| 平均降水量 （mm） | 2.23 (57) | 2.04 (52) | 1.94 (49) | 2.29 (58) | 2.85 (72) | 3.16 (80) | 1.97 (50) | 1.82 (46) | 1.74 (44) | 2.23 (57) | 2.17 (55) | 2.13 (54) | 26.57 (674) |
| 平均降雪量 （cm） | 38.8 (99) | 29.7 (75) | 31.0 (79) | 22.4 (57) | 9.0 (23) | 3.4 (8.6) | 0.0 (0.0) | 0.0 (0.0) | 1.0 (2.5) | 13.4 (34) | 26.5 (67) | 37.9 (96) | 213.1 (541.1) |
来源1：NOAA
来源2：National Oceanic and Atmospheric Administration
人口

根據2020年美國人口普查的數據，錫爾弗蓋特的面積為11.30平方千米，皆為陸地。當地共有人口19人，而人口密度為每平方千米1.68人。
參考文獻

1 2  . United States Census Bureau.   [2022-05-21]. （原始内容存档于2022-05-28）.
↑  . . United States Geological Survey.
↑  . Jim Forte Postal History.   [2024-07-03]. （原始内容存档于2005-03-24）.
↑  . National Oceanic and Atmospheric Administration.   [2023-08-08]. （原始内容存档于2023-08-10）.
↑  .   [2023-08-09]. （原始内容存档于2023-04-11）.
|  论 编帕克縣行政區劃 |
| --- | --- | --- |
：利文斯顿
| 城市 |  利文斯頓  | 帕克縣在蒙大拿州的位置 |
| 市鎮 |  克萊德公園  | 帕克縣在蒙大拿州的位置 |
| 普查規定居民點 |  庫克城  科溫斯普林斯  埃米格蘭特  加德納  賈丁  派恩克里克  普雷  錫爾弗蓋特  南格拉斯頓伯里  斯普林代爾  威爾薩爾  瓦恩格拉斯  | 帕克縣在蒙大拿州的位置 |
| 非建制地區 |  布里斯賓  奇科  | 帕克縣在蒙大拿州的位置 |
| 鬼鎮 |  奧爾德里奇  | 帕克縣在蒙大拿州的位置 |
戀愛女王

| 戀愛女王 Love Queen |
| --- | --- |
类型: 偶像劇1
编剧: 陳虹潔、汪秀賢
导演: 明金成
主演: 楊謹華、洪小鈴、張天霖、卓文萱、陳德烈
制作国家／地区:  臺灣
语言: 中文
集数: 13集
每集长度: 90分鐘（含廣告）
片头曲: 卓文萱《Super No 1》
片尾曲: 卓文萱、曹格《梁山伯與茱麗葉》
制作
人: 王鈞
播出 
首播频道: 華視
播出国家／地区:  臺灣
播出日期: 2006年8月20日 (2006-08-20)—2006年11月12日 (2006-11-12)
 
《戀愛女王》（英語：），是一部台灣愛情偶像劇，王鈞製作，明金成執導。楊謹華、洪小鈴、張天霖、卓文萱、陳德烈主演。本劇講述了三個從外型、個性、職業、夢想、價值觀到衣著品味都截然不同的三個女生，各自因為不同的理由相中同一個房子，又因為各自不同的原因互不相讓，最後莫名其妙成了室友，因而展開這一段糾纏不清、好笑有趣、又難分難捨的同居生活。2006年8月20日起於華視首播。
角色列表

楊謹華 飾 張景涵
洪小鈴 飾 梁嘉欣
張天霖 飾 左少棠
卓文萱 飾 巧樂
陳德烈 飾 李宇信
高以翔 飾 王正勳
橫內晶 飾 今井翔
林美秀 飾 巧樂母親
李沛旭 飾 賴國隆
電視劇歌曲

| 0 | 1 | 2 | 3 | 4 |
| --- | --- | --- | --- | --- |
| 曲別 | 歌名 | 演唱者 | 作詞 | 作曲 |
| 片頭曲 | Super No.1 | 卓文萱 | 宋世堯 | 宋世堯 |
| 片尾曲 | 梁山伯與茱麗葉 | 卓文萱、曹格 | 曹格 | 曹格 |
插曲 對你的愛 卓文萱
重要性采样

重要性采样（英語：）是统计学中估计某一分布性质时使用的一种方法。该方法从与原分布不同的另一个分布中采样，而对原先分布的性质进行估计。重要性采样与计算物理学中的伞形采样（英语：）相关。
原理

假设 X:\Omega \to \mathbb {R} 为概率空间 (\Omega ,{\mathcal {F}},P)上的一个随机变量。我们想要估计X的期望值，记作E[X;P]。如果根据P随机抽取样本 x_{1},\ldots ,x_{n}，估计的期望值即
这一估计的精确度取决于X的方差，
而重要性采样的基本思想则是从另一个分布中抽取样本，用以降低E[X;P]估计的方差。进行重要性采样时，首先选择一个随机变量 L\geq 0，使得E[L;P]=1，并满足P上几乎处处 L(\omega )\neq 0。由此，可以定义新的概率
于是，我们可以从P(L)上抽样，通过变量X/L估计E[X;P]。如果 \operatorname {var} \left[{\frac {X}{L}};P^{(L)}\right]<\operatorname {var} [X;P]成立，此时的估计便优于直接在原分布上采样得到的估计。
当X在Ω上不变号时，最优的L为 L^{*}={\frac {X}{\mathbf {E} [X;P]}}\geq 0。此时X/L*即为要估计的E[X;P]，只需一个样本便可得到该值。然而由于L*与要估计的E[X;P]有关，在实际操作中我们无法取到理论上最优的L*。不过，我们仍可以采用如下方式逼近该理论值：
于是，要估计的期望值可改写为：
注意到，更优（即让估计值方差更小）的P(L)会使得样本分布的频率与其在E[X;P]计算中的权重更加相关。这也是该方法得名“重要性采样”的原因。
重要性采样常用于蒙特卡洛积分。当 P为均匀分布、 \Omega =\mathbb {R} 时，E[X;P]即为实函数 X:\mathbb {R} \to \mathbb {R} 的积分。
2019年斯诺克国际锦标赛

| 比赛信息 |
| --- | --- |
日期: 2019年8月4日－11日
场馆: 百湖影视多功能厅
城市: 大庆
国家/地区: 中国
组织: 世界职业台球与斯诺克协会
比赛形式: 排名赛
总奖金: £802,000
冠军奖金: £175,000
单杆最高分:  贾德·特鲁姆普（英格兰） (141)  馬克·艾倫（北爱尔兰） (141)
决赛
冠军:  贾德·特鲁姆普（英格兰）
亚军:  肖恩·墨菲（英格兰）
比分: 10–3
← 2018（英语：） 2023 → 
2019年世界斯诺克国际锦标赛（英語：）属职业斯诺克排名赛，于2019年8月4日－11日在大庆百湖影视多功能厅举行。本届赛事是2019/20赛季的第二项排名赛，也是斯诺克国际锦标赛自2012年举办以来的第8届比赛。
北爱尔兰球手马克·艾伦在2018年（英语：）决赛中10-5战胜澳大利亚选手尼尔·罗伯逊夺冠。不过在本届比赛半决赛中，艾伦以6-9不敌英格兰选手肖恩·墨菲无缘决赛。世界冠军贾德·特鲁姆普在决赛以10-3战胜墨菲夺冠，这也是他的第12个排名赛冠军。夺冠后，特鲁姆普重回世界第一，而他在上一次排名世界第一时还是2013年。
比赛形式

2019年斯诺克国际锦标赛属第8届斯诺克国际锦标赛，首届比赛于2012年（英语：）举办。本届赛事于2019年8月4日至11日在大庆市百湖影视多功能厅举行，是继颜丙涛夺冠的2019年斯诺克里加大师赛后，2019/20赛季斯诺克的第二项排名赛。
资格赛于2019年6月14日至17日在英格兰谢菲尔德澎福国际运动中心（英语：）进行，设有一场首轮比赛。半决赛前均为11局6胜制，半决赛为17局9胜制，而决赛则是19局10胜制。
比赛形式 > 奖金

本届赛事总奖金高于上一年，总金额为80.2万英镑（去年为77.5万英镑）。冠军奖金与往年相同，均为17.5万英镑。本届赛事奖金明细如下：
冠军：£175,000
亚军：£75,000
四强：£32,000
八强：£21,500
十六强：£13,500
三十二强：£8,500
六十四强：£4,750
单杆最高分：£6,000
总计：£802,000
比赛总结

本届国际锦标赛于2019年8月4日开打，首轮比赛与延期的入围赛同时进行。延期入围赛中的两场比赛以决胜局决出。丁俊晖在5-3落后的情况下战胜了西蒙·利希滕贝格（英语：），而四度世界冠军约翰·希金斯在3-4落后的情况下战胜了21岁以下业余组世界冠军，15岁小将吴宜泽。贾德·特鲁姆普在2019年世界斯诺克锦标赛夺冠后的首场比赛中打出三记单杆过百，以6-1击败乔丹·布朗（英语：）。
正赛抽签

粗体表示比赛胜者。
正赛抽签 > 决赛

| 0 | 1 | 2 |
| --- | --- | --- |
决赛：19局10胜制 裁判： 吕浠琳 2019年8月11日 大庆市百湖影视多功能厅
| 肖恩·墨菲  英格兰 | 3–10 | 贾德·特朗普  英格兰 |
第一阶段：14–85, 5–83 (58), 19–108 (104), 0–77 (58), 0–69, 87–0 (87), 68–37, 23–86 (74), 79–0 (79) 第二阶段：0–80 (80), 30–90 (63), 6–102 (102), 9–99 (62)
| 87 | 单杆最高分 | 104 |
| 0 | 单杆破百数 | 2 |
| 2 | 单杆得分50+数 | 8 |
拉韦西利亚

| 拉韦西利亚 La Vecilla |
| --- | --- |
市镇
拉韦西利亚在西班牙的位置
坐标：42°50′55″N 5°24′21″W﻿ / ﻿42.848722°N 5.405744°W﻿ / 42.848722; -5.405744
国家: 西班牙
自治区: 卡斯蒂利亚-莱昂
省: 莱昂省
面积
 • 总计: 44 平方公里（17 平方英里）
人口（2001）
 • 總計: 448人
 • 密度: 10.2人/平方公里（26.4人/平方英里）
时区: CET（UTC+1）
 • 夏时制: CEST（UTC+2）
拉韦西利亚（西班牙语：），是西班牙卡斯蒂利亚-莱昂莱昂省的一个市镇。 总面积44平方公里，2001年普查人口總數為448人，人口密度為每平方公里10人。
艾丽西亚·霍斯金

| 艾丽西亚·霍斯金 |
| --- | --- |

出生: 2000年2月6日  （24歲） 吉斯伯恩 
母校: Gisborne Girls' High School 梅西大学 
职业: kayaker 
艾丽西亚·霍斯金（英語：，2000年2月6日—），新西兰女子皮划艇运动员，2023年世界皮划艇竞速锦标赛女子四人皮艇500米金牌得主、2024年夏季奥林匹克运动会女子双人皮艇500米和女子四人皮艇500米金牌得主。
参考资料

↑  .   [2024-08-12]. （原始内容存档于2024-03-03）.
|  论 编 奥林匹克运动会皮划艇静水比赛女子双人皮艇500米冠军 |
| --- | --- |
 1960： Mariya Shubina / Antonina Seredina（苏联）  1964： 羅斯維塔·埃塞爾 / 安娜瑪麗·齊默爾曼（德国联队）  1968： 羅斯維塔·埃塞爾 / 安娜瑪麗·齊默爾曼（西德）  1972： Lyudmila Pinayeva / Kateryna Koryshko（苏联）  1976： Nina Gopova / Galina Kreft（苏联）  1980： 卡斯塔·格诺伊斯 / 马丁娜·比朔夫（东德）  1984： 阿涅塔·安德松 / 安娜·奥尔松（瑞典）  1988： 比吉特·費雪 / 安克·诺特纳格尔（东德）  1992： 拉莫娜·波特维希 / 安克·冯·泽克（德国）  1996： 苏珊·贡纳松 / 阿涅塔·安德松（瑞典）  2000： 比吉特·費雪 / 卡特琳·瓦格纳（德国）  2004： 科瓦奇·考陶琳 / 娜塔莎·杜舍夫-亚尼奇（匈牙利）  2008： 科瓦奇·考陶琳 / 娜塔莎·杜舍夫-亚尼奇（匈牙利）  2012： 弗兰齐斯卡·韦伯 / 蒂娜·迪策（德国）  2016： 绍博·高布丽埃洛 / 科扎克·达努塔（匈牙利）  2020： 丽莎·卡林顿 / 凯特琳·雷加尔（新西兰）  2024： 丽莎·卡林顿 / 艾丽西亚·霍斯金（新西兰） 
|  论 编 奥林匹克运动会皮划艇静水比赛女子四人皮艇500米冠军 |
| --- | --- |
 1984： 阿加菲娅·康斯坦丁、纳斯塔西娅·约内斯库、泰克拉·马里内斯库、玛丽亚·斯特凡（罗马尼亚）  1988： 比吉特·費雪、安克·诺特纳格尔、拉莫娜·波特维希、海克·辛格（东德）  1992： 克班·丽塔、多努斯·埃娃、梅萨罗什·艾丽考、齐加尼·金高（匈牙利）  1996： 阿内特·舒克、比吉特·費雪、曼努埃拉·穆克、拉莫娜·波特维希（德国）  2000： 比吉特·費雪、曼努埃拉·穆克、阿内特·舒克、卡特琳·瓦格纳（德国）  2004： 比吉特·費雪、迈克·诺伦、卡特琳·瓦格纳、卡罗琳·莱昂哈特（德国）  2008： 范妮·菲舍尔、妮科尔·赖因哈特、卡特琳·瓦格纳-奥古斯丁、康妮·瓦斯穆特（德国）  2012： 绍博·高布丽埃洛、科扎克·达努塔、科瓦奇·考陶琳、福泽考什-祖尔·克里斯蒂娜（匈牙利）  2016： 绍博·高布丽埃洛、科扎克·达努塔、奇派什·陶马劳、福泽考什-祖尔·克里斯蒂娜（匈牙利）  2020： 科扎克·达努塔、奇派什·陶马劳、卡拉斯·翁瑙、博多妮·多劳（匈牙利）  2024： 丽莎·卡林顿、艾丽西亚·霍斯金、奥利维娅·布雷特、塔拉·沃恩（新西兰）
ML语言

：此条目页的主题不是英文縮寫為ML的機器學習。
| --- | --- |
: 多范型：函数式，指令式
設計者: 罗宾·米尔纳及爱丁堡大学其他人
: 1973年，​51年前​（1973）
型態系統: 类型推论，静态类型，强类型
衍生副語言
Standard ML, OCaml
啟發語言
ISWIM，PAL，POP-2，GEDANKEN
影響語言
Clojure、Coq、Cyclone（英语：）、C++、Elm、Futhark、F#、F*、Haskell、Idris、Lazy ML、Miranda、Nemerle、OCaml、Opa（英语：）、Rust、Scala、Standard ML、Ur
  維基教科書中有關Standard ML Programming的文本 
ML（Meta Language：元语言），是一个函数式、指令式的通用的编程语言，它著称于使用了多态的Hindley–Milner类型推论。ML能自动的指定多数表达式（英语：）的类型，不要求显式的类型标注，而且能够确保类型安全，已经正式证明了有良好类型的ML程序不会导致运行时间类型错误。
ML提供了对函数实际参数的模式匹配、垃圾回收、指令式编程、传值调用和柯里化。它被大量的用于编程语言研究之中，并且是全面规定了的和使用形式语义验证了的少数语言之一。它的类型和模式匹配使得它非常适合并且经常用于在其他形式语言上进行操作，比如在编译器构造、自动化定理证明和形式验证中。
历史

在1970年代早期，ML由爱丁堡大学的罗宾·米尔纳及他人研制出来，用于在LCF（英语：）定理证明器中开发证明策略。LCF的语言是“PPλ”，它是一阶逻辑演算与有类型的多态λ演算的结合，以ML作为元语言。ML的语法从ISWIM及其扩展实现PAL得到了启发，LCF（英语：） ML运行在DEC-10/TOPS-10主机的Stanford LISP 1.6下。
在1980年，Luca Cardelli（英语：）于爱丁堡大学的VAX/VMS系统上开发了ML编译器，它被称为“VAX ML”，以区别于LCF版本的“DEC-10 ML”。VAX ML的编译器和运行时间系统二者，都是用Pascal书写而建立在“函数抽象机器”（FAM）之上。在1982年，爱丁堡大学的Kevin Mitchell，用VAX ML重写了VAX ML编译器，随即John Scott和Alan Mycroft（英语：）加入了开发，在又进行一系列重写改进之后，新的编译器被称为“Edinburgh ML”。
在1981年，INRIA的Gérard Huet（英语：），将最初的LCF ML适配到Multics系统的Maclisp下，并且增加了编译器。这个实现被描述于INRIA内部文档“ML手册”之中，它被开发者自称为“Le_ML”。剑桥大学的Lawrence Paulson（英语：）在1985年用它开发了基于Franz Lisp的Cambridge LCF，进而剑桥大学的Michael J. C. Gordon（英语：）又用它开发了基于Common Lisp的HOL88（英语：）。
在1983年，Robin Milner由两个动机驱使开始重新设计ML。其一是爱丁堡大学的Rod Burstall（英语：）及其小组在规定上的工作，具体化为规定语言CLEAR，和表达可执行规定的函数式语言HOPE。这项工作与ML有关的是两方面成果：首先，HOPE拥有优雅的编程特征，特别是模式匹配，和子句式函数定义；其次，是使用在接口中的签名，进行规定的模块化构造的想法。其二是Luca Cardelli（英语：）在VAX ML上的工作，通过增加命名记录和可变类型，扩展了ML中数据类型的品目。
在1984年，贝尔实验室的David MacQueen提出了对Standard ML的模块系统的设计。在Standard ML的持续设计期间，Edinburgh ML被渐进的修改，充当了Standard ML的近似原型实现。在1986年，普林斯顿大学的Andrew Appel（英语：）和贝尔实验室的David MacQueen，以Edinburgh Standard ML作为起步开发环境，开始了专注于生成高质量机器代码的Standard ML of New Jersey的活跃开发。
在1990年，Robin Milner、Mads Tofte（英语：）和Robert Harper（英语：）制定的Standard ML的正式规定《The Definition of Standard ML》最终完成；在1997年，这个标准规定增补了David MacQueen为作者并进行了修订。在1989年，Mads Tofte（英语：）、Nick Rothwell和David N. Turner于爱丁堡大学开始开发ML Kit编译器，为了强调清晰性而非高效，将标准定义直接转译成一组Standard ML模块；在1992年和1993年期间，主要通过爱丁堡大学的Nick Rothwell和哥本哈根大学计算机科学系（英语：）（DIKU）的Lars Birkedal的工作，ML Kit第一版完成并开源发行。
在1987年，INRIA的Ascánder Suárez，基于巴黎第七大学的Guy Cousineau（法语：）的“范畴抽象机器（英语：）”（CAM），利用Le Lisp的运行时间系统重新实现了Le_ML，并正式命名为Caml。在1990年和1991年，INRIA的Xavier Leroy（英语：）基于用C实现的字节码解释器，利用Damien Doligez（英语：）提供的内存管理系统重新实现了Caml，并称其为Caml Light。在1995年，Xavier Leroy又增加了机器代码编译器和高层模块系统，这个版本也称为“Caml Special Light”。在1996年，INRIA的Didier Rémy和Jérôme Vouillon，向Caml Special Light增加了面向对象特征，从而形成了OCaml。
今天ML家族的两个主要的方言是Standard ML和OCaml。ML的实力大多被用于语言设计和操作，比如建构编译器、分析器、定理证明器，但是它作为通用语言也被用于生物信息和财务系统等领域。ML确立了静态类型函数式编程范型，从而在编程语言历史上占有显要地位，它的思想在影响了众多的语言，例如Haskell、Nemerle、ATS（英语：）和Elm。
解释与编译

ML代码片段很容易通过将其录入到“顶层”来研习，它也叫作读取﹣求值﹣输出循环或REPL。这是打印结果或定义的表达式的推论类型的交互式会话。很多SML实现提供交互式REPL，比如SML/NJ：
$ sml
Standard ML of New Jersey v110.79 [built: Mon Apr 22 10:14:55 2024]
-
可以在提示符-后键入代码。例如计算1 + 2 * 3:
- 1 + 2 * 3;
val it = 7 : int
- it;
val it = 7 : int
顶层推论这个表达式的类型为int并给出结果7。如果输入不完全，解释器会打印第二提示符=，这时通常可以用;终结输入。it是给未指定变量的表达式的标准变量。输入control-C可返回解释器顶层，输入control-D可退出解释器。可以使用第三方工具rlwrap运行SML/NJ解释器，它处理用户输入并提供readline的行编辑、持久历史和补全功能。
下面是输出hello, world!的例子代码，在SML/NJ解释器下执行它：
- print "Hello, world!\n";
Hello, world!
val it = () : unit
- val _ = print "Hello, world!\n";
Hello, world!
使用MLton编译器进行编译执行它：
$ echo 'print "Hello, world!\n";' > hello-world.sml
$ mlton hello-world.sml
$ ./hello-world
Hello, world!
使用LunarML源到源编译器，将前面的例子编译成Javascript代码并使用Node.js执行它:
$ echo 'print "Hello, world!\n";' > hello-world.sml
$ lunarml compile --nodejs hello-world.sml
$ nodejs hello-world.mjs
Hello, world!
核心语言

不同于纯函数式编程语言，ML是兼具一些指令式特征的函数式编程语言。ML的特征包括：传值调用的求值策略，头等函数，带有垃圾收集的自动内存管理，参数多态，静态类型，类型推论，代数数据类型，模式匹配和例外处理。不同于Haskell，ML与大多数编程语言一样使用及早求值。
用ML书写的程序构成自要被求值的表达式（英语：），而非语句或命令，尽管一些表达式返回一个平凡的unit值并且只为其副作用而求值。以下章节介绍采用Standard ML的语法和语义。
核心语言 > 函数

就像所有的函数式语言一样，ML的关键特征是函数，它被用于进行抽象。例如阶乘函数用纯ML可表达为：
fun fac 0 = 1
  | fac n = n * fac (n - 1)
这里将阶乘描述为递归函数，具有一个单一的终止基础情况。它类似于在数学教科书见到的阶乘描述。多数ML代码在设施和语法上类似于数学。
凭借类型推论编译器能推导出，fac接受整数0作为实际参数，则形式参数n也是整数类型int，而fac 0的结果是整数1，则函数fac的结果也是整数类型。函数fac接受一个整数的形式参数并返回一个整数结果，它作为一个整体从而有着“从整数到整数的函数”类型int -> int。函数及其形式参数的"类型"还可以用类型标注（annotation）来描述，使用E : t表示法，它可以被读作表达式E有类型t，它是可选也可忽略的。使用类型标注，这个例子可重写为如下：
fun fac 0 = 1
  | fac (n : int) : int = n * fac (n - 1)
这个函数还依赖于模式匹配，这是ML语言的重要部份。注意函数形式参数不必须在圆括号内但要用空格分隔。当一个函数的实际参数是0，它将返回整数1。对于所有其他情况，尝试第二行。这是一个递归，并且再次执行这个函数直到达到基础情况。它可以使用case表达式重写为：
fun fac n = case n 
     of 0 => 1
      | n => n * fac (n - 1)
这里case介入了模式和对应表达式的序列。它还可以重写为将标识符绑定到lambda函数：
val rec fac =
     fn 0 => 1
      | n => n * fac (n - 1)
这里的关键字val介入了标识符到值的绑定，fn介入了匿名函数的定义，它可以用在fun的位置上，但使用=>算符而非=。绑定到递归的匿名函数需要使用rec关键字来指示。
通过将主要工作写入尾递归风格的内部迭代函数，借助于语言编译或解释系统进行的尾调用优化，这个函数可以得以增进性能，它的调用栈不需要随函数调用数目而成比例的增长。对这个函数可以采用向内部函数增加额外的“累加器”形式参数acc来实现：
fun fac n = let
    fun loop (0, acc) = acc
      | loop (n, acc) = loop (n - 1, n * acc)
    in
        loop (n, 1)
    end
let表达式的值是在in和end之间表达式的值。这个递归函数的实现不保证能够终止，因为负数实际参数会导致递归调用的无穷降链条件。更健壮的实现会在递归前检查实际参数为非负数，并在有问题的情况，即n是负数的时候，启用例外处理：
fun fac n = let
    fun loop (0, acc) = acc
      | loop (n, acc) = loop (n - 1, n * acc)
    in
        if (n < 0) 
        then raise Fail "negative argument"
        else loop (n, 1)
    end
核心语言 > 类型

有一些基本类型可以当作是“内建”的，因为它们是在Standard ML标准基本库中预先定义的，并且语言为它们提供文字（英语：）表示法，比如34是整数，而"34"是字符串。一些最常用的基本类型是：
int 整数，比如3或~12。注意波浪号~表示负号。
real浮点数，比如4.2或~6.4。Standard ML不隐含的提升整数为浮点数，因此表达式2 + 5.67 是无效的。
string字符串，比如"this is a string"或""（空串）。
char字符，比如#"y"或#"\n"（换行符）。
bool布尔值，它是要么true要么false。产生bool值的有比较算符=、<>、>、>=、<、<=，逻辑函数not和短路求值的中缀算符andalso、orelse。
包括上述基本类型的各种类型可以用多种方式组合。一种方式是元组，它是值的有序集合，比如表达式(1, 2)的类型是int * int，而("foo", false)的类型是string * bool。可以使用#1 ("foo", false)这样的语法来提取元组的指定次序的成员。
有0元组()，它的类型指示为unit。但是没有1元组，或者说在例子(1)和1之间没有区别，都有类型int。元组可以嵌套，(1, 2, 3)不同于((1, 2), 3)和(1, (2, 3))二者。前者的类型是int * int * int，其他两个的类型分别是(int * int) * int和int * (int * int)。
组合值的另一种方式是记录。记录很像元组，除了它的成员是有名字的而非有次序的，例如{a = 5.0, b = "five"}有类型{a : real, b : string}，这同于类型{b : string, a : real}。可以使用#a {a = 5.0, b = "five"}这样的语法来选取记录的指定名字的字段。
Standard ML中的函数只接受一个值作为参数，而不是参数的一个列表，可以使用上述元组模式匹配来实际上传递多个参数。函数还可以返回一个元组。例如：
fun sum (a, b) = a + b
fun average pair = sum pair div 2

infix averaged_with
fun a averaged_with b = average (a, b)
val c = 3 averaged_with 7

fun int_pair (n : int) = (n, n)
这里第一段创建了两个类型是int * int -> int的函数sum和average。第二段创建中缀算子averaged_with，接着定义它为类型int * int -> int的函数。最后的int_pair函数的类型是int -> int * int。
下列函数是多态类型的一个例子：
fun pair x = (x, x)
编译器无法推论出的pair的特殊化了的类型，它可以是int -> int * int、real -> real * real甚至是(int * real -> string) -> (int * real -> string) * (int * real -> string)。在Standard ML中，它可以简单指定为多态类型'a -> 'a * 'a，这里的'a（读作“alpha”）是一个类型变量，指示任何可能的类型。在上述定义下，pair 3和pair "x"都是有良好定义的，分别产生(3, 3)和("x", "x")。
SML标准基本库包括了重载标识符：+、-、*、div、mod、/、~、abs、<、>、<=、>=。标准基本库提供了多态函数：!、:=、o、before、ignore。中缀运算符可以有从缺省最低0到最高9的任何运算符优先级。标准基本库提供了如下内建中缀规定：
infix  7  * / div mod
infix  6  + - ^
infixr 5  :: @
infix  4  = <> > >= < <=
infix  3  := o
infix  0  before
核心语言 > 等式类型

算符=和<>分别被定义为多态的等式和不等式。=它确定两个值是否相等，有着类型''a * ''a -> bool。这意味着它的两个运算数必须有相同的类型，这个类型必须是等式类型（eqtype）。上述基本类型中除了real之外，int、real、string、char和bool都是等式类型。
例如：3 = 3、"3" = "3"、#"3" = #"3"和true = true，都是有效的表达式并求值为true；而3 = 4是有效表达式并求值为false，3.0 = 3.0是无效表达式而被编译器拒绝。这是因为IEEE浮点数等式打破了ML中对等式的一些要求。特别是nan不等于自身，所以关系不是自反的。
元组和记录类型是等式类型，当时且仅当它的每个成员类型是等式类型；例如int * string、{b : bool, c : char}和unit是等式类型，而int * real和{x : real}不是。函数类型永远不是等式类型，因为一般情况下不可能确定两个函数是否等价。
核心语言 > 类型声明

类型声明或同义词（synonym）使用type关键字来定义。下面是给在平面中的点的类型声明，计算两点间距离，和通过海伦公式计算给定角点的三角形的面积的函数。
type loc = real * real

fun heron (a: loc, b: loc, c: loc) = let
    fun dist ((x0, y0), (x1, y1)) = let
        val dx = x1 - x0
        val dy = y1 - y0
        in
            Math.sqrt (dx * dx + dy * dy)
        end
    val ab = dist (a, b)
    val bc = dist (b, c)
    val ac = dist (a, c)
    val s = (ab + bc + ac) / 2.0
    in
        Math.sqrt (s * (s - ab) * (s - bc) * (s - ac))
    end
核心语言 > 数据类型

Standard ML提供了对代数数据类型（ADT）的强力支持。一个ML数据类型可以被当作是元组的不交并（积（英语：）之和）。数据类型使用datatype关键字来定义，比如：
datatype int_or_string
  = INT of int
  | STRING of string
  | NEITHER
这个数据类型声明建立一个全新的数据类型int_or_string，还有一起的新构造子（一种特殊函数或值）INT、STRING和NEITHER；每个这种类型的值都是要么INT具有一个整数，要么STRING具有一个字符串，要么NEITHER。写为如下这样：
val i = INT 3
val s = STRING "qq"
val n = NEITHER
val INT j = i
这里最后的一个声明通过模式匹配，将变量j绑定到变量i所绑定的整数3。val 模式 = 表达式是绑定的一般形式，它是良好定义的，当且仅当模式和表达式有相同的类型。
数据类型可以是多态的：
datatype 'a pair
  = PAIR of 'a * 'a
这个数据类型声明建立一个新的类型'a pair家族，比如int pair，string pair等等。
数据类型可以是递归的：
datatype int_list
  = EMPTY
  | INT_LIST of int * int_list
这个数据类型声明建立一个新类型int_list，这个类型的每个值是要么EMPTY（空列表），要么是一个整数和另一个int_list的接合。
通过datatype创建的类型是等式类型，如果它的所有变体，要么是没有参数的空构造子，要么是有等式类型参数的构造子，并且在多态类型情况下所有类型参数也都是等式类型。递归类型在有可能情况下是等式类型，否则就不是。
核心语言 > 列表

基础库提供的复杂数据类型之一是列表list。它是一个递归的、多态的数据类型，可以等价的定义为：
datatype 'a list
  = nil 
  | :: of 'a * 'a list
这里的::是中缀算符，例如3 :: 4 :: 5 :: nil是三个整数的列表。列表是ML程序中最常用的数据类型之一，语言还为生成列表提供了特殊表示法[3, 4, 5]。
real list当然不是等式类型。但是没有int list不能是等式类型的理由，所以它就是等式类型。注意类型变量不同就是不同的列表类型，比如(nil : int list) = (nil : char list)是无效的，因为两个表达式有不同的类型，即使它们有相同的值。但是nil = nil和(nil : int list) = nil都是有效的。
基本库rev函数“反转”一个列表中的元素。它的类型是'a list -> 'a list，就是说它可以接受其元素有任何类型的列表，并返回相同类型的列表。更准确的说，它返回其元素相较于给定列表是反转次序的一个新列表，比如将[ "a", "b", "c" ]映射成[ "c", "b", "a" ]。中缀算符@表示两个列表的串接。
rev和@一般被实现为基本库函数revAppend的简单应用：
fun revAppend ([], l) = l
  | revAppend (x :: r, l) = revAppend(r, x :: l)

fun rev l = revAppend(l, [])

fun l1 @ l2 = revAppend(rev l1, l2)
核心语言 > 模式匹配

Standard ML的数据类型可以轻易的定义和用于编程，在很大程度上是由它的模式匹配，还有多数Standard ML实现的模式穷尽性检查和模式冗余检查。
模式匹配可以在语法上嵌入到变量绑定之中，比如：
val ((m: int, n: int), (r: real, s: real)) = ((2, 3), (2.0, 3.0))

type hyperlink = {protocol: string, address: string, title: string}

val url : hyperlink =
    {title="The Standard ML Basis Library", protocol="https",
     address="//smlfamily.github.io/Basis/overview.html"}
val {protocol=port, address=addr, title=name} = url

val x as (fst, snd) = (2, true)
第一个val绑定了四个变量m、n、r和s；第二个val绑定了一个变量url；第三个val绑定了三个变量port、addr和name，第四个叫分层模式，绑定了三个变量x、fst和snd。
模式匹配可以在语法上嵌入到函数定义中，比如：
datatype shape
  = Circle of loc * real    (* 中心和弧度 *)
  | Square of loc * real    (* 左上角和边长，坐标轴对齐 *)
  | Triangle of loc * loc * loc     (* 角点 *)

fun area (Circle (_, r)) = 3.14 * r * r
  | area (Square (_, s)) = s * s
  | area (Triangle (a, b, c)) = heron (a, b, c)
次序在模式匹配中是紧要的：模式按文本次序来依次进行匹配。在特定计算中，使用下划线_，来省略不需要它的值的子成员，这也叫做通配符（wildcard）模式。所谓的“子句形式”风格的函数定义，这里的模式紧随在函数名字之后出现，只是如下形式的一种语法糖：
fun area shape = case shape
      of Circle (_, r) => 3.14 * r * r
       | Square (_, s) => s * s
       | Triangle (a, b, c) => heron (a, b, c)
模式穷尽性检查将确保数据类型的每个情况都已经顾及到。
如果有遗漏，则产生警告。
如果模式存在冗余，也会导致一个编译时间警告。
核心语言 > 高阶函数

函数可以接受函数作为实际参数，比如：
fun applyToBoth f x y = (f x, f y)
函数可以产生函数作为返回值，比如：
fun constantFn k = (fn anything => k)
函数可以同时接受和产生函数，比如复合函数（英语：）：
fun compose (f, g) = (fn x => f (g x))
基本库的函数List.map，是在Standard ML中最常用的Curry化高阶函数，它在概念上可定义为：
fun map' _ [] = []
  | map' f (x :: xs) = f x :: map f xs
在基本库中将函数复合定义为多态中缀算符(f o g)，map和fold高阶函数有较高效率的实现。
核心语言 > 例外

例外可以使用raise关键字发起，并通过模式匹配handle构造来处理：
exception Undefined;

fun max [x] = x
  | max (x :: xs) = let
    val m = max xs
    in
        if x > m then x else m 
    end
  | max [] =
      raise Undefined

fun main xs = let
    val msg = (Int.toString (max xs))
              handle Undefined => "empty list...there is no max!"
    in
        print (msg ^ "\n")
    end
这里的^是字符串串接算符。可以利用例外系统来实现非局部退出，例如这个函数所采用技术：
exception Zero;

fun listProd ns = let
    fun p [] = 1
      | p (0 :: _) = raise Zero
      | p (h :: t) = h * p t
    in
        (p ns)
        handle Zero => 0
    end
Zero在0情况下发起，控制从函数p中一起出离。
核心语言 > 引用

初始化基础库还以引用的形式提供了可变的存储。引用ref可以在某种意义上被认为是如下这样定义的：
datatype 'a ref = ref of 'a
还定义了内建的:=函数来修改引用的内容，和!函数来检索引用的内容。阶乘函数可以使用引用定义为指令式风格：
fun factImperative n = let
    val i = ref n and acc = ref 1
    in
        while !i > 0 do
            (acc := !acc * !i;
             i := !i - 1);
        !acc
    end
这里使用圆括号对以;分隔的表达式进行了顺序复合。
可变类型'a ref是等式类型，即使它的成员类型不是。两个引用被称为是相等的，如果它们标识相同的“ref单元”，就是说相同的对ref构造子调用生成的同一个指针。因此(ref 1) = (ref 1)和(ref 1.0) = (ref 1.0)都是有效的，并且都求值为false，因为即使两个引用碰巧指向了相同的值，引用自身是分立的，每个都可以独立于其他而改变。
模块语言

模块是ML用于构造大型项目和库的系统。
示例代码

下列例子使用了Standard ML的语法和语义。
示例代码 > 素数

下面是求素数的试除法实现：
fun prime n = let
    fun isPrime (l, i) = let
        fun existsDivisor [] = false 
          | existsDivisor (x :: xs) = 
              if (i mod x) = 0 then true
              else if (x * x) > i then false 
              else existsDivisor xs
        in  
            not (existsDivisor l)
        end
    fun iterate (acc, i) =
          if i > n then acc
          else if isPrime (acc, i)
          then iterate (acc @ [i], i + 2)
          else iterate (acc, i + 2)
    in 
        if n < 2 then []
        else iterate ([2], 3)
    end
基本库find和exists函数在不存在符合条件元素的时候会遍历整个列表，
这里采用了特殊化了的existsDivisor，用以在后续元素都不满足条件时立即结束运算。
下面是埃拉托斯特尼筛法实现：
fun prime n = let
    fun dropComposite (acc, [], _, _) = rev acc
      | dropComposite (acc, l as x :: xs, j, i) = 
          if j > n then List.revAppend (acc, l) 
          else if x < j  
          then dropComposite (x :: acc, xs, j, i)
          else if x > j 
          then dropComposite (acc, l, j + i, i)
          else dropComposite (acc, xs, j + i, i)
    fun init i = let
        fun loop (l, i) = 
              if i <= 2 then l
              else loop (i :: l, i - 2)
        in
            loop ([], i - (i + 1) mod 2)
        end
    fun iterate (acc, []) = rev acc     
      | iterate (acc, l as x :: xs) = 
          if x * x > n
          then 2 :: List.revAppend (acc, l)
          else iterate (x :: acc,
                 dropComposite ([], xs, x * x, x * 2))
    in 
        if n < 2 then [] 
        else iterate ([], init n)
    end
这里基于列表的筛法实现符合埃拉托斯特尼的原初算法。筛法还有基于数组的直观实现。
下面是其解释器下命令行运行实例：
- fun printIntList (l: int list) =
=     print ((String.concatWith " " (map Int.toString l)) ^ "\n");
val printIntList = fn : int list -> unit
- val _ = printIntList (prime 100);
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
示例代码 > 汉明数

正规数是形如 \ 2^{i}\cdot 3^{j}\cdot 5^{k}\ 的整数，对于非负整数 \ i\ 、 \ j\ 和 \ k，它是可以整除 \ 60^{\max(\lceil i\,/2\rceil ,j,k)}\ 的数。计算升序的正规数的算法经由戴克斯特拉得以流行，理查德·汉明最初提出了这个问题，故而这个问题被称为“汉明问题”，这个数列也因而被称为汉明数。Dijkstra计算这些数的想法如下：
汉明数的序列开始于数1。
要加入序列中的数有下述形式：2h, 3h, 5h，这里的h是序列已有的任意的汉明数。
因此，可以生成最初只有一个1的序列H，并接着归并（英语：）序列2H, 3H, 5H，并以此类推。
示例汉明数程序代码，一般用来展示，确使计算只在需要时进行的纯函数式编程方式。
fun Hamming_number n = let
    fun merge (p, q) = let
        fun revMerge (acc, p, q) =
              if not (null p) andalso not (null q) then
                  if hd p < hd q
                  then revMerge ((hd p) :: acc, tl p, q)
                  else if hd p > hd q
                  then revMerge ((hd q) :: acc, p, tl q)
                  else revMerge ((hd p) :: acc, tl p, tl q)
              else if null p 
              then List.revAppend (q, acc)
              else List.revAppend (p, acc)
        in
            if (null p) then q
            else if (null q) then p
            else rev (revMerge ([], p, q))
        end
    fun mul m x =
          if x <= (n div m) then SOME (x * m) else NONE
    fun mapPrefix pred l = let
        fun mapp ([], acc) = rev acc
          | mapp (x :: xs, acc) = 
             (case (pred x)
                of SOME a => mapp (xs, a :: acc)
                 | NONE => rev acc)
        in
            mapp (l, [])
        end
    fun mergeWith f (m, i) = merge (f m, i)
    fun generate l = let
        fun listMul m = mapPrefix (mul m) l
        in
            foldl (mergeWith listMul) [] [2, 3, 5]
        end
    fun iterate (acc, l) =
          if (hd l) > (n div 2) then merge (l, acc)
          else iterate (merge (l, acc), generate l)
    in
        if n > 0 then iterate ([], [1]) else []
    end
产生指定范围内的汉明数需要多轮运算，后面每轮中的三个列表元素乘积运算中都可能产生超出这个范围的结果，它们不需要出现在后续的运算之中。
基本库mapPartial函数与它所映射的函数，通过基于Option结构的SOME和NONE构造子的协定，可以将所映射函数认为不符合条件的元素或者结果排除掉，它会遍历整个列表。
由于这个算法采用升序列表，故而这里将它改写为mapPrefix函数，用来在特定条件不满足条件就立即结束。下面是汉明数程序在解释器下命令行运行实例：
- fun printIntList (l: int list) =
=     print ((String.concatWith " " (map Int.toString l)) ^ "\n");
val printIntList = fn : int list -> unit
- val _ = printIntList (Hamming_number 400);
1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36 40 45 48 50 54 60 64 72 75 80 81 90 96 100 108 120 125 128 135 144 150 160 162 180 192 200 216 225 240 243 250 256 270 288 300 320 324 360 375 384 400
示例代码 > 续体传递风格实例

下面是续体传递风格（CPS）的高阶函数foldr和map的实现，和达成一个整数列表的合计函数的简单用例：
fun foldr' f b l = let
    fun f2 ([], k) = k b
      | f2 (a :: r, k) =
          f2 (r, fn x => k (f (a, x)))
    in
        f2 (l, fn x => x)
    end

fun map' f l = 
      foldr' (fn (x, y) => (f x) :: y) [] l 

fun sum l =
      foldr' (fn (x, y) => (x + y)) 0 l
对于输入[e1, e2, ..., en]，sum函数等价于函数复合(fn x => x) o (fn x => e1 + x) o (fn x => e2 + x) o ... o (fn x => en + x)，它应用于0上得到(e1 + (e2 + (... + (en + 0)...)))。
SML/NJ支持头等对象的续体。头等续体对一门语言而言是能完全控制指令执行次序的能力。它们可以用来跳转到产生对当前函数调用的那个函数，或者跳转到此前已经退出了的函数。头等续体保存了程序执行状态，它不保存程序数据，只保存执行上下文。