- lux/world/file now works with Process, instead of Task.

1 files changed, 94 insertions, 84 deletions

diff --git a/stdlib/test/test/lux/world/file.lux b/stdlib/test/test/lux/world/file.lux
index 1721c8cbb..388a52807 100644
--- a/stdlib/test/test/lux/world/file.lux
+++ b/stdlib/test/test/lux/world/file.lux
@@ -32,131 +32,141 @@
     ($_ seq
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +0 code)))]
-                 result (do T.Monad<Task>
-                          [pre (@.exists? file)
-                           _ (@.write dataL file)
-                           post (@.exists? file)
-                           deleted? (@.delete file)
-                           remains? (@.exists? file)]
-                          (wrap (and (not pre) post
-                                     deleted? (not remains?))))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [pre (@.exists? file)
+                            _ (@.write dataL file)
+                            post (@.exists? file)
+                            deleted? (@.delete file)
+                            remains? (@.exists? file)]
+                           (wrap (and (not pre) post
+                                      deleted? (not remains?)))))]
                 (assert "Can create/delete files."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +1 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file)
-                           output (@.read file)
-                           _ (@.delete file)]
-                          (wrap (:: blob.Eq<Blob> = dataL output)))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file)
+                            output (@.read file)
+                            _ (@.delete file)]
+                           (wrap (:: blob.Eq<Blob> = dataL output))))]
                 (assert "Can write/read files."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +2 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file)
-                           read-size (@.size file)
-                           _ (@.delete file)]
-                          (wrap (n/= file-size read-size)))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file)
+                            read-size (@.size file)
+                            _ (@.delete file)]
+                           (wrap (n/= file-size read-size))))]
                 (assert "Can read file size."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +3 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file)
-                           _ (@.append dataR file)
-                           output (@.read file)
-                           read-size (@.size file)
-                           _ (@.delete file)]
-                          (wrap (and (n/= (n/* +2 file-size) read-size)
-                                     (:: blob.Eq<Blob> = dataL (E.assume (blob.slice +0 (n/dec file-size) output)))
-                                     (:: blob.Eq<Blob> = dataR (E.assume (blob.slice file-size (n/dec read-size) output))))))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file)
+                            _ (@.append dataR file)
+                            output (@.read file)
+                            read-size (@.size file)
+                            _ (@.delete file)]
+                           (wrap (and (n/= (n/* +2 file-size) read-size)
+                                      (:: blob.Eq<Blob> = dataL (E.assume (blob.slice +0 (n/dec file-size) output)))
+                                      (:: blob.Eq<Blob> = dataR (E.assume (blob.slice file-size (n/dec read-size) output)))))))]
                 (assert "Can append to files."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [dir (format "temp_dir_" (%n (n/+ +4 code)))]
-                 result (do T.Monad<Task>
-                          [pre (@.exists? dir)
-                           _ (@.make-dir dir)
-                           post (@.exists? dir)
-                           deleted? (@.delete dir)
-                           remains? (@.exists? dir)]
-                          (wrap (and (not pre) post
-                                     deleted? (not remains?))))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [pre (@.exists? dir)
+                            _ (@.make-dir dir)
+                            post (@.exists? dir)
+                            deleted? (@.delete dir)
+                            remains? (@.exists? dir)]
+                           (wrap (and (not pre) post
+                                      deleted? (not remains?)))))]
                 (assert "Can create/delete directories."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +5 code)))
                        dir (format "temp_dir_" (%n (n/+ +5 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file)
-                           file-is-file (@.file? file)
-                           file-is-directory (@.directory? file)
-                           _ (@.delete file)
-                           _ (@.make-dir dir)
-                           directory-is-file (@.file? dir)
-                           directory-is-directory (@.directory? dir)
-                           _ (@.delete dir)]
-                          (wrap (and file-is-file (not file-is-directory)
-                                     (not directory-is-file) directory-is-directory)))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file)
+                            file-is-file (@.file? file)
+                            file-is-directory (@.directory? file)
+                            _ (@.delete file)
+                            _ (@.make-dir dir)
+                            directory-is-file (@.file? dir)
+                            directory-is-directory (@.directory? dir)
+                            _ (@.delete dir)]
+                           (wrap (and file-is-file (not file-is-directory)
+                                      (not directory-is-file) directory-is-directory))))]
                 (assert "Can differentiate files from directories."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +6 code)))
                        dir (format "temp_dir_" (%n (n/+ +6 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.make-dir dir)
-                           #let [file' (format dir "/" file)]
-                           _ (@.write dataL file')
-                           read-size (@.size file')
-                           deleted-file (@.delete file')
-                           deleted-dir (@.delete dir)]
-                          (wrap (and (n/= file-size read-size)
-                                     deleted-file
-                                     deleted-dir)))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.make-dir dir)
+                            #let [file' (format dir "/" file)]
+                            _ (@.write dataL file')
+                            read-size (@.size file')
+                            deleted-file (@.delete file')
+                            deleted-dir (@.delete dir)]
+                           (wrap (and (n/= file-size read-size)
+                                      deleted-file
+                                      deleted-dir))))]
                 (assert "Can create files inside of directories."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +7 code)))
                        dir (format "temp_dir_" (%n (n/+ +7 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.make-dir dir)
-                           #let [file' (format dir "/" file)]
-                           _ (@.write dataL file')
-                           children (@.files dir)
-                           _ (@.delete file')
-                           _ (@.delete dir)]
-                          (wrap (case children
-                                  (^ (list child))
-                                  (text.ends-with? file' child)
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.make-dir dir)
+                            #let [file' (format dir "/" file)]
+                            _ (@.write dataL file')
+                            children (@.files dir)
+                            _ (@.delete file')
+                            _ (@.delete dir)]
+                           (wrap (case children
+                                   (^ (list child))
+                                   (text.ends-with? file' child)
 
-                                  _
-                                  false)))]
+                                   _
+                                   false))))]
                 (assert "Can list files inside a directory."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file (format "temp_file_" (%n (n/+ +8 code)))]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file)
-                           was-modified? (@.set-last-modified last-modified file)
-                           time-read (@.get-last-modified file)
-                           _ (@.delete file)]
-                          (wrap (and was-modified?
-                                     (:: i.Eq<Instant> = last-modified time-read))))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file)
+                            was-modified? (@.set-last-modified last-modified file)
+                            time-read (@.get-last-modified file)
+                            _ (@.delete file)]
+                           (wrap (and was-modified?
+                                      (:: i.Eq<Instant> = last-modified time-read)))))]
                 (assert "Can change the time of last modification."
                         (E.default false result))))
         (wrap (do P.Monad<Promise>
                 [#let [file0 (format "temp_file_" (%n (n/+ +9 code)) "0")
                        file1 (format "temp_file_" (%n (n/+ +9 code)) "1")]
-                 result (do T.Monad<Task>
-                          [_ (@.write dataL file0)
-                           pre (@.exists? file0)
-                           moved? (@.move file1 file0)
-                           post (@.exists? file0)
-                           confirmed? (@.exists? file1)
-                           deleted? (@.delete file1)]
-                          (wrap (and pre moved? (not post)
-                                     confirmed? deleted?)))]
+                 result (P.future
+                         (do io.Monad<Process>
+                           [_ (@.write dataL file0)
+                            pre (@.exists? file0)
+                            moved? (@.move file1 file0)
+                            post (@.exists? file0)
+                            confirmed? (@.exists? file1)
+                            deleted? (@.delete file1)]
+                           (wrap (and pre moved? (not post)
+                                      confirmed? deleted?))))]
                 (assert "Can move a file from one path to another."
                         (E.default false result))))
         )))