output update (need to gitignore these)

ElaraLang · Oct 3, 2023 · e1ab6b0 · e1ab6b0
1 parent 4825d10
commit e1ab6b0
Show file tree

Hide file tree

Showing 5 changed files with 20 additions and 15 deletions.
diff --git a/build/Main.class b/build/Main.class
diff --git a/build/Main.core.elr b/build/Main.core.elr
@@ -7,4 +7,5 @@ Main.x : Int
 ; 
 Main.main : IO ()
     = let y_2 : Int
-        = Prelude.+ Main.x 1 in Prelude.println (Prelude.toString @Int y_2) }
+        = Prelude.+ Main.x 1 in let z_3 : Int
+        = Prelude.+ y_2 1 in Prelude.println (Prelude.toString @Int z_3) }
diff --git a/build/Main.typed.elr b/build/Main.typed.elr
@@ -19,10 +19,14 @@ let Main.main =
     let y_2  = ((Prelude.(+) : Integer ->
                                Integer ->
                                  Integer Main.x : Integer) : Integer ->
-                                                               Integer 1 : Integer) : Integer in (Prelude.println : Text ->
-                                                                                                                      IO Unit
-                                                                                                                          ((Prelude.toString : forall (a_3 : Type) .
-                                                                                                                                                 a_3 ->
-                                                                                                                                                   Text @Integer) : Text y_2 : Integer) : Text) : IO Unit
-                                                                                                                                                                                                      : IO Unit
+                                                               Integer 1 : Integer) : Integer in let z_3  = ((Prelude.(+) : Integer ->
+                                                                                                                            Integer ->
+                                                                                                                              Integer y_2 : Integer) : Integer ->
+                                                                                                                                                         Integer 1 : Integer) : Integer in (Prelude.println : Text ->
+                                                                                                                                                                                                                IO Unit
+                                                                                                                                                                                                                    ((Prelude.toString : forall (a_4 : Type) .
+                                                                                                                                                                                                                                           a_4 ->
+                                                                                                                                                                                                                                             Text @Integer) : Text z_3 : Integer) : Text) : IO Unit
+                                                                                                                                                                                                                                                                                                : IO Unit
+                                                                                                                                                                                                                                                                                                      : IO Unit
 
diff --git a/build/Prelude.core.elr b/build/Prelude.core.elr
@@ -2,8 +2,8 @@ module Prelude
 { Prelude.println : String -> IO ()
     = Elara.Prim.elaraPrimitive @(String -> IO ()) "println"
 ; 
-Prelude.toString : forall (a_3 : Type). a_3 -> String
-    = Elara.Prim.elaraPrimitive @(a_3 -> String) "toString"
+Prelude.toString : forall (a_4 : Type). a_4 -> String
+    = Elara.Prim.elaraPrimitive @(a_4 -> String) "toString"
 ; 
 Prelude.+ : Int -> Int -> Int
     = Elara.Prim.elaraPrimitive @(Int -> Int -> Int) "+" }
diff --git a/build/Prelude.typed.elr b/build/Prelude.typed.elr
@@ -12,13 +12,13 @@ let Prelude.println =
                                                                                                           IO Unit
 
 
-def Prelude.toString : forall (a_3 : Type) . a_3 -> Text
+def Prelude.toString : forall (a_4 : Type) . a_4 -> Text
 let Prelude.toString =
-    ((Elara.Prim.elaraPrimitive : forall (a_0 : Type) . Text -> a_0 @a_3 ->
-                                                                       Text) : forall (a_3 : Type) .
-                                                                                 a_3 ->
-                                                                                   Text "toString" : Text) : forall (a_3 : Type) .
-                                                                                                               a_3 ->
+    ((Elara.Prim.elaraPrimitive : forall (a_0 : Type) . Text -> a_0 @a_4 ->
+                                                                       Text) : forall (a_4 : Type) .
+                                                                                 a_4 ->
+                                                                                   Text "toString" : Text) : forall (a_4 : Type) .
+                                                                                                               a_4 ->
                                                                                                                  Text
 
 def Prelude.(+) : Integer -> Integer -> Integer