Add circular-buffer exercise

[ageron]

I had a bit of trouble getting the tests to compile due to Roc compiler issues, see:

• Cannot chain Ok in expression containing try operator roc-lang/roc#7080
• Cannot define a function using the try operator ? in an expect statement roc-lang/roc#7081

I found workarounds, but they make the tests a bit ugly. Once these issues are fixed, I'll update this exercise:

• I'll use |> Ok instead of Ok result.
• I'll move all runOperations<N> functions inside their respective expect statement.

[ageron]

It might be a good idea to implement a solution that supports any value type (without changing the stub annotations, they can just continue to return I64 to keep things simple).
Edit: I just implemented this change on my machine, it was pretty straightforward:

• Change CircularBuffer to:

CircularBuffer a : { data : List [Value a, Undefined], start : U64, length : U64 }

• Change empty to:

{ data: List.repeat Undefined capacity, start: 0, length: 0 }

• In read, handle Ok (Value value) and Ok Undefined:

         when data |> List.get start is
            Ok (Value value) -> Ok { newBuffer, value }
            Ok Undefined -> crash "Unreachable: we should never read an Undefined value"
            Err OutOfBounds -> crash "Unreachable: start should never be out of bounds"

• In write and overwrite, use List.replace index (Value value) instead of List.replace index value.

That's it!

Do you think I should push this change? Again, it doesn't affect the stub, which is what 99% users see, so this change would just help the 1% of users who will look at this Example.roc. However, it might also make life a slightly harder for the track maintainers. Wdyt?

[Anton-4]

Let\s keep it like this; in case of doubt, keep it simple :)

[isaacvando]

Looks great!

This makes me think that we should have an exercise somewhere that shows off opaque types. I don't think we should change this solution because it already looks like it was tricky enough to get working, but opaque types could be nice for data structures like this because they allow the implementation details to be hidden and force the user to use the provided API.