include type in scalar value definitions

#336 (comment)

Signed-off-by: Roman Volosatovs <[email protected]>

Author: rvolosatovs

design/mvp/Binary.md

@@ -361,18 +361,18 @@ Notes:
 value                      ::= t:<valtype> len:<uN> v:<val(t)>         => (value t v) (where len = ||v||)
 val(bool)                  ::= 0x00                                    => false
                              | 0x01                                    => true
-val(u8)                    ::= v:<core:byte>                           => v
-val(s8)                    ::= v:<core:byte>                           => v if v < 128 else (v - 256)
-val(s16)                   ::= v:<core:s16>                            => v
-val(u16)                   ::= v:<core:u16>                            => v
-val(s32)                   ::= v:<core:s32>                            => v
-val(u32)                   ::= v:<core:u32>                            => v
-val(s64)                   ::= v:<core:s64>                            => v
-val(u64)                   ::= v:<core:u64>                            => v
-val(f32)                   ::= v:<core:f32>                            => v (if !isnan(v))
-                             | 0x00 0x00 0xC0 0x7F                     => nan
-val(f64)                   ::= v:<core:f64>                            => v (if !isnan(v))
-                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => nan
+val(u8)                    ::= v:<core:byte>                           => (u8 v)
+val(s8)                    ::= v:<core:byte>                           => (s8 v) if v < 128 else (v - 256)
+val(s16)                   ::= v:<core:s16>                            => (s16 v)
+val(u16)                   ::= v:<core:u16>                            => (u16 v)
+val(s32)                   ::= v:<core:s32>                            => (s32 v)
+val(u32)                   ::= v:<core:u32>                            => (u32 v)
+val(s64)                   ::= v:<core:s64>                            => (s64 v)
+val(u64)                   ::= v:<core:u64>                            => (u64 v)
+val(f32)                   ::= v:<core:f32>                            => (f32 v) (if !isnan(v))
+                             | 0x00 0x00 0xC0 0x7F                     => (f32 nan)
+val(f64)                   ::= v:<core:f64>                            => (f64 v) (if !isnan(v))
+                             | 0x00 0x00 0x00 0x00 0x00 0x00 0xF8 0x7F => (f64 nan)
 val(char)                  ::= v:<core:u32>                            => v (if v < 0xD800 or 0xE000 <= v <= 0x10FFFF)
 val(string)                ::= v:<core:name>                           => v
 val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v

design/mvp/Explainer.md

@@ -1390,30 +1390,30 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
 ```wasm
 (component
   (value $a bool true)
-  (value $b u8 1)
-  (value $c u16 2)
-  (value $d u32 3)
-  (value $e u64 4)
-  (value $f u8 5)
-  (value $g u16 6)
-  (value $h u32 7)
-  (value $i u64 8)
-  (value $j f32 9.1)
-  (value $k f64 9.2)
+  (value $b u8 (u8 1))
+  (value $c u16 (u16 2))
+  (value $d u32 (u32 3))
+  (value $e u64 (u64 4))
+  (value $f s8 (s8 5))
+  (value $g s16 (s16 6))
+  (value $h s32 (s32 7))
+  (value $i s64 (s64 8))
+  (value $j f32 (f32 9.1))
+  (value $k f64 (f64 9.2))
   (value $l char 'a')
   (value $m string "hello")
-  (value $n (record (field "a" bool) (field "b" u8)) (record true 1))
-  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" 1))
+  (value $n (record (field "a" bool) (field "b" u8)) (record true (u8 1)))
+  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" (u8 1)))
   (value $p (list (result (option u8)))
     (list
       error
-      (ok (some 1))
+      (ok (some (u8 1)))
       (ok none)
       error
-      (ok (some 2))
+      (ok (some (u8 2)))
     )
   )
-  (value $q (tuple u8 u16 u32) (tuple 1 2 3))
+  (value $q (tuple u8 u16 u32) (tuple (u8 1) (u16 2) (u32 3)))
 
   (type $abc (flags "a" "b" "c"))
   (value $r $abc (flags "a" "c"))
@@ -1446,7 +1446,7 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
     (tuple
       (record
         (some "example")
-        (tuple (some 42) "hello")
+        (tuple (some (u8 42)) "hello")
       )
       (list 'a' 'b' 'c')
       (flags "b" "a")