Merge #886

886:  feat: Compile block expressions as monadic sequences r=Marwes a=Marwes

Rather than removing block expressions entirely, this changes them
to behave as sequence (`seq`) expressions.

```f#
io.println "Hello"
io.println "World"

// Is now equivalent to
seq io.println "Hello"
io.println "World"
```

Co-authored-by: Markus Westerlind <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -71,16 +71,16 @@ fn gluon_rust_boundary_overhead(b: &mut Bencher) {
         if n #Int== 0 then
             ()
         else
-            f n
-            f n
-            f n
-            f n
-            f n
-            f n
-            f n
-            f n
-            f n
-            f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
+            let _ = f n
             for (n #Int- 10) f
     for
     "#;

benches/function_call.rs

@@ -83,8 +83,8 @@ type Tree a = | Tip a | Branch (Tree a) (Tree a)
 
 let tree = Branch (Tip 1) (Branch (Tip 2) (Tip 3))
 
-show tree
-tree == Tip 1
+let tree_str = show tree // "Branch (Tip 1) (Branch (Tip 2) (Tip 3))"
+tree == Tip 1 // False
 ```
 
 ### #[doc(hidden)]

book/src/metadata.md

@@ -8,7 +8,7 @@ If, on the other hand, you are familiar with functional languages you will be ri
 
 ### Identifiers and Literals
 
-The simplest syntactical elements in Gluon are identifiers and literals and none of them should be especially surprising if you are experienced in programming. 
+The simplest syntactical elements in Gluon are identifiers and literals and none of them should be especially surprising if you are experienced in programming.
 
 Identifiers are a sequence of alphanumeric characters including underscore ("\_") which are required to start with either a letter or an underscore. Literals come in four different forms - integer, float, string and character literals.
 
@@ -37,7 +37,7 @@ r###" "## "###
 
 ### Comments
 
-Comments should be immediately familiar if you are accustomed to C-like languages. 
+Comments should be immediately familiar if you are accustomed to C-like languages.
 
 `//` starts a line comment which is ended by a newline
 
@@ -206,7 +206,9 @@ Here, we write out a pattern for each of the variant's constructors and the valu
 ```f#,rust
 match { x = 1.0, pi = 3.14 } with
 | { x = y, pi } -> y + pi
+```
 
+```f#,rust
 // Patterns can be nested as well
 match { x = Some (Some 123) } with
 | { x = Some None } -> 0
@@ -270,6 +272,9 @@ While we have seen that functions can be defined in let expressions it is often
 ```f#,rust
 // \(<identifier)* -> <expr>
 \x y -> x + y - 10
+```
+
+```f#,rust
 // Equivalent to
 let f x y = x + y - 10 in f
 ```
@@ -329,9 +334,9 @@ do { y } = Some { y = "" }
 Some y
 ```
 
-### Seq expressions
+### Sequence expressions
 
-`seq` expressions work just like `do` expressions, only they do not have a binding.
+Sequence expressions work just like `do` expressions, only they do not have a binding.
 
 ```f#,rust
 let io @ { ? } = import! std.io
@@ -340,6 +345,17 @@ seq io.print " "
 io.println "world!"
 ```
 
+The `seq` keyword can also be omitted.
+
+```f#,rust
+let io @ { ? } = import! std.io
+io.print "Hello"
+io.print " "
+io.println "world!"
+```
+
+(In the future one of these ways are likely to be deprecated with only one way remaining, the formatter will be able to update the code in any case).
+
 ### Indentation
 
 If you have been following along this far, you may be think that the syntax so far is pretty limiting. In particular, you wouldn't be wrong in thinking that the `let` and `type` syntax are clunky due to their need to be closed by the `in` keyword. Luckily, Gluon offers a more convenient way of writing bindings by relying on indentation.
@@ -386,7 +402,7 @@ module.id module.pi
 
 ## Typesystem
 
-In gluon, identifiers starting with an uppercase letter is a type whereas identifiers starting with a lowercase letter are type variables. 
+In gluon, identifiers starting with an uppercase letter is a type whereas identifiers starting with a lowercase letter are type variables.
 
 ### Function types
 

book/src/syntax-and-semantics.md

@@ -23,7 +23,7 @@ test_check! {
 test_check_err! {
     not_variant_effect,
     r#"
-    convert_effect! ()
+    let _ = convert_effect! ()
     convert_effect! 1
     "#,
     TypeError::Message(_),

check/tests/effect.rs

@@ -967,7 +967,7 @@ let show : Show a -> Show (List a) = \d ->
     }
 let list@{ } = { show }
 
-list.show string_show
+let _ = list.show string_show
 list.show int_show
 "#;
     let result = support::typecheck(text);
@@ -997,7 +997,7 @@ let semigroup : Semigroup (List a) =
 
 let { append } = semigroup
 
-append (Cons 1 Nil) Nil
+let _ = append (Cons 1 Nil) Nil
 append (Cons "" Nil) Nil
 "#;
     let result = support::typecheck(text);

check/tests/forall.rs

@@ -135,8 +135,8 @@ let f ?eq l r: [a -> a -> Bool] -> a -> a -> Bool = eq l r
 let eq_int l r : Int -> Int -> Bool = True
 #[implicit]
 let eq_string l r : String -> String -> Bool = True
-f 1 2
-f "" ""
+let _ = f 1 2
+let _ = f "" ""
 ()
 "#;
     let result = support::typecheck(text);
@@ -194,8 +194,8 @@ let eq_string @ { ? } =
     #[implicit]
     let eq l r : String -> String -> Bool = True
     { eq }
-f 1 2
-f "" ""
+let _ = f 1 2
+let _ = f "" ""
 ()
 "#;
     let result = support::typecheck(text);
@@ -348,7 +348,7 @@ type Test a = | Test a
 let f ?x y : [Test a] -> () -> Test a = x
 let g ?x y : [Test a] -> a -> Test a = f ()
 let i = Test 1
-g 2
+let _ = g 2
 ()
 "#;
     let (expr, result) = support::typecheck_expr(text);
@@ -522,7 +522,6 @@ let applicative : Applicative Test = {
 }
 
 \_ -> wrap 123
-()
 "#;
     let (_expr, result) = support::typecheck_expr(text);
     assert_err!(result, TypeError::UnableToResolveImplicit(..));
@@ -712,7 +711,7 @@ let put value : s -> State s () = any ()
 
 let get : State s s = any ()
 
-(put 1 *> get)
+let _ = (put 1 *> get)
 (put "hello" *> get)
 "#;
     let result = support::typecheck(text);

check/tests/implicits.rs

@@ -91,8 +91,8 @@ fn equality_of_records_with_differing_fields() {
     let text = r#"
 let eq x y : a -> a -> () = ()
 let f v1 v2 =
-    v1.x
-    v2.y
+    let _ = v1.x
+    let _ = v2.y
     eq v1 v2
 ()
 "#;

check/tests/row_polymorphism.rs

@@ -59,9 +59,9 @@ fn enum_tuple_variants() {
         let { tuple_enum_to_str } = import! functions
         let { assert } = import! std.test
 
-        assert (tuple_enum_to_str Variant == "Variant")
-        assert (tuple_enum_to_str OtherVariant == "OtherVariant")
-        assert (tuple_enum_to_str (One 1) == "One(1)")
+        let _ = assert (tuple_enum_to_str Variant == "Variant")
+        let _ = assert (tuple_enum_to_str OtherVariant == "OtherVariant")
+        let _ = assert (tuple_enum_to_str (One 1) == "One(1)")
         assert (tuple_enum_to_str (LotsOfTupleThings 42 "Text" 0.0) == "LotsOfTupleThings(42, \"Text\", 0.0)")
     "#;
 
@@ -103,7 +103,7 @@ fn enum_struct_variants() {
         let { struct_enum_to_str } = import! functions
         let { assert } = import! std.test
 
-        assert (struct_enum_to_str (OneField { field = 1337 }) == "OneField { field: 1337 }")
+        let _ = assert (struct_enum_to_str (OneField { field = 1337 }) == "OneField { field: 1337 }")
         assert (struct_enum_to_str (TwoFields { name = "Pi", val = 3.14 }) == "TwoFields { name: \"Pi\", val: 3.14 }")
     "#;
 
@@ -158,11 +158,11 @@ fn enum_generic_variants() {
         let { assert } = import! std.test
 
         let l: Either Int Float  = Left 42
-        assert (left l == Some 42)
+        let _ = assert (left l == Some 42)
         let r: Either Int Float  = Right 0.0
-        assert (left r == None)
+        let _ = assert (left r == None)
 
-        assert (extract_str (Left "left") == "left")
+        let _ = assert (extract_str (Left "left") == "left")
         assert (extract_str (Right "right") == "right")
     "#;
 
@@ -193,7 +193,7 @@ fn derive_generates_same_type_as_gluon_define() {
 
         type Enum = | TestVariant | TestVariant2 Int
 
-        test TestVariant
+        let _ = test TestVariant
         test (TestVariant2 123)
     "#;
 

codegen/tests/derive_getable.rs

@@ -62,14 +62,14 @@ fn normal_struct() {
         let { new_struct } = import! functions
         let { assert } = import! std.test
         let { index, len } = import! std.array
-        
+
         let { string, number, vec } = new_struct ()
 
-        assert (string == "hello")
-        assert (number == 1)
-        assert (len vec == 3)
-        assert (index vec 0 == 1.0)
-        assert (index vec 1 == 2.0)
+        let _ = assert (string == "hello")
+        let _ = assert (number == 1)
+        let _ = assert (len vec == 3)
+        let _ = assert (index vec 0 == 1.0)
+        let _ = assert (index vec 1 == 2.0)
         assert (index vec 2 == 3.0)
     "#;
 
@@ -121,12 +121,12 @@ fn generic_struct() {
 
         let { generic, other } = new_generic_struct "hi rust"
 
-        assert (generic == "hi rust")
-        assert (other == 2012)
+        let _ = assert (generic == "hi rust")
+        let _ = assert (other == 2012)
 
         let { generic, other } = new_generic_struct 3.14
 
-        assert (generic == 3.14)
+        let _ = assert (generic == 3.14)
         assert (other == 2012)
     "#;
 
@@ -177,7 +177,7 @@ fn lifetime_struct() {
 
         let { string, other } = new_lifetime_struct ()
 
-        assert (string == "I'm borrowed")
+        let _ = assert (string == "I'm borrowed")
         assert (other == 6.6)
     "#;
 
@@ -231,18 +231,18 @@ fn normal_enum() {
                 match enum with
                 | Nothing -> 0
                 | Tuple x y ->
-                    assert (x == 1920)
-                    assert (y == 1080)
+                    let _ = assert (x == 1920)
+                    let _ = assert (y == 1080)
                     1
                 | Struct { key, value } ->
-                    assert (key == "under the doormat")
-                    assert (value == "lots of gold")
+                    let _ = assert (key == "under the doormat")
+                    let _ = assert (value == "lots of gold")
                     2
-            
+
             assert (tag == actual_tag)
-        
-        assert_enum (new_enum 0) 0
-        assert_enum (new_enum 1) 1
+
+        let _ = assert_enum (new_enum 0) 0
+        let _ = assert_enum (new_enum 1) 1
         assert_enum (new_enum 2) 2
     "#;