revert: "include type in scalar value definitions"

This reverts commit 88e6d8f.

After discussion we agreed that this is not required and parsers will
have to rely on type information, however a "raw" byte value
representation will be introduced in the text format for simplicity

Author: rvolosatovs

design/mvp/Binary.md

@@ -358,18 +358,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>                           => (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(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(char)                  ::= b*:<core:byte>*                         => c (where b* = core:utf8(c))
 val(string)                ::= v:<core:name>                           => v
 val(i:<typeidx>)           ::= v:<val(type-index-space[i])>            => v

design/mvp/Explainer.md

@@ -1364,18 +1364,18 @@ Components may define values in the value index space using following syntax:
 ```ebnf
 value    ::= (value <id>? <valtype> <val>)
 val      ::= false | true
-           | (u8  <core:u8>)
-           | (u16 <core:u16>)
-           | (u32 <core:u32>)
-           | (u64 <core:u64>)
-           | (s8  <core:s8>)
-           | (s16 <core:s16>)
-           | (s32 <core:s32>)
-           | (s64 <core:s64>)
-           | (f32 <f32canon>)
-           | (f32 nan)
-           | (f64 <f64canon>)
-           | (f64 nan)
+           | <core:u8>
+           | <core:u16>
+           | <core:u32>
+           | <core:u64>
+           | <core:s8>
+           | <core:s16>
+           | <core:s32>
+           | <core:s64>
+           | <f32canon>
+           | nan
+           | <f64canon>
+           | nan
            | '<core:stringchar>'
            | <core:name>
            | (record <val>+)
@@ -1394,30 +1394,30 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
 ```wasm
 (component
   (value $a bool true)
-  (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 $b u8  1)
+  (value $c u16 2)
+  (value $d u32 3)
+  (value $e u64 4)
+  (value $f s8  5)
+  (value $g s16 6)
+  (value $h s32 7)
+  (value $i s64 8)
+  (value $j f32 9.1)
+  (value $k f64 9.2)
   (value $l char 'a')
   (value $m string "hello")
-  (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 $n (record (field "a" bool) (field "b" u8)) (record true 1))
+  (value $o (variant (case "a" bool) (case "b" u8)) (variant "b" 1))
   (value $p (list (result (option u8)))
     (list
       error
-      (ok (some (u8 1)))
+      (ok (some 1))
       (ok none)
       error
-      (ok (some (u8 2)))
+      (ok (some 2))
     )
   )
-  (value $q (tuple u8 u16 u32) (tuple (u8 1) (u16 2) (u32 3)))
+  (value $q (tuple u8 u16 u32) (tuple 1 2 3))
 
   (type $abc (flags "a" "b" "c"))
   (value $r $abc (flags "a" "c"))
@@ -1450,7 +1450,7 @@ The validation rules for `value` require the `val` to match the `valtype`.  For
     (tuple
       (record
         (some "example")
-        (tuple (some (u8 42)) "hello")
+        (tuple (some 42) "hello")
       )
       (list 'a' 'b' 'c')
       (flags "b" "a")