Hacker News Reader

> Which can't be achieved in most OOP languages that I know of, except for Scala and that's because Scala has "implicit parameters" which are equivalent to Haskell's type classes.

C++ can do that with template specialization.

I didn't know that, but it doesn't surprise me, seems to me like C++ templates are like their own language grown within C++ and can do lots of crazy things.

It is fairly straightforward, created a pastebin showing how it can be done, you can also make it check that it is implemented at compile time but the logic around that is a bit iffy:

https://pastebin.com/DiFh4GuM

> type classes are different because type classes are solved at compile time

    data Nested a = Nest a (Nested [a]) | Done deriving Show

    build :: Int -> a -> Nested a
    build 0 a = Done
    build i a = Nest a $ build (i- 1) [a]

    main = do
        i <- readLn
        print (build i i)

if you build a value of Nested at runtime then it is impossible to do static dispatch and the dictionary has to be constructed at runtime as well.

Sorry that I mistyped the example at first. If you run this version:

    > main
    23
    Nest 23 (Nest [23] (Nest [[23]] (Nest [[[23]]] (Nest [[[[23]]]] (Nest [[[[[23]]]]] (Nest [[[[[[23]]]]]] (Nest [[[[[[[23]]]]]]] (Nest [[[[[[[[23]]]]]]]] (Nest [[[[[[[[[23]]]]]]]]] (Nest [[[[[[[[[[23]]]]]]]]]] (Nest [[[[[[[[[[[23]]]]]]]]]]] (Nest [[[[[[[[[[[[23]]]]]]]]]]]] (Nest [[[[[[[[[[[[[23]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[23]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[23]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]]]]]] (Nest [[[[[[[[[[[[[[[[[[[[[[23]]]]]]]]]]]]]]]]]]]]]] Done))))))))))))))))))))))

The innermost Nested has type `Nest [[[[[[[[[[[[[[[[[[[[[[Int]]]]]]]]]]]]]]]]]]]]]]` which wasn't known at compile time so the show instance has to be constructed at runtime. This is called polymorphic recursion.

Technically, one might argue that i doesn't store a vtable, but only a reference to a type, which stores a vtable determined at runtime.

I'd say the difference is minor to non-existent.

"i" does not store a reference to a type. Values in Haskell aren't tagged with their type like in OOP.

There is no "isInstanceOf" check in Haskell.

This is a single Show instance that pattern matches to decide on whether to recurse, same as how lists are shown.

Yeah, sorry, forgot the type variable at first.

All you need is a GADT which carries around the type class constraint.

    data Object cls a where
      Object :: cls a => a -> Object cls a

Now, the class `cls a` is carried around with the value `a`. You can even go one step further and reify the vtable by itself.

    data Dict c where
      Dict :: c => Dict

which you can't really do in standard C++.

>the "vtable" (the dictionary of functions) being passed around isn't virtual and is provided per type, not per instance.

This might be nitpicking but vtables in C++ are created per type with instances having a pointer to it.

it is not nitpicking, you are correct to point it out. The only difference is where the vtable is attached to: pointers in Haskell, objects instances in c++.

Although the language does not offer a builtin syntax for it, in C++ is also common to attach the 'vtable' to the 'handle' (a smart pointer or deep copying envelope), in the case of type erased wrappers (std::function, std::any, etc).

> This is called "constrained parametric polymorphism"

The more common terminology is ad-hoc polymorphism AFAIK.

eh, that might be a bit of a stretch. I like my peanut-butter and jelly separate, thank you.

ad-hoc polymorphism is more general. Constrained/Bounded parametric polymorphism is a controlled subset of violations of parametric polymorphism.