Implement Vector.build: implementation and some tests

[GregoryTravis]

This PR implements Vector.build and converts uses of .new_builder to .build within Vector and Vector_Spec.

Checklist

Please ensure that the following checklist has been satisfied before submitting the PR:

• The documentation has been updated, if necessary.
• Screenshots/screencasts have been attached, if there are any visual changes. For interactive or animated visual changes, a screencast is preferred.
• All code follows the
  Scala,
  Java,
  and
  Rust
  style guides. In case you are using a language not listed above, follow the Rust style guide.
• All code has been tested:
  • Unit tests have been written where possible.
  • If GUI codebase was changed, the GUI was tested when built using ./run ide build.

[radeusgd]

I'd rephrase this sentence as providing X to the provided Y sounds weird.

[GregoryTravis]

Changed to "passing a Builder to the provided function"

[radeusgd]

Suggested change

	build (function : Builder -> Any) (capacity : Integer = 10) -> Vector =
	build (function : Builder -> Any) (initial_capacity : Integer = 10) -> Vector =

I think maybe adding initial_ would clarify the meaning of this variable; without initial it could sound like it's the max capacity.

[GregoryTravis]

Done

[radeusgd]

This is a great test.

Not directly related, but while we are at it we could consider solving a long outstanding problem we used to have:

        group_builder.specify "Should propagate the first dataflow error encountered in `append`" <|
            v = Vector.build builder->
                builder.append 1
                builder.append (Error.throw (Illegal_Argument.Error "ERROR2")
                builder.append 3
                builder.append (Error.throw (Illegal_Argument.Error "ERROR4")
                builder.append 5
            v . should_fail_with (Illegal_Argument.Error "ERROR2")

Unfortunately, as far as I know currently this will actually not fail but produce a vector [1, 3, 5], essentially swallowing the dataflow errors.

We used to have a pattern of 'folding' the builder i.e. append returns a builder and this would have to be rewritten as:

                builder . append 1
                        . append (Error.throw (Illegal_Argument.Error "ERROR2")
                        . append 3
                        . append (Error.throw (Illegal_Argument.Error "ERROR4")
                        . append 5

in which case the error would be correctly propagated.

Unfortunately, the 'folding the builder' pattern did not get much traction. In many places it was just not too practical - the builder was inherently mutable object so this more 'functional' folding was often not fitting its usages.

Do you think we could amend the builder to detect that append got a dataflow error and avoid swallowing it?

This could be implemented by holding a encountered_error : Ref (Any | Nothing) inside of Builder, then append can check item.is_error and set this Ref the first time an error is encountered; then Builder.to_vector would first check if encountered_error is set and if so, propagate that error instead of building the vector.

[radeusgd]

But this is a bit out of scope of this PR, so I guess we can also do it as a separate ticket/PR instead.

[GregoryTravis]

Very good idea. #9733

[radeusgd]

Looks great.

Your test inspired me to try improving a dataflow-error swallowing issue with Builder.append - but I guess that may be a task for a separate PR.

[JaroslavTulach]

I'd assume this is a general even for complicated computations. Just wrap your computation in Vector.build builder-> block and that's it.