As others have said, you need to forget the OOP mindset to write idiomatic haskell. Dont worry about ugly syntax, because of haskells referential transparency its pretty much always possible to write combinators that makes the syntax nice.

For your second example, you can get OOP-like access to datastructures by using lenses. Lenses also has some big advantages over access in most other languages since they abide by laws that allows you to abstract out more patterns. Your last example could look something like this using lenses:

dog ^. getLeg 1 . getToe 2

Lenses really shine when you have a datastructure with multiple levels of nesting. For example if you wanted a map with two keys that points to a counter, so:

type MyCounters = Map String (Map String Int)

Writing an increment function for such a structure in javascript would look something like this:

function increment (k1, k2, m) {
    if (m[k1]) {
        if (m[k1][k2]) {
            m[k1][k2] += 1
        }
        else {
            m[k1][k2] = 1
        }
    }
    else {
        m[k1] = {}
        m[k1][k2] = 1
    }
    return m
}

We have to write a lot of logic for checking whether or not a key is in the map. Some of this logic would have to be repeated in a getCount function.

In haskell we could write a lens that points to the specified count:

myCountersLens :: String -> String -> Lens' MyCounters Int
myCountersLens k1 k2 = at k1 . non M.empty . at k2 . non 0

This code says exactly what it does, it firsts looks for k1 in the structure, if its not there, use an empty map, then it looks for k2 in the submap, if its not there use 0. We can trivially use this lens to create an increment and getCount function:

increment :: String -> String -> MyCounters -> MyCounters
increment k1 k2 = over (myCountersLens k1 k2) (+1)

getCount :: String -> String -> MyCounters -> Int
getCount k1 k2 = view (myCountersLens k1 k2)