Nice use of Infinity

My mistake. I thought I had seen some Kata where there were language-specific descriptions. I now realize that that is a rendering concern.

I've updated the description. Thanks for the help.

It's a little embarrassing how much I over-thought isPalindrome.

Nice parameterized type Polish t (as opposed to Number Double | Operator (Double -> Double -> Double) )

Sorry for the re-post. I was trying to add this as a 'suggestion.'

There are a lot of edge cases missed by the test cases and missed by many of the successful submissions (including mine).

• domains with more than three components (e.g. http://www.foo.bar.example/)
• authority parts with more than just a domain (e.g. http://user:password@foo.bar.example/)
• paths with more than one path component (e.g. http://foo.example/deeper/path/with/several/slashes)
• query parts with slashes (e.g. http://foo.example/q?a=//example//;//)
• schemes other than http or https (e.g. ftp://foo.example)
• URL schemes that are not hierarchical (and thus don't have a '//') (e.g. mailto:user@foo.example) One could argue that this is not actually a URL, but a URI if the scheme does not imply a hierarchy.
• authority parts with ports (e.g. http://foo.example:8080)

Additionally, the name is a little misleading as this exercise is looking for the so-called "second level domain," not the full domain.

I recommend adding the following test cases:

Test.expect(domain_name("http://www.foo.bar.example/") == "bar",
 "'http://www.foo.bar.example/' should produce 'bar'"
) 
Test.expect(domain_name("http://user:password@foo.example/") == "foo",
 "'http://user:password@foo.example/' should produce 'foo'"
) 
Test.expect(domain_name("http://foo.example/deeper/path/with/several/slashes") == "foo",
 "'http://foo.example/deeper/path/with/several/slashes' should produce 'foo'"
) 
Test.expect(domain_name("http://foo.example/q?a=//example//;//") == "foo",
 "'http://foo.example/q?a=//example//;//' should produce 'foo'"
) 
Test.expect(domain_name("http://foo.example:8080") == "foo",
 "'http://foo.example:8080' should produce 'foo'"
) 
Test.expect(domain_name("ftp://foo.example") == "foo",
 "'ftp://foo.example' should produce 'foo'"
) 
Test.expect(domain_name("mailto:user@foo.example") == "foo",
 "'mailto:user@foo.example' should produce 'foo'"
) 

Great kata. It is more than just an interesting problem. It exposed my weaknesses with list comprehensions, and I learned more about Haskell through doing the exercise. That is the whole point of a good kata.

I like how concise this is, but I can't get over the n(n-1) divisions. My solution requires no divisions but has a space penalty of 4n bytes, so I can't say it's any better.