upgrade to latest main -- syntax changes

Author: lukewilliamboswell

build.roc

@@ -1,7 +1,6 @@
 app [main!] {
-    # TODO replace with snake_case_builtins release
-    cli: platform "../basic-cli/platform/main.roc",
-    weaver: "https://github.com/smores56/weaver/releases/download/0.6.0/6WdRio4quZ_3HL8cEY_vyx5mzl1xXrEv2a_c1Bswrq4.tar.br",
+    cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.19.0/bi5zubJ-_Hva9vxxPq4kNx4WHX6oFs8OP6Ad0tCYlrY.tar.br",
+    weaver: "https://github.com/smores56/weaver/releases/download/0.6.0/4GmRnyE7EFjzv6dDpebJoWWwXV285OMt4ntHIc6qvmY.tar.br",
 }
 
 import cli.Cmd
@@ -16,28 +15,30 @@ import weaver.Cli
 ## run with: roc ./build.roc
 ##
 main! : _ => Result {} _
-main! = \args ->
+main! = |args|
 
     parsed_args =
         Result.on_err!(
             Cli.parse_or_display_message(cli_parser, args, Arg.to_os_raw),
-            \message -> Err (Exit 1 message),
+            |message| Err(Exit(1, message)),
         )?
 
     run!(parsed_args)
 
 cli_parser =
-    Opt.maybe_str { short: "p", long: "roc", help: "Path to the roc executable. Can be just `roc` or a full path." }
-    |> Cli.finish {
-        name: "basic-webserver-builder",
-        version: "",
-        authors: ["Luke Boswell <https://github.com/lukewilliamboswell>"],
-        description: "Generates all files needed by Roc to use this basic-cli platform.",
-    }
+    Opt.maybe_str({ short: "p", long: "roc", help: "Path to the roc executable. Can be just `roc` or a full path." })
+    |> Cli.finish(
+        {
+            name: "basic-webserver-builder",
+            version: "",
+            authors: ["Luke Boswell <https://github.com/lukewilliamboswell>"],
+            description: "Generates all files needed by Roc to use this basic-cli platform.",
+        },
+    )
     |> Cli.assert_valid
 
 run! : Result Str err => Result {} _
-run! = \maybe_roc ->
+run! = |maybe_roc|
 
     # roc_cmd may be a path or just roc
     roc_cmd = maybe_roc |> Result.with_default("roc")
@@ -61,30 +62,30 @@ run! = \maybe_roc ->
     info!("Successfully built platform files!")
 
 roc_version! : Str => Result {} _
-roc_version! = \roc_cmd ->
+roc_version! = |roc_cmd|
 
     info!("Checking provided roc; executing `${roc_cmd} version`:")?
 
     Cmd.exec!(roc_cmd, ["version"])
     |> Result.map_err(RocVersionCheckFailed)
 
 get_os_and_arch! : {} => Result OSAndArch _
-get_os_and_arch! = \{} ->
+get_os_and_arch! = |{}|
 
     info!("Getting the native operating system and architecture...")?
 
     convert_os_and_arch(Env.platform!({}))
 
 build_stub_app_lib! : Str, Str => Result {} _
-build_stub_app_lib! = \roc_cmd, stub_lib_path ->
+build_stub_app_lib! = |roc_cmd, stub_lib_path|
 
     info!("Building stubbed app shared library ...")?
 
     Cmd.exec!(roc_cmd, ["build", "--lib", "platform/libapp.roc", "--output", stub_lib_path, "--optimize"])
     |> Result.map_err(ErrBuildingAppStub)
 
 get_rust_target_folder! : {} => Result Str _
-get_rust_target_folder! = \{} ->
+get_rust_target_folder! = |{}|
     when Env.var!("CARGO_BUILD_TARGET") is
         Ok(target_env_var) ->
             if Str.is_empty(target_env_var) then
@@ -98,15 +99,15 @@ get_rust_target_folder! = \{} ->
             Ok("target/release/")
 
 cargo_build_host! : {} => Result {} _
-cargo_build_host! = \{} ->
+cargo_build_host! = |{}|
 
     info!("Building rust host ...")?
 
     Cmd.exec!("cargo", ["build", "--release"])
     |> Result.map_err(ErrBuildingHostBinaries)
 
 copy_host_lib! : OSAndArch, Str => Result {} _
-copy_host_lib! = \os_and_arch, rust_target_folder ->
+copy_host_lib! = |os_and_arch, rust_target_folder|
     host_build_path = "${rust_target_folder}libhost.a"
     host_dest_path = "platform/${prebuilt_static_lib_file(os_and_arch)}"
 
@@ -125,7 +126,7 @@ OSAndArch : [
 ]
 
 convert_os_and_arch : _ -> Result OSAndArch _
-convert_os_and_arch = \{ os, arch } ->
+convert_os_and_arch = |{ os, arch }|
     when (os, arch) is
         (MACOS, AARCH64) -> Ok(MacosArm64)
         (MACOS, X64) -> Ok(MacosX64)
@@ -134,14 +135,14 @@ convert_os_and_arch = \{ os, arch } ->
         _ -> Err(UnsupportedNative(os, arch))
 
 stub_file_extension : OSAndArch -> Str
-stub_file_extension = \os_and_arch ->
+stub_file_extension = |os_and_arch|
     when os_and_arch is
         MacosX64 | MacosArm64 -> "dylib"
         LinuxArm64 | LinuxX64 -> "so"
         WindowsX64 | WindowsArm64 -> "dll"
 
 prebuilt_static_lib_file : OSAndArch -> Str
-prebuilt_static_lib_file = \os_and_arch ->
+prebuilt_static_lib_file = |os_and_arch|
     when os_and_arch is
         MacosArm64 -> "macos-arm64.a"
         MacosX64 -> "macos-x64.a"
@@ -151,7 +152,7 @@ prebuilt_static_lib_file = \os_and_arch ->
         WindowsX64 -> "windows-x64.lib"
 
 preprocess_host! : Str, Str, Str => Result {} _
-preprocess_host! = \roc_cmd, stub_lib_path, rust_target_folder ->
+preprocess_host! = |roc_cmd, stub_lib_path, rust_target_folder|
 
     info!("Preprocessing surgical host ...")?
 
@@ -162,5 +163,5 @@ preprocess_host! = \roc_cmd, stub_lib_path, rust_target_folder ->
     |> Result.map_err(ErrPreprocessingSurgicalBinary)
 
 info! : Str => Result {} _
-info! = \msg ->
+info! = |msg|
     Stdout.line!("\u(001b)[34mINFO:\u(001b)[0m ${msg}")

examples/command.roc

@@ -7,10 +7,10 @@ import pf.Utc
 Model : {}
 
 init! : {} => Result Model _
-init! = \{} -> Ok({})
+init! = |{}| Ok({})
 
 respond! : Request, Model => Result Response [CmdStatusErr _]
-respond! = \req, _ ->
+respond! = |req, _|
 
     # Log request date, method and url using echo program
     datetime = Utc.to_iso_8601(Utc.now!({}))

examples/dir.roc

@@ -9,42 +9,32 @@ import pf.Http exposing [Request, Response]
 Model : {}
 
 init! : {} => Result Model _
-init! = \{} ->
+init! = |{}|
+
     # Get current working directory
-    cwd =
-        Result.map_err(
-            Env.cwd!({}),
-            \CwdUnavailable -> Exit(1, "Unable to read current working directory"),
-        )?
+    cwd = Env.cwd!({}) ? |CwdUnavailable| Exit(1, "Unable to read current working directory")
 
     Stdout.line!("The current working directory is ${Path.display(cwd)}")?
 
     # Try to set cwd to examples
-    Result.map_err(
-        Env.set_cwd!(Path.from_str("examples/")),
-        \InvalidCwd -> Exit(1, "Unable to set cwd to examples/"),
-    )?
+    Env.set_cwd!(Path.from_str("examples/")) ? |InvalidCwd| Exit(1, "Unable to set cwd to examples/")
 
     Stdout.line!("Set cwd to examples/")?
 
     # List contents of examples directory
-    paths =
-        Result.map_err(
-            Dir.list!("./"),
-            \DirErr(err) -> Exit(1, "Error reading directory ./:\n\t${Inspect.to_str(err)}"),
-        )?
-
-    paths
-    |> List.map(Path.display)
-    |> Str.join_with(",")
-    |> \paths_str -> "The paths are;\n${paths_str}"
-    |> Stdout.line!
-    |> try
+    paths = Dir.list!("./") ? |DirErr(err)| Exit(1, "Error reading directory ./:\n\t${Inspect.to_str(err)}")
+
+    paths_str =
+        paths
+        |> List.map(Path.display)
+        |> Str.join_with(",")
+
+    Stdout.line!("The paths are;\n${paths_str}")?
 
     Ok({})
 
 respond! : Request, Model => Result Response []
-respond! = \_, _ ->
+respond! = |_, _|
     Ok(
         {
             status: 200,

examples/echo.roc

@@ -7,10 +7,10 @@ import pf.Utc
 Model : {}
 
 init! : {} => Result Model []
-init! = \{} -> Ok({})
+init! = |{}| Ok({})
 
 respond! : Request, Model => Result Response [StdoutErr _]
-respond! = \req, _ ->
+respond! = |req, _|
     # Log request datetime, method and url
     datetime = Utc.to_iso_8601(Utc.now!({}))
 
@@ -22,4 +22,5 @@ respond! = \req, _ ->
     else
         success(req.body)
 
-success = \body -> Ok({ status: 200, headers: [], body })
+success = |body|
+    Ok({ status: 200, headers: [], body })

examples/env.roc

@@ -7,15 +7,15 @@ import pf.Env
 Model : [DebugPrintMode, NonDebugMode]
 
 init! : {} => Result Model [Exit I32 Str]_
-init! = \{} ->
+init! = |{}|
 
     # Check if DEBUG environment variable is set
     when Env.var!("DEBUG") is
         Ok(var) if !(Str.is_empty(var)) -> Ok(DebugPrintMode)
         _ -> Ok(NonDebugMode)
 
 respond! : Request, Model => Result Response [ServerErr Str]_
-respond! = \_, debug ->
+respond! = |_, debug|
     when debug is
         DebugPrintMode ->
             # Respond with all the current environment variables
@@ -26,7 +26,7 @@ respond! = \_, debug ->
             body =
                 vars
                 |> Dict.to_list
-                |> List.map(\(k, v) -> "${k}: ${v}")
+                |> List.map(|(k, v)| "${k}: ${v}")
                 |> Str.join_with("\n")
                 |> Str.concat("\n")
                 |> Str.to_utf8

examples/error-handling.roc

@@ -9,10 +9,10 @@ import pf.Env
 Model : {}
 
 init! : {} => Result Model []
-init! = \{} -> Ok({})
+init! = |{}| Ok({})
 
 respond! : Request, Model => Result Response [ServerErr Str]_
-respond! = \req, _ -> handle_req!(req) |> Result.map_err(map_app_err)
+respond! = |req, _| handle_req!(req) |> Result.map_err(map_app_err)
 
 AppError : [
     EnvVarNotSet Str,
@@ -21,15 +21,15 @@ AppError : [
 ]
 
 map_app_err : AppError -> [ServerErr Str]
-map_app_err = \app_err ->
+map_app_err = |app_err|
     when app_err is
         EnvVarNotSet(env_var_name) -> ServerErr("Environment variable \"${env_var_name}\" was not set.")
         BadBody(err) -> ServerErr("Http error fetching content:\n\t${Inspect.to_str(err)}")
         StdoutErr(err) -> ServerErr("Stdout error logging request:\n\t${err}")
 
 # Here we use AppError to ensure all errors must be handled within our application.
 handle_req! : Request => Result Response AppError
-handle_req! = \req ->
+handle_req! = |req|
     # Log the date, time, method, and url to stdout
     log_request!(req)?
 
@@ -43,24 +43,24 @@ handle_req! = \req ->
     response_with_code!(200, content)
 
 log_request! : Request => Result {} [StdoutErr Str]
-log_request! = \req ->
+log_request! = |req|
     datetime = Utc.to_iso_8601(Utc.now!({}))
 
     Stdout.line!("${datetime} ${Inspect.to_str(req.method)} ${req.uri}")
-    |> Result.map_err(\err -> StdoutErr(Inspect.to_str(err)))
+    |> Result.map_err(|err| StdoutErr(Inspect.to_str(err)))
 
 read_env_var! : Str => Result Str [EnvVarNotSet Str]
-read_env_var! = \env_var_name ->
+read_env_var! = |env_var_name|
     Env.var!(env_var_name)
-    |> Result.map_err(\_ -> EnvVarNotSet(env_var_name))
+    |> Result.map_err(|_| EnvVarNotSet(env_var_name))
 
 fetch_content! : Str => Result Str _
-fetch_content! = \url ->
+fetch_content! = |url|
     Http.get_utf8!(url)
 
 # Respond with the given status code and body
 response_with_code! : U16, Str => Result Response *
-response_with_code! = \code, body ->
+response_with_code! = |code, body|
     Ok(
         {
             status: code,

examples/file-upload-form.roc

@@ -1,6 +1,6 @@
 app [Model, init!, respond!] {
     pf: platform "../platform/main.roc",
-    utils: "https://github.com/quelgar/roc-utils/releases/download/v0.2.0/Ln38Q74rVeU6KAlT8dsB6nyKlUoD-O-43H41nCJ52Yk.tar.br",
+    utils: "https://github.com/lukewilliamboswell/roc-utils/releases/download/0.3.0/w1rWVzjiBSrvc1VHPNX10o0bHI7rmBdT36hFQ0f5R_w.tar.br",
 }
 
 import utils.Base64
@@ -11,10 +11,10 @@ import pf.MultipartFormData
 Model : {}
 
 init! : {} => Result Model []
-init! = \{} -> Ok({})
+init! = |{}| Ok({})
 
 respond! : Request, Model => Result Response [ServerErr Str]_
-respond! = \req, _ ->
+respond! = |req, _|
     if req.method == GET then
         Ok(
             {
@@ -46,7 +46,7 @@ respond! = \req, _ ->
             },
         )
     else if req.method == POST then
-        page = \src ->
+        page = |src|
             Str.to_utf8(
                 """
                 <!DOCTYPE html>

examples/file.roc

@@ -9,12 +9,12 @@ Model : Str
 
 # We only read the file once in `init`. If that fails, we don't launch the server.
 init! : {} => Result Model [Exit I32 Str]_
-init! = \{} ->
+init! = |{}|
     # Read the contents of examples/file.roc
     File.read_utf8!("examples/file.roc")
-    |> Result.map_ok(\contents -> "Source code of current program:\n\n${contents}")
+    |> Result.map_ok(|contents| "Source code of current program:\n\n${contents}")
     |> Result.map_err(
-        \err ->
+        |err|
             when err is
                 FileReadErr(path, file_err) ->
                     Exit(
@@ -30,6 +30,6 @@ init! = \{} ->
     )
 
 respond! : Request, Model => Result Response [ServerErr Str]_
-respond! = \_, model ->
+respond! = |_, model|
     # If the server launched, the model contains the file content.
     Ok({ status: 200, headers: [], body: Str.to_utf8(model) })

examples/hello-web.roc

@@ -11,10 +11,10 @@ Model : {}
 # generate css by running `tailwindcss`,...
 # In this case we don't have anything to initialize, so it is just `Ok {}`.
 init! : {} => Result Model []
-init! = \{} -> Ok({})
+init! = |{}| Ok({})
 
 respond! : Request, Model => Result Response [ServerErr Str]_
-respond! = \req, _ ->
+respond! = |req, _|
     # Log request datetime, method and url
     datetime = Utc.to_iso_8601(Utc.now!({}))