Turn Datum into an enum #105

Twisol · 2021-08-23T03:11:33Z

Hi Will -- it's Jonathan! This weekend, I'm making good on my years-old promise to check out Molt. Feel free to take or leave the changes in this PR; I had an idea to try out and it seems to have worked fairly nicely, but it's up to your discretion in the end.

This PR turns the existing struct Datum into a more Rust-y enum Datum, and propagates those changes throughout expr.rs. In the process, I ended up unifying the type coercion sections for each operator with their respective evaluation sections. I especially noticed an inconsistency between the assumptions made by execution for AND and OR and what the respective coercion was doing; I think the approach in this PR scopes the relevant assumptions much more tightly, so it'll be much more difficult for things to get out of sync like that.

This PR also contains minor contributions for the shift-right operator and absolute value function, which can both be simplified by using core Rust functionality. (Yes, as an arithmetic shift, >> is guaranteed to preserve sign!)

Lastly, I ran rustfmt on my changes to keep things consistent. I find some of the formatting choices it made to be less readable, but I defer to convention :)

Using an enum instead of a struct makes it impossible to use the wrong field, and allows us to couple the tag-based dispatch with uses of those fields. This pays off significantly in type coercions for each operator, where some new helper functions have been used to unify the coercion and evaluation blocks.

According to the language reference, >> is guaranteed to be an arithmetic (sign-preserving) shift. https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators

fogti · 2021-09-18T16:33:05Z

molt/src/expr.rs

-            flt: 0.0,
-            str: String::new(),
-        }
+        Datum::String("".to_owned())


Suggested change

Datum::String("".to_owned())

Datum::String(String::new())

fogti · 2021-09-18T16:35:04Z

molt/src/expr.rs

    pub(crate) fn int(int: MoltInt) -> Self {
-        Self {
-            vtype: Type::Int,
-            int,
-            flt: 0.0,
-            str: String::new(),
-        }
+        Datum::Int(int)
    }

    pub(crate) fn float(flt: MoltFloat) -> Self {
-        Self {
-            vtype: Type::Float,
-            int: 0,
-            flt,
-            str: String::new(),
-        }
+        Datum::Float(flt)
    }


These methods don't really contain any useful functionality anymore, it might be a good idea to replace any calls to them with direct invocations of the enum variant constructors

fogti · 2021-09-18T16:36:46Z

molt/src/expr.rs

+    match value {
+        Datum::Int(v) => molt_ok!(Value::from(v)),
+        Datum::Float(v) => molt_ok!(Value::from(v)),
+        Datum::String(v) => molt_ok!(Value::from(v)),
    }


I'm not sure if this would work, but it might be worth trying

Suggested change

match value {

Datum::Int(v) => molt_ok!(Value::from(v)),

Datum::Float(v) => molt_ok!(Value::from(v)),

Datum::String(v) => molt_ok!(Value::from(v)),

}

molt_ok!(match value {

Datum::Int(v) => Value::from(v),

Datum::Float(v) => Value::from(v),

Datum::String(v) => Value::from(v),

})

fogti · 2021-09-18T16:59:05Z

molt/src/expr.rs

-                if value.int < 0 {
-                    value.int = !((!value.int) >> value2.int)
-                } else {
-                    value.int >>= value2.int;
-                }
+                value = Datum::Int(v1 >> v2)


It might be a good idea to create a unit test which checks this assumption.

oh, if it is explicitly mentioned in the rust manual that won't be necessary.

fogti · 2021-09-18T17:00:48Z

molt/src/expr.rs

+                value = match coerce_pair(operator, &value, &value2)? {
+                    DatumPair::Ints(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
+                    DatumPair::Floats(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
+                    DatumPair::Strings(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
                };


Suggested change

value = match coerce_pair(operator, &value, &value2)? {

DatumPair::Ints(v1, v2) => Datum::Int((v1 < v2) as MoltInt),

DatumPair::Floats(v1, v2) => Datum::Int((v1 < v2) as MoltInt),

DatumPair::Strings(v1, v2) => Datum::Int((v1 < v2) as MoltInt),

};

value = Datum::Int(match coerce_pair(operator, &value, &value2)? {

DatumPair::Ints(v1, v2) => v1 < v2,

DatumPair::Floats(v1, v2) => v1 < v2,

DatumPair::Strings(v1, v2) => v1 < v2,

} as MoltInt);

fogti · 2021-09-18T17:01:46Z

molt/src/expr.rs

+                value = match coerce_pair(operator, &value, &value2)? {
+                    DatumPair::Ints(v1, v2) => Datum::Int((v1 > v2) as MoltInt),
+                    DatumPair::Floats(v1, v2) => Datum::Int((v1 > v2) as MoltInt),
+                    DatumPair::Strings(v1, v2) => Datum::Int((v1 > v2) as MoltInt),
                };


Suggested change

value = match coerce_pair(operator, &value, &value2)? {

DatumPair::Ints(v1, v2) => Datum::Int((v1 > v2) as MoltInt),

DatumPair::Floats(v1, v2) => Datum::Int((v1 > v2) as MoltInt),

DatumPair::Strings(v1, v2) => Datum::Int((v1 > v2) as MoltInt),

};

value = Datum::Int(match coerce_pair(operator, &value, &value2)? {

DatumPair::Ints(v1, v2) => v1 > v2,

DatumPair::Floats(v1, v2) => v1 > v2,

DatumPair::Strings(v1, v2) => v1 > v2,

} as MoltInt);

fogti · 2021-09-18T17:05:26Z

molt/src/expr.rs

+            if v < 0.0 {
+                Ok(Datum::Int((v - 0.5) as MoltInt))
+            } else {
+                Ok(Datum::Int((v + 0.5) as MoltInt))
+            }


Suggested change

if v < 0.0 {

Ok(Datum::Int((v - 0.5) as MoltInt))

} else {

Ok(Datum::Int((v + 0.5) as MoltInt))

}

Ok(Datum::Int(if v < 0.0 {

v - 0.5

} else {

v + 0.5

} as MoltInt))

Twisol added 3 commits August 22, 2021 19:53

Unify shift-right positive and negative branches

8fb81f3

According to the language reference, >> is guaranteed to be an arithmetic (sign-preserving) shift. https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators

Implement expr_abs_func with stdlib abs()

dce93ee

fogti reviewed Sep 18, 2021

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Turn Datum into an enum #105

Turn Datum into an enum #105

Twisol commented Aug 23, 2021

fogti Sep 18, 2021

fogti Sep 18, 2021

fogti Sep 18, 2021

fogti Sep 18, 2021 •

edited

Loading

fogti Sep 18, 2021

fogti Sep 18, 2021

fogti Sep 18, 2021

fogti Sep 18, 2021

-                value = match coerce_pair(operator, &value, &value2)? {
-                    DatumPair::Ints(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
-                    DatumPair::Floats(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
-                    DatumPair::Strings(v1, v2) => Datum::Int((v1 < v2) as MoltInt),
-                };
+                value = Datum::Int(match coerce_pair(operator, &value, &value2)? {
+                    DatumPair::Ints(v1, v2) => v1 < v2,
+                    DatumPair::Floats(v1, v2) => v1 < v2,
+                    DatumPair::Strings(v1, v2) => v1 < v2,
+                } as MoltInt);

Turn Datum into an enum #105

Are you sure you want to change the base?

Turn Datum into an enum #105

Conversation

Twisol commented Aug 23, 2021

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021 • edited Loading

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021

Choose a reason for hiding this comment

fogti Sep 18, 2021 •

edited

Loading