Migrate to new roc

bin/add-exercise

@@ -88,10 +88,11 @@ cat << END_TEST > "exercises/practice/${slug}/${slug}-test.roc"
 END_TEST
 
 cat << END_STUB > "exercises/practice/${slug}/${slug_pascal}.roc"
-module [${slug_camel}]
-
-${slug_camel} = |my_arg|
-    crash "Please implement the '${slug_camel}' function"
+${slug_pascal} :: {}.{
+    ${slug_camel} = |my_arg| {
+        crash "Please implement the '${slug_camel}' function"
+    }
+}
 END_STUB
 
 cp "exercises/practice/${slug}/${slug_pascal}.roc" "exercises/practice/${slug}/.meta/Example.roc"
@@ -107,7 +108,7 @@ Your next steps are:
 - Create the example solution in 'exercises/practice/${slug}/.meta/Example.roc'
 - Verify the example solution by running 'bin/verify-exercises ${slug}'
 - Edit the stub solution in 'exercises/practice/${slug}/${slug_pascal}.roc'
-- Format all your Roc code by running 'roc format' on each .roc file
+- Format all your Roc code by running 'roc fmt' on each .roc file
 - Update the 'difficulty' value for the exercise's entry in the 'config.json' file
 - Validate CI using 'bin/configlet lint' and 'bin/configlet fmt'
 NEXT_STEPS

bin/generate_tests.py

@@ -157,9 +157,9 @@ def to_roc_multiline_string(lines: Union[str, List[str]]) -> str:
     elif len(lines) == 1:
         return to_roc_string(lines[0])
     else:
-        return "\n".join(
-            ["", '"""'] + [escape_roc_string_content(line) for line in lines] + ['"""']
-        ).replace("$(", "\\$(")
+        return "\n" + "\n".join(
+            [r'\\' + escape_roc_string_content(line) for line in lines]
+        ).replace("${", r"\${") + "\n"
 
 
 def to_roc_tuple(values: Any):
@@ -177,7 +177,7 @@ def to_roc_record(obj: Dict[str, Any]):
 
 
 def to_roc_bool(value: bool):
-    return "Bool.true" if value else "Bool.false"
+    return "Bool.True" if value else "Bool.False"
 
 
 def to_roc_list(values: Any):
@@ -187,7 +187,7 @@ def to_roc_list(values: Any):
 
 def to_roc_float(value: Union[int, float]):
     value = float(value)
-    return f"{value!r}f64".replace("+", "")
+    return f"{value!r}.F64".replace("+", "")
 
 
 def to_roc(value: Any) -> str:
@@ -377,9 +377,10 @@ def load_additional_tests(exercise: Path) -> List[TypeJSON]:
 
 def format_file(path: Path) -> NoReturn:
     """
-    Runs roc format on file at path
+    Runs roc fmt on file at path
     """
-    subprocess.check_call(["roc", "format", path])
+    subprocess.check_call(["roc", "fmt", path])
+    pass
 
 
 def drop_timestamp(lines):
@@ -567,6 +568,8 @@ def generate(
     env.tests["error_case"] = error_case
     result = True
     for exercise in sorted(Path("exercises/practice").glob(exercise_glob)):
+        if not exercise.is_dir():
+            continue
         if not generate_exercise(env, spec_path, exercise, check):
             result = False
             if stop_on_failure:

bin/install-roc

@@ -5,12 +5,11 @@
 
 function download_alpha_release() {
     local install_dir="${1}"
-    local install_file="${install_dir}/roc.tar.gz"
-    local release_url="https://github.com/roc-lang/roc/releases/download/alpha4-rolling/roc-linux_x86_64-alpha4-rolling.tar.gz"
+    rm -rf "${install_dir}"
     mkdir -p "${install_dir}"
-    wget -q -O ${install_file} ${release_url}
-    tar -xzf "${install_file}" -C "${install_dir}" --strip-components 1
-    rm -f "${install_file}"
+    cd "${install_dir}"
+    wget --secure-protocol=TLSv1_2 -qO- https://roc-lang.org/install_roc.sh | ROC_CONTINUE_IF_STALE=y ROC_ADD_TO_PATH=n sh
+    ln -s roc_nightly*/roc roc
 }
 
 function update_shell {

config/generator_macros.j2

@@ -17,27 +17,29 @@
 
 {% macro header(imports=[], ignore=[]) -%}
 
-app [main!] {
-    pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.20.0/X73hGh05nNTkDHU06FHC0YfFaQB1pimX7gncRcao5mU.tar.br"
 {%- if imports -%}
+app [main!] {
+    pf: platform "https://github.com/lukewilliamboswell/roc-platform-template-zig/releases/download/0.9/8GdFEvQYS3TeAZxKvTzCLVdQiomweGtXcdZkXNDEeABq.tar.zst"
 {%- for name in imports -%},
     {% if name == "unicode" -%}
-    unicode: "https://github.com/roc-lang/unicode/releases/download/0.3.0/9KKFsA4CdOz0JIOL7iBSI_2jGIXQ6TsFBXgd086idpY.tar.br"
+    unicode: "https://github.com/roc-lang/unicode/..." # TODO: update when a zig-compatible release is available
     {%- elif name == "isodate" -%}
-    isodate: "https://github.com/imclerran/roc-isodate/releases/download/v0.6.2/73w_H-aSJNcWqtXvMG4JQw_HoaApMBLnE92XD4OcVGU.tar.br"
+    isodate: "https://github.com/imclerran/roc-isodate/..." # TODO: update when a zig-compatible release is available
     {%- elif name == "json" -%}
-    json: "https://github.com/lukewilliamboswell/roc-json/releases/download/0.13.0/RqendgZw5e1RsQa3kFhgtnMP8efWoqGRsAvubx4-zus.tar.br"
+    json: "https://github.com/lukewilliamboswell/roc-json/..." # TODO: update when a zig-compatible release is available
     {%- elif name == "parser" -%}
-    parser: "https://github.com/lukewilliamboswell/roc-parser/releases/download/0.10.0/6eZYaXkrakq9fJ4oUc0VfdxU1Fap2iTuAN18q9OgQss.tar.br"
+    parser: "https://github.com/lukewilliamboswell/roc-parser/..." # TODO: update when a zig-compatible release is available
     {%- endif -%}
-{%- endfor -%}
-{%- endif %}
+{%- endfor %}
 }
 
 import pf.Stdout
+{%- endif %}
+{%- endmacro %}
 
-main! = |_args|
-    Stdout.line!("")
+{% macro footer() -%}
 
-{%- endmacro %}
+# This program is only used to run tests with `roc test`, so main! does nothing.
+main! = |_args| { Ok({}) }
 
+{%- endmacro %}

docs/SNIPPET.txt

@@ -1,14 +1,14 @@
-app [main!] { pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.20.0/X73hGh05nNTkDHU06FHC0YfFaQB1pimX7gncRcao5mU.tar.br" }
-
-import pf.Stdout
-
-factorial = |number|
-    when number is
-        1 -> 1
-        n -> n * factorial (n - 1)
-
-expect factorial 5 == 1 * 2 * 3 * 4 * 5
-
-main! = |_args|
-    result = factorial 20 |> Num.to_str
-    Stdout.line! "factorial 20 = ${result}"
+factorial = |number| {
+    match number {
+        1 => 1
+        n => n * factorial(n - 1)
+    }
+}
+
+expect factorial(5) == 1 * 2 * 3 * 4 * 5
+
+main! = |_args| {
+    result = factorial(20)
+    echo!("factorial 20 = ${result.to_str()}")
+    Ok({})
+}

docs/TESTS.md

@@ -22,7 +22,7 @@ roc test hello-world-test.roc
 If you've solved the exercise, you should see 0 failed tests, for example:
 
 ```
-0 failed and 1 passed in 583 ms.
+All (5) tests passed in 123.4 ms.
 ```
 
 However, if your code has any errors, they will look like this:
@@ -36,7 +36,7 @@ This expectation failed:
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 
-1 failed and 0 passed in 1264 ms.
+1 failed and 0 passed in 123.4 ms.
 ```
 
 This should help you fix your code. Once your code works, you can submit it using the `exercism submit` command (see `HELP.md` in the exercise directory for more details).

exercises/practice/accumulate/.meta/Example.roc

@@ -1,12 +1,12 @@
-module [accumulate]
-
-accumulate : List a, (a -> b) -> List b
-accumulate = |list, func|
-    help = |output, input|
-        when input is
-            [] -> output
-            [first, .. as rest] ->
-                List.append(output, func(first))
-                |> help(rest)
-
-    help([], list)
+Accumulate :: {}.{
+	accumulate : List(a), (a -> b) -> List(b)
+	accumulate = |list, func| {
+		help = |output, input| {
+			match input {
+				[] => output
+				[first, .. as rest] => output.append(func(first))->help(rest)
+			}
+		}
+		help([], list)
+	}
+}

exercises/practice/accumulate/.meta/template.j2

@@ -5,36 +5,43 @@
 import {{ exercise | to_pascal }} exposing [{{ cases[0]["property"] | to_snake }}]
 
 {% set accumulators = {
-    "(x) => x * x": "|x|\n        x * x",
+    "(x) => x * x": "|x| { x * x }",
     "(x) => upcase(x)": "to_upper",
-    "(x) => reverse(x)": "reverse",
-    "(x) => accumulate([\"1\", \"2\", \"3\"], (y) => x + y)": "|x|\n        accumulate([\"1\", \"2\", \"3\"], |y| Str.concat(x, y))"
+    "(x) => reverse(x)": "str_reverse",
+    "(x) => accumulate([\"1\", \"2\", \"3\"], (y) => x + y)": "|x| {\n        accumulate([\"1\", \"2\", \"3\"], |y| { Str.concat(x, y) })\n    }"
 } -%}
 
 {% for case in cases -%}
 # {{ case["description"] }}
-expect
+expect {
     result = {{ case["property"] | to_snake }}({{ case["input"]["list"] | to_roc }}, {{ accumulators[case["input"]["accumulator"]] }})
     result == {{ case["expected"] | to_roc }}
+}
 
-{% endfor %}
+{% endfor -%}
 
-reverse : Str -> Str
-reverse = |str|
-    Str.to_utf8(str)
-    |> List.reverse
-    |> Str.from_utf8
-    |> Result.with_default("")
+
+to_upper_char : U8 -> U8
+to_upper_char = |byte| {
+	if 'a' <= byte and byte <= 'z' {
+		byte - 'a' + 'A'
+	} else {
+		byte
+	}
+}
 
 to_upper : Str -> Str
-to_upper = |str|
-    Str.to_utf8(str)
-    |> List.map(
-        |byte|
-            if 'a' <= byte && byte <= 'z' then
-                byte - 'a' + 'A'
-            else
-                byte
-    )
-    |> Str.from_utf8
-    |> Result.with_default("")
+to_upper = |str| {
+	str.to_utf8().map(to_upper_char)->Str.from_utf8() ?? ""
+}
+
+str_reverse : Str -> Str
+str_reverse = |str| {
+	str
+		.to_utf8()
+		.rev()
+		->Str.from_utf8()
+		?? ""
+}
+
+{{ macros.footer() }}

exercises/practice/accumulate/Accumulate.roc

@@ -1,5 +1,6 @@
-module [accumulate]
-
-accumulate : List a, (a -> b) -> List b
-accumulate = |list, func|
-    crash("Please implement 'accumulate'")
+Accumulate :: {}.{
+	accumulate : List(a), (a -> b) -> List(b)
+	accumulate = |list, func| {
+		crash "Please implement the 'accumulate' function"
+	}
+}