Decouple interpreter values from interpreter – Part 4

[turbolent]

Work towards #3693

Description

Move the core functionality of the value implementations of Bool and Int out of the interpreter package and into a new values package. This demonstrates how we could decouple at least some of the more basic values from the interpreter and use them in the VM.

If this approach looks good, we can also refactor the other number value types, and some other primitive value types like e.g. String.

I'm happy with the values package itself, but honestly not really happy with how the integration looks in the interpreter package's BoolValue and IntValue types, especially all the unwrapping and wrapping, casting, type checking, error handling, etc. Maybe this is just temporary, and once we have refactored the value types in the interpreter package fully from the interpreter this ugliness will go away.

Another idea I had was not to create a whole new values.Value type hierarchy with methods, but instead just have global functions, e.g. instead of having IntValue.LessEqual(other ComparableValue), just have IntLessEqual(IntValue, IntValue).

Alternatively we would have to duplicate this code in the VM, which seems worse to me (e.g. potential for mismatch).

Let's discuss this in the Implemention Sync.

---

• Targeted PR against master branch
• Linked to Github issue with discussion and accepted design OR link to spec that describes this work
• Code follows the standards mentioned here
• Updated relevant documentation
• Re-reviewed Files changed in the Github PR explorer
• Added appropriate labels

[github-actions]

Cadence Benchstat comparison

This branch with compared with the base branch onflow:master commit 14086f2
The command for i in {1..N}; do go test ./... -run=XXX -bench=. -benchmem -shuffle=on; done was used.
Bench tests were run a total of 7 times on each branch.

Collapsed results for better readability

[SupunS]

No interpreter imports, nice! 👌

[SupunS]

We could get rid of some of these type-casts by making the interfaces (NumberValue, IntegerValue) generic. e.g: https://github.com/onflow/cadence/compare/bastian/decouple-values-from-interpreter-4...supun/bind-interface-to-type?expand=1#diff-4ba970fa0343b83d635e65319f40746490752a9e69d40072f87221672ce16c81R23-R29

But the downside is, the interface, say IntegerValue, can only be used to define the structure of all the integer values. e.g:

var _ IntegerValue[IntValue] = IntValue{} // Ensures the `IntValue` implements `IntegerValue`

But cannot be actually used in the code, because IntegerValue interface type would always have to be used with a T, making the type too-sepicific.

var someValue Value = ...

 integerValue := someValue.(IntegerValue[IntValue]) // This becomes pointless since `IntegerValue[IntValue]` is not generic enough