List.Generate

官方说明：

给定生成初始值initial的四个函数，针对条件condition进行测试，如果成功，则选择结果并生成下一个值next，以此生成值列表。还可以指定可选参数selector。
List.Generate(initial as function, condition as function, next as function, optional selector as nullable function) as list

解读：

一般来说，函数中只要有一个类型是function的参数，就可以无限延伸扩展，函数套函数，就会比较难。
今天要讲的这个函数，一共4个参数，但4个参数全部都是function你见过没？
个人认为这个函数难度排在所有函数的top3，所以如果你确定要继续往下看，请先弄懂前面讲的List.TransformMany和List.Accumulate，否则。。。
我的理解：List.Generate(()=>初始赋值,列表限定条件,迭代的自定义运算,可选择自定义输出迭代的传输变量)

先看官方给的两个案例：
= List.Generate(()=>10, each _>0, each _-1)
第一参数初始值为10，传递到第二参数进行判断是否>0，如果成立，再传递到第三参数减1，第一步结果为9。
再把9传递到第二参数继续判断，每次成立就传递到第三参数，每次减1。
直到减到结果为1，经过第三参数1-1=0，再传递到第二参数判断，0不大于0，跳出循环。
最终返回前面所有符合条件的值的列表，结果为{10,9,8,7,6,5,4,3,2,1}。
注意，虽然第一步的结果就是9，但最终的结果会包含初始值的10，这是和acc有点区别的地方。

如果说acc相当于for each in next，那么List.Generate则相当于while循环。
打个比方，手机卡充值了100元，打电话2毛一分钟，每拨出一个电话，系统判断余额是否>0，如果是，接通电话，并且每分钟扣掉2毛。一旦余额<0，对不起，您的电话已停机。 最后你跑到营业厅把通话详单打出来，上面显示每通电话扣了多少钱，余额还有多少。
 
还有个可选的第四参数，来看第二个例子：
= List.Generate(()=>[ x = 1 , y = {}] , each [x] < 10 , each [x = List.Count([y]), y = [y] & {x}] , each [x])
初始值为[x=1,y={}]，第一步x<10成立，执行第三参数，结果为[x=0,y={0}]。 后面的步骤只要x也就是y中元素个数<10，就循环一次，而每次循环y中就多一个元素，x就会+1，每步的结果都是record，但是第四参数限制了只输出x，所以最后的结果就是初始的1和0-9组成的list。就是说我办的是家庭套餐，消费记录可能还有其他号码的，但加上第四参数我就只看我自己的号码。  
 
同样，初始值由一个无参函数()=>生成的值，不仅可以是上面的number,record，也可以是list等其他任意类型。
比如要构建一个等差数列，初始值为1，公差为2，列出数列的前9项：
= List.Generate(()=>{1,0},each _{1}<9,each {_{0}+2,_{1}+1},each _{0})
初始值为{1,0}，1为数列的首项，0用来记录循环次数也就是数列的项数。
每循环一次，首项+2，项数+1，当项数不满足<9时跳出循环，第四参数_{0}控制只输出第一个元素，最终结果为{1,3,5,7,9,11,13,15,17}。
 
再来一个简单的案例：指定一个日期，列出从这一天开始到当月最后一天的所有日期。
= List.Generate(()=>#date(2017,8,17),each _<=Date.EndOfMonth(#date(2017,8,17)),each Date.AddDays(_,1))
初始值为该日期，每次循环先判断是否<=当月最后一天，满足就加一天，不满足则跳出循环返回所有符合条件的日期列表。 看到这我们可以大致总结出，List.Accumulate侧重于迭代的最终结果，而List.Generate偏向迭代中每一步的过程。这句话的另一个意思就是，只要取generate结果的最后一个值，就是acc的结果。所以大多数情况下，acc能做的，generate都能实现，只不过是用谁更方便的问题。

比如之前用acc实现的批量替换文本：
= List.Last(List.Generate(()=>[x="上海市浦东新区",y=0],each [y]<=3,each [x=Text.Replace([x],{"上","东","新"}{[y]},{"下","西","旧"}{[y]}),y=[y]+1],each [x]))
x为需要替换的文本，y用来循环索引，初始值为0。第二参数中的3为待替换列表中元素的个数，每一步替换完一个值，y+1，下一步替换下一个元素，直到替换完列表中所有的值。
最终得到初始值和三次替换中每一次的结果列表，再用List.Last取最后一个值。

再比如累计求和：
= List.Skip(List.Generate(()=>[l={1,2,3,4,5},i=0,r=0],each [i]<=5,each [l=[l],i=[i]+1,r=[r]+[l]{[i]}],each [r]))
初始值中，l表示需要累计求和的list，i表示循环索引index，r为result用来装载结果，第二参数中的5为l中的元素个数。
i从0开始，每一步取l中第i个元素，从0开始累加并记录到r中，每次循环i+1，第四参数控制只输出r。
最终返回的结果中包含了初始值0，再用List.Skip跳过初始值。

当嵌套层数比较多时，第一参数都建议使用record而不用list，并且变量名尽量起有意义的名字，否则很容易把自己绕晕。
以上的案例虽然generate也能做，但显然是acc更方便一些，下面看几个generate为最优解的案例：

进制转换

先了解下十进制转二进制的计算过程：将十进制数不断除以2取余数，直到取整的结果=0，最后将余数取反，翻译为M语言就是：

= List.Reverse(
	List.Generate(()=>
		25,
		each _<>0,
		each Number.IntegerDivide(_,2),
		each Number.Mod(_,2)
	)
)

提取1000以内质数

= {2}&List.RemoveNulls(
		List.Generate(()=>[
			n=3,
			m={}
		],
		each [n]<1000, each [ n=[n]+2, m={2..n-1} ], each if List.AnyTrue(List.Transform([m],(x)=>Number.Mod([n],x)=0)) then null else [n]
	)
)

质数为在大于1的自然数中，除了1和它本身以外不再有其他因数。除了2以外，所有的质数都是奇数，但是奇数不一定是质数，比如9=3*3。
整个过程就是循环遍历，把1000以内的所有奇数从3开始，挨个用2..n-1除，判断余数是否为0，返回一个布尔值的列表。
如果列表中有任意一个为true就返回n，否则返回null。
比如5除以2-4都不符合，就返回5。9除以2-8中，9除以3等于3余0，就返回null。
最后移除null，再连接上特殊值2。

约瑟夫环

把13个人围成一圈，从1开始报数，报到4杀掉然后下一位接着从1开始报，剩最后一人为幸存者。
要求列出每一轮被杀死的人及最后的幸存者。
之前在acc中给了一个数学公式推导的解法，这里再给一个generate的模拟解法。

= List.Skip(
	List.Generate(()=>[
			l = {1..13},
			k = List.Count(l),
			n = 1,
			m= l{n-1}
		]
		,each [k]>=0
		,each [
			l = List.RemoveItems([l],{m}),
			k = [k]-1,
			n = [a=Number.Mod([n]+3,[k]),b=if a=0 then [k] else a][b],
			m = [l]{n-1}
		],
		each [m]
	)
)

讲这个问题之前，我们先来看一个简单的问题：一组连续的k个数{1..k}，报任意一个数n，从1开始数到k，然后再从头开始接着数，求数到n时是第几个数。
比如k=3，n=8，那么依次是1,2,3,1,2,3,1,2，数到8时为2。
这很容易理解，每k个数分为一组，用n除以k取余数即为结果。
但是如果n是k的倍数，比如k=3，n=6，取余数为0，那结果应该是k。以上翻译为M语言就是：
= (n,k)=>[a=Number.Mod(n,k),b=if a=0 then k else a][b]
公式可以进一步推导简化，写成：
= (n,k)=>Number.Mod(n-1,k)+1
如果不理解的话脑补一下画"正"字计数法。我们暂且先用上面那个容易理解的，不论n大于还是等于或是小于k，公式都同样适用。

再回来看这个问题，首先从刚开始，每个人身上贴一张从1-13编号的铭牌，这个编号是从开始到结束都不变的，我们记为m。
第一轮报到4的是4号，杀死出局。下一个报到4的是8号，但是4号已出局，目前场上还有12人，从1号开始数现在8号是第7个，这个7是序号，每过一轮都会变一次，我们记为n。
l表示list，为所有未死亡的人的列表，每过一轮少一人，即每次循环使用List.RemoveItems把死亡的人移出队列；k表示剩余人数，每次循环-1。
先假设现在不是13人而是100人站一条直线，报到4的人叫一声但不出局，开始报数的是1，报到4号叫一声，然后从5开始报1，下一个叫的人是8号，m依次为4,8,12,16...
但是现在规则是报到4的人被杀死则出局，每报一轮就少1人，所以n应该为4,8-1=7,12-2=10,16-3=13...是一个首项为4的等差数列，公差为3。
那么现在问题就可以简化成现有k个人，求报到n时是第几个人，直接套用上面的公式。每过一轮n+3，k-1。

整个过程就是，先判断剩余人数k是否>=0，如果满足，每次循环先把已死亡的人移出队列l，然后人数k-1，再找到报4人的序号n，深化出{n-1}个即为本轮死亡人的编号m。
当人数k<=0跳出循环，第四参数控制输出m，最后再用List.Skip跳过初始值，返回最终结果。

总结：

这是一个非常灵活但同时也非常难的函数，相当于while循环。如果没有其他函数，可以用它来模拟替代很多其他函数做的事。
但如果是为了解决一个实际问题，毕竟还有很多函数可以选择，所以我的理解是generate虽然强大，但是不到万不得已不要用。
本来还准备了很多其他案例，但因为不是最优解所以没放上来。
以上案例大多都是算法题，最后再给一个实际应用的案例《BOM树形结构分解》。