将多行Table值函数转换为SQL内联(converting multiline Table valued function to inline in SQL)

 作为Refactor答案的附录，我认为他的方法是正确的。 他将问题细分，直到可以使用内置函数轻松解决问题。 如果你想为学习目的推出你自己的解决方案，我建议你保留这个细分，并从那里开始，实现你自己的复制。 否则，你最终会得到一个功能太多的单一功能。 
 
 所以剩下的问题就是实施复制。 我的第一个想法是查看复制的源代码 。 我通过hoogle找到了它，这引起了我的黑客行为 ，它与源代码有关。 摘录自： 
 
replicate               :: Int -> a -> [a]
replicate n x           =  take n (repeat x)
 
 这是很好和简洁，再次使用内置的功能。 如果你想完全推出自己的复制品，你可以这样做： 
 
myReplicate                 :: Int -> a -> [a]
myReplicate n x | n <= 0    = []
                | otherwise = x : replicate (n-1) x
 
 - - - - - 编辑 - - - - - - - - 
 
 作为一个便笺，我认为你的问题需要两个相当正交的技能。 首先是尽量不要立即解决整个问题，而是要取得一些小进展。 然后，您可以尝试解决这个较小的问题，然后再回到较大的问题。 就你而言，它可能会涉及到认识到你肯定需要一种将角色转换为长度为n的一系列字符的方法。 像map，filter，foldr等函数的经验会帮助你，因为它们每个都代表着一个非常独特的变换，你可能会认识到这一点。 
 
 您的解决方案所需的第二项技能 - 如果您想要自己推出 - 正在识别函数何时可以递归表示。 正如你所看到的，你的问题 - 甚至许多常见的问题 - 可以在没有明确的递归的情况下被解决，但是当需要出现时，它是一个很好的技巧。 递归解决方案并不总是很容易理解，所以我认为熟悉它们的最好方法是阅读和练习。 
 
 为了进一步研究，我相信你已经指出了优秀的学习你一个Haskell和真实世界的Haskell ，但是，如果你没有，在这里他们是。 

As an addendum to Refactor's answer, I think his approach is the correct one. He subdivides the problem until it can be solved trivially using built-in functions. If you want to roll your own solution for learning purposes, I suggest you keep this subdivision, and go from there, implementing your own replicate. Otherwise, you will end up with a single function which does too much. 
 
So the remaining problem is that of implementing replicate. My first idea would be to look at the source code for replicate. I found it via hoogle, which led me to hackage, which has links to the source code. Excerpted from the source:
 
replicate               :: Int -> a -> [a]
replicate n x           =  take n (repeat x)
 
which is nice and concise, again using the built-in functions. If you want to completely roll your own replicate, you can do:
 
myReplicate                 :: Int -> a -> [a]
myReplicate n x | n <= 0    = []
                | otherwise = x : replicate (n-1) x
 
----------EDIT----------------
 
As a side note, I think your problem requires two rather orthogonal skills. The first is trying not to tackle the whole problem at once, but making some small progress instead. Then you can try to solve that smaller problem, before returning to the larger. In your case, it would likely involve recognizing that you definitely need a way of transforming the character into a series of characters of length n. Experience with functions such as map, filter, foldr and so on will help you here, since they each represent a very distinct transformation, which you might recognize. 
 
The second skill required for your solution - if you want to roll your own - is recognizing when a function can be expressed recursively. As you can see, your problem - and indeed many common problems - can be solved without explicit recursion, but it is a nice skill to have, when the need arises. Recursive solutions do not always come easily mind, so I think the best way to gain familiarity with them are to read and practice.
 
For further study, I'm sure you have already been pointed to the excellent Learn You a Haskell and Real World Haskell, but just in case you haven't, here they are.