The point of the post was really to argue that simple features like pattern matching, ADTs, and so on, should be in languages like Python and Go. Also I wanted to make the point that functional non-mutating APIs could be simple and tend to compose well: the `unfoldr` example was all about that. In that vein, it was important that I compare the Haskell code to an imperative version.

For instance, with your `reduce` improvement: I agree that the `reduce` version is better! It's simpler, cleaner, and easier to read. But Python these days is moving away from that sort of thing: `reduce` has been removed from the top-level available functions, and you're discouraged from using it as much as possible. The point I was making is that I think that move is a bad one.

Finally, while the Python code here is shorter, you still don't get any of the benefits of pattern-matching and ADTs.

* You can only deal with 2 cases cleanly (what if you wanted a separate case for the singleton tree?).

* You are not prevented from accessing unavailable fields.

* You don't get any exhaustiveness checking.

Python is untyped. This fundamental separation between Python and Haskell is non-trivial, and can't be papered over. Your complaints about exhaustiveness, field existence, and case analysis are all ultimately about the fact that Python's type system is open for modification, while Haskell's is closed; in Haskell, we can put our foot down and insist that whatever we see is an instance of something that we've heard of, but in Python, this is simply not possible.

I agree, when it comes to Python's moves. I am about ready to leave Python 2, but I'm not going to Python 3.

In my mind, the syntax would be something like this:

    sum_class Tree:
        case Leaf:
            pass
        case Node:
            data: Any
            left: Tree
            right: Tree

    def size(tree):
        case(Tree) tree of:
            Leaf:
                return 0
            Node(_, left, right):
                return 1 + size(left) + size(right)

Here's my version of skew heap in Python 3, edited down to just the essential operations. (Link to slightly fuller version: https://gist.github.com/olooney/97643d07d69d22015ae5bb70c121...). It seems about as clean as the Haskell version presented, mainly because I used None to represent leaves (which is quite Pythonic.) Relative to the code presented in the article, it also benefits from a clear partition of trees of immutable nodes on the one hand, and a class to represent the mutable heap interface on the other.

    from typing import NamedTuple, Any, Optional

    class Node(NamedTuple):
        """A single Node in a binary tree."""
        value: Any
        left: Node
        right: Node

    def merge(p: Optional[Node], q: Optional[Node]) -> Node:
        """
        Implements the critical "merge" operation which is
        used by all operations on a SkewHeap. The merge operation
        does not mutate either tree but returns a new tree which
        contains the least item at the root and is in heap order.
        The resulting tree is not necessarily balanced.
        """
        if p is None: return q
        if q is None: return p

        if q.value < p.value:
            p, q = q, p

        return Node(p.value, merge(p.right, q), p.left)


    class SkewHeap:
        """
        A SkewHeap is a heap data structure which uses an unbalanced binary tree to
        store items. Although no attempt is made to balance the tree, it can be
        shown to have amortized O(log n) time complexity for all operations under
        the assumption that the items inserted are in random order.
        """   
        def __init__(self, items=tuple()):
            """
            SkewHeap() -> new, empty, skew heap.
            SkewHeap(iterable) -> new skew heap initialized from the iterable.
            """
            self.root = None
            for item in items:
                self.push(item)

        def push(self, value: Any):
            """Add an item to this heap."""
            node = Node(value, None, None)
            self.root = merge(self.root, node)

        def pop(self):
            """Remove the least item in this heap and return it."""
            if self.root is None:
                raise ValueError("Cannot pop empty SkewHeap")
            else:
                value = self.root.value
                self.root = merge(self.root.left, self.root.right)
                return value

        def union(self, other: 'SkewHeap') -> 'SkewHeap':
            """Return a new heap which contains all the items of this and another heap combined."""
            ret = SkewHeap()
            ret.root = merge(self.root, other.root)
            return ret

        def __bool__(self) -> bool:
            """Return true iff the heap is non-empty."""
            return self.root is not None

    def test():
        h1 = SkewHeap()
        for item in [42, 13, 50, 11, 14, 50, 91, 72, 91]:
            h1.push(item)
        h2 = SkewHeap([63, 15, 1, 22, 91, 11, 92, 99, 93])
        h = h1.union(h2)

        while h:
            print(h.pop())