I mean, the multiple-ways-to-do-things bit is possible in any language. Even Python, with its guiding principle that &#x27;there&#x27;s only one way to do it&#x27;, would <i>allow</i> you to do it in different ways:<p><pre><code>    def factorial(n):
        if n == 0:
            return 1
        else:
            return n * factorial(n-1)

    def factorial(n):
        return 1 if n == 0 else n * factorial(n-1)

    def factorial(n):
        return eval(&#x27;*&#x27;.join(map(str, range(1, n+1))))

    def factorial(n):
        return reduce(lambda x, y: x * y, range(1, n+1))

    def factorial(n):
        def facts():
            n, r = 1, 1
            while True:
                r, n = n*r, n+1
                yield r
        return next(islice(facts(), n-1, None))
</code></pre>
The difference is: historically, Haskell was an experimental language, a test-bed for trying out new and weird ideas, which meant that experimentation with style has been pretty normal thing. Haskell &quot;culture&quot; encouraged being clever, because that&#x27;s how you found new, interesting ideas. On the other hand, Python doesn&#x27;t have that legacy: most of the implementations above are non-idiomatic <i>because</i> they&#x27;re too clever.<p>So yes, you can write things lots of ways in Haskell. But, if you had production code in Haskell, you wouldn&#x27;t try to be clever, in the same way that you wouldn&#x27;t (or shouldn&#x27;t) try to be clever in production code in Python. You&#x27;d write simple, straightforward code, just like<p><pre><code>    fact n = prod [1..n]</code></pre>