How to make a host type comparable for v8

[viceice]

I have some simple wrapper class, which should be comparable in v8 engine.

[DefaultScriptUsage(ScriptAccess.ReadOnly)]
public sealed class JsUuid : IEquatable<JsUuid>
{
    internal readonly Guid _value;

    public static readonly JsUuid Empty = new(Guid.Empty);

    [ScriptMember("parse")]
    public static JsUuid Parse(object value)
    {
        return value switch
        {
            JsUuid res => res,
            Guid res => new JsUuid(res),
            string js when Guid.TryParse(js, out var res) => new JsUuid(res),
            _ => null
        };
    }

    public JsUuid() : this(Guid.NewGuid())
    {
    }

    public JsUuid(Guid value) => _value = value;

    public static implicit operator JsUuid(Guid g) => new(g);

    public static implicit operator Guid(JsUuid jsUuid) => jsUuid._value;

    [ScriptMember("valueOf")]
    public object ValueOf() => _value?.ToString();


    public bool Equals(JsUuid other) => other?._value == _value;

    public override int GetHashCode() => _value.GetHashCode();

    public override string ToString() => _value.ToString();

    public override bool Equals(object obj) => Equals(obj is Guid g ? g : obj as JsUuid);
}


engine.AddHostType("Uuid", typeof(JsUuid));
Expect(engine.Evaluate("Uuid.Empty === Uuid.Empty")).To.Equal(true);
Expect(engine.Evaluate("Uuid.Empty !== Uuid.parse('00bfea71-e717-4e80-aa17-d0c71b360101')")).To.Equal(true);
Expect(engine.Evaluate("Uuid.parse('00bfea71-e717-4e80-aa17-d0c71b360101') === Uuid.parse('00bfea71-e717-4e80-aa17-d0c71b360101')")).To.Equal(true);

// this works
Expect(engine.Evaluate("Uuid.parse('00bfea71-e717-4e80-aa17-d0c71b360101').valueOf() === Uuid.parse('00bfea71-e717-4e80-aa17-d0c71b360101').valueOf()")).To.Equal(true);

Can't get it to work

[ClearScriptLib]

Hi @viceice,

V8 provides no facility for overriding the behavior of JavaScript operators. For an object, === always tests reference equality. Instead, script code can call one of your Equals methods for value comparison.

One other possibility is to leverage ClearScript's "canonical reference" feature, which exposes the same boxed struct reference for all instances that satisfy equality comparison. This feature allows === to work on things like enum and DateTime instances. To use it, convert JsUuid into a struct and decorate it with ImmutableValueAttribute:

[ImmutableValue]
public struct JsUuid : IEquatable<JsUuid> {
    ...
}

Thanks!

[viceice]

V8 engine should normally call valueOf before comparison.

so if i use standard Javascript classes and implement valueOf which returns a primitiv, comparison just works.

so i would propose to use Gethashcode function as default value for dotnet objects or call valueOf if defined/ implemented.

[ClearScriptLib]

V8 engine should normally call valueOf before comparison.

The engine does not call valueOf for strict comparison, nor when both comparands are objects.

[viceice]

ok, my bad. i though it works for strict comparison. i saw usage on luxon npm library, but it probably only works for greater/ less compare.

will try the struct thing. does it work for guid out of the box? it's also an immutable struct.

[ClearScriptLib]

does it work for guid out of the box?

Unfortunately, no, but we're fixing that in the next release; in fact, we're extending canonical referencing to all readonly struct types.

EDIT: In the meantime, you can use CustomAttributeLoader to add ImmutableValueAttribute to the standard Guid type.