A lens is really just a function `a -> b`

that we
represent backwardsI’m exaggerating a bit here 😅 To see what I
*really* mean, see this post.

and with an extra `Functor f`

parameter lying
around:

`type Lens' a b = Functor f => (b -> f b) -> (a -> f a)`

**What does this mean for function composition?**

Normal function composition looks like this:

```
(.) :: (b -> c) -> (a -> b) -> (a -> c)
f :: a -> b
g :: b -> c
. f :: (a -> c) g
```

We often have to read code that looks like this:

`. f $ x g `

This means “start with `x`

, then run `f`

on it,
and run `g`

after that.” This sentence reads opposite from
how the code reads!

What about for lenses? Here we have `f'`

and
`g'`

which behave similarly in some sense to `f`

and `g`

from before:

```
f' :: Functor f => (b -> f b) -> (a -> f a)
-- ≈ a -> b
g' :: Functor f => (c -> f c) -> (b -> f b)
-- ≈ b -> c
. g' :: Functor f => (c -> f c) -> (a -> f a)
f' -- ≈ a -> c
```

In the lens world, `^.`

behaves kind of like a flipped
`$`

that turns lenses into getters, which lets us write code
like this:

`^. f' . g' x `

This means “start with `x`

, then get `f'`

from
it, then get `g'`

after that.” The sentence reads just like
the code!

This is pretty cool, because it means that lenses (which are “functional” getters) read almost exactly like property access (which are “imperative” getters). Same concise syntax, but with an elegant semantics.