将字符串转换为小写。

lower“This is A TEST”==“This is A TEST”（这是测试）降低“”==“”

将字符串转换为大写。

upper“这是一个测试”==“这是测试”上部“”==“”

删除字符串两侧的空格修剪结束和修剪开始。

trim“hello”==“hello”trimStart“hello”==“hello（你好）”trimEnd“你好”==“你好”\s->trim s==trimEnd（trimStart s）（修剪结束（修剪开始）s））

删除字符串开头的空格，请参阅修剪。

删除字符串末尾的空格，请参阅修剪。

从字符串中分割第一个单词。用于开始解析开头但您希望准确地保留字符串其余部分的空白。

单词1“”==（“”，“”）word1“keyword-rest-of-string”==（“keyword”，“rest-of-string”）word1“keyword\n剩余字符串”==（“keyword”，“剩余字符串”）\s->fst（word1s）==concat（取1$words）\s->单词（snd$word1s）==删除1（单词s）

将第一行从字符串中拆分。

第1行“”==（“”，“”）line1“测试”==（“测试”，“”）line1“测试\n”==（“测试”，“”）line1“test\nrest”==（“test”，“rest”）line1“test\nrest\nmore”==（“test”，“rest\nmore”）

转义字符串，以便将其插入HTML文档或"属性没有任何特殊解释。这需要退出<,>,&和"字符。注意它会逃逸"和'尽管这在HTML正文中不是必需的（但无害）。

escapeHTML“这是一个测试”==“这是测试”转义HTML“<b>\”g&t\“</n>”==“&lt；b&gt；g&gt；&lt；/n&gt；”escapeHTML“t'是另一项测试”==“t&#39；是另一个测试”

转义字符串，使其成为JSON文本的一部分。这需要转义特殊空格和控制字符。此外，请注意，确实如此不在字符串周围添加引号字符。

escapeJSON“这是一个测试”==“这是测试”escapeJSON“\tab\nnewline\\”==“\\ttab\\nnewline\\\\”escapeJSON“\ESC[0mHello”==“\\u001b[0mHello”

的反转转义HTML（不执行常规HTML反转义）

\xs->unescapeHTML（escapeHTML xs）==xs

通用JSON反转义转义JSON以及所有其他JSON转义。

\xs->unescapeJSON（转义JSON xs）==xs

从列表末尾删除一些元素。

dropEnd 3“hello”==“他”dropEnd 5“再见”==“”dropEnd（-1）“再见”==“再见”\i xs->dropEnd i xs`isPrefixOf`xs\i xs->长度（dropEnd i xs）==max 0（长度xs-max 0 i）\i->取3（dropEnd 5[i..]）==取3

从列表末尾选取一些元素。

takeEnd 3“hello”==“llo”takeEnd 5“bye”==“bye”takeEnd（-1）“再见”==“”\i xs->takeEnd i xs`isSuffixOf`xs\i xs->长度（takeEnd i xs）==最小值（最大值0 i）（长度xs）

在末尾拆分n个xs返回第二个元素尝试执行的拆分包含n个元素。

splitAtEnd 3“hello”==（“he”，“llo”）在末尾3拆分“he”==（“”，“he“）\i xs->uncry（++）（splitAt i xs）==xs\i xs->splitAtEnd i xs==（dropEnd i xs，takeEnd i KS）

打破，但从最后开始。

breakEnd为Lower“youRE”==（“you”，“RE”）breakEnd是Lower“youre”==（“youre“，”）breakEnd为Lower“YOURE”==（“，”YOURE“）\f xs->breakEnd（not.f）xs==span结束f xs

跨度，但从末端开始。

span端是上部“youRE”==（“you”，“RE”）span结束（不是.isSpace）“x y z”==（“x y”，“z”）\f xs->取消修剪（++）（span结束f xs）==xs\f xs->spanEnd f xs==swap（两个反向（span f（反向xs）））

的一个版本拖放WhileEnd但具有不同的严格性。功能拖放WhileEnd可以用于无限列表并测试属性在每个字符上。相反，dropWhileEnd'在列表的核心部分是严格的但只测试后缀。此版本通常优于拖放WhileEnd如果列表很短或测试很昂贵。请注意，下面的测试涵盖了质数和非质数变体。

dropWhileEnd isSpace“ab cde”==“ab cde”dropWhileEnd'isSpace“ab cde”==“ab cde”last（dropWhileEnd偶数[undefined，3]）==未定义last（dropWhileEnd'偶数[undefined，3]）==3头部（dropWhileEnd偶数（3:未定义））==3head（dropWhileEnd'even（3:未定义））==未定义

的一个版本takeWhile（拍摄时）从末尾开始操作。

takeWhileEnd偶数[2,3,4,6]==[4,6]

如果第二个列表的后缀为匹配整个第一个列表。

示例：

stripSuffix“bar”“foobar”==仅“foo”stripSuffix“”“baz”==仅“baz“stripSuffix“foo”“quux”==无

返回搜索字符串前后的字符串，或没有什么如果搜索字符串不存在。

示例：

stripInfix“：：”“a:：b:：c”==仅（“a”，“b:：c”）stripInfix“/”“foobar”==无

类似条带Infix，但从末尾搜索字符串。

stripInfixEnd“：：”“a:：b:：c”==仅（“a:“b”，“c”）

从列表中删除给定的前缀。如果序列没有以给定的前缀开头，则返回原始序列。

dropPrefix“Mr.”“Mr.Men”==“Men”dropPrefix“Mr.”“Dr.Men”==“Dr.Man”

从列表中删除给定后缀。如果序列没有以给定后缀结尾，则返回原始序列。

dropSuffix“！”“你好世界！”==“你好世界”dropSuffix“！”“Hello World！！”==“Hello World！”dropSuffix“！”“你好世界。”==“你好世界”

的变体话使用自定义测试。特别地，相邻的分隔符被丢弃，前导或尾随分隔符也被丢弃。

wordsBy（=='：'）“：：xyz:abc:：123:：”==[“xyz”，“abc”，“123”]\s->wordsBy isSpace s==单词s

的变体线使用自定义测试。特别地，如果有尾随分离器，它将被丢弃。

linesBy（=='：'）“：：xyz:abc:：123:：“==[”“，”“，“xyz”，“abc”，“”，“123”，“]\s->linesBy（=='\n'）s==行slinesBy（=='；'）“我的；列表；这里；”==[“我的”，“列表”，“这里”]

查找的第一个实例针在里面干草堆。返回元组的第一个元素是的前缀干草堆之前针匹配。第二个是的余数干草堆，从比赛开始。如果你想要剩下的没有匹配，使用条带Infix。

breakOn“：：”“a：：b：：c”==（“a”，“：：b:：c”）breakOn“/”“foobar”==（“foober”，“”）\大海捞针->let（prefix，match）=breakOn peedle haystack in prefix++match==大海捞球

类似breakOn（断开），但从末尾搜索字符串。

返回元组的第一个元素是干草堆截至并包括最后一场比赛针第二个是剩余的干草堆，在比赛之后。

breakOnEnd“：：”“a:：b:：c”==（“a::b:：”，“c”）

将列表分成由第一个分隔的几部分list参数，使用分隔符。空分隔符是无效，并将导致引发错误。

splitOn“\r\n”“a\r\nb\r\nd\r\ne”==[“a”，“b”，“d”，“e”]splitOn“aaa”“aaaXaaaXaaaXaaa”==[“”，“X”，“X”，“”]拆分“x”“x”==[“”，“”]拆分“x”“”==[“”]\s x->s/=“”==>插入s（splitOns x）==x\c x->拆分开[c]x==拆分（==c）x

将列表拆分为由分隔符分隔的组件，其中，谓词对分隔符元素返回True。这个生成的组件不包含分隔符。两个相邻的分隔符导致输出中有一个空组件。

split（=='a'）“aabbaca”==[“”，“”，“bb”，“c”，“”]拆分（=='a'）“”==[“”]分割（=='：'）“：：xyz:abc:：123:：“==[”“，”“，“xyz”，“abc”，“”，“123”，“，”]split（=='，'）“我的，列表，这里”==[“我的”，“列表”，“这里”]

将列表拆分为给定大小的块。最后一个块可能包含少于n个元素。区块大小必须为正数。

chunksOf 3“我的测试”==[“我的”，“tes”，“t”]chunksOf 3“mytest”==[“myt”，“est”]chunksOf 8“”==[]chunksOf 0“test”==未定义

A总计头使用默认值。

头部定义1[]==1头定义1[2,3,4]==2\x xs->headDef x xs==fromMaybe x（listToMaybe xs）

A总计最后的使用默认值。

上次定义1[]==1上次定义1[2,3,4]==4\x xs->lastDef x xs==last（x:xs）

列表索引函数的总变体(!!)。

[2,3,4] !? 1==只有3个[2,3,4]！？（-1）==什么都没有[]      !? 0==无

组成不和无效的。

notNull[]==假notNull[1]==真\xs->notNull xs==not（空xs）

列表上的非递归转换，如也许 吧。

列表1（\v _->v-2）[5,6,7]==3列表1（\v _->v-2）[]==1\nil-cons xs->maybe nil（uncry-cons）（uncos-xs）==列出nil-cons-xs

如果列表为空，则返回没有什么，否则返回初始化以及最后的。

unsnoc“test”==只是（“tes”，'t'）unsnoc“”==无\xs->unsnoc xs==如果xs为空，则无其他内容（init xs，last xs）

将元素附加到列表的开头(:)。

cons't'“est”==“test”\x xs->uncs（cons x xs）==只是（x，xs）

将元素附加到列表末尾O（n）时间。

snoc“tes”'t'==“test”\xs x->unsnoc（snoc xs x）==Just（xs，x）

相当于下降1，但可能更快，而且只有一个词素。

drop1“”==“”drop1“test”==“est”\xs->drop 1 xs==drop1 xs

相当于拖放结束1，但可能更快，而且只有一个词素。

dropEnd1“”==“”dropEnd1“测试”==“tes”\xs->dropEnd 1 xs==dropEnd1 xs

上的版本concatMap（连接地图）概括为单体而不仅仅是一个列表。

mconcatMap总和[1,2,3]==总和6\f xs->mconcatMap f xs==concatMap

懒惰地比较可折叠的带有数字。

比较长度[1,2,3]1==GT比较长度[1,2]2==EQ\（xs:：[Int]）n->compareLength xs n==比较（长度xs）n比较长度（1:2:3：未定义）2==GT

懒惰地比较两个的长度可折叠的第条。>comparingLength[1，2，3][错误]==GT>comparingLength[1，2]“ab”==均衡器>（xs:：[Int]）（ys:：[Int]）->比较长度xs ys==数据。订单比较长度xs-ys>比较长度1,2==LT>比较长度（1:2:3：未定义）[1,2]==GT

枚举枚举，来自最小界限到最大界限。

enumerate==[False，True]

以下各项的组合组和分类。

组排序[（1，'t'），（3，'t]），（2，'e'\xs->map fst（groupSort xs）==排序（nub（map fst xs））\xs->concatMap-snd（groupSort xs）==map-snd（sortOn fst-xs）

以下各项的组合组和分类，使用值的一部分进行比较。

groupSortOn长度[“test”，“of”，“sized”，“item”]=[[“of”]，[“test”，“tem”]，[sized“]]

以下各项的组合组和分类，使用谓词进行比较。

groupSortBy（compare`on`length）[“test”，“of”，“sized”，“item”]=[[“of”]，[“test”，“tem”]，“size”]]

O（n对数n）. ThenubOrd编号函数从列表中删除重复的元素。特别是，它只保留每个元素的第一次出现。与标准不同结节运算符，此版本需要订单实例因此运行速度逐渐加快。

nubOrd“这是一个测试”==“这个ae”nubOrd（取4（“this”++未定义））==“this“\xs->nubOrd xs==nub xs

的一个版本nubOrd编号使用自定义谓词。

nubOrdBy（compare`on`length）[“a”，“test”，“of”，“this”]==[“a“，”test“，”of“]

的一个版本nubOrd编号对值的一部分进行操作。

nubOrdOn长度[“a”，“test”，“of”，“this”]==[“a“，”test“，”of“]

已弃用使用nubOrdOn号，因为此函数是_O（n^2）_。

的一个版本结节其中对提取的值进行等式。f上的nubOn等于nubBy（（==）在f），但有仅评估的性能优势（f）中的每个元素一次输入列表。

的一个版本组其中对提取的值进行等式。

groupOn腹肌[1，-1，2]==[[1，-1]，[2]]

的一个版本groupOn（组打开）将每个组与其“键”配对用于相等测试的提取值。

groupOnKey abs[1，-1,2]==[（1，[1，-1-），（2，[2]）]

O（n log n）. ThenubSort（数字排序）函数排序并从列表中删除重复的元素。特别是，它只保留每个元素的第一次出现。

nubSort“这是一个测试”==“aehist”\xs->nubSort xs==nub（排序xs）

的一个版本nubSort（数字排序）使用自定义谓词。

nubSortBy（compare `on`length）[“a”，“test”，“of”，“this”]=[“a”，“of”，“test”]

的一个版本nubSort（数字排序）对值的一部分进行操作。

nubSortOn长度[“a”，“test”，“of”，“this”]==[“a“，”of“，”test“]

的一个版本最大限度其中对提取的值进行比较。如果列表为空，则引发错误。每个元素只调用一次函数。

maximumOn id[]==未定义maximumOn长度[“测试”，“额外”，“a”]==“额外”

的一个版本最低限度其中对提取的值进行比较。如果列表为空，则引发错误。每个元素只调用一次函数。

minimumOn id[]==未定义最小长度[“test”，“extra”，“a”]==“a”

严格版本的总和。不同于总和此函数在号码参数，而标准版本只有在优化者介入时才是严格的。

总和'[1,2,3]==6

严格版本的产品。

产品'[1,2,4]==8

严格版本的总和，使用自定义估价函数。

sumOn'读取[“1”，“2”，“3”]==6

严格版本的产品，使用自定义估价函数。

productOn'读为[“1”，“2”，“4”]==8

是两个不相交的列表，没有共同的元素。

不相交[1,2,3][4,5]==真不相交[1,2,3][4,1]==假

O（（m+n）log m），m<=n。是两个不相交的列表，没有共同的元素。

disjointOrd（分离命令）比不相交的例如，disjointOrd（分离命令）不能如果两个列表都是无限的，则终止，而不相交的可以。

disjointOrd[1,2,3][4,5]==真disjointOrd[1,2,3][4,1]==假

的一个版本disjointOrd（分离命令）使用自定义谓词。

disjointOrdBy（compare`on`（`mod`7））[1,2,3][4,5]==真disjointOrdBy（compare`on`（`mod`7））[1,2,3][4,8]==假

所有元素都相同。

allSame[1,1,2]==错误allSame[1,1,1]==真allSame[1]==真allSame[]=真所有相同（1:1:2：未定义）==错误\xs->allSame xs==（长度（nub xs）<=1）

是否有任何元素出现多次。

anySame[1,1,2]==真anySame[1,2,3]==错误anySame（1:2:1：未定义）==真anySame[]==假\xs->anySame xs==（长度（nub xs）<长度xs）

重复应用某些操作，生成输出元素以及列表的其余部分。

当到达空列表时，返回空列表，因此操作是从未应用于空输入。该事实在类型系统中编码为重复网元

\xs->重复（splitAt 3）xs==块3 xs\xs->重复word1（trim xs）==单词xs\xs->重复line1 xs==行xs

重复应用某些操作，生成输出元素以及列表的其余部分。

与相同反复地，但具有更精确的类型签名。

查找操作返回的列表的第一个元素只是，沿着操作的结果。喜欢找到但在函数也计算一些可以重用的昂贵信息。特别有用当函数是单数函数时，请参见第一名JustM。

firstJust id[Nothing，Just 3]==只有3firstJust id[Nothing，Nothing]==没有

合并解压缩和凹面（concat）。

concatUnzip[（“a”，“AB”），（“bc”，“C”）]==（“abc”，“abc”）

合并解压缩3和凹面（concat）。

concatUnzip3[（“a”，“AB”，“”），（“bc”，“C”，“123”）]=（“abc”，“abc”，“123”）

拉链针对枚举。如果枚举用完，则截断输出。

\i xs->zip[i..]xs==zipFrom i xszipFrom False[1..3]==[（False，1），（True，2）]

zip发件人概括为任何组合操作。如果枚举用完，则截断输出。

\i xs->zipWithFrom（，）i xs==zipFrom i xs

喜欢拉链，但要继续使用最长的值。功能始终至少给出一个参数只是和，同时列表包含项目，两个只是值。

zipWithLongest（，）“a”“xyz”==[（仅'a'，仅'x'），（无，仅'y'）zipWith最长（，）“a”“x”==[（仅'a'，仅'x'）]zipWith最长（，）“”“x”==[（没有，只有'x'）]

替换出现的子序列。

replace“el”“_”“Hello Bella”==“H_lo B_la”replace“el”“e”“Hello”==“Helo”replace“”x“”Hello“==”xHxexlxlxox“替换“”x“”==“x”\xs->replace xs-xs-ys==ys

合并两个假定已排序的列表。

merge“ace”“bd”==“abcde”\xs->merge（排序xs）（排序ys）==排序（xs++ys）

喜欢合并，但带有自定义排序函数。