From 8b6bb9d75df72ea83e758eb9c38a2ec989f998c9 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 11 Aug 2023 20:21:53 +0200 Subject: [PATCH 001/129] prep basic-cli 0.5 release --- .github/workflows/basic_cli_build_release.yml | 25 ++++++++++++++++++- .github/workflows/benchmarks.yml | 2 +- .github/workflows/macos_x86_64.yml | 2 +- .github/workflows/markdown_link_check.yml | 2 +- .github/workflows/nix_linux_x86_64.yml | 2 +- .github/workflows/nix_macos_apple_silicon.yml | 2 +- .github/workflows/nix_macos_x86_64.yml | 2 +- .github/workflows/spellcheck.yml | 2 +- .github/workflows/ubuntu_x86_64.yml | 2 +- .github/workflows/windows_release_build.yml | 2 +- .github/workflows/windows_tests.yml | 2 +- ci/build_basic_cli.sh | 11 ++++++-- 12 files changed, 43 insertions(+), 13 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 01c9266454..ff4989eec7 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -1,5 +1,5 @@ on: - #pull_request: + pull_request: workflow_dispatch: # this cancels workflows currently in progress if you start a new one @@ -18,6 +18,7 @@ jobs: - uses: actions/checkout@v3 - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_x86_64-latest.tar.gz + - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_arm64-latest.tar.gz - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_x86_64-latest.tar.gz - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_apple_silicon-latest.tar.gz @@ -49,6 +50,28 @@ jobs: basic-cli/src/linux-x86_64.rh basic-cli/src/linux-x86_64.o + + build-linux-arm64-files: + runs-on: [self-hosted, Linux, ARM64] + needs: [fetch-releases] + steps: + - uses: actions/checkout@v3 + + - name: Download the previously uploaded roc_nightly archives + uses: actions/download-artifact@v3 + + - name: build basic-cli with surgical linker and also with legacy linker + env: + CARGO_BUILD_TARGET: aarch64-unknown-linux-gnu + run: ./ci/build_basic_cli.sh linux_arm64 + + - name: Save .o file + uses: actions/upload-artifact@v3 + with: + name: linux-arm64-files + path: | + basic-cli/src/linux-arm64.o + build-macos-x86_64-files: runs-on: [macos-11] # I expect the generated files to work on macOS 12 needs: [fetch-releases] diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml index 4d016a3e3c..b682c6b1f9 100644 --- a/.github/workflows/benchmarks.yml +++ b/.github/workflows/benchmarks.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: Benchmarks diff --git a/.github/workflows/macos_x86_64.yml b/.github/workflows/macos_x86_64.yml index fc3527fa29..2598a9783e 100644 --- a/.github/workflows/macos_x86_64.yml +++ b/.github/workflows/macos_x86_64.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: Macos x86-64 rust tests diff --git a/.github/workflows/markdown_link_check.yml b/.github/workflows/markdown_link_check.yml index 1b60da4f8c..42fa2e9099 100644 --- a/.github/workflows/markdown_link_check.yml +++ b/.github/workflows/markdown_link_check.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: schedule: - cron: '0 9 * * *' # 9=9am utc+0 diff --git a/.github/workflows/nix_linux_x86_64.yml b/.github/workflows/nix_linux_x86_64.yml index 647adf6fa5..c86e12af5c 100644 --- a/.github/workflows/nix_linux_x86_64.yml +++ b/.github/workflows/nix_linux_x86_64.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: Nix linux x86_64 cargo test diff --git a/.github/workflows/nix_macos_apple_silicon.yml b/.github/workflows/nix_macos_apple_silicon.yml index 0f00277d2c..09fe8922bf 100644 --- a/.github/workflows/nix_macos_apple_silicon.yml +++ b/.github/workflows/nix_macos_apple_silicon.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: Nix apple silicon cargo test diff --git a/.github/workflows/nix_macos_x86_64.yml b/.github/workflows/nix_macos_x86_64.yml index 7c9e43aa28..b5aa5fed37 100644 --- a/.github/workflows/nix_macos_x86_64.yml +++ b/.github/workflows/nix_macos_x86_64.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: Nix macOS x86_64 cargo test diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml index fb7f9284c0..bbdf5ee4e3 100644 --- a/.github/workflows/spellcheck.yml +++ b/.github/workflows/spellcheck.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: SpellCheck diff --git a/.github/workflows/ubuntu_x86_64.yml b/.github/workflows/ubuntu_x86_64.yml index a411f73d12..709428b06d 100644 --- a/.github/workflows/ubuntu_x86_64.yml +++ b/.github/workflows/ubuntu_x86_64.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: CI diff --git a/.github/workflows/windows_release_build.yml b/.github/workflows/windows_release_build.yml index fee39a873a..b47e293034 100644 --- a/.github/workflows/windows_release_build.yml +++ b/.github/workflows/windows_release_build.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: windows - release build diff --git a/.github/workflows/windows_tests.yml b/.github/workflows/windows_tests.yml index 82920c2a5f..9bd857dad3 100644 --- a/.github/workflows/windows_tests.yml +++ b/.github/workflows/windows_tests.yml @@ -1,5 +1,5 @@ on: - pull_request: + #pull_request: name: windows - subset of tests diff --git a/ci/build_basic_cli.sh b/ci/build_basic_cli.sh index 1a74dce3c7..ce34353adf 100755 --- a/ci/build_basic_cli.sh +++ b/ci/build_basic_cli.sh @@ -4,11 +4,18 @@ set -euxo pipefail git clone https://github.com/roc-lang/basic-cli.git +cd basic-cli +git checkout new-abilities-syntax +cd .. -if [ "$(uname -m)" == "x86_64" ] && [ "$(uname -s)" == "Linux" ]; then +if [ "$(uname -s)" == "Linux" ]; then sudo apt-get install musl-tools cd basic-cli/src # we cd to install the target for the right rust version - rustup target add x86_64-unknown-linux-musl + if [ "$(uname -m)" == "x86_64" ]; then + rustup target add x86_64-unknown-linux-musl + elif [ "$(uname -m)" == "aarch64" ]; then + rustup target add aarch64-unknown-linux-gnu + fi cd ../.. fi From e2661585ef9dceb416f3556bcf79d30316732b8d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Aug 2023 10:06:47 +0200 Subject: [PATCH 002/129] arm64 fixes --- .github/workflows/basic_cli_build_release.yml | 4 +++- ci/build_basic_cli.sh | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index ff4989eec7..5414493c6f 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -110,7 +110,7 @@ jobs: basic-cli/src/macos-arm64.o create-release-archive: - needs: [build-linux-x86_64-files, build-macos-x86_64-files, build-macos-apple-silicon-files] + needs: [build-linux-x86_64-files, build-linux-arm64-files, build-macos-x86_64-files, build-macos-apple-silicon-files] name: create release archive runs-on: [ubuntu-20.04] steps: @@ -140,6 +140,8 @@ jobs: - run: cp linux-x86_64-files/* ./basic-cli/src + - run: cp linux-arm64-files/* ./basic-cli/src + - run: cp macos-x86_64-files/* ./basic-cli/src - run: ./roc_nightly/roc build --bundle=${{ env.ARCHIVE_FORMAT }} ./basic-cli/src/main.roc diff --git a/ci/build_basic_cli.sh b/ci/build_basic_cli.sh index ce34353adf..5afe614862 100755 --- a/ci/build_basic_cli.sh +++ b/ci/build_basic_cli.sh @@ -9,7 +9,7 @@ git checkout new-abilities-syntax cd .. if [ "$(uname -s)" == "Linux" ]; then - sudo apt-get install musl-tools + sudo apt-get install -y musl-tools cd basic-cli/src # we cd to install the target for the right rust version if [ "$(uname -m)" == "x86_64" ]; then rustup target add x86_64-unknown-linux-musl From a9b97768b469b00ce5e78e4f3a5ae55e72306fa5 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Aug 2023 12:01:48 +0200 Subject: [PATCH 003/129] specify linux_x86_64 Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 5414493c6f..020fb52638 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -123,7 +123,7 @@ jobs: uses: actions/download-artifact@v3 - name: mv roc nightly and simplify name - run: mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "linux") ./roc_nightly.tar.gz + run: mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "linux_x86_64") ./roc_nightly.tar.gz - name: decompress the tar run: tar -xzvf roc_nightly.tar.gz @@ -164,7 +164,7 @@ jobs: uses: actions/download-artifact@v3 - name: mv roc nightly and simplify name - run: mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "linux") ./roc_nightly.tar.gz + run: mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "linux_x86_64") ./roc_nightly.tar.gz - name: decompress the tar run: tar -xzvf roc_nightly.tar.gz From d5eca4af9814b6e6165fafb04a975329cce95403 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Aug 2023 13:53:15 +0200 Subject: [PATCH 004/129] x86_64 > x64 Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 020fb52638..8d2367ae0c 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -46,9 +46,9 @@ jobs: with: name: linux-x86_64-files path: | - basic-cli/src/metadata_linux-x86_64.rm - basic-cli/src/linux-x86_64.rh - basic-cli/src/linux-x86_64.o + basic-cli/src/metadata_linux-x64.rm + basic-cli/src/linux-x64.rh + basic-cli/src/linux-x64.o build-linux-arm64-files: @@ -88,7 +88,7 @@ jobs: with: name: macos-x86_64-files path: | - basic-cli/src/macos-x86_64.o + basic-cli/src/macos-x64.o build-macos-apple-silicon-files: name: build apple silicon .o file From 628f41ab78e88ce697abbe057784f7031827caab Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Aug 2023 14:55:03 +0200 Subject: [PATCH 005/129] build before final test Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 8d2367ae0c..1a4383e795 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -192,6 +192,7 @@ jobs: cd examples curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/examples/http-get.roc sed -i 's/pf:\ \"[^"]*/pf:\ \"\.\.\/main.roc/g' http-get.roc + ./roc_nightly/roc build http-get.roc cd .. curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp From 08f7865c97c84a33dbdac40c5b980068a3a0372d Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sat, 12 Aug 2023 16:39:49 +0200 Subject: [PATCH 006/129] fix path, back to main branch --- .github/workflows/basic_cli_build_release.yml | 3 ++- ci/build_basic_cli.sh | 3 --- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 1a4383e795..038133ca54 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -192,8 +192,9 @@ jobs: cd examples curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/examples/http-get.roc sed -i 's/pf:\ \"[^"]*/pf:\ \"\.\.\/main.roc/g' http-get.roc - ./roc_nightly/roc build http-get.roc + cd .. + ./roc_nightly/roc build examples/http-get.roc curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp - run: sudo apt install -y expect diff --git a/ci/build_basic_cli.sh b/ci/build_basic_cli.sh index 5afe614862..a3d02ab213 100755 --- a/ci/build_basic_cli.sh +++ b/ci/build_basic_cli.sh @@ -4,9 +4,6 @@ set -euxo pipefail git clone https://github.com/roc-lang/basic-cli.git -cd basic-cli -git checkout new-abilities-syntax -cd .. if [ "$(uname -s)" == "Linux" ]; then sudo apt-get install -y musl-tools From 4b53557c7074504b7340002137b37e06165c3e70 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 18 Aug 2023 19:44:04 +0200 Subject: [PATCH 007/129] added debug upload --- .github/workflows/basic_cli_build_release.yml | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 038133ca54..b862162249 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -9,7 +9,7 @@ concurrency: # use .tar.gz for quick testing env: - ARCHIVE_FORMAT: .tar.br + ARCHIVE_FORMAT: .tar.gz jobs: fetch-releases: @@ -194,8 +194,17 @@ jobs: sed -i 's/pf:\ \"[^"]*/pf:\ \"\.\.\/main.roc/g' http-get.roc cd .. - ./roc_nightly/roc build examples/http-get.roc - curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp + + #./roc_nightly/roc build examples/http-get.roc + #curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp + + # temp for debugging + - name: Save basic-cli-platform + uses: actions/upload-artifact@v3 + with: + name: basic-cli-platform-debug + path: | + basic-cli-platform - run: sudo apt install -y expect From e11725b1e28417c66d27b060d3b68e1b3f042c41 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 21 Aug 2023 17:19:58 +0200 Subject: [PATCH 008/129] add prebuilt-platform flag Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index b862162249..02af002e8b 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -195,16 +195,8 @@ jobs: cd .. - #./roc_nightly/roc build examples/http-get.roc - #curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp - - # temp for debugging - - name: Save basic-cli-platform - uses: actions/upload-artifact@v3 - with: - name: basic-cli-platform-debug - path: | - basic-cli-platform + ./roc_nightly/roc build examples/http-get.roc --prebuilt-platform + curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp - run: sudo apt install -y expect From 6650f62b72ccec1bec39cf9d3e0e7ae542bed9e8 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 22 Aug 2023 14:39:56 +0200 Subject: [PATCH 009/129] try with musl --- .github/workflows/basic_cli_build_release.yml | 6 +++--- ci/build_basic_cli.sh | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 02af002e8b..9af7dface5 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -60,9 +60,9 @@ jobs: - name: Download the previously uploaded roc_nightly archives uses: actions/download-artifact@v3 - - name: build basic-cli with surgical linker and also with legacy linker + - name: build basic-cli env: - CARGO_BUILD_TARGET: aarch64-unknown-linux-gnu + CARGO_BUILD_TARGET: aarch64-unknown-linux-musl run: ./ci/build_basic_cli.sh linux_arm64 - name: Save .o file @@ -73,7 +73,7 @@ jobs: basic-cli/src/linux-arm64.o build-macos-x86_64-files: - runs-on: [macos-11] # I expect the generated files to work on macOS 12 + runs-on: [macos-11] # I expect the generated files to work on macOS 12 and 13 needs: [fetch-releases] steps: - uses: actions/checkout@v3 diff --git a/ci/build_basic_cli.sh b/ci/build_basic_cli.sh index a3d02ab213..1019d55660 100755 --- a/ci/build_basic_cli.sh +++ b/ci/build_basic_cli.sh @@ -11,7 +11,7 @@ if [ "$(uname -s)" == "Linux" ]; then if [ "$(uname -m)" == "x86_64" ]; then rustup target add x86_64-unknown-linux-musl elif [ "$(uname -m)" == "aarch64" ]; then - rustup target add aarch64-unknown-linux-gnu + rustup target add aarch64-unknown-linux-musl fi cd ../.. fi From 75dff53cc8795ffd40f4c1e6bb796ee4335bef00 Mon Sep 17 00:00:00 2001 From: Yuki Omoto Date: Sun, 5 Nov 2023 21:02:08 +0900 Subject: [PATCH 010/129] Fix crash caused by number related type error This fixes an issue where number related type errors cause a crash. For example, using a negative number for `Nat` like List.dropAt [1, 2, 3] -1` as in #5916. so as f64 number. --- crates/compiler/mono/src/ir.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/crates/compiler/mono/src/ir.rs b/crates/compiler/mono/src/ir.rs index 83c2fbf1db..5ab56fafbb 100644 --- a/crates/compiler/mono/src/ir.rs +++ b/crates/compiler/mono/src/ir.rs @@ -9268,9 +9268,13 @@ fn assign_num_literal_expr<'a>( num_value: IntOrFloatValue, hole: &'a Stmt<'a>, ) -> Stmt<'a> { - let layout = layout_cache - .from_var(env.arena, variable, env.subs) - .unwrap(); + let layout = match layout_cache.from_var(env.arena, variable, env.subs) { + Ok(layout) => layout, + Err(_) => match num_value { + IntOrFloatValue::Float(_) => Layout::default_float(), + IntOrFloatValue::Int(_) => Layout::default_integer(), + }, + }; let literal = make_num_literal(&layout_cache.interner, layout, num_str, num_value).to_expr_literal(); From 8580b62f7e5857b6a0395202d77c335a36431fcf Mon Sep 17 00:00:00 2001 From: Yuki Omoto Date: Mon, 6 Nov 2023 21:16:00 +0900 Subject: [PATCH 011/129] Add runtime error to bring an error to roc instead of using wrong number value just to continue the program --- crates/compiler/mono/src/ir.rs | 81 +++++++++++++++++++--------------- 1 file changed, 45 insertions(+), 36 deletions(-) diff --git a/crates/compiler/mono/src/ir.rs b/crates/compiler/mono/src/ir.rs index 5ab56fafbb..59049c5670 100644 --- a/crates/compiler/mono/src/ir.rs +++ b/crates/compiler/mono/src/ir.rs @@ -4268,35 +4268,50 @@ pub fn with_hole<'a>( let arena = env.arena; match can_expr { - Int(_, _, int_str, int, _bound) => assign_num_literal_expr( - env, - layout_cache, - assigned, - variable, - &int_str, - IntOrFloatValue::Int(int), - hole, - ), + Int(_, _, int_str, int, _bound) => { + match assign_num_literal_expr( + env, + layout_cache, + assigned, + variable, + &int_str, + IntOrFloatValue::Int(int), + hole, + ) { + Ok(stmt) => stmt, + Err(_) => hole.clone(), + } + } - Float(_, _, float_str, float, _bound) => assign_num_literal_expr( - env, - layout_cache, - assigned, - variable, - &float_str, - IntOrFloatValue::Float(float), - hole, - ), + Float(_, _, float_str, float, _bound) => { + match assign_num_literal_expr( + env, + layout_cache, + assigned, + variable, + &float_str, + IntOrFloatValue::Float(float), + hole, + ) { + Ok(stmt) => stmt, + Err(_) => hole.clone(), + } + } - Num(_, num_str, num, _bound) => assign_num_literal_expr( - env, - layout_cache, - assigned, - variable, - &num_str, - IntOrFloatValue::Int(num), - hole, - ), + Num(_, num_str, num, _bound) => { + match assign_num_literal_expr( + env, + layout_cache, + assigned, + variable, + &num_str, + IntOrFloatValue::Int(num), + hole, + ) { + Ok(stmt) => stmt, + Err(_) => hole.clone(), + } + } Str(string) => Stmt::Let( assigned, @@ -9267,18 +9282,12 @@ fn assign_num_literal_expr<'a>( num_str: &str, num_value: IntOrFloatValue, hole: &'a Stmt<'a>, -) -> Stmt<'a> { - let layout = match layout_cache.from_var(env.arena, variable, env.subs) { - Ok(layout) => layout, - Err(_) => match num_value { - IntOrFloatValue::Float(_) => Layout::default_float(), - IntOrFloatValue::Int(_) => Layout::default_integer(), - }, - }; +) -> Result, RuntimeError> { + let layout = layout_cache.from_var(env.arena, variable, env.subs)?; let literal = make_num_literal(&layout_cache.interner, layout, num_str, num_value).to_expr_literal(); - Stmt::Let(assigned, Expr::Literal(literal), layout, hole) + Ok(Stmt::Let(assigned, Expr::Literal(literal), layout, hole)) } type ToLowLevelCallArguments<'a> = ( From 8314781390dd7420ce94037263ddffb631bbbbd8 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 13 Nov 2023 12:19:54 +0100 Subject: [PATCH 012/129] use new ROC env var Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_test_arm64.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/basic_cli_test_arm64.yml b/.github/workflows/basic_cli_test_arm64.yml index 7594ece28d..e4278970b1 100644 --- a/.github/workflows/basic_cli_test_arm64.yml +++ b/.github/workflows/basic_cli_test_arm64.yml @@ -51,4 +51,4 @@ jobs: - name: Run all tests with latest roc nightly and latest basic-cli release run: | sed -i 's/x86_64/arm64/g' ./ci/test_latest_release.sh - EXAMPLES_DIR=./latest-release-examples/ ./ci/test_latest_release.sh + ROC=./roc_nightly/roc EXAMPLES_DIR=./latest-release-examples/ ./ci/test_latest_release.sh From d9914bb34abb6c4c6debfc58e27a06dddd107763 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Mon, 13 Nov 2023 16:47:14 +0100 Subject: [PATCH 013/129] temp disable other workflows --- .github/workflows/devtools_test_linux_x86_64.yml | 2 +- .github/workflows/devtools_test_macos_apple_silicon.yml | 2 +- .github/workflows/nix_linux_arm64_cargo.yml | 2 +- .github/workflows/nix_linux_arm64_default.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/devtools_test_linux_x86_64.yml b/.github/workflows/devtools_test_linux_x86_64.yml index 6c8d8b1e1c..b6d332c5ac 100644 --- a/.github/workflows/devtools_test_linux_x86_64.yml +++ b/.github/workflows/devtools_test_linux_x86_64.yml @@ -1,5 +1,5 @@ on: - pull_request: +# pull_request: name: devtools nix files test - linux diff --git a/.github/workflows/devtools_test_macos_apple_silicon.yml b/.github/workflows/devtools_test_macos_apple_silicon.yml index 68027ecb00..45ce2e94c9 100644 --- a/.github/workflows/devtools_test_macos_apple_silicon.yml +++ b/.github/workflows/devtools_test_macos_apple_silicon.yml @@ -1,5 +1,5 @@ on: - pull_request: +# pull_request: name: devtools nix files test - macos diff --git a/.github/workflows/nix_linux_arm64_cargo.yml b/.github/workflows/nix_linux_arm64_cargo.yml index 52dfde0a2e..dc516db913 100644 --- a/.github/workflows/nix_linux_arm64_cargo.yml +++ b/.github/workflows/nix_linux_arm64_cargo.yml @@ -1,5 +1,5 @@ on: - pull_request: +# pull_request: name: test cargo build on linux arm64 inside nix diff --git a/.github/workflows/nix_linux_arm64_default.yml b/.github/workflows/nix_linux_arm64_default.yml index be06485367..73ce60c4cf 100644 --- a/.github/workflows/nix_linux_arm64_default.yml +++ b/.github/workflows/nix_linux_arm64_default.yml @@ -1,5 +1,5 @@ on: - pull_request: +# pull_request: name: test default.nix on linux arm64 From 35440102e566cf5a9c840178cb081140f5f38830 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 13 Nov 2023 22:19:55 -0500 Subject: [PATCH 014/129] Update /fast --- www/wip_new_website/content/fast.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index 6eaf2cda1a..ec1530ba94 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -6,7 +6,7 @@ Roc code is designed to build fast and run fast...but what does "fast" mean here What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc’s performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what languages Roc should generally outperform. -**Limiting factors: memory management and async I/O.** Part of Roc's design is that it is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. Another part of Roc's design is that I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. +**Limiting factors: automatic memory management and always-async I/O.** Part of Roc's design is that it is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. Another part of Roc's design is that I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. **Faster than dynamic or gradual languages.** As a general rule, Roc programs should have almost strictly less runtime overhead than equivalent programs written in languages with dynamic types and automatic memory management. This doesn't mean all Roc programs will outperform all programs in these languages, just that Roc should have a higher ceiling on what performance is achievable. This is because dynamic typing (and gradual typing) requires tracking types at runtime, which has unavoidable overhead. Roc tracks types only at compile time, and tends to have [minimal (often zero) runtime overhead](https://guide.handmade-seattle.com/c/2021/roc-lang-qa/) for language constructs compared to the top performers in industry. For example, Roc's generics, records, functions, numbers, and tag unions have no more runtime overhead than they would in their Rust or C++ equivalents. @@ -14,15 +14,15 @@ When [benchmarking compiled Roc programs](https://www.youtube.com/watch?v=vzfy4E ### Current Progress -Most of Roc's data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. However, there is plenty of room for further compiler optimizations; current optimizations include only [LLVM](https://llvm.org/), [Morphic](https://www.youtube.com/watch?v=F3z39M0gdJU&t=3547s), and [Perceus](https://www.microsoft.com/en-us/research/uploads/prod/2020/11/perceus-tr-v1.pdf). Promising examples of potential future optimizations include closure-aware [inlining](https://en.wikipedia.org/wiki/Inline_expansion), [automatic deforestation](https://www.cs.tufts.edu/~nr/cs257/archive/duncan-coutts/stream-fusion.pdf), and full [compile-time evaluation](https://en.wikipedia.org/wiki/Constant_folding) of top-level declarations. +Most of Roc's data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. -An open design question is how atomic reference counting should work in the context of platforms. Roc uses automatic reference counting (with some compile-time optimizations) to manage memory, and updating reference counts runs a lot faster if you don't need to guard against [data races](https://en.wikipedia.org/wiki/Race_condition#Data_race). If Roc data structures are shared across threads (which might or might not come up, depending on the platform), then in some cases [atomic](https://en.wikipedia.org/wiki/Linearizability#Primitive_atomic_instructions) reference counting might be necessary, which is slower. +However, there is plenty of room for further compiler optimizations. For example, we have [an implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260)) which gives us stack-allocated closures (among other things). However, the current implementation has run into enough problems that we're planning to switch to the more traditional (but slower) heap-based closures until we can find a way to properly implement polymorphic defunctionalization. (If you're interested in getting involved in finding an implementation of the faster approach that works, [we'd love to hear from you!](https://github.com/roc-lang/roc/issues/5969)) -A design of "always use atomic reference counts" would be unnecessarily slow for platforms where atomicity isn't needed. A design of "never use atomic reference counts" would mean sharing Roc data structures across threads would always require deeply copying the entire data structure (which has worked well for Erlang, but which might not work as well for Roc). It seems likely that the best design is for the compiler to sometimes choose one and sometimes choose the other, but the exact design to go with is currently an open question. +Other current optimizations include [LLVM](https://llvm.org/), [Morphic](https://www.youtube.com/watch?v=F3z39M0gdJU&t=3547s), [Perceus](https://www.microsoft.com/en-us/research/uploads/prod/2020/11/perceus-tr-v1.pdf), and tail recursion optimization (including [modulo cons](https://en.wikipedia.org/wiki/Tail_call#Tail_recursion_modulo_cons)). Promising examples of potential future optimizations include closure-aware [inlining](https://en.wikipedia.org/wiki/Inline_expansion), [automatic deforestation](https://www.cs.tufts.edu/~nr/cs257/archive/duncan-coutts/stream-fusion.pdf), and full [compile-time evaluation](https://en.wikipedia.org/wiki/Constant_folding) of top-level declarations. ## Fast Feedback Loops -The goal is for Roc to provide fast feedback loops by making builds normally feel "instant" except on truly massive projects. It's a concrete goal to have them almost always complete in under 1 second on the median computer being used to write Roc (assuming that system is not bogged down with other programs using up its resources), and ideally under the threshold at which humans typically find latency perceptible (around 100 milliseconds). Hot code loading can make the feedback loop even faster, by letting you see changes without having to restart your program. +One of Roc's goals is to provide fast feedback loops by making builds normally feel "instant" except on truly enormous projects. It's a concrete goal to have them almost always complete in under 1 second on the median computer being used to write Roc (assuming that system is not bogged down with other programs using up its resources), and ideally under the threshold at which humans typically find latency perceptible (around 100 milliseconds). Hot code loading can make the feedback loop even faster, by letting you see changes without having to restart your program. Note that although having fast "clean" builds (without the benefit of caching) is a goal, the "normally feels instant" goal refers to builds where caching was involved. After all, the main downside of build latency is that it comes up over and over in a feedback loop; the initial "clean" build comes up rarely by comparison. @@ -31,20 +31,20 @@ Note that although having fast "clean" builds (without the benefit of caching) i `roc check` type-checks your code and reports problems it finds. `roc build` also does this, but it additionally builds a runnable binary of your program. You may notice that `roc build` takes much longer to complete! This is because of two projects that are underway but not completed yet: -- *Development backend* refers to generating machine code directly instead of asking [LLVM](https://llvm.org/) to generate it. LLVM is great at generating optimized machine code, but it takes a long time to generate it—even if you turn off all the optimizations (and `roc` only has LLVM perform optimizations when the `--optimize` flag is set). The dev backend is currently implemented for WebAssembly, which you can see in the [Web REPL](https://www.roc-lang.org/repl), and in `roc repl` on x64 Linux. Work is underway to implement it for `roc build` and `roc run`, as well as macOS, Windows, and the ARM versions of all of these. -- *Surgical linking* refers to a fast way of combining the platform and application into one binary. Today, this works on Linux, Windows, and WebAssembly. `roc build` on macOS is noticeably slower because it falls back on non-surgical linking. +- *Development backend* refers to generating machine code directly instead of asking [LLVM](https://llvm.org/) to generate it. LLVM is great at generating optimized machine code, but it takes a long time to generate it—even if you turn off all the optimizations (and `roc` only has LLVM perform optimizations when the `--optimize` flag is set). The dev backend is currently implemented for WebAssembly, which you can see in the [Web REPL](https://www.roc-lang.org/repl), and in `roc repl` except on Windows. Work is underway to implement it for `roc build` and `roc run`, as well as macOS, Windows, and the ARM versions of all of these. +- *Surgical linking* refers to a fast way of combining the platform and application into one binary. Today, this works on x64 Linux, x64 Windows, and WebAssembly. `roc build` on macOS is noticeably slower because it falls back on non-surgical linking. Here's a table summarizing the current progress: Target | Dev backend | Surgical linking | ---------------------------|-------------|-------------------| WebAssembly | yes | yes | +macOS ARM (Apple Silicon) | repl only | | +macOS x64 (Intel) | repl only | | +Linux ARM | repl only | | Linux x64 | repl only | yes | Windows x64 | | yes | -macOS Intel (x64) | | | -Linux ARM | | | Windows ARM | | | -macOS Apple Silicon (ARM) | | | Once we have full coverage, `roc build` (and `roc run` and `roc test`, which also perform builds) should take only a bit longer than `roc check`. From 3ada01dafdd9a9cdf449daeee1b79968e8094d7a Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Tue, 14 Nov 2023 11:10:31 +0100 Subject: [PATCH 015/129] sudo musl-tools fix --- ci/build_basic_cli.sh | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/ci/build_basic_cli.sh b/ci/build_basic_cli.sh index 1019d55660..832f6d316f 100755 --- a/ci/build_basic_cli.sh +++ b/ci/build_basic_cli.sh @@ -6,7 +6,13 @@ set -euxo pipefail git clone https://github.com/roc-lang/basic-cli.git if [ "$(uname -s)" == "Linux" ]; then - sudo apt-get install -y musl-tools + + # check if musl-tools is installed + if ! dpkg -l | grep -q musl-tools; then + # install musl-tools with timeout for sudo problems with CI + timeout 300s sudo apt-get install -y musl-tools + fi + cd basic-cli/src # we cd to install the target for the right rust version if [ "$(uname -m)" == "x86_64" ]; then rustup target add x86_64-unknown-linux-musl From 07812329409edaf43b936913ca9f69223842a0d5 Mon Sep 17 00:00:00 2001 From: jecaro Date: Mon, 13 Nov 2023 14:30:08 +0100 Subject: [PATCH 016/129] Set a better error msg for non uft8 encoded files --- crates/reporting/src/error/parse.rs | 40 ++++++++++++++++++----------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/crates/reporting/src/error/parse.rs b/crates/reporting/src/error/parse.rs index 4c754275d1..686840203e 100644 --- a/crates/reporting/src/error/parse.rs +++ b/crates/reporting/src/error/parse.rs @@ -3205,21 +3205,31 @@ fn to_header_report<'a>( let surroundings = Region::new(start, *pos); let region = LineColumnRegion::from_pos(lines.convert_pos(*pos)); - let doc = alloc.stack([ - alloc.reflow(r"I am expecting a header, but got stuck here:"), - alloc.region_with_subregion(lines.convert_region(surroundings), region), - alloc.concat([ - alloc.reflow("I am expecting a module keyword next, one of "), - alloc.keyword("interface"), - alloc.reflow(", "), - alloc.keyword("app"), - alloc.reflow(", "), - alloc.keyword("package"), - alloc.reflow(" or "), - alloc.keyword("platform"), - alloc.reflow("."), - ]), - ]); + let is_utf8 = alloc + .src_lines + .iter() + .all(|line| std::str::from_utf8(line.as_bytes()).is_ok()); + + let preamble = if is_utf8 { + vec![ + alloc.reflow(r"I am expecting a header, but got stuck here:"), + alloc.region_with_subregion(lines.convert_region(surroundings), region), + ] + } else { + vec![alloc.reflow(r"I am expecting a header, but the file is not UTF-8 encoded.")] + }; + + let doc = alloc.stack(preamble.into_iter().chain([alloc.concat([ + alloc.reflow("I am expecting a module keyword next, one of "), + alloc.keyword("interface"), + alloc.reflow(", "), + alloc.keyword("app"), + alloc.reflow(", "), + alloc.keyword("package"), + alloc.reflow(" or "), + alloc.keyword("platform"), + alloc.reflow("."), + ])])); Report { filename, From 88bfc8062636b92ae7b4f6456393a1c38a14096a Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 14 Nov 2023 12:38:09 -0500 Subject: [PATCH 017/129] Update www/wip_new_website/content/fast.md Co-authored-by: Ayaz <20735482+ayazhafiz@users.noreply.github.com> Signed-off-by: Richard Feldman --- www/wip_new_website/content/fast.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index ec1530ba94..e8ce9ce548 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -6,7 +6,7 @@ Roc code is designed to build fast and run fast...but what does "fast" mean here What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc’s performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what languages Roc should generally outperform. -**Limiting factors: automatic memory management and always-async I/O.** Part of Roc's design is that it is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. Another part of Roc's design is that I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. +**Limiting factors: automatic memory management and always-async I/O.** Part of Roc's design is that it is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety based on static analysis rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. Another part of Roc's design is that I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. **Faster than dynamic or gradual languages.** As a general rule, Roc programs should have almost strictly less runtime overhead than equivalent programs written in languages with dynamic types and automatic memory management. This doesn't mean all Roc programs will outperform all programs in these languages, just that Roc should have a higher ceiling on what performance is achievable. This is because dynamic typing (and gradual typing) requires tracking types at runtime, which has unavoidable overhead. Roc tracks types only at compile time, and tends to have [minimal (often zero) runtime overhead](https://guide.handmade-seattle.com/c/2021/roc-lang-qa/) for language constructs compared to the top performers in industry. For example, Roc's generics, records, functions, numbers, and tag unions have no more runtime overhead than they would in their Rust or C++ equivalents. From 0e4b2c66ed87843559bf9dfba7f5765839de0de2 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 14 Nov 2023 12:38:21 -0500 Subject: [PATCH 018/129] Update www/wip_new_website/content/fast.md Co-authored-by: Ayaz <20735482+ayazhafiz@users.noreply.github.com> Signed-off-by: Richard Feldman --- www/wip_new_website/content/fast.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index e8ce9ce548..bceb4cb494 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -16,7 +16,7 @@ When [benchmarking compiled Roc programs](https://www.youtube.com/watch?v=vzfy4E Most of Roc's data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. -However, there is plenty of room for further compiler optimizations. For example, we have [an implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260)) which gives us stack-allocated closures (among other things). However, the current implementation has run into enough problems that we're planning to switch to the more traditional (but slower) heap-based closures until we can find a way to properly implement polymorphic defunctionalization. (If you're interested in getting involved in finding an implementation of the faster approach that works, [we'd love to hear from you!](https://github.com/roc-lang/roc/issues/5969)) +However, there is plenty of room for further compiler optimizations. For example, we have [an implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260)) which gives us stack-allocated closures (among other things). However, the current implementation has run into enough problems that we're planning to switch to the more traditional (but slower) heap-based closures until we can find a way to properly implement guaranteed defunctionalization. (If you're interested in getting involved in finding an implementation of the faster approach that works, [we'd love to hear from you!](https://github.com/roc-lang/roc/issues/5969)) Other current optimizations include [LLVM](https://llvm.org/), [Morphic](https://www.youtube.com/watch?v=F3z39M0gdJU&t=3547s), [Perceus](https://www.microsoft.com/en-us/research/uploads/prod/2020/11/perceus-tr-v1.pdf), and tail recursion optimization (including [modulo cons](https://en.wikipedia.org/wiki/Tail_call#Tail_recursion_modulo_cons)). Promising examples of potential future optimizations include closure-aware [inlining](https://en.wikipedia.org/wiki/Inline_expansion), [automatic deforestation](https://www.cs.tufts.edu/~nr/cs257/archive/duncan-coutts/stream-fusion.pdf), and full [compile-time evaluation](https://en.wikipedia.org/wiki/Constant_folding) of top-level declarations. From d01fc9156c0b50c6909f5625b15f55ff867df0d0 Mon Sep 17 00:00:00 2001 From: Brendan Hansknecht Date: Tue, 14 Nov 2023 18:16:04 -0800 Subject: [PATCH 019/129] add missing traits to RocResult --- crates/roc_std/src/lib.rs | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/crates/roc_std/src/lib.rs b/crates/roc_std/src/lib.rs index 8004d568bc..ec549e461a 100644 --- a/crates/roc_std/src/lib.rs +++ b/crates/roc_std/src/lib.rs @@ -101,6 +101,13 @@ where } } +impl Eq for RocResult +where + T: Eq, + E: Eq, +{ +} + impl PartialEq for RocResult where T: PartialEq, @@ -111,6 +118,37 @@ where } } +impl Ord for RocResult +where + T: Ord, + E: Ord, +{ + fn cmp(&self, other: &Self) -> Ordering { + self.as_result_of_refs().cmp(&other.as_result_of_refs()) + } +} + +impl PartialOrd for RocResult +where + T: PartialOrd, + E: PartialOrd, +{ + fn partial_cmp(&self, other: &Self) -> Option { + self.as_result_of_refs() + .partial_cmp(&other.as_result_of_refs()) + } +} + +impl Hash for RocResult +where + T: Hash, + E: Hash, +{ + fn hash(&self, state: &mut H) { + self.as_result_of_refs().hash(state) + } +} + impl Clone for RocResult where T: Clone, From ad4b9293aa4264fce65b130e6dacea5b9f906d90 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 15 Nov 2023 14:21:34 +0100 Subject: [PATCH 020/129] added flags required for ring (musl) See https://github.com/briansmith/ring/blob/445de2fb9c611d0307e57791bad8205290e3919c/mk/cargo.sh#L70 Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 9af7dface5..df4d6a4f80 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -63,6 +63,9 @@ jobs: - name: build basic-cli env: CARGO_BUILD_TARGET: aarch64-unknown-linux-musl + CC_aarch64_unknown_linux_musl: clang-16 + AR_aarch64_unknown_linux_musl: llvm-ar-16 + CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_RUSTFLAGS: "-Clink-self-contained=yes -Clinker=rust-lld" run: ./ci/build_basic_cli.sh linux_arm64 - name: Save .o file From e5c584b9aa40e214385543aedd151aa3638d9b6a Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 15 Nov 2023 16:25:01 +0100 Subject: [PATCH 021/129] test with all examples Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index df4d6a4f80..e73913707a 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -7,9 +7,10 @@ concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: true -# use .tar.gz for quick testing env: + # use .tar.gz for quick testing ARCHIVE_FORMAT: .tar.gz + BASIC_CLI_BRANCH: main jobs: fetch-releases: @@ -187,24 +188,24 @@ jobs: cd basic-cli-platform && ls | grep "tar" | xargs brotli -d ls | grep "tar$" | xargs tar -xf - - name: prep testing http-get.roc + - name: Install expect for tests if we dont have it yet + run: if ! dpkg -l | grep -qw expect; then sudo apt install -y expect + + - name: prep testing run: | mv roc_nightly basic-cli-platform/. cd basic-cli-platform - mkdir examples - cd examples - curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/examples/http-get.roc - sed -i 's/pf:\ \"[^"]*/pf:\ \"\.\.\/main.roc/g' http-get.roc + mkdir src + find . -maxdepth 1 -type f -exec mv {} src/ \; + + mkdir temp-basic-cli + cd temp-basic-cli + git clone https://github.com/roc-lang/basic-cli.git + git checkout ${{ env.BASIC_CLI_BRANCH }} + cp -r examples .. + cp -r ci .. cd .. - ./roc_nightly/roc build examples/http-get.roc --prebuilt-platform - curl -fOL https://raw.githubusercontent.com/roc-lang/basic-cli/main/ci/expect_scripts/http-get.exp - - - run: sudo apt install -y expect - - - name: execute test - run: | - cd basic-cli-platform - expect http-get.exp + ROC=./roc_nightly/roc EXAMPLES_DIR=./examples ./ci/all_tests.sh From 75591c1275a0ea5a691ecc98d28c032806cd525c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 13 Nov 2023 22:43:53 -0500 Subject: [PATCH 022/129] Update some copy and styles --- www/wip_new_website/content/fast.md | 6 ++++++ www/wip_new_website/content/friendly.md | 8 +++++++- www/wip_new_website/content/functional.md | 2 +- www/wip_new_website/main.roc | 8 +++++++- www/wip_new_website/static/site.css | 5 ++++- 5 files changed, 25 insertions(+), 4 deletions(-) diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index bceb4cb494..30c9d738c6 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -49,3 +49,9 @@ Windows ARM | | | Once we have full coverage, `roc build` (and `roc run` and `roc test`, which also perform builds) should take only a bit longer than `roc check`. The next major performance improvement will be caching. Currently, `roc` always builds everything from scratch. Most of the time, it could benefit from caching some of the work it had done in a previous build, but today it doesn't do that. There's a design for the caching system, but essentially none of the implementation has started yet. Hot code loading will be the next major improvement after caching, but it requires full dev backend coverage, and does not have a concrete design yet. + +## Friendly + +In addition to being fast, Roc also aims to be a friendly programming language. + +[What does _friendly_ mean here?](/wip/friendly) diff --git a/www/wip_new_website/content/friendly.md b/www/wip_new_website/content/friendly.md index cc2cd2201b..94b791b0ed 100644 --- a/www/wip_new_website/content/friendly.md +++ b/www/wip_new_website/content/friendly.md @@ -4,7 +4,7 @@ Roc prioritizes being a user-friendly language. This impacts the syntax, semanti ## Syntax and source code formatter -Roc's syntax isn't trivial, but there also isn't much of it to learn. Its design is generally uncluttered and unambiguous. A goal is that you can normally look at a piece of code and quickly get an accurate mental model of what it means, without having to think through several layers of indirection. Here are some examples: +Roc's syntax isn't trivial, but there also isn't much of it to learn. It's designed to be uncluttered and unambiguous. A goal is that you can normally look at a piece of code and quickly get an accurate mental model of what it means, without having to think through several layers of indirection. Here are some examples: - `x = combine y z` always declares a new constant `x` (Roc has [no mutable variables, reassignment, or shadowing](/functional)) to be whatever the `combine` function returns when passed the arguments `y` and `z`. (Function calls in Roc don't need parentheses or commas.) - `user.email` always accesses the `email` field of a record named `user`. (Roc has no inheritance, subclassing, or proxying.) @@ -70,3 +70,9 @@ In the future, there are plans to add built-in support for [benchmarking](https: - Customizable "linter" (e.g. code mods, project-specific rules to enforce) - Editor plugin ecosystem that works across editors, where plugins ship with packages - `roc edit` + +## Functional + +Besides being designed to be [fast](/wip/fast) and friendly, Roc is also a functional programming language. + +[What does _functional_ mean here?](/wip/functional) diff --git a/www/wip_new_website/content/functional.md b/www/wip_new_website/content/functional.md index 20a56ef278..5076ca6ba6 100644 --- a/www/wip_new_website/content/functional.md +++ b/www/wip_new_website/content/functional.md @@ -120,4 +120,4 @@ Pure functions are notably amenable to compiler optimizations. Roc already takes ## Get started -If this design sounds interesting to you, you can give Roc a try by heading over to the [tutorial](https://www.roc-lang.org/tutorial)! +If this design sounds interesting to you, you can give Roc a try by heading over to the [tutorial](/tutorial)! diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index 016f28573e..ffa2d22ae6 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -56,6 +56,12 @@ view = \page, htmlContent -> else [text htmlContent] + bodyAttrs = + if page == "index.html" then + [id "homepage-main"] + else + [] + html [lang "en", class "no-js"] [ head [] [ meta [charset "utf-8"], @@ -81,7 +87,7 @@ view = \page, htmlContent -> # Otherwise, this will work locally and then fail in production! script [] [text "document.documentElement.className = document.documentElement.className.replace('no-js', '');"], ], - body [] [ + body bodyAttrs [ viewNavbar page, main [] mainBody, footer [] [ diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index f55decc5b3..3538e8728e 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -207,12 +207,15 @@ h2 { font-size: 3rem; border-bottom: 4px solid var(--dark-cyan); margin: 0; - margin-top: 72px; margin-bottom: 36px; padding: 36px 0; color: var(--heading-color); } +#homepage-main h2 { + margin-top: 72px; /* On the homepage, these need to be spaced out more. */ +} + h2 a { color: var(--heading-color); } From 6f3cf80fb6cb44aac8b74df7009eda3d3f2eb9bd Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 13 Nov 2023 22:52:45 -0500 Subject: [PATCH 023/129] Add the word Roc next to the bird in the nav bar --- www/wip_new_website/main.roc | 6 ++++-- www/wip_new_website/static/site.css | 5 +++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index ffa2d22ae6..43947daf3a 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -1,7 +1,7 @@ app "roc-website" packages { pf: "../../examples/static-site-gen/platform/main.roc" } imports [ - pf.Html.{ Node, html, head, body, header, footer, div, main, text, nav, a, link, meta, script }, + pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script }, pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, type, role }, InteractiveExample, ] @@ -107,7 +107,9 @@ viewNavbar = \page -> if isHomepage then div [role "presentation"] [] # This is a spacer for the nav bar else - a [id "nav-home-link", href "/wip/", title "The Roc Programming Language"] [rocLogo] + a + [id "nav-home-link", href "/wip/", title "The Roc Programming Language"] + [rocLogo, span [class "home-link-text"] [text "Roc"]] header [id "top-bar"] [ nav [ariaLabel "primary"] [ diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 3538e8728e..d217016b9f 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -253,6 +253,11 @@ h3 { padding: 4px; } +.home-link-text { + padding: 8px; + font-size: 24px; +} + #top-bar-links { display: flex; } From dcd1b18f5dab835a6a591bc8255619ae5dfc67e2 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 15 Nov 2023 11:09:42 -0500 Subject: [PATCH 024/129] Update some homepage copy --- www/wip_new_website/content/friendly.md | 9 +++++---- www/wip_new_website/content/index.md | 19 ++++++++++++------- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/www/wip_new_website/content/friendly.md b/www/wip_new_website/content/friendly.md index 94b791b0ed..28296a87ff 100644 --- a/www/wip_new_website/content/friendly.md +++ b/www/wip_new_website/content/friendly.md @@ -2,7 +2,7 @@ Roc prioritizes being a user-friendly language. This impacts the syntax, semantics, and tools Roc ships with. -## Syntax and source code formatter +## Syntax and Formatter Roc's syntax isn't trivial, but there also isn't much of it to learn. It's designed to be uncluttered and unambiguous. A goal is that you can normally look at a piece of code and quickly get an accurate mental model of what it means, without having to think through several layers of indirection. Here are some examples: @@ -13,7 +13,7 @@ Roc's syntax isn't trivial, but there also isn't much of it to learn. It's desig Roc also ships with a source code formatter that helps you maintain a consistent style with little effort. The `roc format` command neatly formats your source code according to a common style, and it's designed with the time-saving feature of having no configuration options. This feature saves you all the time that would otherwise be spent debating which stylistic tweaks to settle on! -## Helpful compiler +## Helpful Compiler Roc's compiler is designed to help you out. It does complete type inference across all your code, and the type system is *sound*. This means you'll never get a runtime type mismatch if everything type-checked (including null exceptions; Roc doesn't have the [billion-dollar mistake](https://en.wikipedia.org/wiki/Null_pointer#History)), and you also don't have to write any type annotations for the compiler to be able to infer all the types in your program. @@ -44,7 +44,7 @@ Tip: You can convert between integers and fractions using functions like If you like, you can run a program that has compile-time errors like this. (If the program reaches the error at runtime, it will crash.) This lets you do things like trying out code that's only partially finished, or running tests for one part of your code base while other parts have compile errors. (Note that this feature is only partially completed, and often errors out; it has a ways to go before it works for all compile errors!) -## Serialization inference +## Serialization Inference - Type inference is used for schema inference, but you can also spell it out if you like - Reports errors immediately @@ -64,7 +64,8 @@ In the future, there are plans to add built-in support for [benchmarking](https: - also note: future plan to cache tests so we only re-run tests whose answers could possibly have changed. also maybe note: tests that don't perform I/O are guaranteed not to flake b/c pure functions. -## Future plans +## Future Plans + - Package manager (Currently just URLs, content-hashed to make them immutable) with searchable index and no installation step, global cache of immutable downloads instead of per-project folders (no need to .gitignore anything) - Step debugger with replay - Customizable "linter" (e.g. code mods, project-specific rules to enforce) diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index 57004d183a..26424f4853 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -83,18 +83,23 @@ Here are some examples of how it can be used today. From e6bf12f0b858c481ca7ac0dcd32d8d9012ff4ee3 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 15 Nov 2023 18:59:29 +0100 Subject: [PATCH 025/129] fix if Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index e73913707a..c0f5fa149f 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -189,7 +189,7 @@ jobs: ls | grep "tar$" | xargs tar -xf - name: Install expect for tests if we dont have it yet - run: if ! dpkg -l | grep -qw expect; then sudo apt install -y expect + run: if ! dpkg -l | grep -qw expect; then sudo apt install -y expect; fi - name: prep testing run: | From 51c7ba2def8692e3804d5734303127a71c871c55 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Wed, 15 Nov 2023 19:38:21 +0100 Subject: [PATCH 026/129] fix path issue Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index c0f5fa149f..59d3816fa9 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -201,11 +201,12 @@ jobs: mkdir temp-basic-cli cd temp-basic-cli git clone https://github.com/roc-lang/basic-cli.git + cd basic-cli git checkout ${{ env.BASIC_CLI_BRANCH }} - cp -r examples .. - cp -r ci .. + cp -r examples ../.. + cp -r ci ../.. - cd .. + cd ../.. ROC=./roc_nightly/roc EXAMPLES_DIR=./examples ./ci/all_tests.sh From eebe3c3eb52fdf1625c513967617acab8226e498 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 15 Nov 2023 13:37:58 -0500 Subject: [PATCH 027/129] Don't rely on fixed width for homepage box This is necessary to prevent scrollbars on Windows --- www/wip_new_website/content/index.md | 53 ++++++++++++---------------- www/wip_new_website/static/site.css | 15 +++++--- 2 files changed, 33 insertions(+), 35 deletions(-) diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index 26424f4853..7bbd2f6c8e 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -1,28 +1,13 @@ +
@@ -82,21 +67,27 @@ Roc is a very young language (it doesn’t even have a numbered release yet, jus Here are some examples of how it can be used today. diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index 43947daf3a..f0bf390b64 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -2,7 +2,7 @@ app "roc-website" packages { pf: "../../examples/static-site-gen/platform/main.roc" } imports [ pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script }, - pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, type, role }, + pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, ariaHidden, type, role }, InteractiveExample, ] provides [transformFileContent] to pf @@ -103,23 +103,24 @@ viewNavbar : Str -> Html.Node viewNavbar = \page -> isHomepage = page == "index.html" - homeLink = - if isHomepage then - div [role "presentation"] [] # This is a spacer for the nav bar - else - a - [id "nav-home-link", href "/wip/", title "The Roc Programming Language"] - [rocLogo, span [class "home-link-text"] [text "Roc"]] + homeLinkAttrs = + [id "nav-home-link", href "/wip/", title "The Roc Programming Language Homepage"] + |> List.concat (if isHomepage then [ariaHidden "true"] else []) header [id "top-bar"] [ nav [ariaLabel "primary"] [ - homeLink, + a homeLinkAttrs [rocLogo, span [class "home-link-text"] [text "Roc"]], div [id "top-bar-links"] [ - a [href "/wip/tutorial"] [text "tutorial"], - a [href "/wip/install"] [text "install"], - a [href "/wip/community"] [text "community"], - a [href "/wip/docs"] [text "docs"], - a [href "/wip/donate"] [text "donate"], + span [class "inline-block", role "presentation"] [ + a [href "/wip/tutorial"] [text "tutorial"], + a [href "/wip/install"] [text "install"], + a [href "/wip/examples"] [text "examples"], + ], + span [class "inline-block", role "presentation"] [ + a [href "/wip/community"] [text "community"], + a [href "/wip/docs"] [text "docs"], + a [href "/wip/donate"] [text "donate"], + ], ], ], ] diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 7e5bb174ea..3d035155b7 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -63,6 +63,7 @@ footer { font-size: var(--font-size-normal); padding: 20px; box-sizing: border-box; + margin-top: 48px; } #footer { @@ -70,6 +71,10 @@ footer { margin: 0 auto; } +.inline-block { + display: inline-block; +} + hr { color: var(--primary-1); margin-bottom: 1rem; @@ -228,13 +233,14 @@ h3 { font-size: 1.5rem; } -#top-bar { +#top-bar, #top-bar nav { background-color: var(--gray-bg); +} + +#top-bar { height: var(--top-bar-height); box-sizing: border-box; width: 100%; - /* On iPhone SE, without this, we end up with */ - min-width: 392px; } #top-bar nav { @@ -246,12 +252,16 @@ h3 { } #nav-home-link { - display: flex; + display: inline-block; color: var(--top-bar-fg); font-size: 1.8rem; padding: 4px; } +#homepage-main #nav-home-link { + visibility: hidden; +} + .home-link-text { padding: 8px; font-size: 24px; @@ -261,16 +271,11 @@ h3 { margin-bottom: 4px; } -#top-bar-links { - display: flex; -} - #top-bar-links a, #top-bar-links label { box-sizing: border-box; color: var(--top-bar-fg); - font-size: var(--font-size-normal); - display: block; + display: inline-block; height: var(--top-bar-height); padding: 12px 16px; margin: 0 2px; @@ -322,7 +327,7 @@ a:visited code { pre { position: relative; margin-bottom: 16px; - padding: 8px 16px; + padding: 0 0.35rem; box-sizing: border-box; background-color: var(--gray-bg); overflow-x: hidden; @@ -505,7 +510,18 @@ li { @media only screen and (max-width: 1024px) { :root { --font-size-normal: 16px; + --body-max-width: 1024px; } + + #homepage-logo { + /* The bird runs off the screen unless we shrink it */ + height: 80px; + width: auto; + position: absolute; + left: 227px; + top: -28px; + } + /* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile. */ .desktop { display: none; @@ -524,6 +540,10 @@ li { padding: 12px 0; } + .home-link-text { + display: none; /* Don't show "Roc" in the header next to the logo, to save space */ + } + h1 code, h2 code, h3 code, @@ -558,14 +578,9 @@ li { text-align: left; } - #homepage-logo { - height: 116px; - left: 262px; - top: -14px; - } - #first-code-sample { margin: 64px auto; + margin-bottom: 0; } #homepage-tagline { @@ -626,7 +641,8 @@ li { #top-bar-links a, #top-bar-links label { - padding: 12px 8px; + font-size: 1.2rem; + padding: 12px 0.5rem; margin: 0; } @@ -636,14 +652,16 @@ li { } /* iPhone SE and similar */ -@media only screen and (max-width: 350px) { +@media only screen and (max-width: 320px) { #homepage-logo { /* The bird runs off the screen unless we shrink it */ - height: 75px; - width: auto; - position: absolute; - left: 227px; - top: -14px; + left: 188px; + top: -30px; + } + + :root { + --font-size-normal: 14px; + --body-max-width: 320px; } } From b9c7a357bcda8ee4e4f353c80ad211687cb20272 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 15 Nov 2023 22:00:00 -0500 Subject: [PATCH 042/129] Fix more mobile layout and copy --- README.md | 2 +- www/wip_new_website/InteractiveExample.roc | 4 ++-- www/wip_new_website/content/index.md | 8 ++++---- www/wip_new_website/static/site.css | 19 ++++++++++++++----- 4 files changed, 21 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 43415008e7..bd88afac66 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ We are very grateful for our corporate sponsors [Vendr](https://www.vendr.com/), If you would like your company to become a corporate sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383)! -We'd also like to express our gratitude to each and every one of our fantastic [GitHub sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more: +We'd also like to express our gratitude to our generous [individual sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more: * [James Birtles](https://github.com/jamesbirtles) * [Ivo Balbaert](https://github.com/Ivo-Balbaert) diff --git a/www/wip_new_website/InteractiveExample.roc b/www/wip_new_website/InteractiveExample.roc index 33687444e0..9072b30a1c 100644 --- a/www/wip_new_website/InteractiveExample.roc +++ b/www/wip_new_website/InteractiveExample.roc @@ -77,9 +77,9 @@ view = samp [] [text output], ], p [] [ - text "To get started learning the language, try the ", + text "To get started with the language, try the ", a [href "/tutorial"] [text "tutorial"], - text " next!", + text "!", ], p [id "final-tutorial-link"] [ a [class "btn-small", href "/tutorial"] [text "Start Tutorial"] diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index 0ab3dfdd18..3e1a0a2d62 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -14,7 +14,7 @@ @@ -29,7 +29,7 @@

Functional

- Roc has a small number of simple language primitives. It’s a single-paradigm functional language.

+ Roc has a small number of simple language primitives. It’s a single-paradigm functional language.

What does functional mean here?

 @@ -138,7 +138,7 @@ We are very grateful for our corporate sponsors [Vendr](https://www.vendr.com/), If you would like your company to become a corporate sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383)! -We'd also like to express our gratitude to each and every one of our fantastic [GitHub sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more: +We'd also like to express our gratitude to our generous [individual sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more:
  • Aaron White
    • @@ -154,7 +154,7 @@ We'd also like to express our gratitude to each and every one of our fantastic [
  • Zeljko Nesic
-Thank you all so much for helping Roc progress! 💜 +Thank you all for your contributions! Roc would not be what it is without your generosity. 💜 We are currently trying to raise $4,000 USD/month in donations to fund one longtime Roc contributor to continue his work on Roc full-time. We are a small group trying to do big things, and every donation helps! You can donate using: - [GitHub Sponsors](https://github.com/sponsors/roc-lang) diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 3d035155b7..761e632647 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -63,7 +63,7 @@ footer { font-size: var(--font-size-normal); padding: 20px; box-sizing: border-box; - margin-top: 48px; + margin-top: 24px; } #footer { @@ -152,7 +152,7 @@ hr { #sponsor-logos .logo-tweede-golf { position: relative; top: 18px; - height: 76px; + height: 4rem; } #sponsor-logos + p { @@ -507,10 +507,10 @@ li { } /* Mobile-friendly screen width */ -@media only screen and (max-width: 1024px) { +@media only screen and (max-width: 1023px) { :root { --font-size-normal: 16px; - --body-max-width: 1024px; + --body-max-width: none; } #homepage-logo { @@ -522,6 +522,15 @@ li { top: -28px; } + #sponsor-logos { + padding: 4px; + } + + .home-examples-column { + padding-right: 0 !important; + border-right: none !important; + } + /* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile. */ .desktop { display: none; @@ -900,7 +909,7 @@ code .dim { display: flex; flex-direction: row; justify-content: space-between; - gap: 48px; + gap: 45px; width: 100%; } From 7523e0702c5004a750a6838885cddf62eb4686d3 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 15 Nov 2023 22:03:55 -0500 Subject: [PATCH 043/129] Add a CSS hack to fix mobile --- www/wip_new_website/static/site.css | 1 + 1 file changed, 1 insertion(+) diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 761e632647..9c2cff055c 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -50,6 +50,7 @@ body { width: 100%; height: 100%; box-sizing: border-box; + overflow-x: hidden; /* This shouldn't be necessary, but without it, mobile has a right gutter. */ } p { From 3509d6c66653a72b494080da7319d4117c4f6e58 Mon Sep 17 00:00:00 2001 From: John Murray <5672686+JRMurr@users.noreply.github.com> Date: Wed, 15 Nov 2023 23:30:15 -0500 Subject: [PATCH 044/129] don't use flakehub input for flake-compat and update a comment --- default.nix | 10 +++++----- flake.lock | 12 +++++++----- flake.nix | 5 ++++- rust-toolchain.toml | 1 - 4 files changed, 16 insertions(+), 12 deletions(-) diff --git a/default.nix b/default.nix index f620865d28..f05dbb5e43 100644 --- a/default.nix +++ b/default.nix @@ -1,10 +1,10 @@ (import ( - let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in - fetchTarball { - url = lock.nodes.flake-compat.locked.url or "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz"; + let lock = builtins.fromJSON (builtins.readFile ./flake.lock); + in fetchTarball { + url = + "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz"; sha256 = lock.nodes.flake-compat.locked.narHash; } ) - { src = ./.; } -).defaultNix + { src = ./.; }).defaultNix diff --git a/flake.lock b/flake.lock index bc872cbc49..e0c185ee01 100644 --- a/flake.lock +++ b/flake.lock @@ -1,17 +1,19 @@ { "nodes": { "flake-compat": { + "flake": false, "locked": { "lastModified": 1696426674, "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", - "revCount": 57, - "type": "tarball", - "url": "https://api.flakehub.com/f/pinned/edolstra/flake-compat/1.0.1/018afb31-abd1-7bff-a5e4-cff7e18efb7a/source.tar.gz" + "type": "github" }, "original": { - "type": "tarball", - "url": "https://flakehub.com/f/edolstra/flake-compat/1.tar.gz" + "owner": "edolstra", + "repo": "flake-compat", + "type": "github" } }, "flake-utils": { diff --git a/flake.nix b/flake.nix index 499897d34a..e66c73a75a 100644 --- a/flake.nix +++ b/flake.nix @@ -20,7 +20,10 @@ }; # for non flake backwards compatibility - flake-compat.url = "https://flakehub.com/f/edolstra/flake-compat/1.tar.gz"; + flake-compat = { + url = "github:edolstra/flake-compat"; + flake = false; + }; }; outputs = { self, nixpkgs, rust-overlay, flake-utils, nixgl, ... }@inputs: diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 8cd4a6e17d..48dc4f568a 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -9,7 +9,6 @@ # - update nightly-OLD_DATE in .github/workflows/windows_tests.yml # - update nightly-OLD_DATE in .github/workflows/windows_release_build.yml # - update nightly-OLD_DATE in crates/compiler/build/src/link.rs -# - Follow instructions in default.nix: `assert pkgs.lib.assertMsg rustVersionsMatch` ... channel = "1.71.1" # check ^^^ when changing this # From 2c21c7adf1e3467e2410c3ffd575efa62be26664 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 06:51:30 -0500 Subject: [PATCH 045/129] Remove var(--top-bar-height) --- www/wip_new_website/static/site.css | 3 --- 1 file changed, 3 deletions(-) diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 9c2cff055c..1647e2228f 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -32,7 +32,6 @@ --font-size-normal: 18px; --body-max-width: 1024px; - --top-bar-height: 50px; --dark-code-bg: #202746; } @@ -239,7 +238,6 @@ h3 { } #top-bar { - height: var(--top-bar-height); box-sizing: border-box; width: 100%; } @@ -277,7 +275,6 @@ h3 { box-sizing: border-box; color: var(--top-bar-fg); display: inline-block; - height: var(--top-bar-height); padding: 12px 16px; margin: 0 2px; } From 97e28ae506e443b4c4d6212188ffbc22f541f33a Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 07:08:54 -0500 Subject: [PATCH 046/129] Fix overlapping issue on interactive example --- www/wip_new_website/InteractiveExample.roc | 30 +++++----------------- 1 file changed, 6 insertions(+), 24 deletions(-) diff --git a/www/wip_new_website/InteractiveExample.roc b/www/wip_new_website/InteractiveExample.roc index 9072b30a1c..29e7382788 100644 --- a/www/wip_new_website/InteractiveExample.roc +++ b/www/wip_new_website/InteractiveExample.roc @@ -18,23 +18,6 @@ Token : [ view : Html.Node view = output = - # # Select anything here to see an explanation. - # main = - # Path.fromStr "url.txt" - # |> storeEmail - # |> Task.onErr handleErr - # - # storeEmail = \filename -> - # url <- File.readUtf8 filename |> Task.await - # { name, email } <- Http.get url Json.codec |> Task.await - # - # File.writeUtf8 (Path.fromStr "\(name).txt") email - # - # handleUrl = \err -> - # when err is - # HttpErr url _ -> Stderr.line "Error fetching URL \(url)" - # FileReadErr path _ -> Stderr.line "Error reading \(Path.display path)" - # FileWriteErr path _ -> Stderr.line "Error writing \(Path.display path)" sectionsToStr [ Desc [Comment "Click anything here to see an explanation.Tap anything here to\n# see an explanation."] "

Comments in Roc begin with a # and go to the end of the line.

", Newline, @@ -44,21 +27,20 @@ view = Newline, Desc [Kw "|>", Ident "storeEmail"] "

The pipe operator (|>) is syntax sugar for passing the previous value to the next function in the “pipeline.”

This line takes the value that Path.fromStr \"url.txt\" returns and passes it to storeEmail.

The next |> continues the pipeline.

", Newline, - Desc [Kw "|>", Ident "Task.onErr", Ident "handleErr"] "

If the task returned by the previous step in the pipeline fails, pass its error to handleErr.

The pipeline essentially does this:

val1 = Path.fromStr \"url.txt\"\nval2 = storeEmail val1\n\nTask.onErr val2 handleErr

It creates a Path from a string, stores an email based on that path, and then does error handling.

", + Desc [Kw "|>", Ident "Task.onErr", Ident "handleErr"] "

If the task returned by the previous step in the pipeline fails, pass its error to handleErr.

The pipeline essentially does this:

a = Path.fromStr \"url.txt\"\nb = storeEmail a\n\nTask.onErr b handleErr

It creates a Path from a string, stores an email based on that path, and then does error handling.

", Outdent, Newline, - Desc [Ident "storeEmail", Kw "=", Lambda ["filename"]] "

This defines a function named storeEmail.

In Roc, functions are ordinary values, so we assign names to them using = like with any other value.

The \\arg1, arg2 -> syntax begins a function, and the part after -> is the function's body.

", + Desc [Ident "storeEmail", Kw "=", Lambda ["path"]] "

This defines a function named storeEmail. It takes one argument, named path.

In Roc, functions are ordinary values, so we assign names to them using = like with any other value.

The \\arg1, arg2 -> syntax begins a function, and the part after -> is the function's body.

", Indent, - Desc [Ident "url", Kw "<-", Ident "File.readUtf8", Ident "filename", Kw "|>", Ident "Task.await"] "

This reads the contents of the file (as a UTF-8 string) into url.

The <- does backpassing, which is syntax sugar for defining a function. This line desugars to:

Task.await\n    (File.readUtf8 filename)\n    \\url ->

The lines after this one form the body of the \\url -> callback, which runs if the file read succeeds.

", + Desc [Ident "url", Kw "<-", Ident "File.readUtf8", Ident "path", Kw "|>", Ident "Task.await"] "

This reads the contents of the file (as a UTF-8 string) into url.

The <- does backpassing, which is syntax sugar for defining a function. This line desugars to:

Task.await\n    (File.readUtf8 path)\n    \\url ->

The lines after this one form the body of the \\url -> callback, which runs if the file read succeeds.

", Newline, Desc [Ident "user", Kw "<-", Ident "Http.get", Ident "url", Ident "Json.codec", Kw "|>", Ident "Task.await"] "

This fetches the contents of the URL and decodes them as JSON.

If the shape of the JSON isn’t compatible with the type of user (based on type inference), this will give a decoding error immediately.

As with all the other lines ending in |> Task.await, if there’s an error, nothing else in storeEmail will be run, and handleErr will end up handling the error.

", Newline, - Desc [Ident "dest", Kw "=", StrInterpolation "\"" "user.name" ".txt\""] "

The \\(user.name) in this string literal will be replaced with the value in name. This is string interpolation.

Note that this line doesn't end with |> Task.await. Earlier lines needed that because they were I/O tasks, but this is a plain old definition, so there's no task to await.

", + Desc [Ident "dest", Kw "=", Ident "Path.fromStr", StrInterpolation "\"" "user.name" ".txt\""] "

The \\(user.name) in this string literal will be replaced with the value in name. This is string interpolation.

Note that this line doesn't end with |> Task.await. Earlier lines needed that because they were I/O tasks, but this is a plain old definition, so there's no task to await.

", Newline, - Desc [Literal "_"] "

In Roc, if you don’t want to bother naming something, you can always choose the name _.

You can name as many things as you like _, but you can never reference anything named _.

So it’s only useful for when you don’t want to choose a name.

", - Desc [Kw "<-", Ident "File.writeUtf8", ParensAround [Ident "Path.fromStr dest"], Ident "user.email", Kw "|>", Ident "Task.await"] "

This writes the user.email string to the file encoded as UTF-8.

The parentheses here show where the nested call to Path.fromStr begins and ends.

", + Desc [Literal "_", Kw "<-", Ident "File.writeUtf8", Ident "dest", Ident "user.email", Kw "|>", Ident "Task.await"] "

This writes user.email to the file, encoded as UTF-8.

We won’t be using the output of writeUtf8, so we name it _. The special name _ is for when you don’t want to use something.

You can name as many things as you like _, but you can never reference anything named _. So it’s only useful for when you don’t want to choose a name.

", Newline, - Desc [Ident "Stdout.line", StrInterpolation "\"Wrote email to " "dest" "\""] "

This prints what we did to stdout.

Note that this line doesn't end with |> Task.await. That’s because, although Stdout.line returns a task, we don’t need to await it because nothing happens after it.

", + Desc [Ident "Stdout.line", StrInterpolation "\"Wrote email to " "Path.display dest" "\""] "

This prints what we did to stdout.

Note that this line doesn't end with |> Task.await. That’s because, although Stdout.line returns a task, we don’t need to await it because nothing happens after it.

", Outdent, Newline, Desc [Ident "handleErr", Kw "=", Lambda ["err"]] "

Like storeEmail, handleErr is also a function.

Although type annotations are optional everywhere in Roc—because the language has 100% type inference—you could add type annotations to main, storeEmail, and handleErr if you wanted to.

", From 34774dc903cc2c491f4099c6be2e9370899de4c2 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 08:05:18 -0500 Subject: [PATCH 047/129] Fix some placeholder wrapping --- www/public/repl/repl.js | 2 +- www/wip_new_website/content/index.md | 2 +- www/wip_new_website/static/repl.css | 4 ++-- www/wip_new_website/static/site.js | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/www/public/repl/repl.js b/www/public/repl/repl.js index cc19037b46..42b3bc821b 100644 --- a/www/public/repl/repl.js +++ b/www/public/repl/repl.js @@ -44,7 +44,7 @@ repl.elemSourceInput.addEventListener("keyup", onInputKeyup); roc_repl_wasm.default("/repl/roc_repl_wasm_bg.wasm").then(async (instance) => { repl.elemHistory.querySelector("#loading-message").remove(); repl.elemSourceInput.disabled = false; - repl.elemSourceInput.placeholder = "Type some Roc code and press Enter."; + repl.elemSourceInput.placeholder = "Enter some Roc code here."; repl.elemSourceInput.focus(); repl.compiler = instance; diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index 3e1a0a2d62..b740dbf9bf 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -54,7 +54,7 @@
- + diff --git a/www/wip_new_website/static/repl.css b/www/wip_new_website/static/repl.css index c238cd0d8c..fa40b96bae 100644 --- a/www/wip_new_website/static/repl.css +++ b/www/wip_new_website/static/repl.css @@ -8,8 +8,8 @@ #repl-prompt { position: relative; left: 16px; - top: 25px; - line-height: 16px; + top: 1.25rem; + font-size: 1.25rem; height: 0; z-index: 2; font-family: var(--font-mono); diff --git a/www/wip_new_website/static/site.js b/www/wip_new_website/static/site.js index 3e5fda0d78..7716fe45aa 100644 --- a/www/wip_new_website/static/site.js +++ b/www/wip_new_website/static/site.js @@ -72,7 +72,7 @@ roc_repl_wasm.default("/wip/roc_repl_wasm_bg.wasm").then(async (instance) => { loadingMessage.remove(); } - repl.elemSourceInput.placeholder = "Type some Roc code and press Enter."; + repl.elemSourceInput.placeholder = "Enter some Roc code here."; repl.compiler = instance; // Get help text from the compiler, and display it at top of the history panel From 2ffbc5596dd99c36dccf28215664f723c0e926d6 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 08:26:54 -0500 Subject: [PATCH 048/129] Display nav links in grid on mobile --- www/wip_new_website/main.roc | 18 ++++++-------- www/wip_new_website/static/site.css | 37 +++++++++++++++++++++++------ 2 files changed, 37 insertions(+), 18 deletions(-) diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index f0bf390b64..aedbe3aaa5 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -2,7 +2,7 @@ app "roc-website" packages { pf: "../../examples/static-site-gen/platform/main.roc" } imports [ pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script }, - pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, ariaHidden, type, role }, + pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, ariaHidden, type }, InteractiveExample, ] provides [transformFileContent] to pf @@ -111,16 +111,12 @@ viewNavbar = \page -> nav [ariaLabel "primary"] [ a homeLinkAttrs [rocLogo, span [class "home-link-text"] [text "Roc"]], div [id "top-bar-links"] [ - span [class "inline-block", role "presentation"] [ - a [href "/wip/tutorial"] [text "tutorial"], - a [href "/wip/install"] [text "install"], - a [href "/wip/examples"] [text "examples"], - ], - span [class "inline-block", role "presentation"] [ - a [href "/wip/community"] [text "community"], - a [href "/wip/docs"] [text "docs"], - a [href "/wip/donate"] [text "donate"], - ], + a [href "/wip/tutorial"] [text "tutorial"], + a [href "/wip/install"] [text "install"], + a [href "/wip/examples"] [text "examples"], + a [href "/wip/community"] [text "community"], + a [href "/wip/docs"] [text "docs"], + a [href "/wip/donate"] [text "donate"], ], ], ] diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 1647e2228f..edd5e58304 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -71,9 +71,6 @@ footer { margin: 0 auto; } -.inline-block { - display: inline-block; -} hr { color: var(--primary-1); @@ -220,6 +217,10 @@ h2 { margin-top: 60px; /* On the homepage, these need to be spaced out more. */ } +#homepage-main #nav-home-link { + visibility: hidden; +} + h2 a { color: var(--heading-color); } @@ -257,13 +258,11 @@ h3 { padding: 4px; } -#homepage-main #nav-home-link { - visibility: hidden; -} - .home-link-text { padding: 8px; font-size: 24px; + position: relative; + top: -0.6rem; } .home-examples-title { @@ -520,6 +519,10 @@ li { top: -28px; } + #homepage-main #nav-home-link { + display: none; + } + #sponsor-logos { padding: 4px; } @@ -646,6 +649,26 @@ li { font-size: 2rem !important; } + #top-bar-links { + width: 100%; + display: grid; + grid-template-columns: 1fr 1fr 1fr; /* Three equal-width columns */ + grid-template-rows: auto auto; /* Two rows */ + } + + /* Left-align the first link in each row, right-align the last one, and center the middle one. */ + #top-bar-links > :nth-child(3n+1) { + text-align: left; + } + + #top-bar-links > :nth-child(3n+2) { + text-align: center; + } + + #top-bar-links > :nth-child(3n+3) { + text-align: right; + } + #top-bar-links a, #top-bar-links label { font-size: 1.2rem; From c858031f744371396b198002a2f09ad516db0e43 Mon Sep 17 00:00:00 2001 From: jecaro Date: Thu, 16 Nov 2023 16:44:55 +0100 Subject: [PATCH 049/129] Show the right fct name in type error messages --- crates/compiler/constrain/src/expr.rs | 1 + crates/compiler/module/src/called_via.rs | 9 +++ crates/compiler/types/src/types.rs | 1 + crates/repl_test/src/tests.rs | 86 ++++++++++++++++++++++-- crates/reporting/src/error/type.rs | 24 +++++-- crates/reporting/src/report.rs | 17 ++++- 6 files changed, 125 insertions(+), 13 deletions(-) diff --git a/crates/compiler/constrain/src/expr.rs b/crates/compiler/constrain/src/expr.rs index a520d924a9..9b69c8497f 100644 --- a/crates/compiler/constrain/src/expr.rs +++ b/crates/compiler/constrain/src/expr.rs @@ -502,6 +502,7 @@ pub fn constrain_expr( let reason = Reason::FnArg { name: opt_symbol, arg_index: HumanIndex::zero_based(index), + called_via: *called_via, }; let expected_arg = constraints.push_expected_type(ForReason(reason, arg_type_index, region)); diff --git a/crates/compiler/module/src/called_via.rs b/crates/compiler/module/src/called_via.rs index ac72ca8d62..3cb7394be1 100644 --- a/crates/compiler/module/src/called_via.rs +++ b/crates/compiler/module/src/called_via.rs @@ -102,6 +102,15 @@ pub enum UnaryOp { Not, } +impl std::fmt::Display for UnaryOp { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + UnaryOp::Negate => write!(f, "-"), + UnaryOp::Not => write!(f, "!"), + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum BinOp { // highest precedence diff --git a/crates/compiler/types/src/types.rs b/crates/compiler/types/src/types.rs index 39b6349da3..e7fc675b25 100644 --- a/crates/compiler/types/src/types.rs +++ b/crates/compiler/types/src/types.rs @@ -3370,6 +3370,7 @@ pub enum Reason { FnArg { name: Option, arg_index: HumanIndex, + called_via: CalledVia, }, TypedArg { name: Option, diff --git a/crates/repl_test/src/tests.rs b/crates/repl_test/src/tests.rs index 39a0d37038..f7816f0a30 100644 --- a/crates/repl_test/src/tests.rs +++ b/crates/repl_test/src/tests.rs @@ -658,17 +658,17 @@ fn too_few_args() { #[cfg(not(feature = "wasm"))] // TODO: mismatch is due to terminal control codes! #[test] -fn type_problem() { +fn type_problem_function() { expect_failure( - "1 + \"\"", + "Num.add 1 \"not a num\"", indoc!( r#" ── TYPE MISMATCH ─────────────────────────────────────────────────────────────── This 2nd argument to add has an unexpected type: - 4│ 1 + "" - ^^ + 4│ Num.add 1 "not a num" + ^^^^^^^^^^^ The argument is a string of type: @@ -682,6 +682,84 @@ fn type_problem() { ); } +#[cfg(not(feature = "wasm"))] // TODO: mismatch is due to terminal control codes! +#[test] +fn type_problem_binary_operator() { + expect_failure( + "1 + \"\"", + indoc!( + r#" + ── TYPE MISMATCH ─────────────────────────────────────────────────────────────── + + This 2nd argument to + has an unexpected type: + + 4│ 1 + "" + ^^ + + The argument is a string of type: + + Str + + But + needs its 2nd argument to be: + + Num * + "# + ), + ); +} + +#[cfg(not(feature = "wasm"))] // TODO: mismatch is due to terminal control codes! +#[test] +fn type_problem_unary_operator() { + expect_failure( + "!\"not a bool\"", + indoc!( + r#" + ── TYPE MISMATCH ─────────────────────────────────────────────────────────────── + + This 1st argument to ! has an unexpected type: + + 4│ !"not a bool" + ^^^^^^^^^^^^ + + The argument is a string of type: + + Str + + But ! needs its 1st argument to be: + + Bool + "# + ), + ); +} + +#[cfg(not(feature = "wasm"))] // TODO: mismatch is due to terminal control codes! +#[test] +fn type_problem_string_interpolation() { + expect_failure( + "\"This is not a string -> \\(1)\"", + indoc!( + r#" + ── TYPE MISMATCH ─────────────────────────────────────────────────────────────── + + This argument to this string interpolation has an unexpected type: + + 4│ "This is not a string -> \(1)" + ^ + + The argument is a number of type: + + Num * + + But this string interpolation needs its argument to be: + + Str + "# + ), + ); +} + #[test] fn issue_2149_i8_ok() { expect_success(r#"Str.toI8 "127""#, "Ok 127 : Result I8 [InvalidNumStr]"); diff --git a/crates/reporting/src/error/type.rs b/crates/reporting/src/error/type.rs index b3a7e4676d..e4b2ca711e 100644 --- a/crates/reporting/src/error/type.rs +++ b/crates/reporting/src/error/type.rs @@ -1273,12 +1273,24 @@ fn to_expr_report<'b>( } } }, - Reason::FnArg { name, arg_index } => { + Reason::FnArg { + name, + arg_index, + called_via, + } => { let ith = arg_index.ordinal(); - let this_function = match name { - None => alloc.text("this function"), - Some(symbol) => alloc.symbol_unqualified(symbol), + let this_function = match (called_via, name) { + (CalledVia::Space, Some(symbole)) => alloc.symbol_unqualified(symbole), + (CalledVia::BinOp(op), _) => alloc.binop(op), + (CalledVia::UnaryOp(op), _) => alloc.unop(op), + (CalledVia::StringInterpolation, _) => alloc.text("this string interpolation"), + _ => alloc.text("this function"), + }; + + let argument = match called_via { + CalledVia::StringInterpolation => "argument".to_string(), + _ => format!("{ith} argument"), }; report_mismatch( @@ -1292,7 +1304,7 @@ fn to_expr_report<'b>( region, Some(expr_region), alloc.concat([ - alloc.string(format!("This {ith} argument to ")), + alloc.string(format!("This {argument} to ")), this_function.clone(), alloc.text(" has an unexpected type:"), ]), @@ -1300,7 +1312,7 @@ fn to_expr_report<'b>( alloc.concat([ alloc.text("But "), this_function, - alloc.string(format!(" needs its {ith} argument to be:")), + alloc.string(format!(" needs its {argument} to be:")), ]), None, ) diff --git a/crates/reporting/src/report.rs b/crates/reporting/src/report.rs index 386c0d5100..cb86c5eac7 100644 --- a/crates/reporting/src/report.rs +++ b/crates/reporting/src/report.rs @@ -490,6 +490,13 @@ impl<'a> RocDocAllocator<'a> { self.text(content.to_string()).annotate(Annotation::BinOp) } + pub fn unop( + &'a self, + content: roc_module::called_via::UnaryOp, + ) -> DocBuilder<'a, Self, Annotation> { + self.text(content.to_string()).annotate(Annotation::UnaryOp) + } + /// Turns off backticks/colors in a block pub fn type_block( &'a self, @@ -843,6 +850,7 @@ pub enum Annotation { Structure, Symbol, BinOp, + UnaryOp, Error, GutterBar, LineNumber, @@ -1027,6 +1035,9 @@ where BinOp => { self.write_str(self.palette.alias)?; } + UnaryOp => { + self.write_str(self.palette.alias)?; + } Symbol => { self.write_str(self.palette.variable)?; } @@ -1075,9 +1086,9 @@ where match self.style_stack.pop() { None => {} Some(annotation) => match annotation { - Emphasized | Url | TypeVariable | Alias | Symbol | BinOp | Error | GutterBar - | Ellipsis | Typo | TypoSuggestion | ParserSuggestion | Structure | CodeBlock - | PlainText | LineNumber | Tip | Module | Header | Keyword => { + Emphasized | Url | TypeVariable | Alias | Symbol | BinOp | UnaryOp | Error + | GutterBar | Ellipsis | Typo | TypoSuggestion | ParserSuggestion | Structure + | CodeBlock | PlainText | LineNumber | Tip | Module | Header | Keyword => { self.write_str(self.palette.reset)?; } From 1369caee6aad8188f59f3503cdb5a9f004b53c3a Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 16:46:16 -0500 Subject: [PATCH 050/129] Update /fast /friendly and /functional --- www/wip_new_website/content/fast.md | 71 ++++++++---- www/wip_new_website/content/friendly.md | 101 ++++++++++------- www/wip_new_website/content/functional.md | 126 +++++++++++++--------- www/wip_new_website/content/index.md | 14 +-- www/wip_new_website/main.roc | 2 +- www/wip_new_website/static/site.css | 37 +++++-- 6 files changed, 219 insertions(+), 132 deletions(-) diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index 1c102de273..1ef6706f46 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -1,52 +1,77 @@ # Fast -Roc code is designed to build fast and run fast...but what does "fast" mean here? And how close is Roc's curent implementation to realizing that design goal? +Roc code is designed to build fast and run fast...but what does "fast" mean here? And how close is Roc's curent implementation to realizing that goal? -## Fast Programs +## [Fast programs](#fast-programs) {#fast-programs} -What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc’s performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what languages Roc should generally outperform. +What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc’s performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what types of languages Roc should generally outperform. -**Limiting factors: automatic memory management and always-async I/O.** Part of Roc's design is that it is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety based on static analysis rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. Another part of Roc's design is that I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. +### [Limiting factors: memory management and async I/O](#limiting-factors) {#limiting-factors} -**Faster than dynamic or gradual languages.** As a general rule, Roc programs should have almost strictly less runtime overhead than equivalent programs written in languages with dynamic types and automatic memory management. This doesn't mean all Roc programs will outperform all programs in these languages, just that Roc should have a higher ceiling on what performance is achievable. This is because dynamic typing (and gradual typing) requires tracking types at runtime, which has unavoidable overhead. Roc tracks types only at compile time, and tends to have [minimal (often zero) runtime overhead](https://guide.handmade-seattle.com/c/2021/roc-lang-qa/) for language constructs compared to the top performers in industry. For example, Roc's generics, records, functions, numbers, and tag unions have no more runtime overhead than they would in their Rust or C++ equivalents. +Roc is a [memory-safe](https://en.wikipedia.org/wiki/Memory_safety) language with [automatic memory management](https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Reference_counting). Automatic memory management has some unavoidable runtime overhead, and memory safety based on static analysis rules out certain performance optimizations—which is why [unsafe Rust](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) can outperform safe Rust. This gives Roc a lower performance ceiling than languages which support memory unsafety and manual memory management, such as C, C++, Zig, and Rust. -When [benchmarking compiled Roc programs](https://www.youtube.com/watch?v=vzfy4EKwG_Y), the normal goal is to have them outperform the fastest mainstream garbage-collected languages (for example, Go, C#, Java, and JavaScript), but it's a non-goal to outperform languages that support memory unsafety or manual memory management. There will always be some individual benchmarks where mainstream garbage-collected languages outperform Roc, but the goal is for these to be uncommon cases rather than the norm. +Another part of Roc's design is that all I/O operations are done using a lightweight state machine so that they can be asynchronous. This has potential performance benefits compared to synchronous I/O, but it also has some unavoidable overhead. -### Current Progress +### [Generally faster than dynamic or gradual languages](#faster-than) {#faster-than} -Most of Roc's data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. +As a general rule, Roc programs should have almost strictly less runtime overhead than equivalent programs written in languages with dynamic types and automatic memory management. This doesn't mean all Roc programs will outperform all programs in these languages, but it does mean Roc should have a higher ceiling on what performance is achievable. -That said, [our implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260))—which gives us stack-allocated closures, among other optimizations—has several known gaps, and has ways to go before it works across the board. (If you're interested in getting involved in that implementation, [we'd love to hear from you!](https://github.com/roc-lang/roc/issues/5969)) +This is because dynamic typing (and gradual typing) requires tracking types at runtime, which has overhead. Roc tracks types only at compile time, and tends to have [minimal (often zero) runtime overhead](https://vimeo.com/653510682) for language constructs compared to the top performers in industry. For example, Roc's generics, records, functions, numbers, and tag unions have no more runtime overhead than they would in their Rust or C++ equivalents. + +When [benchmarking compiled Roc programs](https://www.youtube.com/watch?v=vzfy4EKwG_Y), the goal is to have them normally outperform the fastest mainstream garbage-collected languages (for example, Go, C#, Java, and JavaScript), but it's a non-goal to outperform languages that support memory unsafety or manual memory management. There will always be some individual benchmarks where mainstream garbage-collected languages outperform Roc, but the goal is for these to be uncommon rather than the norm. + +### [Domain-specific memory management](#domain-specific-memory-management) {#domain-specific-memory-management} + +Roc’s “platforms and applications” design means its automatic memory management can take advantage of domain-specific properties to improve performance. + +For example, if you build an application on the [`basic-cli` platform](https://github.com/roc-lang/basic-cli) compared to the [`basic-webserver` platform](https://github.com/roc-lang/basic-webserver), each of those platforms may use a different memory management strategy under the hood that’s tailored to their respective use cases. Your application's performance can benefit from this, even though building on either of those platforms feels like using ordinary automatic memory management. + +This is because Roc _platforms_ get to determine how memory gets allocated and deallocated in applications built on them. ([`basic-cli`](https://github.com/roc-lang/basic-cli) and [`basic-webserver`](https://github.com/roc-lang/basic-webserver) are examples of platforms, but anyone can build their own platform.) Here are some examples of how platforms can use this to improve application performance: + +- A platform for noninteractive command-line scripts can skip deallocations altogether, since any allocated memory will be cheaply reclaimed by the operating system anyway once the script exits. (This strategy is domain-specific; it would not work well for a long-running, interactive program!) +- A platform for Web servers can put all allocations for each request into a particular [region of memory](https://en.wikipedia.org/wiki/Region-based_memory_management) (this is known as “arena allocation” or ”bump allocation”) and then deallocate the entire region in one cheap operation after the response has been sent. This would essentially drop memory reclamation times to zero. (This strategy relies on Web servers’ request/response architecture, and wouldn't make sense in other use cases. [`nea`](https://github.com/tweedegolf/nea) is a platform in early development that is working towards implementing this.) +- A platform for applications that have very long-lived state could implement [meshing compaction](https://youtu.be/c1UBJbfR-H0?si=D9Gp0cdpjZ_Is5v8) to decrease memory fragmentation. (Compaction would probably be a net negative for performance in the previous two examples.) + +[This talk](https://www.youtube.com/watch?v=cpQwtwVKAfU&t=75s) has more information about platforms and applications, including demos and examples of other benefits they unlock besides performance. + +### [Current progress](#current-progress) {#current-progress} + +Roc's “platforms and applications” design already works, including the domain-specific memory management. Most of Roc’s data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. [This talk](https://vimeo.com/653510682) explains how they’re implemented under the hood. + +That said, [the current implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260))—which unlocks stack-allocated closures, among other optimizations—has [significant known gaps](https://github.com/roc-lang/roc/issues/5969), and has a ways to go before it works across the board. (If you're interested in getting involved in that implementation, [we'd love to hear from you](https://roc.zulipchat.com)!) Current optimizations that are completely implemented (give or take the occasional bug) include [LLVM](https://llvm.org/), [Morphic](https://www.youtube.com/watch?v=F3z39M0gdJU&t=3547s), [Perceus](https://www.microsoft.com/en-us/research/uploads/prod/2020/11/perceus-tr-v1.pdf), and tail recursion optimization (including [modulo cons](https://en.wikipedia.org/wiki/Tail_call#Tail_recursion_modulo_cons)). Promising examples of potential future optimizations include closure-aware [inlining](https://en.wikipedia.org/wiki/Inline_expansion), [automatic deforestation](https://www.cs.tufts.edu/~nr/cs257/archive/duncan-coutts/stream-fusion.pdf), and full [compile-time evaluation](https://en.wikipedia.org/wiki/Constant_folding) of top-level declarations. -We're also interested in improving the performance of the Morphic alias analysis pass itself; if contributing that interests you, please [let us know in the `#contributing` channel](https://roc.zulipchat.com/#narrow/stream/316715-contributing)! +We're also interested in improving the performance of the Morphic alias analysis pass itself; if contributing to that project (or any other optimization project) interests you, please [let us know in the `#contributing` channel](https://roc.zulipchat.com/#narrow/stream/316715-contributing)! ## Fast Feedback Loops -One of Roc's goals is to provide fast feedback loops by making builds normally feel "instant" except on truly enormous projects. It's a concrete goal to have them almost always complete in under 1 second on the median computer being used to write Roc (assuming that system is not bogged down with other programs using up its resources), and ideally under the threshold at which humans typically find latency perceptible (around 100 milliseconds). Hot code loading can make the feedback loop even faster, by letting you see changes without having to restart your program. +One of Roc's goals is to provide fast feedback loops by making builds normally feel "instant" except on truly enormous projects. -Note that although having fast "clean" builds (without the benefit of caching) is a goal, the "normally feels instant" goal refers to builds where caching was involved. After all, the main downside of build latency is that it comes up over and over in a feedback loop; the initial "clean" build comes up rarely by comparison. +It's a concrete goal to have them almost always complete in under 1 second on the median computer being used to write Roc (assuming that system is not bogged down with other programs using up its resources), and ideally under the threshold at which humans typically find latency perceptible (around 100 milliseconds). In the future, hot code loading can make the feedback loop even faster, by letting you see changes without having to restart your program. + +Note that although having fast "clean" builds (without the benefit of caching) is a goal, the "normally feels instant" goal refers to builds where caching was involved. After all, the main downside of build latency is that it comes up over and over in a feedback loop; a fast initial "clean" build is valuable too, but it comes up rarely by comparison. ### Current Progress -`roc check` type-checks your code and reports problems it finds. `roc build` also does this, but it additionally -builds a runnable binary of your program. You may notice that `roc build` takes much longer to complete! This is because +`roc check` checks your code for errors (such as invalid syntax, naming errors, and type mismatches) and reports problems it finds. On typical development laptops, this usually takes well under 1 second for small projects (for very small projects, it can be around 10 milliseconds on some popular machines). To date, the largest known Roc projects have lines of code numbering in the low thousands, so there's no data yet on `roc check` times for larger projects. + +`roc build` does everything `roc check` does, but it additionally builds a runnable binary of your program. You may notice that `roc build` takes much longer to complete! This is because of two projects that are underway but not completed yet: - *Development backend* refers to generating machine code directly instead of asking [LLVM](https://llvm.org/) to generate it. LLVM is great at generating optimized machine code, but it takes a long time to generate it—even if you turn off all the optimizations (and `roc` only has LLVM perform optimizations when the `--optimize` flag is set). The dev backend is currently implemented for WebAssembly, which you can see in the [Web REPL](https://www.roc-lang.org/repl), and in `roc repl` except on Windows. Work is underway to implement it for `roc build` and `roc run`, as well as macOS, Windows, and the ARM versions of all of these. - *Surgical linking* refers to a fast way of combining the platform and application into one binary. Today, this works on x64 Linux, x64 Windows, and WebAssembly. `roc build` on macOS is noticeably slower because it falls back on non-surgical linking. Here's a table summarizing the current progress: -Target | Dev backend | Surgical linking | ----------------------------|-------------|-------------------| -WebAssembly | yes | yes | -macOS ARM (Apple Silicon) | repl only | | -macOS x64 (Intel) | repl only | | -Linux ARM | repl only | | -Linux x64 | repl only | yes | -Windows x64 | | yes | -Windows ARM | | | +Target | Dev backend | Surgical linking | +------------|-------------|-------------------| +WebAssembly | yes | yes | +macOS ARM | repl only | | +macOS x64 | repl only | | +Linux ARM | repl only | | +Linux x64 | repl only | yes | +Windows x64 | | yes | +Windows ARM | | | Once we have full coverage, `roc build` (and `roc run` and `roc test`, which also perform builds) should take only a bit longer than `roc check`. diff --git a/www/wip_new_website/content/friendly.md b/www/wip_new_website/content/friendly.md index 28296a87ff..2904713205 100644 --- a/www/wip_new_website/content/friendly.md +++ b/www/wip_new_website/content/friendly.md @@ -1,77 +1,98 @@ # Friendly -Roc prioritizes being a user-friendly language. This impacts the syntax, semantics, and tools Roc ships with. +Besides having a [friendly community](/wip/community), Roc also prioritizes being a user-friendly language. This impacts the syntax, semantics, and tools Roc ships with. -## Syntax and Formatter +## [Syntax and Formatter](#syntax) {#syntax} Roc's syntax isn't trivial, but there also isn't much of it to learn. It's designed to be uncluttered and unambiguous. A goal is that you can normally look at a piece of code and quickly get an accurate mental model of what it means, without having to think through several layers of indirection. Here are some examples: -- `x = combine y z` always declares a new constant `x` (Roc has [no mutable variables, reassignment, or shadowing](/functional)) to be whatever the `combine` function returns when passed the arguments `y` and `z`. (Function calls in Roc don't need parentheses or commas.) -- `user.email` always accesses the `email` field of a record named `user`. (Roc has no inheritance, subclassing, or proxying.) -- `Email.isValid` always refers to something named `isValid` exported by a module named `Email`. (Module names are always capitalized, and variables/constants never are.) Modules are always defined statically and can't be modified at runtime; there's no [monkey patching](https://en.wikipedia.org/wiki/Monkey_patch) to consider. -- `"My name is \(Str.trim name)"` uses *string interpolation* syntax: a backslash inside a string literal, followed by an expression in parentheses. This code is the same as combining the string `"My name is "` with the string returned by the function call `Str.trim name`. Because Roc's string interpolation syntax begins with a backslash (just like other backlash-escapes such as `\n` and `\"`), you can always tell which parts of a string involve special handling: the parts that begin with backslashes. Everything else works as normal. +- `user.email` always accesses the `email` field of a record named `user`. (Roc has no inheritance, subclassing, or proxying.) +- `Email.isValid` always refers to something named `isValid` exported by a module named `Email`. (Module names are always capitalized, and variables/constants never are.) Modules are always defined statically and can't be modified at runtime; there's no [monkey patching](https://en.wikipedia.org/wiki/Monkey_patch) to consider either. +- `x = doSomething y z` always declares a new constant `x` (Roc has [no mutable variables, reassignment, or shadowing](/functional)) to be whatever the `doSomething` function returns when passed the arguments `y` and `z`. (Function calls in Roc don't need parentheses or commas.) +- `"Name: \(Str.trim name)"` uses *string interpolation* syntax: a backslash inside a string literal, followed by an expression in parentheses. This code is the same as combining the string `"Name: "` with the string returned by the function call `Str.trim name`.

Because Roc's string interpolation syntax begins with a backslash (just like other backlash-escapes such as `\n` and `\"`), you can always tell which parts of a string involve special handling: the parts that begin with backslashes. Everything else works as normal. -Roc also ships with a source code formatter that helps you maintain a consistent style with little effort. The `roc format` command neatly formats your source code according to a common style, and it's designed with the time-saving feature of having no configuration options. This feature saves you all the time that would otherwise be spent debating which stylistic tweaks to settle on! +Roc also ships with a source code formatter that helps you maintain a consistent style with little effort. The `roc format` command neatly formats your source code according to a common style, and it's designed with the time-saving feature of having no configuration options. This feature saves teams all the time they would otherwise spend debating which stylistic tweaks to settle on! -## Helpful Compiler +## [Helpful compiler](#helpful-compiler) {#helpful-compiler} -Roc's compiler is designed to help you out. It does complete type inference across all your code, and the type system is *sound*. This means you'll never get a runtime type mismatch if everything type-checked (including null exceptions; Roc doesn't have the [billion-dollar mistake](https://en.wikipedia.org/wiki/Null_pointer#History)), and you also don't have to write any type annotations for the compiler to be able to infer all the types in your program. +Roc's compiler is designed to help you out. It does complete type inference across all your code, and the type system is [sound](https://en.wikipedia.org/wiki/Type_safety). This means you'll never get a runtime type mismatch if everything type-checked (including null exceptions; Roc doesn't have the [billion-dollar mistake](https://en.wikipedia.org/wiki/Null_pointer#History)), and you also don't have to write any type annotations—the compiler can infer all the types in your program. If there's a problem at compile time, the compiler is designed to report it in a helpful way. Here's an example: -``` -── TYPE MISMATCH ────────────────── /home/my-roc-project/main.roc ─ +
── TYPE MISMATCH ─────── /home/my-roc-project/main.roc ─
 
-Something is off with the `then` branch of this `if` expression:
+Something is off with the then branch of this if:
 
-4│      someInteger : I64
-5│      someInteger =
-6│          if someDecimal > 0 then
-7│              someDecimal + 1
-                ^^^^^^^^^^^^^^^
+4│      someInt : I64
+5│      someInt =
+6│          if someDecimal > 0 then
+7│              someDecimal + 1
+                ^^^^^^^^^^^^^^^
 
 This branch is a fraction of type:
 
-    Dec
+    Dec
 
-But the type annotation on `someInteger` says it should be:
+But the type annotation on `someInt` says it should be:
 
-    I64
+    I64
 
-Tip: You can convert between integers and fractions using functions like
-`Num.toFrac` and `Num.round`.
-```
+Tip: You can convert between integers and fractions
+using functions like `Num.toFrac` and `Num.round`.
-If you like, you can run a program that has compile-time errors like this. (If the program reaches the error at runtime, it will crash.) This lets you do things like trying out code that's only partially finished, or running tests for one part of your code base while other parts have compile errors. (Note that this feature is only partially completed, and often errors out; it has a ways to go before it works for all compile errors!) +If you like, you can run a program that has compile-time errors like this. (If the program reaches the error at runtime, it will crash.) -## Serialization Inference +This lets you do things like trying out code that's only partially finished, or running tests for one part of your code base while other parts have compile errors. (Note that this feature is only partially completed, and often errors out; it has a ways to go before it works for all compile errors!) -- Type inference is used for schema inference, but you can also spell it out if you like -- Reports errors immediately +## [Serialization inference](#serialization-inference) {#serialization-inference} -## Testing +When dealing with [serialized data](https://en.wikipedia.org/wiki/Serialization), an important question is how and when that data will be decoded from a binary format (such as network packets or bytes on disk) into your program's data structures in memory. -You can run `roc test` to run all your tests. Each test is declared with the `expect` keyword, and can be as short as one line. For example, this is a complete test: +A technique used in some popular languages today is to decode without validation. For example, some languages parse [JSON](https://www.json.org) using a function whose return type is unchecked at compile time (commonly called an `any` type). This technique has a low up-front cost, because it does not require specifying the expected shape of the JSON data. + +Unfortunately, if there’s any mismatch between the way that returned value ends up being used and the runtime shape of the JSON, it can result in errors that are time-consuming to debug because they are distant from (and may appear unrelated to) the JSON decoding where the problem originated. Since Roc has a [sound type system](https://en.wikipedia.org/wiki/Type_safety), it does not have an `any` type, and cannot support this technique. + +Another technique is to validate the serialized data against a schema specified at compile time, and give an error during decoding if the data doesn't match this schema. Serialization formats like [protocol buffers](https://protobuf.dev/) require this approach, but some languages encourage (or require) doing it for _all_ serialized data formats, which prevents decoding errors from propagating throughout the program and causing distant errors. Roc supports and encourages using this technique. + +In addition to this, Roc also supports serialization _inference_. It has some characteristics of both other approaches: +- Like the first technique, it does not require specifying a schema up front. +- Like the second technique, it reports any errors immediately during decoding rather than letting the problems propagate through the program. + +This technique works by using Roc's type inference to infer the expected shape of serialized data based on how it's used in your program. Here's an example, using [`Decode.fromBytes`](https://www.roc-lang.org/builtins/Decode#fromBytes) to decode some JSON: + +
when Decode.fromBytes data Json.codec is
+    Ok decoded -> # (use the decoded data here)
+    Err err -> # handle the decoding failure
+ +In this example, whether the `Ok` or `Err` branch gets taken at runtime is determined by the way the `decoded` value is used in the source code. + +For example, if `decoded` is used like a record with a `username` field and an `email` field, both of which are strings, then this will fail at runtime if the JSON doesn't have fields with those names and those types. No type annotations are needed for this; it relies entirely on Roc's type inference, which by design can correctly infer types for your entire program even without annotations. + +Serialization inference has a low up-front cost in the same way that the decode-without-validating technique does, but it doesn't have the downside of decoding failures propagating throughout your program to cause distant errors at runtime. (It also works for encoding; there is an [Encode.toBytes](https://www.roc-lang.org/builtins/Encode#toBytes) function which encodes similarly to how [`Decode.fromBytes`](https://www.roc-lang.org/builtins/Decode#fromBytes) decodes.) + +Explicitly writing out a schema has its own benefits that can balance out the extra up-front time investment, but having both techniques available means you can choose whatever will work best for you in a given scenario. + +## [Testing](#testing) {#testing} + +The `roc test` command runs a Roc program's tests. Each test is declared with the `expect` keyword, and can be as short as one line. For example, this is a complete test: ```roc ## One plus one should equal two. expect 1 + 1 == 2 ``` -If the test fails, `roc test` will show you the source code of the `expect`, along with the values of any named variables inside it, so you don't have to separately check what they were. If you write a documentation comment right before it (like `## One plus one should equal two` here), that will also be included in the test output, so you can use that to optionally describe the test if you want to. +If the test fails, `roc test` will show you the source code of the `expect`, along with the values of any named variables inside it, so you don't have to separately check what they were. + +If you write a documentation comment right before it (like `## One plus one should equal two` here), it will appear in the test output, so you can use that to add some descriptive context to the test if you want to. + +## [Inline expectations](#inline-expect) {#inline-expect} + +You can also use `expect` in the middle of functions. This lets you verify assumptions that can't reasonably be encoded in types, but which can be checked at runtime. Similarly to [assertions](https://en.wikipedia.org/wiki/Assertion_(software_development)) in other languages, these will run not only during normal program execution, but also during your tests—and they will fail the test if any of them fails. + +Unlike assertions (and unlike the `crash` keyword), failed `expect`s do not halt the program; instead, the failure will be reported and the program will continue. This means all `expect`s can be safely removed during `--optimize` builds without affecting program behavior—and so `--optimize` does remove them. This means you can add inline `expect`s without having to weigh each one's helpfulness against the performance cost of its runtime check, because they won't have any runtime cost after `--optimize` removes them. In the future, there are plans to add built-in support for [benchmarking](https://en.wikipedia.org/wiki/Benchmark_(computing)), [generative tests](https://en.wikipedia.org/wiki/Software_testing#Property_testing), [snapshot tests](https://en.wikipedia.org/wiki/Software_testing#Output_comparison_testing), simulated I/O (so you don't have to actually run the real I/O operations, but also don't have to change your code to accommodate the tests), and "reproduction replays"—tests generated from a recording of what actually happened during a particular run of your program, which deterministically simulate all the I/O that happened. -- also note: future plan to cache tests so we only re-run tests whose answers could possibly have changed. also maybe note: tests that don't perform I/O are guaranteed not to flake b/c pure functions. - -## Future Plans - -- Package manager (Currently just URLs, content-hashed to make them immutable) with searchable index and no installation step, global cache of immutable downloads instead of per-project folders (no need to .gitignore anything) -- Step debugger with replay -- Customizable "linter" (e.g. code mods, project-specific rules to enforce) -- Editor plugin ecosystem that works across editors, where plugins ship with packages -- `roc edit` - ## Functional Besides being designed to be [fast](/wip/fast) and friendly, Roc is also a functional programming language. diff --git a/www/wip_new_website/content/functional.md b/www/wip_new_website/content/functional.md index 5076ca6ba6..bdbc430dca 100644 --- a/www/wip_new_website/content/functional.md +++ b/www/wip_new_website/content/functional.md @@ -2,7 +2,7 @@ Roc is designed to have a small number of simple language primitives. This goal leads Roc to be a single-paradigm [functional](https://en.wikipedia.org/wiki/Functional_programming) language, while its [performance goals](/fast) lead to some design choices that are uncommon in functional languages. -## Opportunistic mutation +## [Opportunistic mutation](#opportunistic-mutation) {#opportunistic-mutation} All Roc values are semantically immutable, but may be opportunistically mutated behind the scenes when it would improve performance (without affecting the program's behavior). For example: @@ -13,17 +13,23 @@ colors |> Set.insert "Blue" ``` -The [`Set.insert`](https://www.roc-lang.org/builtins/Set#insert) function takes a `Set` and returns a `Set`. The returned one has the given value inserted into it. Knowing this, it might seem like these three `Set.insert` calls would result in the creation of three brand-new sets, but Roc's *opportunistic mutation* optimizations mean this will be much more efficient than that. +The [`Set.insert`](https://www.roc-lang.org/builtins/Set#insert) function takes a `Set` and returns a `Set` with the given value inserted. It might seem like these three `Set.insert` calls would result in the creation of three brand-new sets, but Roc's *opportunistic mutation* optimizations mean this will be much more efficient. -Opportunistic mutation works by detecting when a semantically immutable value can be safely mutated in-place without changing the behavior of the program. If `colors` is *unique* here—that is, nothing else is currently referencing it, and nothing else will reference it before it goes out of scope—then `Set.insert` will mutate it and then return it. Cloning it first would have no benefit, because nothing in the program could possibly tell the difference! +Opportunistic mutation works by detecting when a semantically immutable value can be safely mutated in-place without changing the behavior of the program. If `colors` is *unique* here—that is, nothing else is currently referencing it—then `Set.insert` will mutate it and then return it. Cloning it first would have no benefit, because nothing in the program could possibly tell the difference! -If `colors` is not unique, then the first call to `Set.insert` will not mutate it. Instead, it will clone `colors`, insert `"Purple"` into the clone, and then return that. At that point, since the clone will be unique (nothing else is referencing it, since it was just created, and the only thing that will reference it in the future is the `Set.insert` function it's handed off to), the subsequent `Set.insert` calls will all mutate in-place. Roc has ways of detecting uniqueness at compile time, so this optimization will often have no runtime cost, but in some cases it instead uses automatic reference counting to tell when something that was previously shared has become unique over the course of the running program. +If `colors` is _not_ unique, however, then the first call to `Set.insert` will not mutate it. Instead, it will clone `colors`, insert `"Purple"` into the clone, and then return that. At that point, since the clone will be unique (nothing else is referencing it, since it was just created), the subsequent `Set.insert` calls will all mutate in-place. -## Everything is immutable (semantically) +Roc has ways of detecting uniqueness at compile time, so this optimization will often have no runtime cost, but in some cases it instead uses automatic reference counting to tell when something that was previously shared has become unique over the course of the running program. -This design means that all Roc values are semantically immutable, even though they can still benefit from the performance of in-place mutation. In many languages, this is reversed; everything is mutable, and it's up to the programmer to "defensively" clone wherever modification is undesirable. Roc's approach means that cloning happens automatically, which can be less error-prone than defensive cloning (which might be accidentally forgotten), but which—to be fair—can also increase unintentional cloning. It's a different default with different tradeoffs. +## [Everything is immutable (semantically)](#everything-is-immutable) {#everything-is-immutable} -A performance benefit of this design compared to having direct mutation primitives is that it lets Roc rule out [reference cycles](https://en.wikipedia.org/wiki/Reference_counting#Dealing_with_reference_cycles). Any language which supports direct mutation can have reference cycles. Detecting these cycles automatically at runtime has a cost (which has similar characteristics to the cost of a tracing garbage collector), and failing to detect them can result in memory leaks. Roc's automatic reference counting neither pays for runtime cycle collection nor memory leaks from cycles, because the language's lack of direct mutation primitives lets it rule out reference cycles at language design time. +Since mutation is only ever done when it wouldn’t change the behavior of the program, all Roc values are semantically immutable—even though they can still benefit from the performance of in-place mutation. + +In many languages, this is reversed; everything is mutable by default, and it's up to the programmer to “defensively” clone to avoid undesirable modification. Roc's approach means that cloning happens automatically, which can be less error-prone than defensive cloning (which might be forgotten), but which—to be fair—can also increase unintentional cloning. It's a different default with different tradeoffs. + +A reliability benefit of semantic immutability everywhere is that it rules out [data races](https://en.wikipedia.org/wiki/Race_condition#Data_race). These concurrency bugs can be difficult to reproduce and time-consuming to debug, and they are only possible through direct mutation. Roc's semantic immutability rules out this category of bugs. + +A performance benefit of having no direct mutation is that it lets Roc rule out [reference cycles](https://en.wikipedia.org/wiki/Reference_counting#Dealing_with_reference_cycles). Languages which support direct mutation can have reference cycles, and detecting these cycles automatically at runtime has a cost. (Failing to detect them can result in memory leaks in languages that use reference counting.) Roc's automatic reference counting neither pays for runtime cycle collection nor memory leaks from cycles, because the language's lack of direct mutation primitives lets it rule out reference cycles at language design time. An ergonomics benefit of having no direct mutation primitives is that functions in Roc tend to be chainable by default. For example, consider the `Set.insert` function. In many languages, this function would be written to accept a `Set` to mutate, and then return nothing. In contrast, in Roc it will necessarily be written to return a (potentially) new `Set`, even if in-place mutation will end up happening anyway if it's unique. @@ -38,86 +44,100 @@ colors To be fair, direct mutation primitives have benefits too. Some algorithms are more concise or otherwise easier to read when written with direct mutation, and direct mutation can make the performance characteristics of some operations clearer. -As such, Roc's opportunistic mutation design means that reference cycles can be ruled out, and functions will tend to be more ameanable for chaining, but also that some algorithms will be harder to express, and that performance optimization will likely tend to involve more profiling. These tradeoffs fit well with the language's overall design goals. +As such, Roc's opportunistic mutation design means that data races and reference cycles can be ruled out, and that functions will tend to be more ameanable for chaining, but also that some algorithms will be harder to express, and that performance optimization will likely tend to involve more profiling. These tradeoffs fit well with the language's overall design goals. -## No reassignment or shadowing +## [No reassignment or shadowing](#no-reassignment) {#no-reassignment} In some languages, the following is allowed. -``` -x = 1 -x = 2 -``` +
x = 1
+x = 2
-In Roc, this will give a compile-time error. Once a name has been assigned to a value, nothing in the same scope can assign it again. (This includes [shadowing](https://en.wikipedia.org/wiki/Variable_shadowing), which is disallowed.) This can make Roc code easier to read, because the answer to the question "might this have a different value at some later point in the scope?" is always "no." That said, this can also make Roc code take longer to write, because of needing to come up with unique names to avoid shadowing, although pipelining (as shown in the previous section) reduces how often intermediate values need to be named. +In Roc, this will give a compile-time error. Once a name has been assigned to a value, nothing in the same scope can assign it again. (This includes [shadowing](https://en.wikipedia.org/wiki/Variable_shadowing), which is disallowed.) + +This can make Roc code easier to read, because the answer to the question "might this have a different value later on in the scope?" is always "no." + +That said, this can also make Roc code take longer to write, due to needing to come up with unique names to avoid shadowing—although pipelining (as shown in the previous section) reduces how often intermediate values need names. + +### [Avoiding regressions](#avoiding-regressions) {#avoiding-regressions} A benefit of this design is that it makes Roc code easier to rearrange without causing regressions. Consider this code: -```roc -func = \arg -> - greeting = "Hello" - welcome = \name -> "\(greeting), \(name)!" - # … - message = welcome "friend" - # … -``` +
func = \arg ->
+    greeting = "Hello"
+    welcome = \name -> "\(greeting), \(name)!"
+
+    # …
+
+    message = welcome "friend"
+
+    # …
Suppose I decide to extract the `welcome` function to the top level, so I can reuse it elsewhere: -```roc -func = \arg -> - # … - message = welcome "Hello" "friend" - # … +
func = \arg ->
+    # …
 
-welcome = \prefix, name -> "\(prefix), \(name)!"
-```
+    message = welcome "Hello" "friend"
 
-Without knowing the rest of `func`, we can be confident this change will not alter the code's behavior. In contrast, suppose Roc allowed reassignment. Then it's possible something in the `# …` parts of the code could have modified `greeting` before it was used in the `message =` declaration. For example:
+    # …
 
-```roc
-func = \arg ->
-    greeting = "Hello"
-    welcome = \name -> "\(greeting), \(name)!"
-    # …
-    if someCondition then
-        greeting = "Hi"
-        # …
-    else
-        # …
-    # …
-    message = welcome "friend"
-    # …
-```
+welcome = \prefix, name -> "\(prefix), \(name)!"
-In this example, if we didn't read the whole function to see that `greeting` was later sometimes (but not always) changed from `"Hello"` to `"Hi"`, we might not have realized that changing it to `message = welcome "Hello" "friend"` would cause a regression due to having the greeting always be `"Hello"`. Because Roc disallows reassignment, this particular regression can't happen, and so the code can be confidently rearranged without checking the rest of the function. +Even without knowing the rest of `func`, we can be confident this change will not alter the code's behavior. + +In contrast, suppose Roc allowed reassignment. Then it's possible something in the `# …` parts of the code could have modified `greeting` before it was used in the `message =` declaration. For example: + +
func = \arg ->
+    greeting = "Hello"
+    welcome = \name -> "\(greeting), \(name)!"
+
+    # …
+
+    if someCondition then
+        greeting = "Hi"
+        # …
+    else
+        # …
+
+    # …
+    message = welcome "friend"
+    # …
+ +If we didn't read the whole function and notice that `greeting` was sometimes (but not always) reassigned from `"Hello"` to `"Hi"`, we might not have known that changing it to `message = welcome "Hello" "friend"` would cause a regression due to having the greeting always be `"Hello"`. Even if Roc disallowed reassignment but allowed shadowing, a similar regression could happen if the `welcome` function were shadowed between when it was defined here and when `message` later called it in the same scope. Because Roc allows neither shadowing nor reassignment, these regressions can't happen, and rearranging code can be done with more confidence. -In fairness, reassignment has benefits too. For example, using it with [early-exit control flow operations](https://en.wikipedia.org/wiki/Control_flow#Early_exit_from_loops) such as a `break` keyword can be a nice way to represent certain types of logic without incurring extra runtime overhead. Roc does not have these operations; looping is done either with convenience functions like [`List.walkUntil`](https://www.roc-lang.org/builtins/List#walkUntil) or with recursion (Roc implements [tail-call optimization](https://en.wikipedia.org/wiki/Tail_call), including [modulo cons](https://en.wikipedia.org/wiki/Tail_call#Tail_recursion_modulo_cons)), but early-exit operators can potentially make some code easier to follow (and potentially even slightly more efficient) when used in scenarios where breaking out of nested loops with a single instruction is desirable. +In fairness, reassignment has benefits too. For example, using it with [early-exit control flow operations](https://en.wikipedia.org/wiki/Control_flow#Early_exit_from_loops) such as a `break` keyword can be a nice way to represent certain types of logic without incurring extra runtime overhead. -## Managed effects over side effects +Roc does not have early-exits or loop syntax; looping is done either with convenience functions like [`List.walkUntil`](https://www.roc-lang.org/builtins/List#walkUntil) or with recursion (Roc implements [tail-call optimization](https://en.wikipedia.org/wiki/Tail_call), including [modulo cons](https://en.wikipedia.org/wiki/Tail_call#Tail_recursion_modulo_cons)), but early-exit operators can potentially make some code easier to follow (and potentially even slightly more efficient) when used in scenarios where breaking out of nested loops with a single instruction is desirable. -Many languages support first-class [asynchronous](https://en.wikipedia.org/wiki/Asynchronous_I/O) effects, which can improve a system's throughput (usually at the cost of some latency) especially in the presence of long-running I/O operations like network requests. Asynchronous effects are commonly represented by a value such as a [Promise or Future](https://en.wikipedia.org/wiki/Futures_and_promises) (Roc calls these Tasks), which represent an effect to be performed. These values can be composed together, potentially while customizing their concurrency properties and supporting I/O interruptions like cancellation and timeouts. +## [Managed effects over side effects](#managed-effects) {#managed-effects} -Most languages also have a separate system for synchronous effects, namely [side effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Having demand for two ways to perform the same effect can lead to a great deal of duplication across a language's ecosystem. +Many languages support first-class [asynchronous](https://en.wikipedia.org/wiki/Asynchronous_I/O) effects, which can improve a system's throughput (usually at the cost of some latency) especially in the presence of long-running I/O operations like network requests. + +Asynchronous effects are commonly represented by a value such as a [Promise or Future](https://en.wikipedia.org/wiki/Futures_and_promises) (Roc calls these Tasks), which represent an effect to be performed. Tasks can be composed together, potentially while customizing concurrency properties and supporting I/O interruptions like cancellation and timeouts. + +Most languages also have a separate system for synchronous effects, namely [side effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Having two different ways to perform every I/O operation—one synchronous and one asynchronous—can lead to a lot of duplication across a language's ecosystem. Instead of having [side effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)), Roc functions exclusively use *managed effects* in which they return descriptions of effects to run, in the form of Tasks. Tasks can be composed and chained together, until they are ultimately handed off (usually via a `main` function or something similar) to an effect runner outside the program, which actually performs the effects the tasks describe. Having only (potentially asynchronous) *managed effects* and no (synchronous) *side effects* both simplifies the language's ecosystem and makes certain guarantees possible. For example, the combination of managed effects and semantically immutable values means all Roc functions are [pure](https://en.wikipedia.org/wiki/Pure_function)—that is, they have no side effects and always return the same answer when called with the same arguments. -## Pure functions +## [Pure functions](#pure-functions) {#pure-functions} -Pure functions have a number of implementation benefits, such as [referential transparency](https://en.wikipedia.org/wiki/Referential_transparency) and being trivial to [memoize](https://en.wikipedia.org/wiki/Memoization). They also have testing benefits; for example, Roc tests which either use simulated effects (or which do not involve tasks at all) never flake. They either consistently pass or consistently fail. Because of this, their results can be cached, so `roc test` can skip re-running them unless their source code (including dependencies) changed. (This caching has not yet been implemented, but is planned.) +Pure functions have some valuable properties, such as [referential transparency](https://en.wikipedia.org/wiki/Referential_transparency) and being trivial to [memoize](https://en.wikipedia.org/wiki/Memoization). They also have testing benefits; for example, all Roc tests which either use simulated effects (or which do not involve Tasks at all) can never flake. They either consistently pass or consistently fail. Because of this, their results can be cached, so `roc test` can skip re-running them unless their source code (including dependencies) changed. (This caching has not yet been implemented, but is planned.) -Roc does support [tracing](https://en.wikipedia.org/wiki/Tracing_(software)) via the `dbg` keyword, an essential [debugging](https://en.wikipedia.org/wiki/Debugging) tool which is unusual among side effects in that—similarly to opportunistic mutation—using it should not affect the behavior of the program. As such, it usually does not impact the guarantees of pure functions aside from potentially impeding optimizations. (An example of an exception to this would be if a program sent its `dbg` traces to log files which the program itself then read back in. This is not recommended.) +Roc does support [tracing](https://en.wikipedia.org/wiki/Tracing_(software)) via the `dbg` keyword, an essential [debugging](https://en.wikipedia.org/wiki/Debugging) tool which is unusual among side effects in that—similarly to opportunistic mutation—using it should not affect the behavior of the program. As such, it typically does not impact the guarantees of pure functions in practice. -Pure functions are notably amenable to compiler optimizations. Roc already takes advantage of them to implement [function-level dead code elimination](https://elm-lang.org/news/small-assets-without-the-headache). Here are some other examples of optimizations that will benefit from this in the future; these are planned, but not yet implemented: +Pure functions are notably amenable to compiler optimizations, and Roc already takes advantage of them to implement [function-level dead code elimination](https://elm-lang.org/news/small-assets-without-the-headache). Here are some other examples of optimizations that will benefit from this in the future; these are planned, but not yet implemented: - [Loop fusion](https://en.wikipedia.org/wiki/Loop_fission_and_fusion), which can do things like combining consecutive `List.map` calls (potentially intermingled with other operations that traverse the list) into one pass over the list. - [Compile-time evaluation](https://en.wikipedia.org/wiki/Compile-time_function_execution), which basically takes [constant folding](https://en.wikipedia.org/wiki/Constant_folding) to its natural limit: anything that can be evaluated at compile time is evaluated then. This saves work at runtime, and is easy to opt out of: if you want evaluation to happen at runtime, you can instead wrap the logic in a function and call it as needed. - [Hoisting](https://en.wikipedia.org/wiki/Loop-invariant_code_motion), which moves certain operations outside loops to prevent them from being re-evaluated unnecessarily on each step of the loop. It's always safe to hoist calls to pure functions, and in some cases they can be hoisted all the way to the top level, at which point they become eligible for compile-time evaluation. +There are other optimizations (some of which have yet to be considered) that pure functions enable; this is just a sample! + ## Get started If this design sounds interesting to you, you can give Roc a try by heading over to the [tutorial](/tutorial)! diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index b740dbf9bf..140543e4f0 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -12,24 +12,24 @@
@@ -62,7 +62,7 @@ ## [Examples](#examples) {#examples} -Roc is a very young language (it doesn’t even have a numbered release yet, just nightly builds!) but it can already be used for several things if you’re up for being an early adopter—with all the bugs and missing features which come with that territory. +Roc is a young language (it doesn’t even have a numbered release yet, just nightly builds!) but it can already be used for several things if you’re up for being an early adopter—with all the bugs and missing features which come with that territory. Here are some examples of how it can be used today. diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index aedbe3aaa5..5c46a3ec50 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -60,7 +60,7 @@ view = \page, htmlContent -> if page == "index.html" then [id "homepage-main"] else - [] + [class "article-layout"] html [lang "en", class "no-js"] [ head [] [ diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 8e3b07eec5..cbb6f60ac1 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -56,6 +56,10 @@ p { margin-top: 0; } +p, li { + max-width: 720px; +} + footer { width: 100%; color: var(--text-color); @@ -114,11 +118,13 @@ hr { #individual-sponsors { list-style-type: none; padding: 24px 40px; + max-width: 720px; } #individual-sponsors li { display: inline; white-space: nowrap; + margin: 0.2rem; } #individual-sponsors li::after { @@ -201,14 +207,23 @@ h1 { h2 { display: inline-block; - font-size: 3rem; + font-size: 2.5rem; + line-height: 5rem; border-bottom: 4px solid var(--dark-cyan); + padding: 0; margin: 0; - margin-bottom: 36px; - padding: 36px 0; + margin-bottom: 2rem; color: var(--heading-color); } +.article-layout main { + max-width: 720px; +} + +.article-layout p, .article-layout li, .article-layout pre { + font-size: 20px; +} + #homepage-main h2 { margin-top: 60px; /* On the homepage, these need to be spaced out more. */ } @@ -217,7 +232,7 @@ h2 { visibility: hidden; } -h2 a { +h2 a, h3 a { color: var(--heading-color); } @@ -412,6 +427,7 @@ table { border-collapse: collapse; overflow-x: auto; border: 2px solid #f0f0f0; + margin-bottom: 1rem; } thead { @@ -499,6 +515,10 @@ li { font-size: 20px; } +.nowrap { + white-space: nowrap; +} + /* Mobile-friendly screen width */ @media only screen and (max-width: 1023px) { :root { @@ -562,10 +582,6 @@ li { white-space: normal; } - .nobreak-on-mobile { - white-space: nowrap; - } - /* Homepage */ #homepage-intro-box { @@ -861,6 +877,11 @@ code .lowerident { color: white; } +samp .error, +code .error { + color: hsl(0, 96%, 67%); +} + /* Types, Tags, and Modules */ samp .type, code .type, From d8789c551acc3c745e855e62b5b6a0e6e5f9dae4 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 22:59:09 -0500 Subject: [PATCH 051/129] Tweak homepage copy --- www/wip_new_website/content/index.md | 20 +++++++++++--------- www/wip_new_website/static/site.css | 2 ++ 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index 140543e4f0..d2920967d3 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -14,14 +14,14 @@ @@ -29,7 +29,7 @@

Functional

- Roc has a small number of simple language primitives. It’s a single-paradigm functional language.

+ Roc has a small number of simple language primitives. It’s a single-paradigm functional language.

What does functional mean here?

 @@ -62,7 +62,10 @@ ## [Examples](#examples) {#examples} -Roc is a young language (it doesn’t even have a numbered release yet, just nightly builds!) but it can already be used for several things if you’re up for being an early adopter—with all the bugs and missing features which come with that territory. +Roc is a young language. It doesn’t even have a numbered release yet, just nightly builds! + +However, it can already be used for several things if you’re up for being an early adopter—
+with all the bugs and missing features which come with that territory. Here are some examples of how it can be used today. @@ -94,9 +97,8 @@ log(`Roc says ${fn() -### Other Examples - -There are a variety of [other examples](/wip/examples) you can check out, if you’d like to get a feel for some different ways people write Roc code. +### [Other Examples](#other-examples) {#other-examples} +You can find more use cases and examples on the [examples page](/wip/examples)!
@@ -108,7 +110,7 @@ Here’s a code sample that shows a few different aspects of Roc: * JSON deserialization via type inference * Common syntax sugar: string interpolation, pipelines, and backpassing -The [tutorial](/tutorial) introduces these gradually and in more depth, but this gives you a brief overview. +The [tutorial](/tutorial) introduces these gradually and in more depth, but this gives a brief overview. @@ -136,7 +138,7 @@ We are very grateful for our corporate sponsors [Vendr](https://www.vendr.com/),

-If you would like your company to become a corporate sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383)! +If you would like your organization to become an official sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383)! We'd also like to express our gratitude to our generous [individual sponsors](https://github.com/sponsors/roc-lang/)! A special thanks to those sponsoring $25/month or more: diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index cbb6f60ac1..52d5d2e215 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -923,6 +923,8 @@ code .dim { margin: 0 auto; fill: var(--primary-1); text-shadow: 1px 1px 1px #010101; + position: relative; + top: -2px; } /* HOME GOALS */ From b5d3182cab321f40b6780335757b9ed70bbdc25f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 16 Nov 2023 23:32:48 -0500 Subject: [PATCH 052/129] Update some WIP website pages --- www/wip_new_website/content/bdfn.md | 2 +- www/wip_new_website/content/community.md | 22 ++++--- www/wip_new_website/content/donate.md | 15 +++-- www/wip_new_website/content/install.md | 78 +++++------------------- www/wip_new_website/static/site.css | 5 +- 5 files changed, 43 insertions(+), 79 deletions(-) diff --git a/www/wip_new_website/content/bdfn.md b/www/wip_new_website/content/bdfn.md index 1681e382fd..0a0e4dc86b 100644 --- a/www/wip_new_website/content/bdfn.md +++ b/www/wip_new_website/content/bdfn.md @@ -10,4 +10,4 @@ Something that needs figuring out between now and then is how to keep the langua (This would be easy to solve if zero happened to be the optimal number of new features to add over time, but unfortunately the programming landscape will change around the language, so remaining static is unlikely to be best. As such, the goal becomes finding a system which keeps the number of new features low without artificially forcing it to zero.) -I don't have any plans for when the transition away from BDFN will happen, other than that I certainly imagine it being well after a 1.0 release of the language. +I don't have any plans for when the transition away from BDFN will happen, other than that I expect it to be well after a 1.0 release of the language! diff --git a/www/wip_new_website/content/community.md b/www/wip_new_website/content/community.md index ac8e71a7b4..89edc58642 100644 --- a/www/wip_new_website/content/community.md +++ b/www/wip_new_website/content/community.md @@ -3,30 +3,36 @@ [Roc Zulip Chat](https://roc.zulipchat.com/) is the most active community gathering place. We love it when new people stop by and introduce themselves in [`#introductions`](https://roc.zulipchat.com/#narrow/stream/387892-introductions) so others can welcome you to the community! -The Roc Online Meetup meets about once per month. The organizer posts a [when2meet](https://when2meet.com) for the next month's meetup, so we can find the best time that works for everyone -who's interested in attending. This happens in [`#gatherings` on Zulip](https://roc.zulipchat.com/#narrow/stream/303057-gatherings). The organizer will then make a post on Zulip with a finalized time and a link to where people can join. They usually last between 1-2 hours, and consist of some informal presentations followed by casual conversation. They're fun! +The Roc Online Meetup meets about once per month. The organizer posts a [when2meet](https://when2meet.com) for the next month's meetup in [`#gatherings` on Zulip](https://roc.zulipchat.com/#narrow/stream/303057-gatherings), so we can find the best time that works for everyone +who's interested in attending. The organizer then posts a finalized time and a link to where people can join. They usually last between 1-2 hours, and consist of some casual show-and-tell presentations followed by conversation. They’re fun! We have not had a Roc conference yet, although there have been a few Roc talks given at conferences, and a few times when Roc community members have met up in person. -## Code of Conduct +### [Code of Conduct](#code-of-conduct) {#code-of-conduct} The Roc project enforces [a code of conduct](https://github.com/roc-lang/roc/blob/main/CODE_OF_CONDUCT.md). Please read and follow it! -## Contributing +### [Contributing](#contributing) {#contributing} All the source code to the Roc project is on GitHub in the [roc-lang](https://github.com/roc-lang) organization. The compiler and CLI are at [roc-lang/roc](https://github.com/roc-lang/roc), and there's a tag for [Good First Issues](https://github.com/roc-lang/roc/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22). The project has [many contributors](https://github.com/roc-lang/roc/graphs/contributors), and we like to invest in helping new contributors get started. If you'd like to become a new contributor (even if you don't know what you'd like that contribution to be yet), just make a post in [the "new contributors" topic](https://roc.zulipchat.com/#narrow/stream/316715-contributing/topic/new.20contributors) and say hello! -## Design ideas, feature requests, proposals, etc. +### [Ideas, proposals, and feature requests](#ideas) {#ideas} -Roc doesn't have a formal process for managing design proposals. At the current size of the project, having a formal process (e.g. a [RFC](https://en.wikipedia.org/wiki/Change_request) system) would be more heavyweight than it's worth. Fow now, the guiding principle is that as a community we should all be friendly, supportive, and openly share and discuss ideas without the expectation that they will necessarily be accepted or not. We follow a [BDFN](/bdfn) leadership model today, although this is planned to change someday. +Roc doesn't have a formal process for managing design proposals. + +At the current size of the project, having a formal process (like a [RFC](https://en.wikipedia.org/wiki/Change_request) system) would be more heavyweight than it's worth. Fow now, the guiding principle is that as a community we should all be friendly, supportive, and openly share and discuss ideas without the expectation that they will necessarily be accepted or not. We follow a [BDFN](/bdfn) leadership model today, although this is planned to change someday. There are three loose stages that a design proposal can go through in Roc: idea, proposal, and implementation. These are guidelines, not strict requirements; their goal is to prevent the outcome where someone does a lot of implementation work only to have their contribution never make it into the code base because it's determined that we wanted to go in a different design direction. Confirming ahead of time that the design direction is desired can prevent implementing something that ends up not being used. -In the idea stage, people are encouraged to describe their idea and explore the problem, potential solutions, and trade-offs. It's a good idea to share the idea in [`#ideas` on Zulip](https://roc.zulipchat.com/#narrow/stream/304641-ideas). There's no prerequisite for sharing an idea (it's only an idea, after all!) and likewise there's also no obligation for any contributor to necessarily act on it. +In the idea stage, people are encouraged to describe their idea and explore the problem, potential solutions, and tradeoffs. It's a good idea to share the idea in [`#ideas` on Zulip](https://roc.zulipchat.com/#narrow/stream/304641-ideas). There's no prerequisite for sharing an idea (it's only an idea, after all!) and likewise there's also no obligation for any contributor to necessarily act on it. -If the idea seems promising and worth developing further (as confirmed by a Roc contributor with expertise in the relevant area, doesn't have to be the [BDFN](/bdfn)), usually the next step is to get more specific with a written proposal that details all the necessary information about what the change would involve. A written proposal isn't always necessary (e.g. it may be deemed a simple and uncontroversial enough change that we're comfortable proceeding straight to implementation), but since writing proposals can be time-consuming, it's definitely a good idea to get confirmation at the idea stage from an experienced contributor before taking the time to write one up. +If the idea seems promising and worth developing further (as confirmed by a Roc contributor with expertise in the relevant area—not necessarily the [BDFN](/wip/bdfn)), usually the next step is to get more specific with a written proposal that details all the necessary information about what the change would involve. + +A written proposal isn't always necessary (for example, it may be deemed a simple and uncontroversial enough change that we're comfortable proceeding straight to implementation), but since writing proposals can be time-consuming, it's definitely a good idea to get confirmation at the idea stage from an experienced contributor before taking the time to write one up. There's no guarantee that a proposal will be accepted, and even if it is, there's no guarantee that something won't come up during implementation that changes the tradeoffs and means it doesn't end up making it into the language after all. But if it is accepted (again, doesn't have to be by the [BDFN](/bdfn) - although the BDFN does have final say if there's a disagreement at some point), that means a [Pull Request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) should be reviewed, and the general understanding is that the PR will be accepted unless some problem is discovered during implementation that wasn't anticipated at the proposal stage. + +This is the process we’re using for now, but of course it may change in the future! diff --git a/www/wip_new_website/content/donate.md b/www/wip_new_website/content/donate.md index 3990828612..c9061051db 100644 --- a/www/wip_new_website/content/donate.md +++ b/www/wip_new_website/content/donate.md @@ -1,8 +1,13 @@ # Donate -- [Github Sponsorship](https://github.com/sponsors/roc-lang) +We are a small group trying to do big things, and we are grateful for every donation! Right now we are trying to raise $4,000 USD/month in donations to fund one longtime Roc contributor to continue his work on Roc full-time. - +You can donate to Roc’s development using: +- [GitHub Sponsors](https://github.com/sponsors/roc-lang) +- [Liberapay](https://liberapay.com/roc_lang) + +All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 503(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. + +It also means that the foundation’s tax filings are a [matter of public record](https://en.wikipedia.org/wiki/501(c)(3)_organization#Transparency), so you have real transparency into how your donations are advancing Roc! + +If you would like your organization to become an official sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383). We’d love to talk to you! diff --git a/www/wip_new_website/content/install.md b/www/wip_new_website/content/install.md index e6cb3e9e30..06c2540b6a 100644 --- a/www/wip_new_website/content/install.md +++ b/www/wip_new_website/content/install.md @@ -1,13 +1,16 @@ # Install Roc -Roc is a work in progress. It doesn't have a numbered release yet, but it does have nightly builds that you can download. +Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download if you’d like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)! -There are currently a few OS-specific issues: -* macOS: There are no known compatibility issues, but the compiler doesn't run as fast as it does on Linux or Windows, because we don't (yet) do our own linking like we do on those targets. (Linking works similarly on Linux and Windows, but the way macOS does it is both different and significantly more complicated.) -* Windows: There are some known Windows-specific compiler bugs, and probably some other unknown ones because more people have tried out Roc on Mac and Linux than on Windows. -* Linux: The nightlies are built with glibc, so they aren't usable on distros that don't use (dynamically linked) glibc, like Alpine or NixOS. In the future we plan to build Linux releases with [musl libc](https://wiki.musl-libc.org/) to address this, but this requires [building LLVM from source with musl](https://wiki.musl-libc.org/building-llvm.html). -* Other operating systems: Roc has not been built on any other operating systems. Building from source on them might work, but hasn't been tried. +There are currently a few known OS-specific issues: +* **macOS:** There are no known compatibility issues, but the compiler doesn't run as fast as it does on Linux or Windows, because we don't (yet) do our own linking like we do on those targets. (Linking works similarly on Linux and Windows, but the way macOS does it is both different and significantly more complicated.) +* **Windows:** There are some known Windows-specific compiler bugs, and probably some other unknown ones because more people have tried out Roc on Mac and Linux than on Windows. +* **Linux:** The nightlies are built with glibc, so they aren't usable on distros that don't use (dynamically linked) glibc, like Alpine or NixOS. In the future we plan to build Linux releases with [musl libc](https://wiki.musl-libc.org/) to address this, but this requires [building LLVM from source with musl](https://wiki.musl-libc.org/building-llvm.html). +* **Other operating systems:** Roc has not been built on any other operating systems. [Building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md) on another OS might work, but you might very well be the first person ever to try it! +### [Getting Started](#getting-started) {#getting-started} + +Here are some Getting Started guides for different operating systems: - [Linux x86-64](https://github.com/roc-lang/roc/blob/main/getting_started/linux_x86_64.md) @@ -16,65 +19,14 @@ There are currently a few OS-specific issues: - [Windows](https://github.com/roc-lang/roc/blob/main/getting_started/windows.md) - [Other Systems](https://github.com/roc-lang/roc/blob/main/getting_started/other.md) -## Nightly +### [Editor Extensions](#editor-extensions) {#editor-extensions} - +There is currently a [VS Code extension](https://marketplace.visualstudio.com/items?itemName=IvanDemchenko.roc-lang-unofficial) for Roc which includes instructions in its README for how to enable a Roc language server. -## Roc CLI +Currently that language server has to be built from source; it would be a fantastic contribution if anyone could get it incorporated it into the extension directly. If you'd like to help with this, just make a post in [the "new contributors" topic on Zulip](https://roc.zulipchat.com/#narrow/stream/316715-contributing/topic/new.20contributors) and say hello! - -- Script `roc myApp.roc` -- Develop `roc dev` -- Test `roc test` -- Run `roc run` -- Build `roc build` -- Format `roc format` -- Documentation `roc docs` +### [Tutorial](#tutorial) {#tutorial} -## Package Management +Once you've installed roc, check out the [tutorial](/tutorial) to learn how to Roc! -You can include packages using an URL: - -```roc -app "hello" - packages { - # basic-cli platform - pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br", - # json package - # TODO update to json 0.3.0 - json: "https://github.com/lukewilliamboswell/roc-json/releases/download/0.2.0/gh4zvR8xyEsef0R961Fcv5vxFEZJ-GJF-7bQwgL2Xz8.tar.br", - } - imports [ - pf.Stdout, - json.Core, - ] - provides [main] to pf -``` - -A full Roc package manager will be developed in the future. - - - -## Editor Support - - - -- Language Server -- Neo(Vim) +Start Tutorial diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index 52d5d2e215..ae92c3a7b2 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -140,6 +140,7 @@ hr { padding: 24px 36px; padding-bottom: 36px; min-width: 308px; /* Widest logo plus padding - Firefox on Android needs this */ + max-width: none !important; } #sponsor-logos svg { @@ -154,8 +155,8 @@ hr { #sponsor-logos .logo-tweede-golf { position: relative; - top: 18px; - height: 4rem; + top: 14px; + height: 4.5rem; } #sponsor-logos + p { From 2ffe2fd2dd1b1a4949c3cf43b926932d856dac1a Mon Sep 17 00:00:00 2001 From: jecaro Date: Fri, 17 Nov 2023 10:51:27 +0100 Subject: [PATCH 053/129] fix golden tests accordingly --- crates/compiler/load/tests/test_reporting.rs | 40 ++++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/crates/compiler/load/tests/test_reporting.rs b/crates/compiler/load/tests/test_reporting.rs index 32732ceb7d..cf516a53e8 100644 --- a/crates/compiler/load/tests/test_reporting.rs +++ b/crates/compiler/load/tests/test_reporting.rs @@ -2447,7 +2447,7 @@ mod test_reporting { @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `add` has an unexpected type: + This 2nd argument to + has an unexpected type: 4│ 0x4 + "foo" ^^^^^ @@ -2456,7 +2456,7 @@ mod test_reporting { Str - But `add` needs its 2nd argument to be: + But + needs its 2nd argument to be: Int * "### @@ -2472,7 +2472,7 @@ mod test_reporting { @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `add` has an unexpected type: + This 2nd argument to + has an unexpected type: 4│ 0x4 + 3.14 ^^^^ @@ -2481,7 +2481,7 @@ mod test_reporting { Frac * - But `add` needs its 2nd argument to be: + But + needs its 2nd argument to be: Int * @@ -2500,7 +2500,7 @@ mod test_reporting { @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `add` has an unexpected type: + This 2nd argument to + has an unexpected type: 4│ 42 + True ^^^^ @@ -2509,7 +2509,7 @@ mod test_reporting { [True] - But `add` needs its 2nd argument to be: + But + needs its 2nd argument to be: Num * "### @@ -3556,7 +3556,7 @@ mod test_reporting { ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `add` has an unexpected type: + This 2nd argument to + has an unexpected type: 14│ x + y + h + l + minlit + maxlit ^^^^^^ @@ -3565,7 +3565,7 @@ mod test_reporting { U128 - But `add` needs its 2nd argument to be: + But + needs its 2nd argument to be: I128 or Dec "### @@ -3843,7 +3843,7 @@ mod test_reporting { @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `add` has an unexpected type: + This 2nd argument to + has an unexpected type: 4│ \{ x, y ? True } -> x + y ^ @@ -3852,7 +3852,7 @@ mod test_reporting { [True] - But `add` needs its 2nd argument to be: + But + needs its 2nd argument to be: Num a "### @@ -6377,7 +6377,7 @@ In roc, functions are always written as a lambda, like{} @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `mul` has an unexpected type: + This 2nd argument to * has an unexpected type: 5│ mult = \a, b -> a * b ^ @@ -6386,7 +6386,7 @@ In roc, functions are always written as a lambda, like{} F64 - But `mul` needs its 2nd argument to be: + But * needs its 2nd argument to be: Num * @@ -6421,7 +6421,7 @@ In roc, functions are always written as a lambda, like{} @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `mul` has an unexpected type: + This 2nd argument to * has an unexpected type: 5│ mult = \a, b -> a * b ^ @@ -6430,7 +6430,7 @@ In roc, functions are always written as a lambda, like{} F64 - But `mul` needs its 2nd argument to be: + But * needs its 2nd argument to be: Num a @@ -9234,7 +9234,7 @@ In roc, functions are always written as a lambda, like{} @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `isEq` has an unexpected type: + This 2nd argument to == has an unexpected type: 9│ Job lst -> lst == "" ^^ @@ -9243,7 +9243,7 @@ In roc, functions are always written as a lambda, like{} Str - But `isEq` needs its 2nd argument to be: + But == needs its 2nd argument to be: List [Job ∞] as ∞ "### @@ -10013,7 +10013,7 @@ In roc, functions are always written as a lambda, like{} @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `isEq` has an unexpected type: + This 2nd argument to == has an unexpected type: 4│ 0x80000000000000000000000000000000 == -0x80000000000000000000000000000000 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -10022,7 +10022,7 @@ In roc, functions are always written as a lambda, like{} I128 - But `isEq` needs its 2nd argument to be: + But == needs its 2nd argument to be: U128 "### @@ -10038,7 +10038,7 @@ In roc, functions are always written as a lambda, like{} @r###" ── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─ - This 2nd argument to `isEq` has an unexpected type: + This 2nd argument to == has an unexpected type: 4│ 170141183460469231731687303715884105728 == -170141183460469231731687303715884105728 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -10047,7 +10047,7 @@ In roc, functions are always written as a lambda, like{} I128 or Dec - But `isEq` needs its 2nd argument to be: + But == needs its 2nd argument to be: U128 "### From 946598cbc7f04484ca38a09c27d126577b9a9f53 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 11:24:44 +0100 Subject: [PATCH 054/129] fix nonprofit type --- www/wip_new_website/content/donate.md | 2 +- www/wip_new_website/content/index.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/www/wip_new_website/content/donate.md b/www/wip_new_website/content/donate.md index c9061051db..3fae70a842 100644 --- a/www/wip_new_website/content/donate.md +++ b/www/wip_new_website/content/donate.md @@ -6,7 +6,7 @@ You can donate to Roc’s development using: - [GitHub Sponsors](https://github.com/sponsors/roc-lang) - [Liberapay](https://liberapay.com/roc_lang) -All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 503(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. +All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 501(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. It also means that the foundation’s tax filings are a [matter of public record](https://en.wikipedia.org/wiki/501(c)(3)_organization#Transparency), so you have real transparency into how your donations are advancing Roc! diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index d2920967d3..e0b7fdd64a 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -162,4 +162,4 @@ We are currently trying to raise $4,000 USD/month in donations to fund one longt - [GitHub Sponsors](https://github.com/sponsors/roc-lang) - [Liberapay](https://liberapay.com/roc_lang) -All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 503(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. +All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 501(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. From a720e4472b7b7861a2bffbcfb2b129459a953d87 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 14:12:57 +0100 Subject: [PATCH 055/129] forgot this env var Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_test_arm64.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/basic_cli_test_arm64.yml b/.github/workflows/basic_cli_test_arm64.yml index e4278970b1..fc4ef3d476 100644 --- a/.github/workflows/basic_cli_test_arm64.yml +++ b/.github/workflows/basic_cli_test_arm64.yml @@ -36,7 +36,7 @@ jobs: - run: expect -v # Run all tests - - run: EXAMPLES_DIR=./examples/ ./ci/all_tests.sh + - run: ROC=./roc_nightly/roc EXAMPLES_DIR=./examples/ ./ci/all_tests.sh ###### # Now test the latest basic-cli release, not the main branch From cb488eab4e582ebb89758d08d2b8db02797b7eea Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 15:15:30 +0100 Subject: [PATCH 056/129] use prebuilt-platform flag Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index d87ad49a37..d35231d183 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -206,7 +206,8 @@ jobs: cp -r examples ../.. cp -r ci ../.. - cd ../.. - - ROC=./roc_nightly/roc EXAMPLES_DIR=./examples/ ./ci/all_tests.sh + - name: run tests + run: | + cd basic-cli-platform + ROC=./roc_nightly/roc EXAMPLES_DIR=./examples/ ROC_BUILD_FLAGS=--prebuilt-platform ./ci/all_tests.sh From 6093c0615940509c0b06f0c85ec1df30bb5b5c9a Mon Sep 17 00:00:00 2001 From: DuhPesky Date: Fri, 17 Nov 2023 07:57:47 -0700 Subject: [PATCH 057/129] lighten bg color for site --- www/wip_new_website/static/site.css | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index ae92c3a7b2..c5b0109281 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -758,7 +758,7 @@ li { --primary-1: #9c7cea; --primary-2: #1bd6bd; --text-color: #ccc; - --body-bg-color: #0e0e0f; + --body-bg-color: #151517; --border-color: var(--gray); --code-color: #eeeeee; --logo-solid: #8f8f8f; From abd622b5a62f223dec14740d5810134263eb7fb2 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 16:39:49 +0100 Subject: [PATCH 058/129] Update basic_cli_build_release.yml Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index d35231d183..ef755f408e 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -205,6 +205,8 @@ jobs: git checkout ${{ env.BASIC_CLI_BRANCH }} cp -r examples ../.. cp -r ci ../.. + cp -r LICENSE ../.. + # LICENSE is necessary for command test - name: run tests run: | From 2233ba470b1c16c1b0e1fbc6bcb78951cb063d6c Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 17:04:40 +0100 Subject: [PATCH 059/129] minor changes --- flake.nix | 6 ++++-- nix/default.nix | 2 ++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/flake.nix b/flake.nix index e66c73a75a..cfb5b92855 100644 --- a/flake.nix +++ b/flake.nix @@ -159,9 +159,11 @@ # You can build this package (the roc CLI) with the `nix build` command. packages = { - default = rocBuild.roc-full; + default = rocBuild.roc-cli; + + # all rust crates in workspace.members of Cargo.toml full = rocBuild.roc-full; - + # only the CLI crate = executable provided in nightly releases cli = rocBuild.roc-cli; lang-server = rocBuild.roc-lang-server; }; diff --git a/nix/default.nix b/nix/default.nix index 0796b64f4d..d62664a142 100644 --- a/nix/default.nix +++ b/nix/default.nix @@ -16,8 +16,10 @@ let rust-shell = (rustVersion.override { extensions = [ "rust-src" "rust-analyzer" ]; }); + # all rust crates in workspace.members of Cargo.toml roc-full = callPackage ./builder.nix { }; roc-lang-server = callPackage ./builder.nix { subPackage = "lang_srv"; }; + # only the CLI crate = executable provided in nightly releases roc-cli = callPackage ./builder.nix { subPackage = "cli"; }; }; From 3fc701455ff18616d51dcfd57b13b98bc0ed7304 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 17 Nov 2023 11:13:29 -0500 Subject: [PATCH 060/129] Update /docs and /install --- www/wip_new_website/content/docs.md | 12 ++++-------- www/wip_new_website/content/install.md | 2 +- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/www/wip_new_website/content/docs.md b/www/wip_new_website/content/docs.md index c0f065a0ba..ff2cb26769 100644 --- a/www/wip_new_website/content/docs.md +++ b/www/wip_new_website/content/docs.md @@ -4,14 +4,10 @@ Builtin Package - [docs](https://www.roc-lang.org/builtins) Basic-CLI Platform - [repo](https://github.com/roc-lang/basic-cli) - [docs](https://www.roc-lang.org/packages/basic-cli) -## Guides +### [Guides](#guides) {#guides} -[Frequently Asked Questions](https://github.com/roc-lang/roc/blob/main/FAQ.md) +[Tutorial](/tutorial) + +[FAQ (Frequently Asked Questions)](https://github.com/roc-lang/roc/blob/main/FAQ.md) [Roc for Elm Programmers](https://github.com/roc-lang/roc/blob/main/roc-for-elm-programmers.md) - -## Language Reference - - - - diff --git a/www/wip_new_website/content/install.md b/www/wip_new_website/content/install.md index 06c2540b6a..6beaf4ee98 100644 --- a/www/wip_new_website/content/install.md +++ b/www/wip_new_website/content/install.md @@ -1,4 +1,4 @@ -# Install Roc +# Install Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download if you’d like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)! From 1a97e5179dfe67bddd8301dff445c9e66658fb24 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 18:01:01 +0100 Subject: [PATCH 061/129] fix devtools diff check --- .github/workflows/devtools_test_linux_x86_64.yml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/devtools_test_linux_x86_64.yml b/.github/workflows/devtools_test_linux_x86_64.yml index 6c8d8b1e1c..45659609ba 100644 --- a/.github/workflows/devtools_test_linux_x86_64.yml +++ b/.github/workflows/devtools_test_linux_x86_64.yml @@ -15,25 +15,25 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Only run all steps if flake.lock or flake.nix changed + - name: Only run all steps if a nix file changed id: checklock run: | - if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake'; then - echo "A flake file was changed. Testing devtools nix files..." - echo "flake_changed=true" >> $GITHUB_ENV + if git diff --name-only origin/${{ github.base_ref }} HEAD | grep 'nix'; then + echo "A nix file was changed. Testing devtools nix files..." + echo "nix_changed=true" >> $GITHUB_ENV else - echo "No flake file was changed. No need to run tests." - echo "flake_changed=false" >> $GITHUB_ENV + echo "A nix file was changed. No need to run tests." + echo "nix_changed=false" >> $GITHUB_ENV fi - uses: cachix/install-nix-action@v23 - if: env.flake_changed == 'true' + if: env.nix_changed == 'true' with: nix_path: nixpkgs=channel:nixos-unstable - name: test devtools/flake.nix - if: env.flake_changed == 'true' + if: env.nix_changed == 'true' id: devtools_test_step run: | sed -i "s|/home/username/gitrepos/roc|$(realpath .)|g" devtools/flake.nix From 882c71f68b3549916ca84781fec6e7ce3a98d645 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 18:14:15 +0100 Subject: [PATCH 062/129] try another devtools test fix --- .github/workflows/devtools_test_linux_x86_64.yml | 2 +- .github/workflows/devtools_test_macos_apple_silicon.yml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/devtools_test_linux_x86_64.yml b/.github/workflows/devtools_test_linux_x86_64.yml index 45659609ba..bc4eb36b60 100644 --- a/.github/workflows/devtools_test_linux_x86_64.yml +++ b/.github/workflows/devtools_test_linux_x86_64.yml @@ -16,8 +16,8 @@ jobs: - uses: actions/checkout@v3 - name: Only run all steps if a nix file changed - id: checklock run: | + git fetch origin ${{ github.base_ref }} if git diff --name-only origin/${{ github.base_ref }} HEAD | grep 'nix'; then echo "A nix file was changed. Testing devtools nix files..." echo "nix_changed=true" >> $GITHUB_ENV diff --git a/.github/workflows/devtools_test_macos_apple_silicon.yml b/.github/workflows/devtools_test_macos_apple_silicon.yml index 68027ecb00..67c88fb68e 100644 --- a/.github/workflows/devtools_test_macos_apple_silicon.yml +++ b/.github/workflows/devtools_test_macos_apple_silicon.yml @@ -16,8 +16,8 @@ jobs: - uses: actions/checkout@v3 - name: Only run all steps if flake.lock or flake.nix changed - id: checklock run: | + git fetch origin ${{ github.base_ref }} if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake'; then echo "A flake file was changed. Testing devtools nix files..." echo "flake_changed=true" >> $GITHUB_ENV @@ -41,7 +41,7 @@ jobs: nix develop --show-trace - name: Print tip on fail - if: env.flake_changed == 'true' + if: steps.devtools_test_step.outcome == 'failure' run: | echo "The devtools test failed, this can likely be fixed by" echo "locally deleting devtools/flake.lock and following the" From c22c4e06e00b60a89bf18b9c44157a95f384f959 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 19:21:46 +0100 Subject: [PATCH 063/129] update devtools flake --- devtools/flake.lock | 120 +++++++++++++++++--------------------------- 1 file changed, 47 insertions(+), 73 deletions(-) mode change 100755 => 100644 devtools/flake.lock diff --git a/devtools/flake.lock b/devtools/flake.lock old mode 100755 new mode 100644 index c15d838e56..d90cc13aad --- a/devtools/flake.lock +++ b/devtools/flake.lock @@ -1,21 +1,36 @@ { "nodes": { + "flake-compat": { + "flake": false, + "locked": { + "lastModified": 1696426674, + "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", + "owner": "edolstra", + "repo": "flake-compat", + "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", + "type": "github" + }, + "original": { + "owner": "edolstra", + "repo": "flake-compat", + "type": "github" + } + }, "flake-utils": { "inputs": { "systems": "systems" }, "locked": { - "lastModified": 1692799911, - "narHash": "sha256-3eihraek4qL744EvQXsK1Ha6C3CR7nnT8X2qWap4RNk=", + "lastModified": 1694529238, + "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=", "owner": "numtide", "repo": "flake-utils", - "rev": "f9e7cf818399d17d347f847525c5a5a8032e4e44", + "rev": "ff7b65b44d01cf9ba6a71320833626af21126384", "type": "github" }, "original": { - "owner": "numtide", - "repo": "flake-utils", - "type": "github" + "id": "flake-utils", + "type": "indirect" } }, "flake-utils_2": { @@ -23,44 +38,11 @@ "systems": "systems_2" }, "locked": { - "lastModified": 1681202837, - "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=", + "lastModified": 1694529238, + "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=", "owner": "numtide", "repo": "flake-utils", - "rev": "cfacdce06f30d2b68473a46042957675eebb3401", - "type": "github" - }, - "original": { - "owner": "numtide", - "repo": "flake-utils", - "type": "github" - } - }, - "flake-utils_3": { - "locked": { - "lastModified": 1659877975, - "narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=", - "owner": "numtide", - "repo": "flake-utils", - "rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0", - "type": "github" - }, - "original": { - "owner": "numtide", - "repo": "flake-utils", - "type": "github" - } - }, - "flake-utils_4": { - "inputs": { - "systems": "systems_3" - }, - "locked": { - "lastModified": 1681202837, - "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=", - "owner": "numtide", - "repo": "flake-utils", - "rev": "cfacdce06f30d2b68473a46042957675eebb3401", + "rev": "ff7b65b44d01cf9ba6a71320833626af21126384", "type": "github" }, "original": { @@ -71,18 +53,21 @@ }, "nixgl": { "inputs": { - "flake-utils": "flake-utils_3", + "flake-utils": [ + "roc", + "flake-utils" + ], "nixpkgs": [ "roc", "nixpkgs" ] }, "locked": { - "lastModified": 1676383589, - "narHash": "sha256-KCkWZXCjH+C4Kn7fUGSrEl5btk+sERHhZueSsvVbPWc=", + "lastModified": 1685908677, + "narHash": "sha256-E4zUPEUFyVWjVm45zICaHRpfGepfkE9Z2OECV9HXfA4=", "owner": "guibou", "repo": "nixGL", - "rev": "c917918ab9ebeee27b0dd657263d3f57ba6bb8ad", + "rev": "489d6b095ab9d289fe11af0219a9ff00fe87c7c5", "type": "github" }, "original": { @@ -93,35 +78,36 @@ }, "nixpkgs": { "locked": { - "lastModified": 1690279121, - "narHash": "sha256-XoPGhV1UJQPue6RiehAu7lQwKss3J1B/K0QtVOMD83A=", + "lastModified": 1693140250, + "narHash": "sha256-URyIDETtu1bbxcSl83xp7irEV04dPEgj7O3LjHcD1Sk=", "owner": "nixos", "repo": "nixpkgs", - "rev": "821c72743ceae44bdd09718d47cab98fd5fd90af", + "rev": "676fe5e01b9a41fa14aaa48d87685677664104b1", "type": "github" }, "original": { "owner": "nixos", "repo": "nixpkgs", - "rev": "821c72743ceae44bdd09718d47cab98fd5fd90af", + "rev": "676fe5e01b9a41fa14aaa48d87685677664104b1", "type": "github" } }, "roc": { "inputs": { + "flake-compat": "flake-compat", "flake-utils": "flake-utils_2", "nixgl": "nixgl", "nixpkgs": "nixpkgs", "rust-overlay": "rust-overlay" }, "locked": { - "lastModified": 1694000770, - "narHash": "sha256-92bAbPmwXxD6rwaAViG5O9r91ZBh9bqaZhM3egPCjuw=", - "path": "/home/anton/gitrepos/roc", + "lastModified": 1700241573, + "narHash": "sha256-+hjY1FieVbF8jvRE3Cvo8GBWh1OlFrF+QDFF8OlWM/s=", + "path": "/home/username/gitrepos/JRMurr/roc", "type": "path" }, "original": { - "path": "/home/anton/gitrepos/roc", + "path": "/home/username/gitrepos/JRMurr/roc", "type": "path" } }, @@ -133,18 +119,21 @@ }, "rust-overlay": { "inputs": { - "flake-utils": "flake-utils_4", + "flake-utils": [ + "roc", + "flake-utils" + ], "nixpkgs": [ "roc", "nixpkgs" ] }, "locked": { - "lastModified": 1690252178, - "narHash": "sha256-9oEz822bvbHobfCUjJLDor2BqW3I5tycIauzDlzOALY=", + "lastModified": 1695694299, + "narHash": "sha256-0CucEiOZzOVHwmGDJKNXLj7aDYOqbRtqChp9nbGrh18=", "owner": "oxalica", "repo": "rust-overlay", - "rev": "8d64353ca827002fb8459e44d49116c78d868eba", + "rev": "c89a55d2d91cf55234466934b25deeffa365188a", "type": "github" }, "original": { @@ -182,21 +171,6 @@ "repo": "default", "type": "github" } - }, - "systems_3": { - "locked": { - "lastModified": 1681028828, - "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", - "owner": "nix-systems", - "repo": "default", - "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", - "type": "github" - }, - "original": { - "owner": "nix-systems", - "repo": "default", - "type": "github" - } } }, "root": "root", From 8a848c3fbd0af76c4f742db8adfd098eb31e3e18 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 19:25:52 +0100 Subject: [PATCH 064/129] forgot mac changes --- .../workflows/devtools_test_macos_apple_silicon.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/devtools_test_macos_apple_silicon.yml b/.github/workflows/devtools_test_macos_apple_silicon.yml index 67c88fb68e..ccf1fe39bd 100644 --- a/.github/workflows/devtools_test_macos_apple_silicon.yml +++ b/.github/workflows/devtools_test_macos_apple_silicon.yml @@ -15,15 +15,15 @@ jobs: steps: - uses: actions/checkout@v3 - - name: Only run all steps if flake.lock or flake.nix changed + - name: Only run all steps if a nix file changed run: | git fetch origin ${{ github.base_ref }} - if git diff --name-only ${{ github.event.before }} ${{ github.sha }} | grep 'flake'; then - echo "A flake file was changed. Testing devtools nix files..." - echo "flake_changed=true" >> $GITHUB_ENV + if git diff --name-only origin/${{ github.base_ref }} HEAD | grep 'nix'; then + echo "A nix file was changed. Testing devtools nix files..." + echo "nix_changed=true" >> $GITHUB_ENV else - echo "No flake file was changed. No need to run tests." - echo "flake_changed=false" >> $GITHUB_ENV + echo "A nix file was changed. No need to run tests." + echo "nix_changed=false" >> $GITHUB_ENV fi - name: test devtools/flake.nix From 41e600fe7718ece831ede39f409b3291bf1b96c8 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 19:27:36 +0100 Subject: [PATCH 065/129] fix env var --- .github/workflows/devtools_test_macos_apple_silicon.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/devtools_test_macos_apple_silicon.yml b/.github/workflows/devtools_test_macos_apple_silicon.yml index ccf1fe39bd..874e2c026f 100644 --- a/.github/workflows/devtools_test_macos_apple_silicon.yml +++ b/.github/workflows/devtools_test_macos_apple_silicon.yml @@ -27,7 +27,7 @@ jobs: fi - name: test devtools/flake.nix - if: env.flake_changed == 'true' + if: env.nix_changed == 'true' id: devtools_test_step run: | sed -i '' "s|/home/username/gitrepos/roc|$(realpath .)|g" devtools/flake.nix From badc45d442fe50dc7ec1f8609b12a82678cd9891 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 20:02:14 +0100 Subject: [PATCH 066/129] ci install ncat(nmap) Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index ef755f408e..631e0c8cdb 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -191,6 +191,9 @@ jobs: - name: Install expect for tests if we dont have it yet run: if ! dpkg -l | grep -qw expect; then sudo apt install -y expect; fi + - name: Install ncat (included with nmap) for tests if we dont have it yet + run: if ! dpkg -l | grep -qw nmap; then sudo apt install -y nmap; fi + - name: prep testing run: | mv roc_nightly basic-cli-platform/. From 04b620b9f449ccbd730087ebfe97d2ecc5f012c8 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Fri, 17 Nov 2023 20:49:50 +0100 Subject: [PATCH 067/129] apparently nmap does not contain ncat Signed-off-by: Anton-4 <17049058+Anton-4@users.noreply.github.com> --- .github/workflows/basic_cli_build_release.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 631e0c8cdb..246b29222d 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -191,8 +191,8 @@ jobs: - name: Install expect for tests if we dont have it yet run: if ! dpkg -l | grep -qw expect; then sudo apt install -y expect; fi - - name: Install ncat (included with nmap) for tests if we dont have it yet - run: if ! dpkg -l | grep -qw nmap; then sudo apt install -y nmap; fi + - name: Install ncat for tests if we dont have it yet + run: if ! dpkg -l | grep -qw ncat; then sudo apt install -y ncat; fi - name: prep testing run: | From 0e2dbb433f8337cfb66134763ce702cb252b4087 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 17 Nov 2023 23:18:54 -0500 Subject: [PATCH 068/129] Get rid of fancy quotes --- www/wip_new_website/InteractiveExample.roc | 14 +++++++------- www/wip_new_website/content/community.md | 4 ++-- www/wip_new_website/content/docs.md | 6 ++++-- www/wip_new_website/content/donate.md | 6 +++--- www/wip_new_website/content/fast.md | 10 +++++----- www/wip_new_website/content/friendly.md | 2 +- www/wip_new_website/content/functional.md | 4 ++-- www/wip_new_website/content/index.md | 14 +++++++------- www/wip_new_website/content/install.md | 2 +- www/wip_new_website/content/tutorial.md | 2 +- www/wip_new_website/static/site.js | 2 +- 11 files changed, 34 insertions(+), 32 deletions(-) diff --git a/www/wip_new_website/InteractiveExample.roc b/www/wip_new_website/InteractiveExample.roc index 29e7382788..752a7b697f 100644 --- a/www/wip_new_website/InteractiveExample.roc +++ b/www/wip_new_website/InteractiveExample.roc @@ -25,7 +25,7 @@ view = Indent, Desc [Ident "Path.fromStr", Str "\"url.txt\""] "

This converts the string \"url.txt\" into a Path by passing it to Path.fromStr.

Function arguments are separated with whitespace. Parentheses are only needed in nested function calls.

", Newline, - Desc [Kw "|>", Ident "storeEmail"] "

The pipe operator (|>) is syntax sugar for passing the previous value to the next function in the “pipeline.”

This line takes the value that Path.fromStr \"url.txt\" returns and passes it to storeEmail.

The next |> continues the pipeline.

", + Desc [Kw "|>", Ident "storeEmail"] "

The pipe operator (|>) is syntax sugar for passing the previous value to the next function in the \"pipeline.\"

This line takes the value that Path.fromStr \"url.txt\" returns and passes it to storeEmail.

The next |> continues the pipeline.

", Newline, Desc [Kw "|>", Ident "Task.onErr", Ident "handleErr"] "

If the task returned by the previous step in the pipeline fails, pass its error to handleErr.

The pipeline essentially does this:

a = Path.fromStr \"url.txt\"\nb = storeEmail a\n\nTask.onErr b handleErr

It creates a Path from a string, stores an email based on that path, and then does error handling.

", Outdent, @@ -34,24 +34,24 @@ view = Indent, Desc [Ident "url", Kw "<-", Ident "File.readUtf8", Ident "path", Kw "|>", Ident "Task.await"] "

This reads the contents of the file (as a UTF-8 string) into url.

The <- does backpassing, which is syntax sugar for defining a function. This line desugars to:

Task.await\n    (File.readUtf8 path)\n    \\url ->

The lines after this one form the body of the \\url -> callback, which runs if the file read succeeds.

", Newline, - Desc [Ident "user", Kw "<-", Ident "Http.get", Ident "url", Ident "Json.codec", Kw "|>", Ident "Task.await"] "

This fetches the contents of the URL and decodes them as JSON.

If the shape of the JSON isn’t compatible with the type of user (based on type inference), this will give a decoding error immediately.

As with all the other lines ending in |> Task.await, if there’s an error, nothing else in storeEmail will be run, and handleErr will end up handling the error.

", + Desc [Ident "user", Kw "<-", Ident "Http.get", Ident "url", Ident "Json.codec", Kw "|>", Ident "Task.await"] "

This fetches the contents of the URL and decodes them as JSON.

If the shape of the JSON isn't compatible with the type of user (based on type inference), this will give a decoding error immediately.

As with all the other lines ending in |> Task.await, if there's an error, nothing else in storeEmail will be run, and handleErr will end up handling the error.

", Newline, Desc [Ident "dest", Kw "=", Ident "Path.fromStr", StrInterpolation "\"" "user.name" ".txt\""] "

The \\(user.name) in this string literal will be replaced with the value in name. This is string interpolation.

Note that this line doesn't end with |> Task.await. Earlier lines needed that because they were I/O tasks, but this is a plain old definition, so there's no task to await.

", Newline, - Desc [Literal "_", Kw "<-", Ident "File.writeUtf8", Ident "dest", Ident "user.email", Kw "|>", Ident "Task.await"] "

This writes user.email to the file, encoded as UTF-8.

We won’t be using the output of writeUtf8, so we name it _. The special name _ is for when you don’t want to use something.

You can name as many things as you like _, but you can never reference anything named _. So it’s only useful for when you don’t want to choose a name.

", + Desc [Literal "_", Kw "<-", Ident "File.writeUtf8", Ident "dest", Ident "user.email", Kw "|>", Ident "Task.await"] "

This writes user.email to the file, encoded as UTF-8.

We won't be using the output of writeUtf8, so we name it _. The special name _ is for when you don't want to use something.

You can name as many things as you like _, but you can never reference anything named _. So it's only useful for when you don't want to choose a name.

", Newline, - Desc [Ident "Stdout.line", StrInterpolation "\"Wrote email to " "Path.display dest" "\""] "

This prints what we did to stdout.

Note that this line doesn't end with |> Task.await. That’s because, although Stdout.line returns a task, we don’t need to await it because nothing happens after it.

", + Desc [Ident "Stdout.line", StrInterpolation "\"Wrote email to " "Path.display dest" "\""] "

This prints what we did to stdout.

Note that this line doesn't end with |> Task.await. That's because, although Stdout.line returns a task, we don't need to await it because nothing happens after it.

", Outdent, Newline, Desc [Ident "handleErr", Kw "=", Lambda ["err"]] "

Like storeEmail, handleErr is also a function.

Although type annotations are optional everywhere in Roc—because the language has 100% type inference—you could add type annotations to main, storeEmail, and handleErr if you wanted to.

", Indent, Desc [Kw "when", Ident "err", Kw "is"] "

This will run one of the following lines depending on what value the err argument has.

Each line does a pattern match on the shape of the error to decide whether to run, or to move on and try the next line's pattern.

Roc will do compile-time exhaustiveness checking and tell you if you forgot to handle any error cases here that could have occurred, based on the tasks that were run in storeEmail.

", Indent, - Desc [Literal "HttpErr", Ident "url", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error fetching URL " "url" "\""] "

This line will run if the Http.get request from earlier encountered an HTTP error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the HttpErr. If we wanted to print more detail about what the error was, we’d name that something other than _ and actually use it.

", + Desc [Literal "HttpErr", Ident "url", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error fetching URL " "url" "\""] "

This line will run if the Http.get request from earlier encountered an HTTP error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the HttpErr. If we wanted to print more detail about what the error was, we'd name that something other than _ and actually use it.

", Newline, - Desc [Literal "FileReadErr", Ident "path", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error reading from " "Path.display path" "\""] "

This line will run if the File.readUtf8 from earlier encountered a file I/O error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the FileReadErr. If we wanted to print more detail about what the error was, we’d name that something other than _ and actually use it.

", + Desc [Literal "FileReadErr", Ident "path", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error reading from " "Path.display path" "\""] "

This line will run if the File.readUtf8 from earlier encountered a file I/O error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the FileReadErr. If we wanted to print more detail about what the error was, we'd name that something other than _ and actually use it.

", Newline, - Desc [Literal "FileWriteErr", Ident "path", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error writing to " "Path.display path" "\""] "

This line will run if the File.writeUtf8 from earlier encountered a file I/O error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the FileWriteErr. If we wanted to print more detail about what the error was, we’d name that something other than _ and actually use it.

", + Desc [Literal "FileWriteErr", Ident "path", Kw "_", Kw "->", Ident "Stderr.line", StrInterpolation "\"Error writing to " "Path.display path" "\""] "

This line will run if the File.writeUtf8 from earlier encountered a file I/O error.

It handles the error by printing an error message to stderr.

The _ is where more information about the error is stored in the FileWriteErr. If we wanted to print more detail about what the error was, we'd name that something other than _ and actually use it.

", ] div [role "presentation"] [ diff --git a/www/wip_new_website/content/community.md b/www/wip_new_website/content/community.md index 89edc58642..ef6a14b5ae 100644 --- a/www/wip_new_website/content/community.md +++ b/www/wip_new_website/content/community.md @@ -4,7 +4,7 @@ We love it when new people stop by and introduce themselves in [`#introductions`](https://roc.zulipchat.com/#narrow/stream/387892-introductions) so others can welcome you to the community! The Roc Online Meetup meets about once per month. The organizer posts a [when2meet](https://when2meet.com) for the next month's meetup in [`#gatherings` on Zulip](https://roc.zulipchat.com/#narrow/stream/303057-gatherings), so we can find the best time that works for everyone -who's interested in attending. The organizer then posts a finalized time and a link to where people can join. They usually last between 1-2 hours, and consist of some casual show-and-tell presentations followed by conversation. They’re fun! +who's interested in attending. The organizer then posts a finalized time and a link to where people can join. They usually last between 1-2 hours, and consist of some casual show-and-tell presentations followed by conversation. They're fun! We have not had a Roc conference yet, although there have been a few Roc talks given at conferences, and a few times when Roc community members have met up in person. @@ -35,4 +35,4 @@ A written proposal isn't always necessary (for example, it may be deemed a simpl There's no guarantee that a proposal will be accepted, and even if it is, there's no guarantee that something won't come up during implementation that changes the tradeoffs and means it doesn't end up making it into the language after all. But if it is accepted (again, doesn't have to be by the [BDFN](/bdfn) - although the BDFN does have final say if there's a disagreement at some point), that means a [Pull Request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request) should be reviewed, and the general understanding is that the PR will be accepted unless some problem is discovered during implementation that wasn't anticipated at the proposal stage. -This is the process we’re using for now, but of course it may change in the future! +This is the process we're using for now, but of course it may change in the future! diff --git a/www/wip_new_website/content/docs.md b/www/wip_new_website/content/docs.md index ff2cb26769..1e95c3dae4 100644 --- a/www/wip_new_website/content/docs.md +++ b/www/wip_new_website/content/docs.md @@ -1,8 +1,8 @@ # Documentation -Builtin Package - [docs](https://www.roc-lang.org/builtins) +[Builtins](https://www.roc-lang.org/builtins) -Basic-CLI Platform - [repo](https://github.com/roc-lang/basic-cli) - [docs](https://www.roc-lang.org/packages/basic-cli) +The basic-cLI platform - [repo](https://github.com/roc-lang/basic-cli) - [docs](https://www.roc-lang.org/packages/basic-cli) ### [Guides](#guides) {#guides} @@ -11,3 +11,5 @@ Basic-CLI Platform - [repo](https://github.com/roc-lang/basic-cli) - [docs](http [FAQ (Frequently Asked Questions)](https://github.com/roc-lang/roc/blob/main/FAQ.md) [Roc for Elm Programmers](https://github.com/roc-lang/roc/blob/main/roc-for-elm-programmers.md) + +In the future, there will be a language reference here as well. However, it doesn't exist yet! diff --git a/www/wip_new_website/content/donate.md b/www/wip_new_website/content/donate.md index c9061051db..ef31dfc5e8 100644 --- a/www/wip_new_website/content/donate.md +++ b/www/wip_new_website/content/donate.md @@ -2,12 +2,12 @@ We are a small group trying to do big things, and we are grateful for every donation! Right now we are trying to raise $4,000 USD/month in donations to fund one longtime Roc contributor to continue his work on Roc full-time. -You can donate to Roc’s development using: +You can donate to Roc's development using: - [GitHub Sponsors](https://github.com/sponsors/roc-lang) - [Liberapay](https://liberapay.com/roc_lang) All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 503(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. -It also means that the foundation’s tax filings are a [matter of public record](https://en.wikipedia.org/wiki/501(c)(3)_organization#Transparency), so you have real transparency into how your donations are advancing Roc! +It also means that the foundation's tax filings are a [matter of public record](https://en.wikipedia.org/wiki/501(c)(3)_organization#Transparency), so you have real transparency into how your donations are advancing Roc! -If you would like your organization to become an official sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383). We’d love to talk to you! +If you would like your organization to become an official sponsor of Roc's development, please [DM Richard Feldman on Zulip](https://roc.zulipchat.com/#narrow/pm-with/281383-user281383). We'd love to talk to you! diff --git a/www/wip_new_website/content/fast.md b/www/wip_new_website/content/fast.md index 1ef6706f46..fbb9177fb0 100644 --- a/www/wip_new_website/content/fast.md +++ b/www/wip_new_website/content/fast.md @@ -4,7 +4,7 @@ Roc code is designed to build fast and run fast...but what does "fast" mean here ## [Fast programs](#fast-programs) {#fast-programs} -What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc’s performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what types of languages Roc should generally outperform. +What "fast" means in embedded systems is different from what it means in games, which in turn is different from what it means on the Web. To better understand Roc's performance capabilities, let's look at the upper bound of how fast optimized Roc programs are capable of running, and the lower bound of what types of languages Roc should generally outperform. ### [Limiting factors: memory management and async I/O](#limiting-factors) {#limiting-factors} @@ -22,21 +22,21 @@ When [benchmarking compiled Roc programs](https://www.youtube.com/watch?v=vzfy4E ### [Domain-specific memory management](#domain-specific-memory-management) {#domain-specific-memory-management} -Roc’s “platforms and applications” design means its automatic memory management can take advantage of domain-specific properties to improve performance. +Roc's "platforms and applications" design means its automatic memory management can take advantage of domain-specific properties to improve performance. -For example, if you build an application on the [`basic-cli` platform](https://github.com/roc-lang/basic-cli) compared to the [`basic-webserver` platform](https://github.com/roc-lang/basic-webserver), each of those platforms may use a different memory management strategy under the hood that’s tailored to their respective use cases. Your application's performance can benefit from this, even though building on either of those platforms feels like using ordinary automatic memory management. +For example, if you build an application on the [`basic-cli` platform](https://github.com/roc-lang/basic-cli) compared to the [`basic-webserver` platform](https://github.com/roc-lang/basic-webserver), each of those platforms may use a different memory management strategy under the hood that's tailored to their respective use cases. Your application's performance can benefit from this, even though building on either of those platforms feels like using ordinary automatic memory management. This is because Roc _platforms_ get to determine how memory gets allocated and deallocated in applications built on them. ([`basic-cli`](https://github.com/roc-lang/basic-cli) and [`basic-webserver`](https://github.com/roc-lang/basic-webserver) are examples of platforms, but anyone can build their own platform.) Here are some examples of how platforms can use this to improve application performance: - A platform for noninteractive command-line scripts can skip deallocations altogether, since any allocated memory will be cheaply reclaimed by the operating system anyway once the script exits. (This strategy is domain-specific; it would not work well for a long-running, interactive program!) -- A platform for Web servers can put all allocations for each request into a particular [region of memory](https://en.wikipedia.org/wiki/Region-based_memory_management) (this is known as “arena allocation” or ”bump allocation”) and then deallocate the entire region in one cheap operation after the response has been sent. This would essentially drop memory reclamation times to zero. (This strategy relies on Web servers’ request/response architecture, and wouldn't make sense in other use cases. [`nea`](https://github.com/tweedegolf/nea) is a platform in early development that is working towards implementing this.) +- A platform for Web servers can put all allocations for each request into a particular [region of memory](https://en.wikipedia.org/wiki/Region-based_memory_management) (this is known as "arena allocation" or "bump allocation") and then deallocate the entire region in one cheap operation after the response has been sent. This would essentially drop memory reclamation times to zero. (This strategy relies on Web servers' request/response architecture, and wouldn't make sense in other use cases. [`nea`](https://github.com/tweedegolf/nea) is a platform in early development that is working towards implementing this.) - A platform for applications that have very long-lived state could implement [meshing compaction](https://youtu.be/c1UBJbfR-H0?si=D9Gp0cdpjZ_Is5v8) to decrease memory fragmentation. (Compaction would probably be a net negative for performance in the previous two examples.) [This talk](https://www.youtube.com/watch?v=cpQwtwVKAfU&t=75s) has more information about platforms and applications, including demos and examples of other benefits they unlock besides performance. ### [Current progress](#current-progress) {#current-progress} -Roc's “platforms and applications” design already works, including the domain-specific memory management. Most of Roc’s data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. [This talk](https://vimeo.com/653510682) explains how they’re implemented under the hood. +Roc's "platforms and applications" design already works, including the domain-specific memory management. Most of Roc's data structures are already close to their theoretical limit in terms of performance, at least without changing their behavior or introducing memory unsafety. [This talk](https://vimeo.com/653510682) explains how they're implemented under the hood. That said, [the current implementation](https://ayazhafiz.com/articles/23/a-lambda-calculus-with-coroutines-and-heapless-closures) of [defunctionalization](https://blog.sigplan.org/2019/12/30/defunctionalization-everybody-does-it-nobody-talks-about-it/) (based on [this paper](https://dl.acm.org/doi/pdf/10.1145/3591260))—which unlocks stack-allocated closures, among other optimizations—has [significant known gaps](https://github.com/roc-lang/roc/issues/5969), and has a ways to go before it works across the board. (If you're interested in getting involved in that implementation, [we'd love to hear from you](https://roc.zulipchat.com)!) diff --git a/www/wip_new_website/content/friendly.md b/www/wip_new_website/content/friendly.md index 2904713205..49ee707588 100644 --- a/www/wip_new_website/content/friendly.md +++ b/www/wip_new_website/content/friendly.md @@ -50,7 +50,7 @@ When dealing with [serialized data](https://en.wikipedia.org/wiki/Serialization) A technique used in some popular languages today is to decode without validation. For example, some languages parse [JSON](https://www.json.org) using a function whose return type is unchecked at compile time (commonly called an `any` type). This technique has a low up-front cost, because it does not require specifying the expected shape of the JSON data. -Unfortunately, if there’s any mismatch between the way that returned value ends up being used and the runtime shape of the JSON, it can result in errors that are time-consuming to debug because they are distant from (and may appear unrelated to) the JSON decoding where the problem originated. Since Roc has a [sound type system](https://en.wikipedia.org/wiki/Type_safety), it does not have an `any` type, and cannot support this technique. +Unfortunately, if there's any mismatch between the way that returned value ends up being used and the runtime shape of the JSON, it can result in errors that are time-consuming to debug because they are distant from (and may appear unrelated to) the JSON decoding where the problem originated. Since Roc has a [sound type system](https://en.wikipedia.org/wiki/Type_safety), it does not have an `any` type, and cannot support this technique. Another technique is to validate the serialized data against a schema specified at compile time, and give an error during decoding if the data doesn't match this schema. Serialization formats like [protocol buffers](https://protobuf.dev/) require this approach, but some languages encourage (or require) doing it for _all_ serialized data formats, which prevents decoding errors from propagating throughout the program and causing distant errors. Roc supports and encourages using this technique. diff --git a/www/wip_new_website/content/functional.md b/www/wip_new_website/content/functional.md index bdbc430dca..86d62a5c9d 100644 --- a/www/wip_new_website/content/functional.md +++ b/www/wip_new_website/content/functional.md @@ -23,9 +23,9 @@ Roc has ways of detecting uniqueness at compile time, so this optimization will ## [Everything is immutable (semantically)](#everything-is-immutable) {#everything-is-immutable} -Since mutation is only ever done when it wouldn’t change the behavior of the program, all Roc values are semantically immutable—even though they can still benefit from the performance of in-place mutation. +Since mutation is only ever done when it wouldn't change the behavior of the program, all Roc values are semantically immutable—even though they can still benefit from the performance of in-place mutation. -In many languages, this is reversed; everything is mutable by default, and it's up to the programmer to “defensively” clone to avoid undesirable modification. Roc's approach means that cloning happens automatically, which can be less error-prone than defensive cloning (which might be forgotten), but which—to be fair—can also increase unintentional cloning. It's a different default with different tradeoffs. +In many languages, this is reversed; everything is mutable by default, and it's up to the programmer to "defensively" clone to avoid undesirable modification. Roc's approach means that cloning happens automatically, which can be less error-prone than defensive cloning (which might be forgotten), but which—to be fair—can also increase unintentional cloning. It's a different default with different tradeoffs. A reliability benefit of semantic immutability everywhere is that it rules out [data races](https://en.wikipedia.org/wiki/Race_condition#Data_race). These concurrency bugs can be difficult to reproduce and time-consuming to debug, and they are only possible through direct mutation. Roc's semantic immutability rules out this category of bugs. diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index d2920967d3..d393b23ce6 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -21,7 +21,7 @@ @@ -29,7 +29,7 @@

Functional

- Roc has a small number of simple language primitives. It’s a single-paradigm functional language.

+ Roc has a small number of simple language primitives. It's a single-paradigm functional language.

What does functional mean here?

 @@ -62,9 +62,9 @@ ## [Examples](#examples) {#examples} -Roc is a young language. It doesn’t even have a numbered release yet, just nightly builds! +Roc is a young language. It doesn't even have a numbered release yet, just nightly builds! -However, it can already be used for several things if you’re up for being an early adopter—
+However, it can already be used for several things if you're up for being an early adopter—
with all the bugs and missing features which come with that territory. Here are some examples of how it can be used today. @@ -76,7 +76,7 @@ Here are some examples of how it can be used today. Stdout.line "Hello!"

You can use Roc to create scripts and command-line interfaces (CLIs). The compiler produces binary executables, so Roc programs can run on devices that don't have Roc itself installed.

As an example, the HTML for this website is generated using a simple Roc script. You can see the code for it in the main Roc code repository.

-

If you’re looking for a starting point for building a command-line program in Roc, basic-cli is a popular platform to check out.

+

If you're looking for a starting point for building a command-line program in Roc, basic-cli is a popular platform to check out.

@@ -104,7 +104,7 @@ You can find more use cases and examples on the [examples page](/wip/examples)! ## [Code Sample with Explanations](#code-sample) {#code-sample} -Here’s a code sample that shows a few different aspects of Roc: +Here's a code sample that shows a few different aspects of Roc: * File I/O and HTTP requests * Pattern matching for error handling * JSON deserialization via type inference diff --git a/www/wip_new_website/content/install.md b/www/wip_new_website/content/install.md index 6beaf4ee98..ddaa322cdf 100644 --- a/www/wip_new_website/content/install.md +++ b/www/wip_new_website/content/install.md @@ -1,6 +1,6 @@ # Install -Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download if you’d like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)! +Roc is a very young language with many incomplete features and known bugs. It doesn't even have a numbered release yet, but it does have [nightly builds](https://github.com/roc-lang/roc/releases) that you can download if you'd like to try it out without [building from source](https://github.com/roc-lang/roc/blob/main/BUILDING_FROM_SOURCE.md)! There are currently a few known OS-specific issues: * **macOS:** There are no known compatibility issues, but the compiler doesn't run as fast as it does on Linux or Windows, because we don't (yet) do our own linking like we do on those targets. (Linking works similarly on Linux and Windows, but the way macOS does it is both different and significantly more complicated.) diff --git a/www/wip_new_website/content/tutorial.md b/www/wip_new_website/content/tutorial.md index 9170dd3636..23aafa00c6 100644 --- a/www/wip_new_website/content/tutorial.md +++ b/www/wip_new_website/content/tutorial.md @@ -31,7 +31,7 @@ Let's start by getting acquainted with Roc's [_Read-Eval-Print-Loop_](https://en If Roc is [installed](/wip/install.html), you should see this: -
The rockin’ roc repl
+
The rockin' roc repl
So far, so good! diff --git a/www/wip_new_website/static/site.js b/www/wip_new_website/static/site.js index 7716fe45aa..4b0ed0bcdc 100644 --- a/www/wip_new_website/static/site.js +++ b/www/wip_new_website/static/site.js @@ -44,7 +44,7 @@ const repl = { }, { match: (input) => input.match(/^["][^\\]+\\\(name\)/i), - show: `

Nicely done! This is an example of string interpolation, which replaces part of a string with whatever you put inside the parentheses after a \\.

Now that you’ve written a few expressions, you can either continue exploring in this REPL, or move on to the tutorial to learn how to make full programs.

Welcome to Roc! ${tutorialButtonSvg} Start Tutorial

`, + show: `

Nicely done! This is an example of string interpolation, which replaces part of a string with whatever you put inside the parentheses after a \\.

Now that you've written a few expressions, you can either continue exploring in this REPL, or move on to the tutorial to learn how to make full programs.

Welcome to Roc! ${tutorialButtonSvg} Start Tutorial

`, }, ], From 8477be5550f634db2de44b8f9b5a23413d534c0f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Fri, 17 Nov 2023 23:29:37 -0500 Subject: [PATCH 069/129] Update /docs --- www/wip_new_website/content/docs.md | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/www/wip_new_website/content/docs.md b/www/wip_new_website/content/docs.md index 1e95c3dae4..b66dfb6866 100644 --- a/www/wip_new_website/content/docs.md +++ b/www/wip_new_website/content/docs.md @@ -1,15 +1,13 @@ # Documentation -[Builtins](https://www.roc-lang.org/builtins) +- [Builtins](https://www.roc-lang.org/builtins) - docs for modules built into the language—`Str`, `Num`, etc. +- basic-webserver - a platform for making Web servers ([source code](https://github.com/roc-lang/basic-webserver)) +- [basic-cli](https://www.roc-lang.org/packages/basic-cli) - a platform for making command-line interfaces ([source code](https://github.com/roc-lang/basic-cli)) -The basic-cLI platform - [repo](https://github.com/roc-lang/basic-cli) - [docs](https://www.roc-lang.org/packages/basic-cli) +In the future, a language reference will be on this page too. -### [Guides](#guides) {#guides} +## [Guides](#guides) {#guides} -[Tutorial](/tutorial) - -[FAQ (Frequently Asked Questions)](https://github.com/roc-lang/roc/blob/main/FAQ.md) - -[Roc for Elm Programmers](https://github.com/roc-lang/roc/blob/main/roc-for-elm-programmers.md) - -In the future, there will be a language reference here as well. However, it doesn't exist yet! +- [FAQ (Frequently Asked Questions)](https://github.com/roc-lang/roc/blob/main/FAQ.md) +- [Roc for Elm Programmers](https://github.com/roc-lang/roc/blob/main/roc-for-elm-programmers.md) +- [Tutorial](/tutorial) From 2bd867394142617c22612d2b53ab76062f7c840e Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 19:01:57 -0500 Subject: [PATCH 070/129] Revise webpage titles --- www/wip_new_website/content/design_goals.md | 146 -------------------- www/wip_new_website/main.roc | 13 +- 2 files changed, 6 insertions(+), 153 deletions(-) delete mode 100644 www/wip_new_website/content/design_goals.md diff --git a/www/wip_new_website/content/design_goals.md b/www/wip_new_website/content/design_goals.md deleted file mode 100644 index 045bc71b78..0000000000 --- a/www/wip_new_website/content/design_goals.md +++ /dev/null @@ -1,146 +0,0 @@ - -# Design Goals - - - -Roc's goal is to be a fast, friendly, functional language. It's very much a work in progress; below, you can see the current progress towards this goal. This website is intentionally unstyled as a way to emphasize the language's current level of incompleteness. The website will become more polished after the language itself becomes more polished! - -Roc compiles to machine code or to [WebAssembly](https://webassembly.org). Eventually you'll be able to use Roc to build high-quality servers, command-line applications, graphical native desktop user interfaces, among other classes of applications. Today, only command-line interfaces have support beyond the proof-of-concept stage; the other use cases will mature over time. - -Like [Lua](https://www.lua.org/), Roc's automatic memory management doesn't require a virtual machine, and it's possible to call Roc functions directly from any language that can call [C](https://en.wikipedia.org/wiki/C_(programming_language)) functions. This makes Roc additionally useful as a language for implementing plugins, and gives you a way to incrementally transition a legacy code base from another language to Roc. - -So far, the Roc compiler has progressed past the "proof of concept" stage, but there are currently lots of known bugs and unimplemented features, and the documentation for both the language and the standard library is incomplete. The overall ecosystem is in its infancy, and the compiler is neither battle-tested nor fuzz-tested yet, so we don't recommend relying on Roc for critical projects until its development is further along. - -# Fast{#fast} - - - -## Goal - -We want Roc to run faster than any non-systems language (like C, C++, Rust, or Zig) that sees mainstream use in industry. The goal is that nobody should find themselves thinking "I should rewrite my Roc program in \[some mainstream garbage-collected language\] because that will make it run significantly faster." - -When benchmarking Roc code against similarly-optimized programs written in [Go](https://go.dev), [Swift](https://www.swift.org/), [Java](https://www.oracle.com/java/), [C#](https://learn.microsoft.com/en-us/dotnet/csharp), or [JavaScript](https://www.ecma-international.org/publications-and-standards/standards/ecma-262), we generally aim for Roc to outperform all of those languages. Outperforming systems languages like Rust, Zig, C, D, and C++ is a non-goal, as is outperforming research languages that see little or no use in industry. (Realistically, there will always be certain specific benchmarks where some popular non-systems-level languages outperform Roc, but the goal is to usually be at the front of that pack.) - -## Current progress - -Progress towards this performance goal is already quite far along. - -Roc already uses unboxed data structures and unboxed closures, monomorphizes polymorphic code, and uses LLVM as a compiler backend. These optimizations, especially unboxed closures and monomorphization, can be found in several systems-level languages (like C++ and Rust), but not in any mainstream garbage-collected languages. Roc closures in particular have the distinction of being as ergonomic as the closures found in garbage-collected languages (where they are typically boxed), but have the performance of systems language closures (which are typically unboxed, but have more complicated types). - -Because of these optimizations, in many cases Roc code already compiles to the same machine instructions that the equivalent code written in one of these systems languages would. Something we do regularly is to compare the LLVM instructions generated by Roc's compiler and by these systems languages' compilers, to check whether we're generating equivalent instructions. - -That said, there are also cases where Roc has strictly more runtime overhead than languages like C, C++, Zig, and Rust do. The most costly is automatic memory management, which Roc implements using automatic reference counting. Static reference count optimizations like elision and reuse (thanks to Morphic and [Perceus](https://www.microsoft.com/en-us/research/publication/perceus-garbage-free-reference-counting-with-reuse/)) improve things, but significant runtime overhead remains. - -Eliminating this overhead altogether would require sacrificing other design goals (e.g. it would require introducing memory-unsafe operations, or compile-time lifetime errors), and there isn't much overhead left to remove outside of automatic memory management. For example, smaller sources of overhead include mandatory array bounds checks, disallowing cyclic references (which rules out a certain niche of efficient graph data structures), and automatic opportunistic in-place mutation instead of direct mutation. Even if all of these sources of overhead were completely eliminated, it seems unlikely that typical Roc programs would see a particularly big performance boost. - -Overall, we expect Roc's performance in the use cases mentioned above (servers, CLIs, GUIs, etc.) to be about the same as the equivalent C++ code would be, if all that C++ code (including its dependencies) were written in a restricted subset of C++ which always did array bounds checks and used shared pointers for all heap allocations. The Roc code might even run somewhat faster, because its reference counts are non-atomic by default, and can be statically optimized away in some cases—but then again, Roc also has a bit of overhead to perform opportunistic in-place mutation instead of direct mutation. - -To be clear, we don't expect this because we've benchmarked a bunch of programs written in Roc and in this restricted C++ subset, and found that the numbers were about the same (although if you know C++ well enough and want to do such experiments, we'd happy to help and would be interested to see the results!) but rather because Roc's compiler and [clang](https://clang.llvm.org/) should both be generating essentially the same LLVM instructions when the C++ is restricted to that subset. - -Of course, _unrestricted_ C++ code can certainly run faster than unrestricted Roc code. The same is true when comparing other such minimal-overhead systems languages to Roc, including Rust, Zig, C, and D. The point of the comparison is to give you a general idea of what Roc compiles to, since it is quite different from the VMs and JITted bytecode interpreters found in today's most popular garbage-collected languages! - -The talk [Outperforming Imperative with Pure Functional Languages](https://youtu.be/vzfy4EKwG_Y) discusses some early results from Roc's optimizations, and [Roc at Handmade Seattle](https://media.handmade-seattle.com/roc-lang) gets into low-level details of how Roc's compiler generates programs similarly to how clang does. - -# Friendly{#friendly} - - - -## Goals - -Roc aims to be a user-friendly language with a friendly community of users. - -A programming language can be much more than a tool for writing software, it can also be a way for people to come together through shared experiences, to teach and to learn from one another, and to make new friends. - -No community is perfect, but a community where people show kindness to each another by default can be a true joy to participate in. That all starts with friendliness, especially towards beginners, and including towards people who prefer other programming languages. After all, languages are tools people use to create software, and there's no need for us to create artificial divisions between ourselves based on the tools we use! - -On a technical level, Roc aims to ship a toolset where user-friendliness is a major priority. This includes everything from helpful error messages (aiming to meet the bar set by [Elm](https://elm-lang.org)) to quality-of-life improvements inspired by dynamic languages (always being able to run your program even if there are compile errors, automatic serialization and deserialization using schemas determined by type inference, reliable hot code loading that's always enabled and requires no configuration to set up, etc.) to accessibility features in the included editor. - -Roc also aims to ship a single binary that includes not only a compiler, but also a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop), package manager, test runner, debugger, static analyzer, code formatter, and a full-featured editor, all of which are designed to work seamlessly together. - -## Current Progress - -Work has not yet started on the package manager, static analyzer, debugger, or hot code loading system, and although work has started on the editor, it's not yet far enough along to be usable for practical purposes. The standard library is perhaps 80 percent complete in terms of functionality, but a lot of operations do not yet have documentation. - -The REPL fully supports entering arbitrary expressions, and will evaluate them and print the results. It remembers recent expressions entered in the current session (if you press the up arrow), but it can't yet execute effects. You can try out the REPL in a browser at [roc-lang.org/repl](https://roc-lang.org/repl) - it uses a WebAssembly build of Roc's compiler, and compiles the code you write to WebAssembly on the fly, which it then executes in the browser to display the answer. - -The compiler works well enough on a basic level to build things with it, but some error messages could use significant improvement, and it has a lot of known bugs and missing features. You can currently use it on macOS (either Intel or Apple Silicon), Linux (only x86-64 machines at the moment), and Windows (only recently supported; debugging and testing features don't work on it yet, and there are likely bugs we haven't encountered yet due to lack of battle testing). Support for other operating systems has not yet been discussed. - -The compiler doesn't yet support incremental compilation or hot code loading, and build times vary based on what machine you're building for. - -For example, suppose you run \`roc check\`, which reports errors it finds (type mismatches, naming errors, and so on) but doesn't actually build an executable, on a code base that's under a thousand lines of code. On an M1 MacBook Pro, this typically takes about 10 milliseconds. - -In contrast, if you do \`roc build\` (or \`roc run\`) on that same machine, it will take closer to 500 milliseconds instead. Almost all that extra time is spent waiting for LLVM to generate (unoptimized) machine code, and then for the system linker to assemble an executable from it. - -Fortunately, we can eliminate almost all of those extra 490 millisconds of build time by using Roc's (work in progress) development backend instead of LLVM. This compiles directly from Roc's internal representation to machine code, like most compilers did before LLVM. (LLVM can optimize code into running very fast, but even when it performs no optimization at all, LLVM itself takes a lot longer to run than generating unoptimized machine code directly.) - -The LLVM backend is currently the most feature-complete, followed closely by the WebAssembly backend (which the online REPL uses exclusively, instead of LLVM). The x86 and ARM backends still have a ways to go, but improving them can be done by anyone with the patience to read some documentation; we have issues split up for them, and are happy to help new contributors get up and running! - -Builds on Linux and Windows also use Roc's surgical linker instead of the system linker, which runs so fast that linking essentially disappears from the performance profile altogether. The surgical linker currently only works on Linux and Windows, and it currently supports building executables but not (yet) dynamic libraries, which is relevant if you're using Roc to create plugins or want to call Roc functions from existing code bases in other languages. Work has started on macOS surgical linking, but it isn't usable yet. If you're interested in working on that, please get in touch on [Roc Zulip](https://roc.zulipchat.com/)! - -The test runner currently has first-class support for running standard non-effectful tests. It does not yet have first-class support for effectful tests, property-based tests, snapshot tests, or "simulation tests" (where effects are replaced by hardcoded values during the test - similar to "mocking" in other languages), although these are all planned for the future. - -The code formatter is nearly feature-complete, although occasionally it will report an error - usually due to a comment being placed somewhere it doesn't yet know how to handle. Unlike most of the rest of the compiler, the formatter is one place where the number of known bugs is so small that fuzzing would be very helpful as a way to surface bugs we don't yet know about. (If you're interested in working on setting up fuzzing for the formatter, please let us know in the [`#contributing` channel](https://roc.zulipchat.com/#narrow/stream/316715-contributing) on Zulip! Separately, we're also very interested in fuzzing the compiler, even though we already have a sizable list of known bugs there.) - -On the community side, so far the community is a friendly bunch, and we want to keep it that way as it grows! We hope to do that by encouraging a culture of kindness and helping one another out, especially by being welcoming towards beginners. - -If you'd like to join in, the best place to do that is in our Zulip chat. Feel free to drop by the [`introductions` topic](https://roc.zulipchat.com/#narrow/stream/231634-beginners/topic/introductions) and introduce yourself! - -# Functional{#functional} - - - -## Goals - -Roc aims to be a purely functional programming language. This means all Roc functions are [pure functions](https://en.wikipedia.org/wiki/Pure_function), and all effects are [managed effects](https://medium.com/@kaw2k/managed-effects-and-elm-36b7fcd246a9) instead of side effects. - -A major motivating reason for this is to facilitate tooling. For example, in the future the goal is that Roc's test runner won't bother re-running tests whose outcomes could not possibly have changed (because they were pure functions whose inputs did not change). Tests that contain only pure functions can be trivially run in parallel, and they will never [flake](https://www.smashingmagazine.com/2021/04/flaky-tests-living-nightmare/). Additionally, having the guarantee that the application contains only pure functions can also make certain debugging tools more reliable, such as time travel and retroactive tracing. - -Roc also takes a novel approach to managed effects. In most programming languages, the standard library contains both data structures and I/O primitives (e.g. for using the file system or the network), and then you might decide to use a [framework](https://en.wikipedia.org/wiki/Application_framework) on top of that standard library. - -In Roc, every application is built on a _platform_. A platform is like a framework except that it also provides I/O primitives and behind-the-scenes memory management. (Roc's standard library only contains data structures.) In practice, this means that using Roc feels similar to using any other programming language where you've chosen to use a framework, except that the documentation for your I/O primitives comes from the framework instead of the standard library. - -This might sound like a minor distinction, but it turns out there are a lot of surprising benefits to organizing things this way, which would be impossible to achieve without having platforms as a first-class language concept. [The Edges of Cutting-Edge Languages](https://youtu.be/cpQwtwVKAfU) goes into more detail about some of these benefits. - -## Current Progress - -Today, platforms as a concept already exist, and there are a few different ones implemented. You can find them in the [`examples/`](https://github.com/roc-lang/roc/tree/main/examples) directory in the source code repository. The platform for building command-line interfaces is the most fully featured; the others are mostly in the proof-of-concept stage. - -Roc's built-in tooling is not yet far enough along to take advantage of pure functions. For example, there is a built-in test runner, but it does not yet run tests in parallel or skip running tests whose outcomes could not possibly have changed. - -Roc is already a purely functional programming language, though, so all of these benefits are ready to be unlocked as the tooling implementations progress! diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index 5c46a3ec50..f73ffef454 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -9,13 +9,12 @@ app "roc-website" pageData = Dict.empty {} - |> Dict.insert "community.html" { title: "Community", description: "The Roc community" } - |> Dict.insert "design_goals.html" { title: "Design Goals", description: "Roc's design goals" } - |> Dict.insert "docs.html" { title: "Documentation", description: "Learn the Roc programming language" } - |> Dict.insert "index.html" { title: "Roc", description: "The Roc programming language" } - |> Dict.insert "install.html" { title: "Install", description: "Getting started with the Roc programming language" } - |> Dict.insert "donate.html" { title: "Donate", description: "Sponsor Roc" } - |> Dict.insert "tutorial.html" { title: "Tutorial", description: "The Roc tutorial" } + |> Dict.insert "community.html" { title: "Roc Community", description: "Connect with the Roc programming language community" } + |> Dict.insert "docs.html" { title: "Roc Docs", description: "Documentation for the Roc programming language, including builtins" } + |> Dict.insert "index.html" { title: "The Roc Programming Language", description: "A fast, friendly, functional language" } + |> Dict.insert "install.html" { title: "Install Roc", description: "Install the Roc programming language" } + |> Dict.insert "donate.html" { title: "Donate to Roc", description: "Support the Roc programming language by donating or sponsoring" } + |> Dict.insert "tutorial.html" { title: "Roc Tutorial", description: "Learn the Roc programming language" } getPage : Str -> { title : Str, description : Str } getPage = \current -> From b8f89a121b32de3ccd2d7c1ed6052ca2a8d1bdb1 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 19:18:24 -0500 Subject: [PATCH 071/129] Fix some generated documentation styles --- crates/docs/src/lib.rs | 4 ++-- crates/docs/src/static/styles.css | 11 ++++++++--- www/public/styles.css | 11 +++++------ www/wip_new_website/content/docs.md | 4 ++-- 4 files changed, 17 insertions(+), 13 deletions(-) diff --git a/crates/docs/src/lib.rs b/crates/docs/src/lib.rs index ff09138e4d..2cd3e7bcca 100644 --- a/crates/docs/src/lib.rs +++ b/crates/docs/src/lib.rs @@ -200,7 +200,7 @@ fn render_package_index(root_module: &LoadedModule) -> String { // The HTML for the index page let mut index_buf = String::new(); - push_html(&mut index_buf, "h2", vec![], "Exposed Modules"); + push_html(&mut index_buf, "h2", vec![("class", "module-name")], "Exposed Modules"); push_html( &mut index_buf, "ul", @@ -222,7 +222,7 @@ fn render_module_documentation( push_html(&mut buf, "h2", vec![("class", "module-name")], { let mut link_buf = String::new(); - push_html(&mut link_buf, "a", vec![("href", "/#")], module_name); + push_html(&mut link_buf, "a", vec![("href", "/")], module_name); link_buf }); diff --git a/crates/docs/src/static/styles.css b/crates/docs/src/static/styles.css index b2fc3fb812..bfd2d1cfe1 100644 --- a/crates/docs/src/static/styles.css +++ b/crates/docs/src/static/styles.css @@ -173,8 +173,9 @@ main { line-height: 1.85em; margin-top: 2px; padding: 48px; - - min-width: 0; /* necessary for text-overflow: ellipsis to work in descendants */ + max-width: 740px; + /* necessary for text-overflow: ellipsis to work in descendants */ + min-width: 0; } /* Module links on the package index page (/index.html) */ @@ -254,7 +255,8 @@ padding: 0px 16px; font-family: var(--font-sans); font-size: 24px; height: 100%; - min-width: 0; /* necessary for text-overflow: ellipsis to work in descendants */ + /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants, but we want this anyway. */ + min-width: 1024px; } .top-header-triangle { @@ -548,6 +550,8 @@ pre>samp { .top-header { justify-content: space-between; width: auto; + /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants. */ + min-width: 0; } .pkg-full-name { @@ -591,6 +595,7 @@ pre>samp { grid-row-end: above-footer; padding: 18px; font-size: 16px; + max-width: none; } #sidebar-nav { diff --git a/www/public/styles.css b/www/public/styles.css index e5c8d31df3..0c398e375b 100644 --- a/www/public/styles.css +++ b/www/public/styles.css @@ -164,8 +164,8 @@ main { font-family: var(--font-sans); font-size: 24px; height: 100%; - min-width: 0; - /* necessary for text-overflow: ellipsis to work in descendants */ + /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants, but we want this anyway. */ + min-width: 1024px; } .top-header-triangle { @@ -403,10 +403,6 @@ pre { /* This is only visible in mobile. */ } - .top-header { - width: auto; - } - .pkg-full-name { margin-left: 8px; margin-right: 12px; @@ -478,7 +474,10 @@ pre { } .top-header { + width: auto; justify-content: space-between; + /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants. */ + min-width: 0; } .content { diff --git a/www/wip_new_website/content/docs.md b/www/wip_new_website/content/docs.md index b66dfb6866..4882b6e650 100644 --- a/www/wip_new_website/content/docs.md +++ b/www/wip_new_website/content/docs.md @@ -1,8 +1,8 @@ # Documentation -- [Builtins](https://www.roc-lang.org/builtins) - docs for modules built into the language—`Str`, `Num`, etc. +- [builtins](/builtins) - docs for modules built into the language—`Str`, `Num`, etc. - basic-webserver - a platform for making Web servers ([source code](https://github.com/roc-lang/basic-webserver)) -- [basic-cli](https://www.roc-lang.org/packages/basic-cli) - a platform for making command-line interfaces ([source code](https://github.com/roc-lang/basic-cli)) +- [basic-cli](/packages/basic-cli) - a platform for making command-line interfaces ([source code](https://github.com/roc-lang/basic-cli)) In the future, a language reference will be on this page too. From b173f8368efcc9bcbdf8545e6a592344f45623a8 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 20:03:40 -0500 Subject: [PATCH 072/129] Update docs styles --- crates/docs/src/static/styles.css | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/crates/docs/src/static/styles.css b/crates/docs/src/static/styles.css index bfd2d1cfe1..cdf9069f07 100644 --- a/crates/docs/src/static/styles.css +++ b/crates/docs/src/static/styles.css @@ -9,6 +9,7 @@ --violet: #7c38f5; --violet-bg: #ece2fd; --magenta: #a20031; + --light-cyan: #8af4e6; --link-color: var(--violet); --code-link-color: var(--violet); @@ -53,7 +54,7 @@ table tr td { } .logo svg:hover { - fill: var(--green); + fill: var(--light-cyan); } .pkg-full-name { @@ -79,6 +80,14 @@ table tr td { margin-bottom: 24px; padding: 8px 16px; border-left: 2px solid var(--violet); + /* Negative indent plus padding means all lines after the first will be indented. */ + text-indent: -3.15em; + padding-left: 4em; +} + +.entry-name a { + position: relative; + left: 3.6rem; } .entry-name a { @@ -130,7 +139,7 @@ a:hover code { } .pkg-and-logo a:hover { - color: var(--green); + color: var(--light-cyan); text-decoration: none; } @@ -342,7 +351,7 @@ color: inherit; } .module-name a:hover { - color: var(--green); + color: var(--light-cyan); } .sidebar-module-link { @@ -744,6 +753,6 @@ code .dim { } .copy-button:hover { - border-color: var(--green); - color: var(--green); + border-color: var(--light-cyan); + color: var(--light-cyan); } From 06e15973fdf871817cff9cc7f4e9c446001aa766 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 20:03:54 -0500 Subject: [PATCH 073/129] Don't auto-indent doc headings It looks bad if there are newlines in there --- crates/docs/src/static/styles.css | 8 -------- 1 file changed, 8 deletions(-) diff --git a/crates/docs/src/static/styles.css b/crates/docs/src/static/styles.css index cdf9069f07..bb6064444d 100644 --- a/crates/docs/src/static/styles.css +++ b/crates/docs/src/static/styles.css @@ -80,14 +80,6 @@ table tr td { margin-bottom: 24px; padding: 8px 16px; border-left: 2px solid var(--violet); - /* Negative indent plus padding means all lines after the first will be indented. */ - text-indent: -3.15em; - padding-left: 4em; -} - -.entry-name a { - position: relative; - left: 3.6rem; } .entry-name a { From 93fe2409e7741075f8bddcf1751d8182f72b1f2c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 20:09:51 -0500 Subject: [PATCH 074/129] Fix link hover color on generated docs --- crates/docs/src/static/styles.css | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/crates/docs/src/static/styles.css b/crates/docs/src/static/styles.css index bb6064444d..3aafa6ca81 100644 --- a/crates/docs/src/static/styles.css +++ b/crates/docs/src/static/styles.css @@ -9,7 +9,7 @@ --violet: #7c38f5; --violet-bg: #ece2fd; --magenta: #a20031; - --light-cyan: #8af4e6; + --link-hover-color: #333; --link-color: var(--violet); --code-link-color: var(--violet); @@ -54,7 +54,7 @@ table tr td { } .logo svg:hover { - fill: var(--light-cyan); + fill: var(--link-hover-color); } .pkg-full-name { @@ -131,7 +131,7 @@ a:hover code { } .pkg-and-logo a:hover { - color: var(--light-cyan); + color: var(--link-hover-color); text-decoration: none; } @@ -343,7 +343,7 @@ color: inherit; } .module-name a:hover { - color: var(--light-cyan); + color: var(--link-hover-color); } .sidebar-module-link { @@ -522,6 +522,7 @@ pre>samp { --violet: #CAADFB; --violet-bg: #332944; --magenta: #f39bac; + --link-hover-color: #fff; --link-color: var(--violet); --code-link-color: var(--violet); @@ -745,6 +746,6 @@ code .dim { } .copy-button:hover { - border-color: var(--light-cyan); - color: var(--light-cyan); + border-color: var(--link-hover-color); + color: var(--link-hover-color); } From 9a12175a96c6fb0f644aff9bc5bf3e20b1197ccb Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 21:02:33 -0500 Subject: [PATCH 075/129] Drop redundant exposed Set --- crates/compiler/builtins/roc/main.roc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/compiler/builtins/roc/main.roc b/crates/compiler/builtins/roc/main.roc index a11f36ec53..8e73148b6b 100644 --- a/crates/compiler/builtins/roc/main.roc +++ b/crates/compiler/builtins/roc/main.roc @@ -1,3 +1,3 @@ package "builtins" - exposes [Str, Num, Bool, Result, List, Dict, Set, Decode, Encode, Hash, Set, Box, TotallyNotJson] + exposes [Str, Num, Bool, Result, List, Dict, Set, Decode, Encode, Hash, Box, TotallyNotJson] packages {} From 89be091f8756525b53a10f63749eb7ff67b2a36d Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 21:02:49 -0500 Subject: [PATCH 076/129] Order modules in docs sidebar based on `exposes` --- crates/compiler/load_internal/src/file.rs | 16 ++++++++++++++-- crates/compiler/load_internal/src/module.rs | 2 +- crates/docs/src/lib.rs | 8 ++++---- 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/crates/compiler/load_internal/src/file.rs b/crates/compiler/load_internal/src/file.rs index 57386b4546..ea2af62253 100644 --- a/crates/compiler/load_internal/src/file.rs +++ b/crates/compiler/load_internal/src/file.rs @@ -3291,7 +3291,7 @@ fn finish( exposed_types_storage: ExposedTypesStorageSubs, resolved_implementations: ResolvedImplementations, dep_idents: IdentIdsByModule, - documentation: VecMap, + mut documentation: VecMap, abilities_store: AbilitiesStore, // #[cfg(debug_assertions)] checkmate: Option, @@ -3330,6 +3330,18 @@ fn finish( roc_checkmate::dump_checkmate!(checkmate); + let mut docs_by_module = Vec::with_capacity(state.exposed_modules.len()); + + for module_id in state.exposed_modules.iter() { + let docs = documentation.remove(module_id).unwrap_or_else(|| { + panic!("A module was exposed but didn't have an entry in `documentation` somehow: {module_id:?}"); + }); + + docs_by_module.push(docs); + } + + debug_assert_eq!(documentation.len(), 0); + LoadedModule { module_id: state.root_id, interns, @@ -3346,7 +3358,7 @@ fn finish( resolved_implementations, sources, timings: state.timings, - docs_by_module: documentation, + docs_by_module, abilities_store, } } diff --git a/crates/compiler/load_internal/src/module.rs b/crates/compiler/load_internal/src/module.rs index 323456fb5f..c106c4083c 100644 --- a/crates/compiler/load_internal/src/module.rs +++ b/crates/compiler/load_internal/src/module.rs @@ -43,7 +43,7 @@ pub struct LoadedModule { pub resolved_implementations: ResolvedImplementations, pub sources: MutMap)>, pub timings: MutMap, - pub docs_by_module: VecMap, + pub docs_by_module: Vec<(ModuleId, ModuleDocumentation)>, pub abilities_store: AbilitiesStore, pub typechecked: MutMap, } diff --git a/crates/docs/src/lib.rs b/crates/docs/src/lib.rs index 2cd3e7bcca..faa90e6baa 100644 --- a/crates/docs/src/lib.rs +++ b/crates/docs/src/lib.rs @@ -110,13 +110,13 @@ pub fn generate_docs_html(root_file: PathBuf, build_dir: &Path) { .replace("", &base_url()) .replace( "", - render_sidebar(loaded_module.docs_by_module.values()).as_str(), + render_sidebar(loaded_module.docs_by_module.iter().map(|(_, docs)| docs)).as_str(), ); let all_exposed_symbols = { let mut set = VecSet::default(); - for docs in loaded_module.docs_by_module.values() { + for (_, docs) in loaded_module.docs_by_module.iter() { set.insert_all(docs.exposed_symbols.iter().copied()); } @@ -146,7 +146,7 @@ pub fn generate_docs_html(root_file: PathBuf, build_dir: &Path) { } // Write each package module's index.html file - for module_docs in loaded_module.docs_by_module.values() { + for (_, module_docs) in loaded_module.docs_by_module.iter() { let module_name = module_docs.name.as_str(); let module_dir = build_dir.join(module_name.replace('.', "/").as_str()); @@ -183,7 +183,7 @@ fn render_package_index(root_module: &LoadedModule) -> String { // The list items containing module links let mut module_list_buf = String::new(); - for module in root_module.docs_by_module.values() { + for (_, module) in root_module.docs_by_module.iter() { // The anchor tag containing the module link let mut link_buf = String::new(); From 91c528193d55e8feda5875ced3dc2a797489fa47 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 21:33:38 -0500 Subject: [PATCH 077/129] cargo fmt --- crates/docs/src/lib.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/docs/src/lib.rs b/crates/docs/src/lib.rs index faa90e6baa..5fc3d5753a 100644 --- a/crates/docs/src/lib.rs +++ b/crates/docs/src/lib.rs @@ -200,7 +200,12 @@ fn render_package_index(root_module: &LoadedModule) -> String { // The HTML for the index page let mut index_buf = String::new(); - push_html(&mut index_buf, "h2", vec![("class", "module-name")], "Exposed Modules"); + push_html( + &mut index_buf, + "h2", + vec![("class", "module-name")], + "Exposed Modules", + ); push_html( &mut index_buf, "ul", From 7f87af7d5e57e5d621478a5b789aad5c3c0f918f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 21:33:38 -0500 Subject: [PATCH 078/129] cargo fmt --- crates/docs/src/lib.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/docs/src/lib.rs b/crates/docs/src/lib.rs index faa90e6baa..5fc3d5753a 100644 --- a/crates/docs/src/lib.rs +++ b/crates/docs/src/lib.rs @@ -200,7 +200,12 @@ fn render_package_index(root_module: &LoadedModule) -> String { // The HTML for the index page let mut index_buf = String::new(); - push_html(&mut index_buf, "h2", vec![("class", "module-name")], "Exposed Modules"); + push_html( + &mut index_buf, + "h2", + vec![("class", "module-name")], + "Exposed Modules", + ); push_html( &mut index_buf, "ul", From b725a114cf4374fed665083171af55ebe07e44d3 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 22:16:14 -0500 Subject: [PATCH 079/129] Remove fancy quote from rockin' roc repl --- crates/repl_cli/src/lib.rs | 2 +- www/generate_tutorial/src/input/tutorial.md | 2 +- www/public/repl/index.html | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/repl_cli/src/lib.rs b/crates/repl_cli/src/lib.rs index 5d70da11bb..965ce87906 100644 --- a/crates/repl_cli/src/lib.rs +++ b/crates/repl_cli/src/lib.rs @@ -20,7 +20,7 @@ use target_lexicon::Triple; use crate::cli_gen::eval_llvm; pub const WELCOME_MESSAGE: &str = concatcp!( - "\n The rockin’ ", + "\n The rockin' ", BLUE, "roc repl", END_COL, diff --git a/www/generate_tutorial/src/input/tutorial.md b/www/generate_tutorial/src/input/tutorial.md index fd1f7b41fc..c22cc82261 100644 --- a/www/generate_tutorial/src/input/tutorial.md +++ b/www/generate_tutorial/src/input/tutorial.md @@ -8,7 +8,7 @@ Let's start by getting acquainted with Roc's [_Read-Eval-Print-Loop_](https://en If Roc is [installed](#installation), you should see this: -
The rockin’ roc repl
+
The rockin' roc repl
So far, so good! diff --git a/www/public/repl/index.html b/www/public/repl/index.html index a26ddb85cf..878ed8a2cd 100644 --- a/www/public/repl/index.html +++ b/www/public/repl/index.html @@ -24,7 +24,7 @@
-

The rockin’ Roc REPL

+

The rockin' Roc REPL

Loading REPL WebAssembly module…please wait!
From 42630d8b500d153e3be7373c3ee2802b60327a2f Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 22:16:27 -0500 Subject: [PATCH 080/129] Restyle WIP tutorial --- www/wip_new_website/main.roc | 9 +++++---- www/wip_new_website/static/site.css | 28 +++++++++++++++++++++++++++- 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index f73ffef454..d90efb5fcf 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -56,10 +56,10 @@ view = \page, htmlContent -> [text htmlContent] bodyAttrs = - if page == "index.html" then - [id "homepage-main"] - else - [class "article-layout"] + when page is + "index.html" -> [id "homepage-main"] + "tutorial.html" -> [id "tutorial-main", class "article-layout"] + _ -> [class "article-layout"] html [lang "en", class "no-js"] [ head [] [ @@ -72,6 +72,7 @@ view = \page, htmlContent -> # The homepage doesn't actually use latin-ext preloadWoff2 "/fonts/lato-v23-latin/lato-v23-latin-regular.woff2", preloadWoff2 "/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff2", + preloadWoff2 "/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2", link [rel "prefetch", href "/repl/roc_repl_wasm.js"], link [rel "stylesheet", href "/wip/site.css"], link [rel "stylesheet", href "/wip/repl.css"], diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index c5b0109281..a3397e3077 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -685,6 +685,19 @@ li { } } + +@font-face { + font-family: "Permanent Marker"; + font-style: normal; + font-weight: 400; + font-display: swap; + src: url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2") format("woff2"), + url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff") format("woff"); + unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, + U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, + U+2215, U+FEFF, U+FFFD; +} + /* latin-ext */ @font-face { font-family: "Lato"; @@ -1100,7 +1113,20 @@ code .dim { border-color: var(--light-cyan); } -/* Tutorial Table of Contents */ +/* Tutorial */ + +#tutorial-main h1, +#tutorial-main h2, +#tutorial-main h3, +#tutorial-main h4, +#tutorial-main h5 { + font-family: "Permanent Marker"; + line-height: 1rem; + margin-top: 1.75rem; + margin-bottom: 0; + color: var(--header-link-color); + border: none; +} #tutorial-toc { background-color: var(--gray-bg); From 3ad2c677b372bea06c609a0829100a8e45584d74 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 23:26:18 -0500 Subject: [PATCH 081/129] Update WIP tutorial --- www/wip_new_website/content/tutorial.md | 60 +++++----- www/wip_new_website/static/site.css | 140 +++++++++++++++++++++++- www/wip_new_website/static/site.js | 2 +- 3 files changed, 173 insertions(+), 29 deletions(-) diff --git a/www/wip_new_website/content/tutorial.md b/www/wip_new_website/content/tutorial.md index 23aafa00c6..b6a79bdfa3 100644 --- a/www/wip_new_website/content/tutorial.md +++ b/www/wip_new_website/content/tutorial.md @@ -1,29 +1,37 @@ -# Tutorial + +
+
+

Tutorial

+

Welcome to Roc!

+

This tutorial will teach you how to build Roc applications. Along the way, you'll learn how to write tests, use the REPL, and more!

+
+
+

Installation

+

Roc doesn’t have a numbered release or an installer yet, but you can follow the install instructions for your OS here . If you get stuck, friendly people will be happy to help if you open a topic in #beginners on Roc Zulip Chat and ask for assistance!

+
-This tutorial will teach you how to build Roc applications. Along the way, you'll learn how to write tests, use the REPL, and much more! - - - -## [Strings and Numbers](#strings-and-numbers) {#strings-and-numbers} +## [REPL](#repl) {#repl} Let's start by getting acquainted with Roc's [_Read-Eval-Print-Loop_](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop), or **REPL** for short. Run this in a terminal: @@ -2008,3 +2016,5 @@ Here are various Roc expressions involving operators, and what they desugar to. These are all of the language keywords supported by Roc; `if`,`then`,`else`,`when`,`as`,`is`,`dbg`,`expect`,`expect-fx`,`crash`,`interface`,`app`,`package`,`platform`,`hosted`,`exposes`,`imports`,`with`,`generates`,`packages`,`requires`,`provides`,`to` + +
diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index a3397e3077..ba5e7845ee 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -1,5 +1,6 @@ :root { /* WCAG AAA Compliant colors */ + --code-bg: #f4f8f9; --gray-bg: #f4f8f9; --gray: #717171; --orange: #bf5000; @@ -33,6 +34,11 @@ --font-size-normal: 18px; --body-max-width: 1024px; --dark-code-bg: #202746; + + /* Tutorial */ + --header-link-color: #107F79; + --header-link-hover: #222; + --h1-color: #8055E4; } html { @@ -217,7 +223,7 @@ h2 { color: var(--heading-color); } -.article-layout main { +.article-layout main, .article-layout pre { max-width: 720px; } @@ -527,6 +533,10 @@ li { --body-max-width: none; } + #tutorial-main main { + max-width: none; + } + #homepage-logo { /* The bird runs off the screen unless we shrink it */ height: 80px; @@ -637,6 +647,7 @@ li { h5 { line-height: 1.2em !important; font-size: 2rem !important; + width: auto; } #top-bar-links { @@ -758,7 +769,7 @@ li { @media (prefers-color-scheme: dark) { :root { /* WCAG AAA Compliant colors */ - /* WCAG AAA Compliant colors */ + --code-bg: #202746; --gray-bg: #202746; --gray: #b6b6b6; --orange: #fd6e08; @@ -778,6 +789,11 @@ li { --faded-color: #bbbbbb; --gray: #6e6e6e; --heading-color: #eee; + + /* Tutorial */ + --header-link-color: #9C7CEA; + --header-link-hover: #ddd; + --h1-color: #1bc6bd; } .logo-dark { @@ -1115,6 +1131,12 @@ code .dim { /* Tutorial */ +#tutorial-main main { + display: flex; + flex-direction: row-reverse; + max-width: 1024px; +} + #tutorial-main h1, #tutorial-main h2, #tutorial-main h3, @@ -1124,12 +1146,68 @@ code .dim { line-height: 1rem; margin-top: 1.75rem; margin-bottom: 0; - color: var(--header-link-color); border: none; } +#tutorial-main h1 a, +#tutorial-main h2 a, +#tutorial-main h3 a, +#tutorial-main h4 a, +#tutorial-main h5 a { + color: var(--header-link-color); +} + +#tutorial-main h1 a:hover, +#tutorial-main h2 a:hover, +#tutorial-main h3 a:hover, +#tutorial-main h4 a:hover, +#tutorial-main h5 a:hover { + text-decoration: none; + color: var(--header-link-hover); +} + +#tutorial-main h1 { + font-size: 7rem; + line-height: 7rem; + color: var(--h1-color); + margin-top: 24px; + margin-bottom: 1.75rem; + text-shadow: 1px 1px 1px #010101; +} + +#tutorial-main h2 { + font-size: 4rem; + line-height: 4rem; + text-shadow: 1px 1px 1px #010101; + padding: 0.8rem 0; + margin-top: 2.5rem; + width: 60rem; /* Without this, "Building an application" wraps and looks awkward */ +} + +#tutorial-main h3 { + font-size: 3rem; + line-height: 3rem; + text-shadow: 1px 1px 1px #010101; + margin-bottom: 0.5rem; +} + +#tutorial-main h4 { + font-size: 2rem; + text-shadow: 1px 1px 1px #010101; +} + +#tutorial-body, #tutorial-body pre { + max-width: 646px; +} + #tutorial-toc { background-color: var(--gray-bg); + flex: 0 0 auto; /* Take up as much space as it needs */ + margin-top: 30px; + background: var(--code-bg); + padding: 12px 24px; + margin-left: 64px; + align-self: flex-start; /* Aligns to the start, not stretching in height */ } #tutorial-toc > ul { @@ -1148,6 +1226,62 @@ code .dim { text-overflow: ellipsis; /* Adds an ellipsis if the content overflows */ } +#tutorial-toc code { + background: none; + color: inherit; + margin: 0; + padding: 0; +} + +#tutorial-toc ol { + padding: 3px; + margin: 8px 0; + list-style: none; + padding-bottom: 0; + margin-bottom: 0; +} + +#tutorial-toc h2 { + font-family: inherit; + font-size: 2em; + text-shadow: none; + margin: 0; + padding: 16px 0; +} + +#toc-search { + background-color: var(--toc-search-bg); + border: 1px solid var(--toc-search-border); + color: inherit; + padding: 6px 8px; + margin-top: 16px; + margin-bottom: 4px; + box-sizing: border-box; + width: 100%; + font-size: inherit; +} + +#tutorial-toc-toggle, +#tutorial-toc-toggle-label, +#close-tutorial-toc { + display: none; + /* This may be overridden on mobile-friendly screen widths */ +} + +#tutorial-toc-toggle, +#tutorial-toc-toggle-label { + font-size: 1.1rem; + float: right; +} + +#close-tutorial-toc { + position: absolute; + top: 20px; + right: 8px; + font-size: 18px; + padding: 12px 24px; +} + /* for larger screens */ @media only screen and (min-width: 768px) { #tutorial-toc > ul > li { diff --git a/www/wip_new_website/static/site.js b/www/wip_new_website/static/site.js index 4b0ed0bcdc..b61a79c684 100644 --- a/www/wip_new_website/static/site.js +++ b/www/wip_new_website/static/site.js @@ -40,7 +40,7 @@ const repl = { }, { match: (input) => input.replace(/ /g, "").match(/^name="/i), - show: '

This created a new definition—name is now defined to be equal to the string you entered.

Try using this definition by entering "Hi, \\(name)!"

', + show: '

This created a new definition—name is now defined to be equal to the string you entered.

Try using this definition by entering "Hi, \\(name)!"

', }, { match: (input) => input.match(/^["][^\\]+\\\(name\)/i), From 71f6bd6cbd1b7bee3f15aacdbb493ed863ef9caa Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sat, 18 Nov 2023 23:29:35 -0500 Subject: [PATCH 082/129] Revise final tutorial section --- www/wip_new_website/content/tutorial.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/www/wip_new_website/content/tutorial.md b/www/wip_new_website/content/tutorial.md index b6a79bdfa3..ca78769139 100644 --- a/www/wip_new_website/content/tutorial.md +++ b/www/wip_new_website/content/tutorial.md @@ -17,6 +17,7 @@
  • Tasks
  • Abilities
  • Advanced Concepts
    • +
  • Reserved Keywords
  • Operator Desugaring Table
    • @@ -1989,6 +1990,12 @@ For this reason, any time you see a function that only runs a `when` on its only \[This part of the tutorial has not been written yet. Coming soon!\] +### [Reserved Keywords](#reserved-keywords) {#reserved-keywords} + +These are all the reserved keywords in Roc. You can't choose any of these as names, except as record field names. + +`if`, `then`, `else`, `when`, `as`, `is`, `dbg`, `expect`, `expect-fx`, `crash`, `interface`, `app`, `package`, `platform`, `hosted`, `exposes`, `imports`, `with`, `generates`, `packages`, `requires`, `provides`, `to` + ### [Operator Desugaring Table](#operator-desugaring-table) {#operator-desugaring-table} Here are various Roc expressions involving operators, and what they desugar to. @@ -2011,10 +2018,5 @@ Here are various Roc expressions involving operators, and what they desugar to. | a \|> b | `b a` | | a b c \|> f x y | `f (a b c) x y` | - ### [Language Keywords](#language-keywords) {#language-keywords} - -These are all of the language keywords supported by Roc; - -`if`,`then`,`else`,`when`,`as`,`is`,`dbg`,`expect`,`expect-fx`,`crash`,`interface`,`app`,`package`,`platform`,`hosted`,`exposes`,`imports`,`with`,`generates`,`packages`,`requires`,`provides`,`to`
    From 9217494570c22e3f933650d94ea084023e01960e Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 13:30:56 +0100 Subject: [PATCH 083/129] set up basic_webserver build --- .github/workflows/basic_cli_build_release.yml | 2 +- .../basic_webserver_build_release.yml | 164 ++++++++++++++++++ ci/build_basic_webserver.sh | 52 ++++++ 3 files changed, 217 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/basic_webserver_build_release.yml create mode 100644 ci/build_basic_webserver.sh diff --git a/.github/workflows/basic_cli_build_release.yml b/.github/workflows/basic_cli_build_release.yml index 246b29222d..b08b97674e 100644 --- a/.github/workflows/basic_cli_build_release.yml +++ b/.github/workflows/basic_cli_build_release.yml @@ -1,5 +1,5 @@ on: - pull_request: +# pull_request: workflow_dispatch: # this cancels workflows currently in progress if you start a new one diff --git a/.github/workflows/basic_webserver_build_release.yml b/.github/workflows/basic_webserver_build_release.yml new file mode 100644 index 0000000000..41db268377 --- /dev/null +++ b/.github/workflows/basic_webserver_build_release.yml @@ -0,0 +1,164 @@ +on: + pull_request: + workflow_dispatch: + +# this cancels workflows currently in progress if you start a new one +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +env: + # use .tar.gz for quick testing + ARCHIVE_FORMAT: .tar.gz + BASIC_WEBSERVER_BRANCH: more-features + +jobs: + fetch-releases: + runs-on: [ubuntu-20.04] + steps: + - uses: actions/checkout@v3 + + - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_x86_64-latest.tar.gz + - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_arm64-latest.tar.gz + - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_x86_64-latest.tar.gz + - run: curl -fOL https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-macos_apple_silicon-latest.tar.gz + + - name: Save roc_nightly archives + uses: actions/upload-artifact@v3 + with: + path: roc_nightly-* + + build-linux-x86_64-files: + runs-on: [ubuntu-20.04] + needs: [fetch-releases] + steps: + - uses: actions/checkout@v3 + + - name: Download the previously uploaded roc_nightly archives + uses: actions/download-artifact@v3 + + - name: build basic-webserver with surgical linker and also with legacy linker + env: + CARGO_BUILD_TARGET: x86_64-unknown-linux-musl + run: ./ci/build_basic_webserver.sh linux_x86_64 "--linker legacy" + + - name: Save .rh, .rm and .o file + uses: actions/upload-artifact@v3 + with: + name: linux-x86_64-files + path: | + basic-webserver/platform/metadata_linux-x64.rm + basic-webserver/platform/linux-x64.rh + basic-webserver/platform/linux-x64.o + + + build-linux-arm64-files: + runs-on: [self-hosted, Linux, ARM64] + needs: [fetch-releases] + steps: + - uses: actions/checkout@v3 + + - name: Download the previously uploaded roc_nightly archives + uses: actions/download-artifact@v3 + + - name: build basic-webserver + env: + CARGO_BUILD_TARGET: aarch64-unknown-linux-musl + CC_aarch64_unknown_linux_musl: clang-16 + AR_aarch64_unknown_linux_musl: llvm-ar-16 + CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_RUSTFLAGS: "-Clink-self-contained=yes -Clinker=rust-lld" + run: ./ci/build_basic_webserver.sh linux_arm64 + + - name: Save .o file + uses: actions/upload-artifact@v3 + with: + name: linux-arm64-files + path: | + basic-webserver/platform/linux-arm64.o + + build-macos-x86_64-files: + runs-on: [macos-11] # I expect the generated files to work on macOS 12 and 13 + needs: [fetch-releases] + steps: + - uses: actions/checkout@v3 + + - name: Download the previously uploaded roc_nightly archives + uses: actions/download-artifact@v3 + + - run: ./ci/build_basic_webserver.sh macos_x86_64 + + - name: Save .o files + uses: actions/upload-artifact@v3 + with: + name: macos-x86_64-files + path: | + basic-webserver/platform/macos-x64.o + + build-macos-apple-silicon-files: + name: build apple silicon .o file + runs-on: [self-hosted, macOS, ARM64] + needs: [fetch-releases] + steps: + - uses: actions/checkout@v3 + + - name: Download the previously uploaded roc_nightly archives + uses: actions/download-artifact@v3 + + - run: ./ci/build_basic_webserver.sh macos_apple_silicon + + - name: Save macos-arm64.o file + uses: actions/upload-artifact@v3 + with: + name: macos-apple-silicon-files + path: | + basic-webserver/platform/macos-arm64.o + + create-release-archive: + needs: [build-linux-x86_64-files, build-linux-arm64-files, build-macos-x86_64-files, build-macos-apple-silicon-files] + name: create release archive + runs-on: [ubuntu-20.04] + steps: + - uses: actions/checkout@v3 + + - name: remove all folders except the ci folder + run: ls | grep -v ci | xargs rm -rf + + - name: Download the previously uploaded files + uses: actions/download-artifact@v3 + + - name: mv roc nightly and simplify name + run: mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "linux_x86_64") ./roc_nightly.tar.gz + + - name: decompress the tar + run: tar -xzvf roc_nightly.tar.gz + + - name: delete tar + run: rm roc_nightly.tar.gz + + - name: rename nightly folder + run: mv roc_nightly* roc_nightly + + - run: | + git clone https://github.com/roc-lang/basic-webserver.git + cd basic-webserver + git checkout ${{ env.BASIC_WEBSERVER_BRANCH }} + cd .. + + - run: cp macos-apple-silicon-files/* ./basic-webserver/platform + + - run: cp linux-x86_64-files/* ./basic-webserver/platform + + - run: cp linux-arm64-files/* ./basic-webserver/platform + + - run: cp macos-x86_64-files/* ./basic-webserver/platform + + - run: ./roc_nightly/roc build --bundle=${{ env.ARCHIVE_FORMAT }} ./basic-webserver/platform/main.roc + + - run: echo "TAR_FILENAME=$(ls -d basic-webserver/platform/* | grep ${{ env.ARCHIVE_FORMAT }})" >> $GITHUB_ENV + + - name: Upload platform archive + uses: actions/upload-artifact@v3 + with: + name: basic-webserver-platform + path: | + ${{ env.TAR_FILENAME }} diff --git a/ci/build_basic_webserver.sh b/ci/build_basic_webserver.sh new file mode 100644 index 0000000000..9df00a2be9 --- /dev/null +++ b/ci/build_basic_webserver.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash + +# https://vaneyckt.io/posts/safer_bash_scripts_with_set_euxo_pipefail/ +set -euxo pipefail + +git clone https://github.com/roc-lang/basic-webserver.git + +cd basic-webserver +git checkout more-features + +if [ "$(uname -s)" == "Linux" ]; then + + # check if musl-tools is installed + if ! dpkg -l | grep -q musl-tools; then + # install musl-tools with timeout for sudo problems with CI + timeout 300s sudo apt-get install -y musl-tools + fi + + cd basic-webserver/platform # we cd to install the target for the right rust version + if [ "$(uname -m)" == "x86_64" ]; then + rustup target add x86_64-unknown-linux-musl + elif [ "$(uname -m)" == "aarch64" ]; then + rustup target add aarch64-unknown-linux-musl + fi + cd ../.. +fi + +mv $(ls -d artifact/* | grep "roc_nightly.*tar\.gz" | grep "$1") ./roc_nightly.tar.gz + +# decompress the tar +tar -xzvf roc_nightly.tar.gz + +# delete tar +rm roc_nightly.tar.gz + +# simplify dir name +mv roc_nightly* roc_nightly + +cd roc_nightly + +# build the basic-webserver platform +./roc build ../basic-webserver/examples/echo.roc + +# We need this extra variable so we can safely check if $2 is empty later +EXTRA_ARGS=${2:-} + +# In some rare cases it's nice to be able to use the legacy linker, so we produce the .o file to be able to do that +if [ -n "${EXTRA_ARGS}" ]; + then ./roc build $EXTRA_ARGS ../basic-webserver/examples/echo.roc +fi + +cd .. From 4cb9b24f397f95d69a9f92288575b187d18256c6 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 13:41:58 +0100 Subject: [PATCH 084/129] chmod +x --- ci/build_basic_webserver.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 ci/build_basic_webserver.sh diff --git a/ci/build_basic_webserver.sh b/ci/build_basic_webserver.sh old mode 100644 new mode 100755 From ee74635afca7298b6500fef745fbcb0979647083 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 13:51:43 +0100 Subject: [PATCH 085/129] forgot cd --- ci/build_basic_webserver.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/ci/build_basic_webserver.sh b/ci/build_basic_webserver.sh index 9df00a2be9..dbdd036e98 100755 --- a/ci/build_basic_webserver.sh +++ b/ci/build_basic_webserver.sh @@ -7,6 +7,7 @@ git clone https://github.com/roc-lang/basic-webserver.git cd basic-webserver git checkout more-features +cd .. if [ "$(uname -s)" == "Linux" ]; then From a9c92735400fcafb27e5d405afb3b8b9fdb301fd Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 15:16:42 +0100 Subject: [PATCH 086/129] prevent undefined symbol --- ci/build_basic_webserver.sh | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/ci/build_basic_webserver.sh b/ci/build_basic_webserver.sh index dbdd036e98..dd5dc4d962 100755 --- a/ci/build_basic_webserver.sh +++ b/ci/build_basic_webserver.sh @@ -9,7 +9,10 @@ cd basic-webserver git checkout more-features cd .. -if [ "$(uname -s)" == "Linux" ]; then +OS=$(uname -s) +ARCH=$(uname -m) + +if [ "$OS" == "Linux" ]; then # check if musl-tools is installed if ! dpkg -l | grep -q musl-tools; then @@ -18,9 +21,9 @@ if [ "$(uname -s)" == "Linux" ]; then fi cd basic-webserver/platform # we cd to install the target for the right rust version - if [ "$(uname -m)" == "x86_64" ]; then + if [ "$ARCH" == "x86_64" ]; then rustup target add x86_64-unknown-linux-musl - elif [ "$(uname -m)" == "aarch64" ]; then + elif [ "$ARCH" == "aarch64" ]; then rustup target add aarch64-unknown-linux-musl fi cd ../.. @@ -39,8 +42,11 @@ mv roc_nightly* roc_nightly cd roc_nightly -# build the basic-webserver platform -./roc build ../basic-webserver/examples/echo.roc +# prevent https://github.com/roc-lang/basic-webserver/issues/9 +if [ "$OS" != "Linux" ] || [ "$ARCH" != "x86_64" ]; then + # build the basic-webserver platform + ./roc build ../basic-webserver/examples/echo.roc +fi # We need this extra variable so we can safely check if $2 is empty later EXTRA_ARGS=${2:-} From 116aad26509885422a64d76c85affd9f6941ee27 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 15:44:32 +0100 Subject: [PATCH 087/129] get brotli started --- .github/workflows/basic_webserver_build_release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/basic_webserver_build_release.yml b/.github/workflows/basic_webserver_build_release.yml index 41db268377..1b35265b67 100644 --- a/.github/workflows/basic_webserver_build_release.yml +++ b/.github/workflows/basic_webserver_build_release.yml @@ -9,7 +9,7 @@ concurrency: env: # use .tar.gz for quick testing - ARCHIVE_FORMAT: .tar.gz + ARCHIVE_FORMAT: .tar.br BASIC_WEBSERVER_BRANCH: more-features jobs: From b208922e9015f3bd48e4e580fdbea91fc1609546 Mon Sep 17 00:00:00 2001 From: Anton-4 <17049058+Anton-4@users.noreply.github.com> Date: Sun, 19 Nov 2023 20:26:39 +0100 Subject: [PATCH 088/129] upgrade some examples to basic-cli 0.6 --- examples/helloWorld.roc | 2 +- examples/inspect-logging.roc | 2 +- examples/parser/examples/letter-counts.roc | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/helloWorld.roc b/examples/helloWorld.roc index fe6bddd76e..50e600dd4e 100644 --- a/examples/helloWorld.roc +++ b/examples/helloWorld.roc @@ -1,5 +1,5 @@ app "helloWorld" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } imports [pf.Stdout] provides [main] to pf diff --git a/examples/inspect-logging.roc b/examples/inspect-logging.roc index fd284def02..147ad05e26 100644 --- a/examples/inspect-logging.roc +++ b/examples/inspect-logging.roc @@ -2,7 +2,7 @@ # Shows how Roc values can be logged # app "inspect-logging" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } + packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br" } imports [ pf.Stdout, LogFormatter, diff --git a/examples/parser/examples/letter-counts.roc b/examples/parser/examples/letter-counts.roc index b7a58e7ab5..23a28cfb27 100644 --- a/examples/parser/examples/letter-counts.roc +++ b/examples/parser/examples/letter-counts.roc @@ -1,6 +1,6 @@ app "example" packages { - cli: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br", + cli: "https://github.com/roc-lang/basic-cli/releases/download/0.6.0/QOQW08n38nHHrVVkJNiPIjzjvbR3iMjXeFY5w1aT46w.tar.br", parser: "../package/main.roc", } imports [ From 84559770d0a7e17436904e47bfa048b684095fac Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 19 Nov 2023 19:27:05 -0500 Subject: [PATCH 089/129] Fix repl color on new homepage light theme --- www/wip_new_website/static/site.css | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index ba5e7845ee..e6402801b6 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -396,7 +396,8 @@ pre > code { } #homepage-repl-container #repl, -#homepage-repl-container #repl code { +#homepage-repl-container #repl code, +#homepage-repl-container #source-input { color: white; background-color: var(--dark-code-bg); } From ad743854d700fea9764e053a160d44941366c056 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 19 Nov 2023 19:45:01 -0500 Subject: [PATCH 090/129] Merge repl css into site.css --- www/public/repl/repl.js | 2 +- www/wip_new_website/main.roc | 1 - www/wip_new_website/static/repl.css | 164 -------------------------- www/wip_new_website/static/site.css | 171 ++++++++++++++++++++++++++++ www/wip_new_website/static/site.js | 4 +- 5 files changed, 174 insertions(+), 168 deletions(-) delete mode 100644 www/wip_new_website/static/repl.css diff --git a/www/public/repl/repl.js b/www/public/repl/repl.js index 42b3bc821b..009b4d523c 100644 --- a/www/public/repl/repl.js +++ b/www/public/repl/repl.js @@ -9,7 +9,7 @@ console.error = function displayErrorInHistoryPanel(string) { updateHistoryEntry(repl.inputHistoryIndex, false, html); }; -import * as roc_repl_wasm from "./roc_repl_wasm.js"; +import * as roc_repl_wasm from "/repl/roc_repl_wasm.js"; // ---------------------------------------------------------------------------- // REPL state diff --git a/www/wip_new_website/main.roc b/www/wip_new_website/main.roc index d90efb5fcf..82ce4a31fd 100644 --- a/www/wip_new_website/main.roc +++ b/www/wip_new_website/main.roc @@ -75,7 +75,6 @@ view = \page, htmlContent -> preloadWoff2 "/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2", link [rel "prefetch", href "/repl/roc_repl_wasm.js"], link [rel "stylesheet", href "/wip/site.css"], - link [rel "stylesheet", href "/wip/repl.css"], # Safari ignores rel="icon" and only respects rel="mask-icon". It will render the SVG with # fill="#000" unless this `color` attribute here is hardcoded (not a CSS `var()`) to override it. link [rel "mask-icon", href "/favicon.svg", color "#7d59dd"], diff --git a/www/wip_new_website/static/repl.css b/www/wip_new_website/static/repl.css deleted file mode 100644 index fa40b96bae..0000000000 --- a/www/wip_new_website/static/repl.css +++ /dev/null @@ -1,164 +0,0 @@ -#repl { - position: relative; - display: flex; - flex-direction: column; - font-size: 18px; -} - -#repl-prompt { - position: relative; - left: 16px; - top: 1.25rem; - font-size: 1.25rem; - height: 0; - z-index: 2; - font-family: var(--font-mono); - color: var(--light-cyan); - /* Let clicks pass through to the textarea */ - pointer-events: none; - user-select: none; -} - -#source-input { - width: 100%; - font-family: var(--font-mono); - color: var(--code-color); - background-color: var(--code-bg); - display: inline-block; - height: 78px; - padding: 16px; - padding-left: 36px; - border: 1px solid transparent; - margin: 0; - margin-bottom: 2em; - box-sizing: border-box; - font-size: 18px; - resize: none; -} - -#source-input:focus { - outline: 2px solid var(--primary-1); - box-sizing: border-box; -} - -.history { - padding: 1em; - padding-bottom: 0; - flex: 1; -} - -#help-text, -#history-text { - white-space: pre-wrap; -} - -#history-text { - margin-top: 16px; - min-height: 26px; -} - -#loading-message { - text-align: center; - /* approximately match height after loading and printing help message */ - height: 96px; -} - -.history-item { - margin-bottom: 24px; - overflow-x: hidden; -} - -.history-item .input { - margin: 0; - margin-bottom: 8px; -} - -.history-item .output { - margin: 0; -} - -.panic { - color: #ff6666; -} - -.input-line-prefix { - color: var(--cyan); -} - -.color-red { - color: #ff6666; -} - -.color-green { - color: var(--green); -} - -.color-yellow { - color: var(--orange); -} - -.color-blue { - color: var(--cyan); -} - -.color-magenta { - color: var(--primary-1); -} - -.color-cyan { - color: var(--cyan); -} - -.color-white { - /* Really this isn't white so much as "default text color." For the repl, this should be black - in a light color scheme, and only white in dark mode. The name could be better! */ - color: black; -} - -@media (prefers-color-scheme: dark) { - .color-white { - color: white; - } -} - -.bold { - font-weight: bold; -} - -.underline { - text-decoration: underline; -} - -/* Mobile-friendly screen width */ -@media only screen and (max-width: 767px) { - #repl { - margin: 0; - padding: 0; - min-height: calc(100vh - var(--top-bar-height)); - } - - code.history { - flex-grow: 1; - } - - #source-input { - margin: 0; - } - - #loading-message { - margin: 0; - } - - #homepage-repl-container { - flex-direction: column; - } - - #homepage-repl-container #repl-description { - padding: 0; - margin-bottom: 1.5em; - } - - #repl-arrow { - display: none; - } -} diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css index e6402801b6..444cbf2464 100644 --- a/www/wip_new_website/static/site.css +++ b/www/wip_new_website/static/site.css @@ -361,6 +361,177 @@ pre > code { color: var(--code-color); } + +/* REPL */ + +#repl { + position: relative; + display: flex; + flex-direction: column; + font-size: 18px; +} + +#repl-prompt { + position: relative; + left: 16px; + top: 1.25rem; + font-size: 1.25rem; + height: 0; + z-index: 2; + font-family: var(--font-mono); + color: var(--light-cyan); + /* Let clicks pass through to the textarea */ + pointer-events: none; + user-select: none; +} + +#source-input { + width: 100%; + font-family: var(--font-mono); + color: var(--code-color); + background-color: var(--code-bg); + display: inline-block; + height: 78px; + padding: 16px; + padding-left: 36px; + border: 1px solid transparent; + margin: 0; + margin-bottom: 2em; + box-sizing: border-box; + font-size: 18px; + resize: none; +} + +#source-input:focus { + outline: 2px solid var(--primary-1); + box-sizing: border-box; +} + +.history { + padding: 1em; + padding-bottom: 0; + flex: 1; +} + +#help-text, +#history-text { + white-space: pre-wrap; +} + +#history-text { + margin-top: 16px; + min-height: 26px; +} + +#loading-message { + text-align: center; + /* approximately match height after loading and printing help message */ + height: 96px; +} + +.history-item { + margin-bottom: 24px; + overflow-x: hidden; +} + +.history-item .input { + margin: 0; + margin-bottom: 8px; +} + +.history-item .output { + margin: 0; +} + +.panic { + color: #ff6666; +} + +.input-line-prefix { + color: var(--cyan); +} + +.color-red { + color: #ff6666; +} + +.color-green { + color: var(--green); +} + +.color-yellow { + color: var(--orange); +} + +.color-blue { + color: var(--cyan); +} + +.color-magenta { + color: var(--primary-1); +} + +.color-cyan { + color: var(--cyan); +} + +.color-white { + /* Really this isn't white so much as "default text color." For the repl, this should be black + in a light color scheme, and only white in dark mode. The name could be better! */ + color: black; +} + +@media (prefers-color-scheme: dark) { + .color-white { + color: white; + } +} + +.bold { + font-weight: bold; +} + +.underline { + text-decoration: underline; +} + +/* Mobile-friendly screen width */ +@media only screen and (max-width: 767px) { + #repl { + margin: 0; + padding: 0; + min-height: calc(100vh - var(--top-bar-height)); + } + + code.history { + flex-grow: 1; + } + + #source-input { + margin: 0; + } + + #loading-message { + margin: 0; + } + + #homepage-repl-container { + flex-direction: column; + } + + #homepage-repl-container #repl-description { + padding: 0; + margin-bottom: 1.5em; + } + + #repl-arrow { + display: none; + } +} + + +/* Homepage */ + /* The repl won't work at all if you have JS disabled. */ .no-js #try-roc { display: none !important; diff --git a/www/wip_new_website/static/site.js b/www/wip_new_website/static/site.js index b61a79c684..2553f3c144 100644 --- a/www/wip_new_website/static/site.js +++ b/www/wip_new_website/static/site.js @@ -11,7 +11,7 @@ console.error = function displayErrorInHistoryPanel(string) { updateHistoryEntry(repl.inputHistoryIndex, false, html); }; -import * as roc_repl_wasm from "./roc_repl_wasm.js"; +import * as roc_repl_wasm from "/repl/roc_repl_wasm.js"; const isHomepage = document.getElementById("homepage-repl-container") != null; @@ -65,7 +65,7 @@ resetSourceInputHeight(); repl.elemSourceInput.addEventListener("input", resetSourceInputHeight); repl.elemSourceInput.addEventListener("keydown", onInputKeydown); repl.elemSourceInput.addEventListener("keyup", onInputKeyup); -roc_repl_wasm.default("/wip/roc_repl_wasm_bg.wasm").then(async (instance) => { +roc_repl_wasm.default("/repl/roc_repl_wasm_bg.wasm").then(async (instance) => { const loadingMessage = repl.elemHistory.querySelector("#loading-message"); if (loadingMessage != null) { From 25f6d5f6f3deb54eca298ec2d16e72da78b88f9e Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 19 Nov 2023 19:45:11 -0500 Subject: [PATCH 091/129] Clean up a link on the homepage --- www/wip_new_website/content/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/www/wip_new_website/content/index.md b/www/wip_new_website/content/index.md index b0d26f33c4..a48b5c7d4d 100644 --- a/www/wip_new_website/content/index.md +++ b/www/wip_new_website/content/index.md @@ -162,4 +162,4 @@ We are currently trying to raise $4,000 USD/month in donations to fund one longt - [GitHub Sponsors](https://github.com/sponsors/roc-lang) - [Liberapay](https://liberapay.com/roc_lang) -All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered [US 501(c)(3) nonprofit organization](https://en.wikipedia.org/wiki/501(c)(3)_organization), which means these donations are tax-exempt in the US. +All donations go through the [Roc Programming Language Foundation](https://foundation.roc-lang.org/), a registered US 501(c)(3) nonprofit organization, which means these donations are tax-exempt in the US. From f7cd9422f63a3c31b612fe18f45c44e406568e4b Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 19 Nov 2023 19:48:18 -0500 Subject: [PATCH 092/129] Remove an obsolete style --- www/public/site.css | 6 ------ 1 file changed, 6 deletions(-) diff --git a/www/public/site.css b/www/public/site.css index ae10354c4e..ff97750576 100644 --- a/www/public/site.css +++ b/www/public/site.css @@ -163,12 +163,6 @@ pre>samp { display: block; } -.repl-prompt:before { - /* Add this using CSS so it isn't selectable, which would be annoying when trying to copy/paste! */ - color: var(--repl-prompt); - content: "» "; -} - .repl-err { color: var(--magenta); } From f4b8d1b4ffade97cbe825280cc2e5061c5c8a265 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Sun, 19 Nov 2023 00:29:47 -0500 Subject: [PATCH 093/129] Replace roc-lang.org with WIP site --- .gitignore | 9 +- www/.gitignore | 3 - .../InteractiveExample.roc | 0 www/README.md | 33 +- www/{wip_new_website => }/build-dev-local.sh | 7 +- www/build.sh | 26 +- www/{wip_new_website => }/content/bdfn.md | 0 .../content/community.md | 0 www/{wip_new_website => }/content/docs.md | 0 www/{wip_new_website => }/content/donate.md | 0 www/{wip_new_website => }/content/fast.md | 0 www/{wip_new_website => }/content/friendly.md | 0 .../content/functional.md | 0 www/{wip_new_website => }/content/index.md | 16 +- www/{wip_new_website => }/content/install.md | 0 www/content/repl/index.md | 15 + www/{wip_new_website => }/content/tutorial.md | 0 www/generate_tutorial/.gitignore | 2 - www/generate_tutorial/src/input/tutorial.md | 1989 ----------------- www/generate_tutorial/src/tutorial.roc | 116 - www/{wip_new_website => }/main.roc | 18 +- www/{wip_new_website => }/optimize.sh | 8 +- www/public/homepage.css | 15 - www/public/index.html | 316 --- www/public/repl/index.html | 39 - www/public/repl/repl.css | 173 -- www/public/repl/repl.js | 307 --- www/public/site.css | 1108 ++++++--- www/public/site.js | 551 ++++- www/public/styles.css | 487 ---- www/wip_new_website/.gitignore | 4 - www/wip_new_website/README.md | 30 - www/wip_new_website/static/site.css | 1462 ------------ www/wip_new_website/static/site.js | 515 ----- 34 files changed, 1340 insertions(+), 5909 deletions(-) delete mode 100644 www/.gitignore rename www/{wip_new_website => }/InteractiveExample.roc (100%) rename www/{wip_new_website => }/build-dev-local.sh (78%) rename www/{wip_new_website => }/content/bdfn.md (100%) rename www/{wip_new_website => }/content/community.md (100%) rename www/{wip_new_website => }/content/docs.md (100%) rename www/{wip_new_website => }/content/donate.md (100%) rename www/{wip_new_website => }/content/fast.md (100%) rename www/{wip_new_website => }/content/friendly.md (100%) rename www/{wip_new_website => }/content/functional.md (100%) rename www/{wip_new_website => }/content/index.md (97%) rename www/{wip_new_website => }/content/install.md (100%) create mode 100644 www/content/repl/index.md rename www/{wip_new_website => }/content/tutorial.md (100%) delete mode 100644 www/generate_tutorial/.gitignore delete mode 100644 www/generate_tutorial/src/input/tutorial.md delete mode 100644 www/generate_tutorial/src/tutorial.roc rename www/{wip_new_website => }/main.roc (91%) rename www/{wip_new_website => }/optimize.sh (83%) delete mode 100644 www/public/homepage.css delete mode 100644 www/public/index.html delete mode 100644 www/public/repl/index.html delete mode 100644 www/public/repl/repl.css delete mode 100644 www/public/repl/repl.js delete mode 100644 www/public/styles.css delete mode 100644 www/wip_new_website/.gitignore delete mode 100644 www/wip_new_website/README.md delete mode 100644 www/wip_new_website/static/site.css delete mode 100644 www/wip_new_website/static/site.js diff --git a/.gitignore b/.gitignore index 437842eb4c..fd1a81c005 100644 --- a/.gitignore +++ b/.gitignore @@ -61,9 +61,6 @@ roc_linux_x86_64.tar.gz # nix result -# tutorial -www/src/roc-tutorial - # Only keep Cargo.lock dependencies for the main compiler. # Examples and test only crates should be fine to be unlocked. # This remove unneccessary lock file versioning. @@ -77,7 +74,11 @@ www/src/roc-tutorial # checkmate checkmate_*.json +www/build/ +www/main +www/dist + # ignore the examples folder in the WIP website, this is copied from roc-lang/examples in when building the site -www/wip_new_website/content/examples +www/content/examples www/examples-main.zip www/examples-main \ No newline at end of file diff --git a/www/.gitignore b/www/.gitignore deleted file mode 100644 index 486776780d..0000000000 --- a/www/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -/build -roc_repl_wasm.js -roc_repl_wasm_bg.wasm diff --git a/www/wip_new_website/InteractiveExample.roc b/www/InteractiveExample.roc similarity index 100% rename from www/wip_new_website/InteractiveExample.roc rename to www/InteractiveExample.roc diff --git a/www/README.md b/www/README.md index 3ffdf87a21..016e87cb75 100644 --- a/www/README.md +++ b/www/README.md @@ -1,12 +1,37 @@ # www.roc-lang.org +## Prerequisites + +- Linux or MacOS operating system, Windows users can use linux through WSL. +- Install [git](https://chat.openai.com/share/71fb3ae6-80d7-478c-8a27-a36aaa5ba921) +- Install [nix](https://nixos.org/download.html) + +## Building the website from scratch + +```bash +git clone https://github.com/roc-lang/roc.git +cd roc +nix develop +./www/build.sh +# make the roc command available +export PATH="$(pwd)/target/release/:$PATH" +bash build-dev-local.sh +``` + +Open http://0.0.0.0:8080 in your browser. + +## After you've made a change locally + +In the terminal where the web server is running: +1. kill the server with Ctrl+C +2. re-run the build script +3. refresh the page in your browser + To view the website after you've made a change, execute: ```bash -./www/build.sh -cd www/build -simple-http-server --nocache --index # already installed if you're using `nix develop`, otherwise use `cargo install simple-http-server` +bash build-dev-local.sh ``` -Open http://0.0.0.0:8000 in your browser. +Open http://0.0.0.0:8080 in your browser. diff --git a/www/wip_new_website/build-dev-local.sh b/www/build-dev-local.sh similarity index 78% rename from www/wip_new_website/build-dev-local.sh rename to www/build-dev-local.sh index 0fdf551425..37c62eb167 100755 --- a/www/wip_new_website/build-dev-local.sh +++ b/www/build-dev-local.sh @@ -11,9 +11,8 @@ DIR="$(dirname "$0")" cd "$DIR" || exit rm -rf dist/ -cp -r ../build dist/ -mkdir -p dist/wip -roc run main.roc -- content/ dist/wip/ -cp -r static/* dist/wip/ +cp -r build dist/ +cp -r public/* dist/ +roc run main.roc -- content/ dist/ npx http-server dist/ -p 8080 -c-1 --cors diff --git a/www/build.sh b/www/build.sh index cf0ae4c911..77248c6332 100755 --- a/www/build.sh +++ b/www/build.sh @@ -17,16 +17,15 @@ cd $SCRIPT_RELATIVE_DIR rm -rf build/ cp -r public/ build/ -mkdir build/wip # for WIP site # download the latest code for the examples echo 'Downloading latest examples...' curl -fLJO https://github.com/roc-lang/examples/archive/refs/heads/main.zip unzip examples-main.zip -cp -R examples-main/examples/ wip_new_website/content/examples/ +cp -R examples-main/examples/ content/examples/ -# relace links in wip_new_website/content/examples/index.md to work on the WIP site -sed -i 's|](/|](/wip/examples/|g' wip_new_website/content/examples/index.md +# relace links in content/examples/index.md to work on the WIP site +sed -i '' 's|](/|](/examples/|' content/examples/index.md # clean up examples artifacts rm -rf examples-main examples-main.zip @@ -48,11 +47,10 @@ curl -fLJO https://github.com/roc-lang/roc/archive/www.tar.gz # Download the latest pre-built Web REPL as a zip file. (Build takes longer than Netlify's timeout.) REPL_TARFILE="roc_repl_wasm.tar.gz" curl -fLJO https://github.com/roc-lang/roc/releases/download/nightly/$REPL_TARFILE +mkdir repl tar -xzf $REPL_TARFILE -C repl -tar -xzf $REPL_TARFILE -C wip # note we also need this for WIP repl rm $REPL_TARFILE ls -lh repl -ls -lh wip popd @@ -77,9 +75,6 @@ rm -rf roc_nightly roc_releases.json # we use `! [ -v GITHUB_TOKEN_READ_ONLY ];` to check if we're on a netlify server if ! [ -v GITHUB_TOKEN_READ_ONLY ]; then - echo 'Building tutorial.html from tutorial.md...' - mkdir www/build/tutorial - cargo build --release --bin roc roc=target/release/roc @@ -96,19 +91,12 @@ else mv roc_nightly* roc_nightly roc='./roc_nightly/roc' - - echo 'Building tutorial.html from tutorial.md...' - mkdir www/build/tutorial fi $roc version -$roc run www/generate_tutorial/src/tutorial.roc -- www/generate_tutorial/src/input/ www/build/tutorial/ -mv www/build/tutorial/tutorial.html www/build/tutorial/index.html -# For WIP site -echo 'Building WIP site...' -$roc run www/wip_new_website/main.roc -- www/wip_new_website/content/ www/build/wip/ -cp -r www/wip_new_website/static/* www/build/wip/ +echo 'Building site markdown content' +$roc run www/main.roc -- www/content/ www/build/ # cleanup rm -rf roc_nightly roc_releases.json @@ -153,5 +141,3 @@ if [ -v GITHUB_TOKEN_READ_ONLY ]; then rm -rf $BASIC_CLI_DIR/generated-docs done <<< "$VERSION_NUMBERS" fi - -popd diff --git a/www/wip_new_website/content/bdfn.md b/www/content/bdfn.md similarity index 100% rename from www/wip_new_website/content/bdfn.md rename to www/content/bdfn.md diff --git a/www/wip_new_website/content/community.md b/www/content/community.md similarity index 100% rename from www/wip_new_website/content/community.md rename to www/content/community.md diff --git a/www/wip_new_website/content/docs.md b/www/content/docs.md similarity index 100% rename from www/wip_new_website/content/docs.md rename to www/content/docs.md diff --git a/www/wip_new_website/content/donate.md b/www/content/donate.md similarity index 100% rename from www/wip_new_website/content/donate.md rename to www/content/donate.md diff --git a/www/wip_new_website/content/fast.md b/www/content/fast.md similarity index 100% rename from www/wip_new_website/content/fast.md rename to www/content/fast.md diff --git a/www/wip_new_website/content/friendly.md b/www/content/friendly.md similarity index 100% rename from www/wip_new_website/content/friendly.md rename to www/content/friendly.md diff --git a/www/wip_new_website/content/functional.md b/www/content/functional.md similarity index 100% rename from www/wip_new_website/content/functional.md rename to www/content/functional.md diff --git a/www/wip_new_website/content/index.md b/www/content/index.md similarity index 97% rename from www/wip_new_website/content/index.md rename to www/content/index.md index a48b5c7d4d..12300bd612 100644 --- a/www/wip_new_website/content/index.md +++ b/www/content/index.md @@ -12,21 +12,21 @@
    diff --git a/www/wip_new_website/content/install.md b/www/content/install.md similarity index 100% rename from www/wip_new_website/content/install.md rename to www/content/install.md diff --git a/www/content/repl/index.md b/www/content/repl/index.md new file mode 100644 index 0000000000..210ffed363 --- /dev/null +++ b/www/content/repl/index.md @@ -0,0 +1,15 @@ + +# The rockin’ Roc REPL + + + + \ No newline at end of file diff --git a/www/wip_new_website/content/tutorial.md b/www/content/tutorial.md similarity index 100% rename from www/wip_new_website/content/tutorial.md rename to www/content/tutorial.md diff --git a/www/generate_tutorial/.gitignore b/www/generate_tutorial/.gitignore deleted file mode 100644 index 6981c2e5ec..0000000000 --- a/www/generate_tutorial/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -tutorial -src/output/tutorial.html \ No newline at end of file diff --git a/www/generate_tutorial/src/input/tutorial.md b/www/generate_tutorial/src/input/tutorial.md deleted file mode 100644 index c22cc82261..0000000000 --- a/www/generate_tutorial/src/input/tutorial.md +++ /dev/null @@ -1,1989 +0,0 @@ - - -## [Strings and Numbers](#strings-and-numbers) {#strings-and-numbers} - -Let's start by getting acquainted with Roc's [_Read-Eval-Print-Loop_](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop), or **REPL** for short. Run this in a terminal: - -roc repl - -If Roc is [installed](#installation), you should see this: - -
    The rockin' roc repl
    - -So far, so good! - -### [Hello, World!](#hello-world) {#hello-world} - -Try typing this in the REPL and pressing Enter: - -"Hello, World!" - -The REPL should cheerfully display the following: - -
    "Hello, World!" : Str
    - -Congratulations! You've just written your first Roc code. - -### [Naming Things](#naming-things) {#naming-things} - -When you entered the _expression_ `"Hello, World!"`, the REPL printed it back out. It also printed `: Str`, because `Str` is that expression's type. We'll talk about types later; for now, let's ignore the `:` and whatever comes after it whenever we see them. - -Let's try that out. Put this into the repl and press Enter: - -
    val1
    - -You should see the same `"Hello, World!"` line as before. - -You can also assign specific names to expressions. Try entering these lines: - -
    greeting = "Hi"
    -
    audience = "World"
    - -From now until you exit the REPL, you can refer to either `greeting` or `audience` by those names! We'll use these later on in the tutorial. - -### [Arithmetic](#arithmetic) {#arithmetic} - -Now let's try using an _operator_, specifically the `+` operator. Enter this: - -
    1 + 1
    - -You should see this output: - -
    2 : Num *                # val2
    - -According to the REPL, one plus one equals two. Sounds right! - -Roc will respect [order of operations](https://en.wikipedia.org/wiki/Order_of_operations) when using multiple arithmetic operators like `+` and `-`, but you can use parentheses to specify exactly how they should be grouped. - -
    1 + 2 * (3 - 4)
-
--1 : Num *
-
    - -### [Calling Functions](#calling-functions) {#calling-functions} - -Remember back in the [string interpolation](#string-interpolation) section when we mentioned other ways to combine strings? Here's one of them: - -
    Str.concat "Hi " "there!"
-
-"Hi there!" : Str
-
    - -Here we're calling the `Str.concat` function and passing two arguments: the string `"Hi "` and the string `"there!"`. This _concatenates_ the two strings together (that is, it puts one after the other) and returns the resulting combined string of `"Hi there!"`. - -Note that in Roc, we don't need parentheses or commas to call functions. We don't write `Str.concat("Hi ", "there!")` but rather `Str.concat "Hi " "there!"`. - -That said, just like in the arithmetic example above, we can use parentheses to specify how nested function calls should work. For example, we could write this: - -
    Str.concat "Birds: " (Num.toStr 42)
-
-"Birds: 42" : Str
-
    - -This calls `Num.toStr` on the number `42`, which converts it into the string `"42"`, and then passes that string as the second argument to `Str.concat`. - -The parentheses are important here to specify how the function calls nest. Try removing them, and see what happens: - -
    Str.concat "Birds: " Num.toStr 42
-
-<error>
-
    - -The error tells us that we've given `Str.concat` too many arguments. Indeed we have! We've passed it three arguments: - -1. The string `"Birds"` -2. The function `Num.toStr` -3. The number `42` - -That's not what we intended to do. Putting parentheses around the `Num.toStr 42` call clarifies that we want it to be evaluated as its own expression, rather than being two arguments to `Str.concat`. - -Both the `Str.concat` function and the `Num.toStr` function have a dot in their names. In `Str.concat`, `Str` is the name of a _module_, and `concat` is the name of a function inside that module. Similarly, `Num` is a module, and `toStr` is a function inside that module. - -We'll get into more depth about modules later, but for now you can think of a module as a named collection of functions. Eventually we'll discuss how to use them for more than that. - -### [String Interpolation](#string-interpolation) {#string-interpolation} - -An alternative syntax for `Str.concat` is _string interpolation_, which looks like this: - -
    "\(greeting) there, \(audience)!"
    - -This is syntax sugar for calling `Str.concat` several times, like so: - -```roc -Str.concat greeting (Str.concat " there, " (Str.concat audience "!")) -``` - -You can put entire single-line expressions inside the parentheses in string interpolation. For example: - -
    "Two plus three is: \(Num.toStr (2 + 3))"
    - -By the way, there are many other ways to put strings together! Check out the [documentation](https://www.roc-lang.org/builtins/Str) for the `Str` module for more. - -## [Building an Application](#building-an-application) {#building-an-application} - -Let's move out of the REPL and create our first Roc application! - -Make a file named `main.roc` and put this in it: - -```roc -app "hello" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout] - provides [main] to pf - -main = - Stdout.line "I'm a Roc application!" -``` - -Try running this with: - -roc dev - -You should see a message about a file being downloaded, followed by this: - -I'm a Roc application! - -Congratulations, you've written your first Roc application! We'll go over what the parts above `main` do later, but let's play around a bit first. - -### [Defs](#defs) {#defs} - -Try replacing the `main` line with this: - -```roc -birds = 3 - -iguanas = 2 - -total = Num.toStr (birds + iguanas) - -main = - Stdout.line "There are \(total) animals." -``` - -Now run `roc dev` again. This time the "Downloading ..." message won't appear; the file has been cached from last time, and won't need to be downloaded again. - -You should see this: - -There are 5 animals. - -`main.roc` now has four definitions (_defs_ for short) `birds`, `iguanas`, `total`, and `main`. - -A definition names an expression. - -- The first two defs assign the names `birds` and `iguanas` to the expressions `3` and `2`. -- The next def assigns the name `total` to the expression `Num.toStr (birds + iguanas)`. -- The last def assigns the name `main` to an expression which returns a `Task`. We'll [discuss tasks later](#tasks). - -Once we have a def, we can use its name in other expressions. For example, the `total` expression refers to `birds` and `iguanas`, and `Stdout.line "There are \(total) animals."` refers to `total`. - -You can name a def using any combination of letters and numbers, but they have to start with a letter. - -**Note:** Defs are constant; they can't be reassigned. We'd get an error if we wrote these two defs in the same scope: - -```roc -birds = 3 -birds = 2 -``` - -### [Defining Functions](#defining-functions) {#defining-functions} - -So far we've called functions like `Num.toStr`, `Str.concat`, and `Stdout.line`. Next let's try defining a function of our own. - -```roc -birds = 3 - -iguanas = 2 - -total = addAndStringify birds iguanas - -main = - Stdout.line "There are \(total) animals." - -addAndStringify = \num1, num2 -> - Num.toStr (num1 + num2) -``` - -This new `addAndStringify` function we've defined accepts two numbers, adds them, calls `Num.toStr` on the result, and returns that. - -The `\num1, num2 ->` syntax defines a function's arguments, and the expression after the `->` is the body of the function. Whenever a function gets called, its body expression gets evaluated and returned. - -### [if-then-else](#if-then-else) {#if-then-else} - -Let's modify this function to return an empty string if the numbers add to zero. - -```roc -addAndStringify = \num1, num2 -> - sum = num1 + num2 - - if sum == 0 then - "" - else - Num.toStr (num1 + num2) -``` - -We did two things here: - -- We introduced a _local def_ named `sum`, and set it equal to `num1 + num2`. Because we defined `sum` inside `addAndStringify`, it's _local_ to that scope and can't be accessed outside that function. -- We added an `if`\-`then`\-`else` conditional to return either `""` or `Num.toStr sum` depending on whether `sum == 0`. - -Every `if` must be accompanied by both `then` and also `else`. Having an `if` without an `else` is an error, because `if` is an expression, and all expressions must evaluate to a value. If there were ever an `if` without an `else`, that would be an expression that might not evaluate to a value! - -### [else if](#else-if) {#else-if} - -We can combine `if` and `else` to get `else if`, like so: - -```roc -addAndStringify = \num1, num2 -> - sum = num1 + num2 - - if sum == 0 then - "" - else if sum < 0 then - "negative" - else - Num.toStr (num1 + num2) -``` - -Note that `else if` is not a separate language keyword! It's just an `if`/`else` where the `else` branch contains another `if`/`else`. This is easier to see with different indentation: - -```roc -addAndStringify = \num1, num2 -> - sum = num1 + num2 - - if sum == 0 then - "" - else - if sum < 0 then - "negative" - else - Num.toStr (num1 + num2) -``` - -This differently-indented version is equivalent to writing `else if sum < 0 then` on the same line, although the convention is to use the original version's style. - -### [Comments](#comments) {#comments} - -This is a comment in Roc: - -```roc -# The 'name' field is unused by addAndStringify -``` - -Whenever you write `#` it means that the rest of the line is a comment, and will not affect the -running program. Roc does not have multiline comment syntax. - -### [Doc Comments](#doc-comments) {#doc-comments} - -Comments that begin with `##` are "doc comments" which will be included in generated documentation (`roc docs`). They can include code blocks by adding five spaces after `##`. - -```roc -## This is a comment for documentation, and includes a code block. -## -## x = 2 -## expect x == 2 -``` - -Like other comments, doc comments do not affect the running program. - -## [Debugging](#debugging) {#debugging} - -[Print debugging](https://en.wikipedia.org/wiki/Debugging#Techniques) is the most common debugging technique in the history of programming, and Roc has a `dbg` keyword to facilitate it. Here's an example of how to use `dbg`: - -```roc -pluralize = \singular, plural, count -> - dbg count - - if count == 1 then - singular - else - plural -``` - -Whenever this `dbg` line of code is reached, the value of `count` will be printed to [stderr](), along with the source code file and line number where the `dbg` itself was written: - -[pluralize.roc 6:8] 5 - -Here, `[pluralize.roc 6:8]` tells us that this `dbg` was written in the file `pluralize.roc` on line 6, column 8. - -You can give `dbg` any expression you like, for example: - -```roc -dbg Str.concat singular plural -``` - -An easy way to print multiple values at a time is to wrap them in a tag, for example a concise tag like `T`: - -```roc -dbg T "the value of count is:" count -``` - -> **Note:** `dbg` is a debugging tool, and is only available when running your program via a `roc` subcommand (for example using `roc dev`, `roc run`, or `roc test`). When you build a standalone application with `roc build`, any uses of `dbg` won't be included! - -## [Records](#records) {#records} - -Currently our `addAndStringify` function takes two arguments. We can instead make it take one argument like so: - -```roc -total = addAndStringify { birds: 5, iguanas: 7 } - -addAndStringify = \counts -> - Num.toStr (counts.birds + counts.iguanas) -``` - -The function now takes a _record_, which is a group of named values. Records are not [objects](https://en.wikipedia.org/wiki/Object_(computer_science)); they don't have methods or inheritance, they just store information. - -The expression `{ birds: 5, iguanas: 7 }` defines a record with two _fields_ (the `birds` field and the `iguanas` field) and then assigns the number `5` to the `birds` field and the number `7` to the `iguanas` field. Order doesn't matter with record fields; we could have also specified `iguanas` first and `birds` second, and Roc would consider it the exact same record. - -When we write `counts.birds`, it accesses the `birds` field of the `counts` record, and when we write `counts.iguanas` it accesses the `iguanas` field. - -When we use [`==`](/builtins/Bool#isEq) on records, it compares all the fields in both records with [`==`](/builtins/Bool#isEq), and only considers the two records equal if all of their fields are equal. If one record has more fields than the other, or if the types associated with a given field are different between one field and the other, the Roc compiler will give an error at build time. - -> **Note:** Some other languages have a concept of "identity equality" that's separate from the "structural equality" we just described. Roc does not have a concept of identity equality; this is the only way equality works! - -### [Accepting extra fields](#accepting-extra-fields) {#accepting-extra-fields} - -The `addAndStringify` function will accept any record with at least the fields `birds` and `iguanas`, but it will also accept records with more fields. For example: - -```roc -total = addAndStringify { birds: 5, iguanas: 7 } - -# The `note` field is unused by addAndStringify -totalWithNote = addAndStringify { birds: 4, iguanas: 3, note: "Whee!" } - -addAndStringify = \counts -> - Num.toStr (counts.birds + counts.iguanas) -``` - -This works because `addAndStringify` only uses `counts.birds` and `counts.iguanas`. If we were to use `counts.note` inside `addAndStringify`, then we would get an error because `total` is calling `addAndStringify` passing a record that doesn't have a `note` field. - -### [Record shorthands](#record-shorthands) {#record-shorthands} - -Roc has a couple of shorthands you can use to express some record-related operations more concisely. - -Instead of writing `\record -> record.x` we can write `.x` and it will evaluate to the same thing: a function that takes a record and returns its `x` field. You can do this with any field you want. For example: - -```roc -# returnFoo is a function that takes a record -# and returns the `foo` field of that record. -returnFoo = .foo - -returnFoo { foo: "hi!", bar: "blah" } -# returns "hi!" -``` - -Sometimes we assign a def to a field that happens to have the same name—for example, `{ x: x }`. -In these cases, we shorten it to writing the name of the def alone—for example, `{ x }`. We can do this with as many fields as we like; here are several different ways to define the same record: - -- `{ x: x, y: y }` -- `{ x, y }` -- `{ x: x, y }` -- `{ x, y: y }` - -### [Record destructuring](#record-destructuring) {#record-destructuring} - -We can use _destructuring_ to avoid naming a record in a function argument, instead giving names to its individual fields: - -```roc -addAndStringify = \{ birds, iguanas } -> - Num.toStr (birds + iguanas) -``` - -Here, we've _destructured_ the record to create a `birds` def that's assigned to its `birds` field, and an `iguanas` def that's assigned to its `iguanas` field. We can customize this if we like: - -```roc -addAndStringify = \{ birds, iguanas: lizards } -> - Num.toStr (birds + lizards) -``` - -In this version, we created a `lizards` def that's assigned to the record's `iguanas` field. (We could also do something similar with the `birds` field if we like.) - -Finally, destructuring can be used in defs too: - -```roc -{ x, y } = { x: 5, y: 10 } -``` - -### [Making records from other records](#making-records-from-other-records) {#making-records-from-other-records} - -So far we've only constructed records from scratch, by specifying all of their fields. We can also construct new records by using another record to use as a starting point, and then specifying only the fields we want to be different. For example, here are two ways to get the same record: - -```roc -original = { birds: 5, zebras: 2, iguanas: 7, goats: 1 } -fromScratch = { birds: 4, zebras: 2, iguanas: 3, goats: 1 } -fromOriginal = { original & birds: 4, iguanas: 3 } -``` - -The `fromScratch` and `fromOriginal` records are equal, although they're defined in different ways. - -- `fromScratch` was built using the same record syntax we've been using up to this point. -- `fromOriginal` created a new record using the contents of `original` as defaults for fields that it didn't specify after the `&`. - -Note that `&` can't introduce new fields to a record, or change the types of existing fields. -(Trying to do either of these will result in an error at build time!) - -## [Optional Record Fields](#optional-record-fields) {#optional-record-fields} - -Roc supports optional record fields using the `?` operator. This can be a useful pattern where you pass a function a record of configuration values, some of which you'd like to provide defaults for. - -In Roc you can write a function like: - -```roc -table = \{ - height, - width, - title? "oak", - description? "a wooden table" - } - -> -``` - -This is using *optional field destructuring* to destructure a record while -also providing default values for any fields that might be missing. - -Here's the type of `table`: - -```roc -table : - { - height : Pixels, - width : Pixels, - title ? Str, - description ? Str, - } - -> Table -``` - -This says that `table` takes a record with two *required* fields, `height` and -`width`, and two *optional* fields, `title` and `description`. It also says that -the `height` and `width` fields have the type `Pixels`, a type alias for some -numeric type, and the `title` and `description` fields have the type `Str`. -This means you can choose to omit the `title`, `description`, or both fields, when calling the function... but if you provide them, they must have the type `Str`. - -This is also the type that would have been inferred for `table` if no annotation -had been written. Roc's compiler can tell from the destructuring syntax -`title ? ""` that `title` is an optional field, and that it has the type `Str`. -These default values can reference other expressions in the record destructure; if you wanted, you could write `{ height, width, title ? "", description ? Str.concat "A table called " title }`. - -Destructuring is the only way to implement a record with optional fields. For example, if you write the expression `config.title` and `title` is an -optional field, you'll get a compile error. - -This means it's never possible to end up with an *optional value* that exists -outside a record field. Optionality is a concept that exists only in record -fields, and it's intended for the use case of config records like this. The -ergonomics of destructuring mean this wouldn't be a good fit for data modeling, consider using a `Result` type instead. - -## [Tags](#tags) {#tags} - -Sometimes we want to represent that something can have one of several values. For example: - -```roc -stoplightColor = - if something > 0 then - Red - else if something == 0 then - Yellow - else - Green -``` - -Here, `stoplightColor` can have one of three values: `Red`, `Yellow`, or `Green`. The capitalization is very important! If these were lowercase (`red`, `yellow`, `green`), then they would refer to defs. However, because they are capitalized, they instead refer to _tags_. - -A tag is a literal value just like a number or a string. Similarly to how I can write the number `42` or the string `"forty-two"` without defining them first, I can also write the tag `FortyTwo` without defining it first. Also, similarly to how `42 == 42` and `"forty-two" == "forty-two"`, it's also the case that `FortyTwo == FortyTwo`. - -Let's say we wanted to turn `stoplightColor` from a `Red`, `Green`, or `Yellow` into a string. Here's one way we could do that: - -```roc -stoplightStr = - if stoplightColor == Red then - "red" - else if stoplightColor == Green then - "green" - else - "yellow" -``` - -We can express this logic more concisely using `when`/`is` instead of `if`/`then`: - -```roc -stoplightStr = - when stoplightColor is - Red -> "red" - Green -> "green" - Yellow -> "yellow" -``` - -This results in the same value for `stoplightStr`. In both the `when` version and the `if` version, we have three conditional branches, and each of them evaluates to a string. The difference is how the conditions are specified; here, we specify between `when` and `is` that we're making comparisons against `stoplightColor`, and then we specify the different things we're comparing it to: `Red`, `Green`, and `Yellow`. - -Besides being more concise, there are other advantages to using `when` here. - -1. We don't have to specify an `else` branch, so the code can be more self-documenting about exactly what all the options are. -2. We get more compiler help. If we try deleting any of these branches, we'll get a compile-time error saying that we forgot to cover a case that could come up. For example, if we delete the `Green ->` branch, the compiler will say that we didn't handle the possibility that `stoplightColor` could be `Green`. It knows this because `Green` is one of the possibilities in our `stoplightColor = if ...` definition. - -We can still have the equivalent of an `else` branch in our `when` if we like. Instead of writing `else`, we write `_ ->` like so: - -```roc -stoplightStr = - when stoplightColor is - Red -> "red" - _ -> "not red" -``` - -This lets us more concisely handle multiple cases. However, it has the downside that if we add a new case - for example, if we introduce the possibility of `stoplightColor` being `Orange`, the compiler can no longer tell us we forgot to handle that possibility in our `when`. After all, we are handling it - just maybe not in the way we'd decide to if the compiler had drawn our attention to it! - -## [Exhaustiveness](#exhaustiveness) {#exhaustiveness} - -We can make this `when` _exhaustive_ (that is, covering all possibilities) without using `_ ->` by using `|` to specify multiple matching conditions for the same branch: - -```roc -stoplightStr = - when stoplightColor is - Red -> "red" - Green | Yellow -> "not red" -``` - -You can read `Green | Yellow` as "either `Green` or `Yellow`". By writing it this way, if we introduce the possibility that `stoplightColor` can be `Orange`, we'll get a compiler error telling us we forgot to cover that case in this `when`, and then we can handle it however we think is best. - -We can also combine `if` and `when` to make branches more specific: - -```roc -stoplightStr = - when stoplightColor is - Red -> "red" - Green | Yellow if contrast > 75 -> "not red, but very high contrast" - Green | Yellow if contrast > 50 -> "not red, but high contrast" - Green | Yellow -> "not red" -``` - -This will give the same answer for `stoplightStr` as if we had written the following: - -```roc -stoplightStr = - when stoplightColor is - Red -> "red" - Green | Yellow -> - if contrast > 75 then - "not red, but very high contrast" - else if contrast > 50 then - "not red, but high contrast" - else - "not red" -``` - -Either style can be a reasonable choice depending on the circumstances. - -### [Tags with payloads](#tags-with-payloads) {#tags-with-payloads} - -Tags can have _payloads_—that is, values inside them. For example: - -```roc -stoplightColor = - if something > 100 then - Red - else if something > 0 then - Yellow - else if something == 0 then - Green - else - Custom "some other color" - -stoplightStr = - when stoplightColor is - Red -> "red" - Green | Yellow -> "not red" - Custom description -> description -``` - -This makes two changes to our earlier `stoplightColor` / `stoplightStr` example. - -1. We sometimes chose to set `stoplightColor` to be `Custom "some other color"`. When we did this, we gave the `Custom` tag a _payload_ of the string `"some other color"`. -2. We added a `Custom` tag in our `when`, with a payload which we named `description`. Because we did this, we were able to refer to `description` in the body of the branch (that is, the part after the `->`) just like a def or a function argument. - -Any tag can be given a payload like this. A payload doesn't have to be a string; we could also have said (for example) `Custom { r: 40, g: 60, b: 80 }` to specify an RGB color instead of a string. Then in our `when` we could have written `Custom record ->` and then after the `->` used `record.r`, `record.g`, and `record.b` to access the `40`, `60`, `80` values. We could also have written `Custom { r, g, b } ->` to _destructure_ the record, and then accessed these `r`, `g`, and `b` defs after the `->` instead. - -A tag can also have a payload with more than one value. Instead of `Custom { r: 40, g: 60, b: 80 }` we could write `Custom 40 60 80`. If we did that, then instead of destructuring a record with `Custom { r, g, b } ->` inside a `when`, we would write `Custom r g b ->` to destructure the values directly out of the payload. - -We refer to whatever comes before a `->` in a `when` expression as a _pattern_—so for example, in the `Custom description -> description` branch, `Custom description` would be a pattern. In programming, using patterns in branching conditionals like `when` is known as [pattern matching](https://en.wikipedia.org/wiki/Pattern_matching). You may hear people say things like "let's pattern match on `Custom` here" as a way to suggest making a `when` branch that begins with something like `Custom description ->`. - -### [Pattern Matching on Lists](#pattern-matching-on-lists) {#pattern-matching-on-lists} - -You can also pattern match on lists, like so: - -```roc -when myList is - [] -> 0 # the list is empty - [Foo, ..] -> 1 # it starts with a Foo tag - [_, ..] -> 2 # it contains at least one element, which we ignore - [Foo, Bar, ..] -> 3 # it starts with a Foo tag followed by a Bar tag - [Foo, Bar, Baz] -> 4 # it has exactly 3 elements: Foo, Bar, and Baz - [Foo, a, ..] -> 5 # its first element is Foo, and its second we name `a` - [Ok a, ..] -> 6 # it starts with an Ok containing a payload named `a` - [.., Foo] -> 7 # it ends with a Foo tag - [A, B, .., C, D] -> 8 # it has certain elements at the beginning and end -``` - -This can be both more concise and more efficient (at runtime) than calling [`List.get`](https://www.roc-lang.org/builtins/List#get) multiple times, since each call to `get` requires a separate conditional to handle the different `Result`s they return. - -> **Note:** Each list pattern can only have one `..`, which is known as the "rest pattern" because it's where the _rest_ of the list goes. - -## [Booleans](#booleans) {#booleans} - -In many programming languages, `true` and `false` are special language keywords that refer to the two [boolean](https://en.wikipedia.org/wiki/Boolean_data_type) values. In Roc, booleans do not get special keywords; instead, they are exposed as the ordinary values `Bool.true` and `Bool.false`. - -This design is partly to keep the number of special keywords in the language smaller, but mainly to suggest how booleans are intended to be used in Roc: for [_boolean logic_](https://en.wikipedia.org/wiki/Boolean_algebra) (`&&`, `||`, and so on) as opposed to for data modeling. Tags are the preferred choice for data modeling, and having tag values be more concise than boolean values helps make this preference clear. - -As an example of why tags are encouraged for data modeling, in many languages it would be common to write a record like `{ name: "Richard", isAdmin: Bool.true }`, but in Roc it would be preferable to write something like `{ name: "Richard", role: Admin }`. At first, the `role` field might only ever be set to `Admin` or `Normal`, but because the data has been modeled using tags instead of booleans, it's much easier to add other alternatives in the future, like `Guest` or `Moderator` - some of which might also want payloads. - -## [Lists](#lists) {#lists} - -Another thing we can do in Roc is to make a _list_ of values. Here's an example: - -```roc -names = ["Sam", "Lee", "Ari"] -``` - -This is a list with three elements in it, all strings. We can add a fourth element using `List.append` like so: - -```roc -List.append names "Jess" -``` - -This returns a **new** list with `"Jess"` after `"Ari"`, and doesn't modify the original list at all. All values in Roc (including lists, but also records, strings, numbers, and so on) are immutable, meaning whenever we want to "change" them, we want to instead pass them to a function which returns some variation of what was passed in. - -### [List.map](#list-map) {#list-map} - -A common way to transform one list into another is to use `List.map`. Here's an example of how to use it: - -```roc -List.map [1, 2, 3] \num -> num * 2 -``` - -This returns `[2, 4, 6]`. - -`List.map` takes two arguments: - -1. An input list -2. A function that will be called on each element of that list - -It then returns a list which it creates by calling the given function on each element in the input list. In this example, `List.map` calls the function `\num -> num * 2` on each element in `[1, 2, 3]` to get a new list of `[2, 4, 6]`. - -We can also give `List.map` a named function, instead of an anonymous one: - -```roc -List.map [1, 2, 3] Num.isOdd -``` - -This `Num.isOdd` function returns `Bool.true` if it's given an odd number, and `Bool.false` otherwise. So `Num.isOdd 5` returns `Bool.true` and `Num.isOdd 2` returns `Bool.false`. - -As such, calling `List.map [1, 2, 3] Num.isOdd` returns a new list of `[Bool.true, Bool.false, Bool.true]`. - -### [List element type compatibility](#list-element-type-compatibility) {#list-element-type-compatibility} - -If we tried to give `List.map` a function that didn't work on the elements in the list, then we'd get an error at compile time. Here's a valid, and then an invalid example: - -```roc -# working example -List.map [-1, 2, 3, -4] Num.isNegative -# returns [Bool.true, Bool.false, Bool.false, Bool.true] -``` - -```roc -# invalid example -List.map ["A", "B", "C"] Num.isNegative -# error: isNegative doesn't work on strings! -``` - -Because `Num.isNegative` works on numbers and not strings, calling `List.map` with `Num.isNegative` and a list of numbers works, but doing the same with a list of strings doesn't work. - -This wouldn't work either: - -```roc -List.map ["A", "B", "C", 1, 2, 3] Num.isNegative -``` - -Every element in a Roc list has to share the same type. For example, we can have a list of strings like `["Sam", "Lee", "Ari"]`, or a list of numbers like `[1, 2, 3, 4, 5]` but we can't have a list which mixes strings and numbers like `["Sam", 1, "Lee", 2, 3]`, that would be a compile-time error. - -Ensuring that all elements in a list share a type eliminates entire categories of problems. For example, it means that whenever you use `List.append` to add elements to a list, as long as you don't have any compile-time errors, you won't get any runtime errors from calling `List.map` afterwards, no matter what you appended to the list! More generally, it's safe to assume that unless you run out of memory, `List.map` will run successfully unless you got a compile-time error about an incompatibility (like `Num.neg` on a list of strings). - -### [Lists that hold elements of different types](#lists-that-hold-elements-of-different-types) {#lists-that-hold-elements-of-different-types} - -We can use tags with payloads to make a list that contains a mixture of different types. For example: - -```roc -List.map [StrElem "A", StrElem "b", NumElem 1, StrElem "c", NumElem -3] \elem -> - when elem is - NumElem num -> Num.isNegative num - StrElem str -> Str.isCapitalized str -# returns [Bool.true, Bool.false, Bool.false, Bool.false, Bool.true] -``` - -Compare this with the example from earlier, which caused a compile-time error: - -```roc -List.map ["A", "B", "C", 1, 2, 3] Num.isNegative -``` - -The version that uses tags works because we aren't trying to call `Num.isNegative` on each element. Instead, we're using a `when` to tell when we've got a string or a number, and then calling either `Num.isNegative` or `Str.isCapitalized` depending on which type we have. - -We could take this as far as we like, adding more different tags (e.g. `BoolElem Bool.true`) and then adding more branches to the `when` to handle them appropriately. - -### [Using tags as functions](#using-tags-as-functions) {#using-tags-as-functions} - -Let's say I want to apply a tag to a bunch of elements in a list. For example: - -```roc -List.map ["a", "b", "c"] \str -> Foo str -``` - -This is a perfectly reasonable way to write it, but I can also write it like this: - -```roc -List.map ["a", "b", "c"] Foo -``` - -These two versions compile to the same thing. As a convenience, Roc lets you specify a tag name where a function is expected; when you do this, the compiler infers that you want a function which uses all of its arguments as the payload to the given tag. - -### [List.any and List.all](#list-any-and-list-all) {#list-any-and-list-all} - -There are several functions that work like `List.map`, they walk through each element of a list and do something with it. Another is `List.any`, which returns `Bool.true` if calling the given function on any element in the list returns `Bool.true`: - -```roc -List.any [1, 2, 3] Num.isOdd -# returns `Bool.true` because 1 and 3 are odd -``` - -```roc -List.any [1, 2, 3] Num.isNegative -# returns `Bool.false` because none of these is negative -``` - -There's also `List.all` which only returns `Bool.true` if all the elements in the list pass the test: - -```roc -List.all [1, 2, 3] Num.isOdd -# returns `Bool.false` because 2 is not odd -``` - -```roc -List.all [1, 2, 3] Num.isPositive -# returns `Bool.true` because all of these are positive -``` - -### [Removing elements from a list](#removing-elements-from-a-list) {#removing-elements-from-a-list} - -You can also drop elements from a list. One way is `List.dropAt` - for example: - -```roc -List.dropAt ["Sam", "Lee", "Ari"] 1 -# drops the element at offset 1 ("Lee") and returns ["Sam", "Ari"] -``` - -Another way is to use `List.keepIf`, which passes each of the list's elements to the given function, and then keeps them only if that function returns `Bool.true`. - -```roc -List.keepIf [1, 2, 3, 4, 5] Num.isEven -# returns [2, 4] -``` - -There's also `List.dropIf`, which does the opposite: - -```roc -List.dropIf [1, 2, 3, 4, 5] Num.isEven -# returns [1, 3, 5] -``` - -### [Getting an individual element from a list](#getting-an-individual-element-from-a-list) {#getting-an-individual-element-from-a-list} - -Another thing we can do with a list is to get an individual element out of it. `List.get` is a common way to do this; it takes a list and an index, and then returns the element at that index... if there is one. But what if there isn't? - -For example, what do each of these return? - -```roc -List.get ["a", "b", "c"] 1 -``` - -```roc -List.get ["a", "b", "c"] 100 -``` - -The answer is that the first one returns `Ok "b"` and the second one returns `Err OutOfBounds`. They both return tags! This is done so that the caller becomes responsible for handling the possibility that the index is outside the bounds of that particular list. - -Here's how calling `List.get` can look in practice: - -```roc -when List.get ["a", "b", "c"] index is - Ok str -> "I got this string: \(str)" - Err OutOfBounds -> "That index was out of bounds, sorry!" -``` - -There's also `List.first`, which always gets the first element, and `List.last` which always gets the last. They return `Err ListWasEmpty` instead of `Err OutOfBounds`, because the only way they can fail is if you pass them an empty list! - -These functions demonstrate a common pattern in Roc: operations that can fail returning either an `Ok` tag with the answer (if successful), or an `Err` tag with another tag describing what went wrong (if unsuccessful). In fact, it's such a common pattern that there's a whole module called `Result` which deals with these two tags. Here are some examples of `Result` functions: - -```roc -Result.withDefault (List.get ["a", "b", "c"] 100) "" -# returns "" because that's the default we said to use if List.get returned an Err -``` -```roc -Result.isOk (List.get ["a", "b", "c"] 1) -# returns `Bool.true` because `List.get` returned an `Ok` tag. (The payload gets ignored.) - -# Note: There's a Result.isErr function that works similarly. -``` - -### [Walking the elements in a list](#walking-the-elements-in-a-list) {#walking-the-elements-in-a-list} - -We've now seen a few different ways you can transform lists. Sometimes, though, there's nothing -that quite does what you want, and you might find yourself calling `List.get` repeatedly to -retrieve every element in the list and use it to build up the new value you want. That approach -can work, but it has a few downsides: - -* Each `List.get` call returns a `Result` that must be dealt with, even though you plan to use every element in the list anyway -* There's a runtime performance overhead associated with each of these `Result`s, which you won't find in other "look at every element in the list" operations like `List.keepIf`. -* It's more verbose than the alternative we're about to discuss - -The `List.walk` function gives you a way to walk over the elements in a list and build up whatever -return value you like. It's a great alternative to calling `List.get` on every element in the list -because it's more concise, runs faster, and doesn't give you any `Result`s to deal with. - -Here's an example: - -```roc -List.walk [1, 2, 3, 4, 5] { evens: [], odds: [] } \state, elem -> - if Num.isEven elem then - { state & evens: List.append state.evens elem } - else - { state & odds: List.append state.odds elem } - -# returns { evens: [2, 4], odds: [1, 3, 5] } -``` - -In this example, we walk over the list `[1, 2, 3, 4, 5]` and add each element to either the `evens` or `odds` field of a `state` record: `{ evens, odds }`. By the end, that record has a list of all the even numbers in the list and a list of all the odd numbers. - -`List.walk` takes a few ingredients: - -1. A list. (`[1, 2, 3, 4, 5]`) -2. An initial `state` value. (`{ evens: [], odds: [] }`) -3. A function which takes the current `state` and element, and returns a new `state`. (`\state, elem -> ...`) - -It then proceeds to walk over each element in the list and call that function. Each time, the state that function returns becomes the argument to the next function call. Here are the arguments the function will receive, and what it will return, as `List.walk` walks over the list `[1, 2, 3, 4, 5]`: - -| State | Element | Return Value | -| --------------------------------- | ------- | ------------------------------------ | -| `{ evens: [], odds: [] }` | `1` | `{ evens: [], odds: [1] }` | -| `{ evens: [], odds: [1] }` | `2` | `{ evens: [2], odds: [1] }` | -| `{ evens: [2], odds: [1] }` | `3` | `{ evens: [2], odds: [1, 3] }` | -| `{ evens: [2], odds: [1, 3] }` | `4` | `{ evens: [2, 4], odds: [1, 3] }` | -| `{ evens: [2, 4], odds: [1, 3] }` | `5` | `{ evens: [2, 4], odds: [1, 3, 5] }` | - -Note that the initial `state` argument is `{ evens: [], odds: [] }` because that's the argument -we passed `List.walk` for its initial state. From then on, each `state` argument is whatever the -previous function call returned. - -Once the list has run out of elements, `List.walk` returns whatever the final function call returned—in this case, `{ evens: [2, 4], odds: [1, 3, 5] }`. (If the list was empty, the function never gets called and `List.walk` returns the initial state.) - -Note that the state doesn't have to be a record; it can be anything you want. For example, if you made it a `Bool`, you could implement `List.any` using `List.walk`. You could also make the state be a list, and implement `List.map`, `List.keepIf`, or `List.dropIf`. There are a lot of things you can do with `List.walk`! - -A helpful way to remember the argument order for `List.walk` is that that its arguments follow the same pattern as what we've seen with `List.map`, `List.any`, `List.keepIf`, and `List.dropIf`: the first argument is a list, and the last argument is a function. The difference here is that `List.walk` has one more argument than those other functions; the only place it could go while preserving that pattern is in the middle! - -> **Note:** Other languages give this operation different names, such as `fold`, `reduce`, `accumulate`, `aggregate`, `compress`, and `inject`. Some languages also have operations like `forEach` or `for...in` syntax, which walk across every element and perform potentially side-effecting operations on them; `List.walk` can be used to replace these too, if you include a `Task` in the state. We'll talk about tasks, and how to use them with `List.walk`, later on. - -### [The pipe operator](#the-pipe-operator) {#the-pipe-operator} - -When you have nested function calls, sometimes it can be clearer to write them in a "pipelined" style using the `|>` operator. Here are three examples of writing the same expression; they all compile to exactly the same thing, but two of them use the `|>` operator to change how the calls look. - -```roc -Result.withDefault (List.get ["a", "b", "c"] 1) "" -``` -```roc -List.get ["a", "b", "c"] 1 -|> Result.withDefault "" -``` - -The `|>` operator takes the value that comes before the `|>` and passes it as the first argument to whatever comes after the `|>`. So in the example above, the `|>` takes `List.get ["a", "b", "c"] 1` and passes that value as the first argument to `Result.withDefault`, making `""` the second argument to `Result.withDefault`. - -We can take this a step further like so: - -```roc -["a", "b", "c"] -|> List.get 1 -|> Result.withDefault "" -``` - -This is still equivalent to the first expression. Since `|>` is known as the "pipe operator," we can read this as "start with `["a", "b", "c"]`, then pipe it to `List.get`, then pipe it to `Result.withDefault`." - -One reason the `|>` operator injects the value as the first argument is to make it work better with functions where argument order matters. For example, these two uses of `List.append` are equivalent: - -```roc -List.append ["a", "b", "c"] "d" -``` -```roc -["a", "b", "c"] -|> List.append "d" -``` - -Another example is `Num.div`. All three of the following do the same thing, because `a / b` in Roc is syntax sugar for `Num.div a b`: - -```roc -first / second -``` -```roc -Num.div first second -``` -```roc -first |> Num.div second -``` - -All operators in Roc are syntax sugar for normal function calls. See the [Operator Desugaring Table](https://www.roc-lang.org/tutorial#operator-desugaring-table) at the end of this tutorial for a complete list of them. - -## [Types](#types) {#types} - -Sometimes you may want to document the type of a definition. For example, you might write: - -```roc -# Takes a firstName string and a lastName string, and returns a string -fullName = \firstName, lastName -> - "\(firstName) \(lastName)" -``` - -Comments can be valuable documentation, but they can also get out of date and become misleading. If someone changes this function and forgets to update the comment, it will no longer be accurate. - -### [Type Annotations](#type-annotations) {#type-annotations} - -Here's another way to document this function's type, which doesn't have that problem: - -```roc -fullName : Str, Str -> Str -fullName = \firstName, lastName -> - "\(firstName) \(lastName)" -``` - -The `fullName :` line is a _type annotation_. It's a strictly optional piece of metadata we can add above a def to describe its type. Unlike a comment, the Roc compiler will check type annotations for accuracy. If the annotation ever doesn't fit with the implementation, we'll get a compile-time error. - -The annotation `fullName : Str, Str -> Str` says "`fullName` is a function that takes two strings as arguments and returns a string." - -We can give type annotations to any value, not just functions. For example: - -```roc -firstName : Str -firstName = "Amy" - -lastName : Str -lastName = "Lee" -``` - -These annotations say that both `firstName` and `lastName` have the type `Str`. - -We can annotate records similarly. For example, we could move `firstName` and `lastName` into a record like so: - -```roc -amy : { firstName : Str, lastName : Str } -amy = { firstName: "Amy", lastName: "Lee" } - -jen : { firstName : Str, lastName : Str } -jen = { firstName: "Jen", lastName: "Majura" } -``` - -### [Type Aliases](#type-aliases) {#type-aliases} - -When we have a recurring type annotation like this, it can be nice to give it its own name. We do this like so: - -```roc -Musician : { firstName : Str, lastName : Str } - -amy : Musician -amy = { firstName: "Amy", lastName: "Lee" } - -simone : Musician -simone = { firstName: "Simone", lastName: "Simons" } -``` - -Here, `Musician` is a _type alias_. A type alias is like a def, except it gives a name to a type instead of to a value. Just like how you can read `name : Str` as "`name` has the type `Str`," you can also read `Musician : { firstName : Str, lastName : Str }` as "`Musician` has the type `{ firstName : Str, lastName : Str }`." - -### [Type Parameters](#type-parameters) {#type-parameters} - -Annotations for lists must specify what type the list's elements have: - -```roc -names : List Str -names = ["Amy", "Simone", "Tarja"] -``` - -You can read `List Str` as "a list of strings." Here, `Str` is a _type parameter_ that tells us what type of `List` we're dealing with. `List` is a _parameterized type_, which means it's a type that requires a type parameter. There's no way to give something a type of `List` without a type parameter. You have to specify what type of list it is, such as `List Str` or `List Bool` or `List { firstName : Str, lastName : Str }`. - -### [Wildcard Types (\*)](#wildcard-type) {#wildcard-type} - -There are some functions that work on any list, regardless of its type parameter. For example, `List.isEmpty` has this type: - -```roc -isEmpty : List * -> Bool -``` - -The `*` is a _wildcard type_; a type that's compatible with any other type. `List *` is compatible with any type of `List` like `List Str`, `List Bool`, and so on. So you can call `List.isEmpty ["I am a List Str"]` as well as `List.isEmpty [Bool.true]`, and they will both work fine. - -The wildcard type also comes up with empty lists. Suppose we have one function that takes a `List Str` and another function that takes a `List Bool`. We might reasonably expect to be able to pass an empty list (that is, `[]`) to either of these functions, and we can! This is because a `[]` value has the type `List *`. It is a "list with a wildcard type parameter", or a "list whose element type could be anything." - -### [Type Variables](#type-variables) {#type-variables} - -`List.reverse` works similarly to `List.isEmpty`, but with an important distinction. As with `isEmpty`, we can call `List.reverse` on any list, regardless of its type parameter. However, consider these calls: - -```roc -strings : List Str -strings = List.reverse ["a", "b"] - -bools : List Bool -bools = List.reverse [Bool.true, Bool.false] -``` - -In the `strings` example, we have `List.reverse` returning a `List Str`. In the `bools` example, it's returning a `List Bool`. So what's the type of `List.reverse`? - -We saw that `List.isEmpty` has the type `List * -> Bool`, so we might think the type of `List.reverse` would be `reverse : List * -> List *`. However, remember that we also saw that the type of the empty list is `List *`? `List * -> List *` is actually the type of a function that always returns empty lists! That's not what we want. - -What we want is something like one of these: - -```roc -reverse : List elem -> List elem -``` - -```roc -reverse : List value -> List value -``` - -```roc -reverse : List a -> List a -``` - -Any of these will work, because `elem`, `value`, and `a` are all _type variables_. A type variable connects two or more types in the same annotation. So you can read `List elem -> List elem` as "takes a list and returns a list that has **the same element type**." Just like `List.reverse` does! - -You can choose any name you like for a type variable, but it has to be lowercase. (You may have noticed all the types we've used until now are uppercase; that is no accident! Lowercase types are always type variables, so all other named types have to be uppercase.) All three of the above type annotations are equivalent; the only difference is that we chose different names (`elem`, `value`, and `a`) for their type variables. - -You can tell some interesting things about functions based on the type parameters involved. For example, any function that returns `List *` definitely always returns an empty list. You don't need to look at the rest of the type annotation, or even the function's implementation! The only way to have a function that returns `List *` is if it returns an empty list. - -Similarly, the only way to have a function whose type is `a -> a` is if the function's implementation returns its argument without modifying it in any way. This is known as [the identity function](https://en.wikipedia.org/wiki/Identity_function). - -### [Tag Union Types](#tag-union-types) {#tag-union-types} - -We can also annotate types that include tags: - -```roc -colorFromStr : Str -> [Red, Green, Yellow] -colorFromStr = \string -> - when string is - "red" -> Red - "green" -> Green - _ -> Yellow -``` - -You can read the type `[Red, Green, Yellow]` as "a tag union of the tags `Red`, `Green`, and `Yellow`." - -Some tag unions have only one tag in them. For example: - -```roc -redTag : [Red] -redTag = Red -``` - -### [Accumulating Tag Types](#accumulating-tag-types) {#accumulating-tag-types} - -Tag union types can accumulate more tags based on how they're used. Consider this `if` expression: - -```roc -\str -> - if Str.isEmpty str then - Ok "it was empty" - else - Err ["it was not empty"] -``` - -Here, Roc sees that the first branch has the type `[Ok Str]` and that the `else` branch has the type `[Err (List Str)]`, so it concludes that the whole `if` expression evaluates to the combination of those two tag unions: `[Ok Str, Err (List Str)]`. - -This means this entire `\str -> ...` function has the type `Str -> [Ok Str, Err (List Str)]`. However, it would be most common to annotate it as `Result Str (List Str)` instead, because the `Result` type (for operations like `Result.withDefault`, which we saw earlier) is a type alias for a tag union with `Ok` and `Err` tags that each have one payload: - -```roc -Result ok err : [Ok ok, Err err] -``` - -We just saw how tag unions get combined when different branches of a conditional return different tags. Another way tag unions can get combined is through pattern matching. For example: - -```roc -when color is - Red -> "red" - Yellow -> "yellow" - Green -> "green" -``` - -Here, Roc's compiler will infer that `color`'s type is `[Red, Yellow, Green]`, because those are the three possibilities this `when` handles. - -### [Opaque Types](#opaque-types) {#opaque-types} - -A type can be defined to be opaque to hide its internal structure. This is a lot more amazing than it may seem. It can make your code more modular, robust, and easier to read: -- If a type is opaque you can modify its internal structure and be certain that no dependencies need to be updated. -- You can prevent that data needs to be checked multiple times. For example, you can create an opaque `NonEmptyList` from a `List` after you've checked it. Now all functions that you pass this `NonEmptyList` to do not need to handle the empty list case. -- Having the type `Username` in a type signature gives you more context compared to `Str`. Even if the `Username` is an opaque type for `Str`. - -You can create an opaque type with the `:=` operator. Let's make one called `Username`: - -```roc -Username := Str - -fromStr : Str -> Username -fromStr = \str -> - @Username str - -toStr : Username -> Str -toStr = \@Username str -> - str -``` - -The `fromStr` function turns a string into a `Username` by calling `@Username` on that string. The `toStr` function turns a `Username` back into a string by pattern matching `@Username str` to unwrap the string from the `Username` opaque type. - -Now we can expose the `Username` opaque type so that other modules can use it in type annotations. However, other modules can't use the `@Username` syntax to wrap or unwrap `Username` values. That operation is only available in the same scope where `Username` itself was defined; trying to use it outside that scope will give an error. - -Note that if we define `Username := Str` inside another module (e.g. `Main`) and also use `@Username`, this will compile, however the new `Username` type in main would not be equal to the one defined in the `Username` module. Although both opaque types have the name `Username`, they were defined in different modules and so they are type-incompatible with each other, and even attempting to use `==` to compare them would be a type mismatch. - -## [Numeric types](#numeric-types) {#numeric-types} - -Roc has different numeric types that each have different tradeoffs. They can all be broken down into two categories: [fractions](https://en.wikipedia.org/wiki/Fraction), and [integers](https://en.wikipedia.org/wiki/Integer). In Roc we call these `Frac` and `Int` for short. - -### [Integers](#integers) {#integers} - -Roc's integer types have two important characteristics: their _size_ and their [_signedness_](https://en.wikipedia.org/wiki/Signedness). Together, these two characteristics determine the range of numbers the integer type can represent. - -For example, the Roc type `U8` can represent the numbers 0 through 255, whereas the `I16` type can represent the numbers -32768 through 32767. You can actually infer these ranges from their names (`U8` and `I16`) alone! - -The `U` in `U8` indicates that it's _unsigned_, meaning that it can't have a minus [sign](), and therefore can't be negative. The fact that it's unsigned tells us immediately that its lowest value is zero. The 8 in `U8` means it is 8 [bits](https://en.wikipedia.org/wiki/Bit) in size, which means it has room to represent 2⁸ (=256) different numbers. Since one of those 256 different numbers is 0, we can look at `U8` and know that it goes from `0` (since it's unsigned) to `255` (2⁸ - 1, since it's 8 bits). - -If we change `U8` to `I8`, making it a _signed_ 8-bit integer, the range changes. Because it's still 8 bits, it still has room to represent 2⁸ different numbers. However, now in addition to one of those 256 numbers being zero, about half of the rest will be negative, and the others positive. So instead of ranging from, say -255 to 255 (which, counting zero, would represent 511 different numbers; too many to fit in 8 bits!) an `I8` value ranges from -128 to 127. - -Notice that the negative extreme is `-128` versus `127` (not `128`) on the positive side. That's because of needing room for zero; the slot for zero is taken from the positive range because zero doesn't have a minus sign. - -Following this pattern, the 16 in `I16` means that it's a signed 16-bit integer. That tells us it has room to represent 2¹⁶ (=65536) different numbers. Half of 65536 is 32768, so the lowest `I16` would be -32768, and the highest would be 32767. - -Choosing a size depends on your performance needs and the range of numbers you want to represent. Consider: - -- Larger integer sizes can represent a wider range of numbers. If you absolutely need to represent numbers in a certain range, make sure to pick an integer size that can hold them! -- Smaller integer sizes take up less memory. These savings rarely matters in variables and function arguments, but the sizes of integers that you use in data structures can add up. This can also affect whether those data structures fit in [cache lines](https://en.wikipedia.org/wiki/CPU_cache#Cache_performance), which can easily be a performance bottleneck. -- Certain processors work faster on some numeric sizes than others. There isn't even a general rule like "larger numeric sizes run slower" (or the reverse, for that matter) that applies to all processors. In fact, if the CPU is taking too long to run numeric calculations, you may find a performance improvement by experimenting with numeric sizes that are larger than otherwise necessary. However, in practice, doing this typically degrades overall performance, so be careful to measure properly! - -Here are the different fixed-size integer types that Roc supports: - -| Range | Type | -|-------------------------------------------------------------------------------------------------------------------|--------| -| `-128`
    `127` | `I8` | -| `0`
    `255` | `U8` | -| `-32_768`
    `32_767` | `I16` | -| `0`
    `65_535` | `U16` | -| `-2_147_483_648`
    `2_147_483_647` | `I32` | -| `0`
    (over 4 billion) `4_294_967_295` | `U32` | -| `-9_223_372_036_854_775_808`
    `9_223_372_036_854_775_807` | `I64` | -| `0`
    _(over 18 quintillion)_`18_446_744_073_709_551_615` | `U64` | -| `-170_141_183_460_469_231_731_687_303_715_884_105_728`
    `170_141_183_460_469_231_731_687_303_715_884_105_727` | `I128` | -| `0`
    _(over 340 undecillion)_`340_282_366_920_938_463_463_374_607_431_768_211_455` | `U128` | - -Roc also has one variable-size integer type: `Nat` (short for "natural number"). The size of `Nat` is equal to the size of a memory address, which varies by system. For example, when compiling for a 64-bit system, `Nat` works the same way as `U64`. When compiling for a 32-bit system, it works the same way as `U32`. Most popular computing devices today are 64-bit, so `Nat` is usually the same as `U64`, but Web Assembly is typically 32-bit - so when running a Roc program built for Web Assembly, `Nat` will work like a `U32` in that program. - -A common use for `Nat` is to store the length of a collection like a `List`; there's a function `List.len : List * -> Nat` which returns the length of the given list. 64-bit systems can represent longer lists in memory than 32-bit systems can, which is why the length of a list is represented as a `Nat`. - -If any operation would result in an integer that is either too big or too small to fit in that range (e.g. calling `Int.maxI32 + 1`, which adds 1 to the highest possible 32-bit integer), then the operation will [overflow](https://en.wikipedia.org/wiki/Integer_overflow). When an overflow occurs, the program will crash. - -As such, it's very important to design your integer operations not to exceed these bounds! - -### [Fractions](#fractions) {#fractions} - -Roc has three fractional types: - -- `F32`, a 32-bit [floating-point number](https://en.wikipedia.org/wiki/IEEE_754) -- `F64`, a 64-bit [floating-point number](https://en.wikipedia.org/wiki/IEEE_754) -- `Dec`, a 128-bit decimal [fixed-point number](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) - -These are different from integers, they can represent numbers with fractional components, such as 1.5 and -0.123. - -`Dec` is the best default choice for representing [base-10 decimal numbers](https://en.wikipedia.org/wiki/Decimal) like [currency](https://en.wikipedia.org/wiki/Currency), because it is base-10 under the hood. In contrast, `F64` and `F32` are [base-2](https://en.wikipedia.org/wiki/Binary_number) under the hood, which can lead to decimal precision loss even when doing addition and subtraction. For example, when using `F64`, running 0.1 + 0.2 returns 0.3000000000000000444089209850062616169452667236328125, whereas when using `Dec`, 0.1 + 0.2 returns 0.3. - -`F32` and `F64` have direct hardware support on common processors today. There is no hardware support for fixed-point decimals, so under the hood, a `Dec` is an `I128`; operations on it perform [base-10 fixed-point arithmetic](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) with 18 decimal places of precision. - -This means a `Dec` can represent whole numbers up to slightly over 170 quintillion, along with 18 decimal places. (To be precise, it can store numbers between `-170_141_183_460_469_231_731.687303715884105728` and `170_141_183_460_469_231_731.687303715884105727`.) Why 18 decimal places? It's the highest number of decimal places where you can still convert any `U64` to a `Dec` without losing information. - -While the fixed-point `Dec` has a fixed range, the floating-point `F32` and `F64` do not. Instead, outside of a certain range they start to lose precision instead of immediately overflowing the way integers and `Dec` do. `F64` can represent [between 15 and 17 significant digits](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) before losing precision, whereas `F32` can only represent [between 6 and 9](https://en.wikipedia.org/wiki/Single-precision_floating-point_format#IEEE_754_single-precision_binary_floating-point_format:_binary32). - -There are some use cases where `F64` and `F32` can be better choices than `Dec` despite their precision drawbacks. For example, in graphical applications they can be a better choice for representing coordinates because they take up less memory, various relevant calculations run faster, and decimal precision loss isn't as big a concern when dealing with screen coordinates as it is when dealing with something like currency. - -### [Num, Int, and Frac](#num-int-and-frac) {#num-int-and-frac} - -Some operations work on specific numeric types - such as `I64` or `Dec` - but operations support multiple numeric types. For example, the `Num.abs` function works on any number, since you can take the [absolute value](https://en.wikipedia.org/wiki/Absolute_value) of integers and fractions alike. Its type is: - -```roc -abs : Num a -> Num a -``` - -This type says `abs` takes a number and then returns a number of the same type. Remember that we can see the type of number is the same because the [type variable](#type-variables) `a` is used on both sides. That's because the `Num` type is compatible with both integers and fractions. - -There's also an `Int` type which is only compatible with integers, and a `Frac` type which is only compatible with fractions. For example: - -```roc -Num.xor : Int a, Int a -> Int a -``` -```roc -Num.cos : Frac a -> Frac a -``` -When you write a number literal in Roc, it has the type `Num *`. So you could call `Num.xor 1 1` and also `Num.cos 1` and have them all work as expected; the number literal `1` has the type `Num *`, which is compatible with the more constrained types `Int` and `Frac`. For the same reason, you can pass number literals to functions expecting even more constrained types, like `I32` or `F64`. - -### [Number Literals](#number-literals) {#number-literals} - -By default, a number literal with no decimal point has the type `Num *`—that is, we know it's "a number" but nothing more specific. (Number literals with decimal points have the type `Frac *` instead.) - -You can give a number literal a more specific type by adding the type you want as a lowercase suffix. For example, `1u8` specifies `1` with the type `U8`, and `5dec` specifies `5` with the type `Dec`. - -The full list of possible suffixes includes: - -`u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `u128`, `i128`, `nat`, `f32`, `f64`, `dec` - -Integer literals can be written in [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) form by prefixing with `0x` followed by hexadecimal characters (`a` - `f` in addition to `0` - `9`). For example, writing `0xfe` is the same as writing `254`. Similarly, the prefix `0b` specifies binary integers. Writing `0b0000_1000` is the same as writing `8`. - -## [Crashing](#crashing) {#crashing} - -Ideally, Roc programs would never crash. However, there are some situations where they may. For example: - -1. When doing normal integer arithmetic (e.g. `x + y`) that [overflows](https://en.wikipedia.org/wiki/Integer_overflow). -2. When the system runs out of memory. -3. When a variable-length collection (like a `List` or `Str`) gets too long to be representable in the operating system's address space. (A 64-bit operating system's address space can represent several [exabytes](https://en.wikipedia.org/wiki/Byte#Multiple-byte_units) of data, so this case should not come up often.) - -Crashes in Roc are not like [try/catch exceptions](https://en.wikipedia.org/wiki/Exception_handling) found in some other programming languages. There is no way to "catch" a crash. It immediately ends the program, and what happens next is defined by the [platform](https://github.com/roc-lang/roc/wiki/Roc-concepts-explained#platform). For example, a command-line interface platform might exit with a nonzero [exit code](https://en.wikipedia.org/wiki/Exit_status), whereas a web server platform might have the current request respond with a [HTTP 500 error](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#500). - -### [Crashing in unreachable branches](#crashing-in-unreachable-branches) {#crashing-in-unreachable-branches} - -You can intentionally crash a Roc program, for example inside a conditional branch that you believe is unreachable. Suppose you're certain that a particular `List U8` contains valid UTF-8 bytes, which means when you call `Str.fromUtf8` on it, the `Result` it returns will always be `Ok`. In that scenario, you can use the `crash` keyword to handle the `Err` case like so: - -```roc -answer : Str -answer = - when Str.fromUtf8 definitelyValidUtf8 is - Ok str -> str - Err _ -> crash "This should never happen!" -``` - -If the unthinkable happens, and somehow the program reaches this `Err` branch even though that was thought to be impossible, then it will crash - just like if the system had run out of memory. The string passed to `crash` will be provided to the platform as context; each platform may do something different with it. - -> **Note:** `crash` is a language keyword and not a function; you can't assign `crash` to a variable or pass it to a function. - -### [Crashing for TODOs](#crashing-for-todos) {#crashing-for-todos} - -Another use for `crash` is as a TODO marker when you're in the middle of building something: - -```roc -if x > y then - transmogrify (x * 2) -else - crash "TODO handle the x <= y case" -``` - -This lets you do things like write tests for the non-`crash` branch, and then come back and finish the other branch later. - -### [Crashing for error handling](#crashing-for-error-handling) {#crashing-for-error-handling} - -`crash` is not for error handling. - -The reason Roc has a `crash` keyword is for scenarios where it's expected that no error will ever happen (like in [unreachable branches](#crashing-in-unreachable-branches)), or where graceful error handling is infeasible (like running out of memory). - -Errors that are recoverable should be represented using normal Roc types (like [Result](https://www.roc-lang.org/builtins/Result)) and then handled without crashing. For example, by having the application report that something went wrong, and then continue running from there. - -## [Tests and expectations](#tests-and-expectations) {#tests-and-expectations} - -You can write automated tests for your Roc code like so: - -```roc -pluralize = \singular, plural, count -> - countStr = Num.toStr count - - if count == 1 then - "\(countStr) \(singular)" - else - "\(countStr) \(plural)" - -expect pluralize "cactus" "cacti" 1 == "1 cactus" - -expect pluralize "cactus" "cacti" 2 == "2 cacti" -``` - -If you put this in a file named `main.roc` and run `roc test`, Roc will execute the two `expect` expressions (that is, the two `pluralize` calls) and report any that returned `Bool.false`. - -If a test fails, it will not show the actual value that differs from the expected value. To show the actual value, you can write the expect like this: - -```roc -expect - funcOut = pluralize "cactus" "cacti" 1 - - funcOut == "2 cactus" -``` - -### [Inline Expectations](#inline-expects) {#inline-expects} - -Expects do not have to be at the top level: - -```roc -pluralize = \singular, plural, count -> - countStr = Num.toStr count - - if count == 1 then - "\(countStr) \(singular)" - else - expect count > 0 - - "\(countStr) \(plural)" -``` - -This `expect` will fail if you call `pluralize` passing a count of 0. - -Note that inline `expect`s do not halt the program! They are designed to inform, not to affect control flow. In fact, if you do `roc build`, they are not even included in the final binary. -So you'll want to use `roc dev` or `roc test` to get the output for `expect`. - -## [Modules](#modules) {#modules} - -Each `.roc` file is a separate module and contains Roc code for different purposes. Here are all of the different types of modules that Roc supports; - -- **Builtins** provide functions that are automatically imported into every module. -- **Applications** are combined with a platform and compiled into an executable. -- **Interfaces** provide functions which can be imported into other modules. -- **Packages** organise modules to share functionality across applications and platforms. -- **Platforms** provide effects such as IO to interface with the outside world. -- **Hosted** *note this module type is likely to be deprecated soon*. - -### [Builtin Modules](#builtin-modules) {#builtin-modules} - -There are several modules that are built into the Roc compiler, which are imported automatically into every Roc module. They are: - -1. `Bool` -2. `Str` -3. `Num` -4. `List` -5. `Result` -6. `Dict` -7. `Set` - -You may have noticed that we already used the first five. For example, when we wrote `Str.concat` and `Num.isEven`, we were referencing functions stored in the `Str` and `Num` modules. - -These modules are not ordinary `.roc` files that live on your filesystem. Rather, they are built directly into the Roc compiler. That's why they're called "builtins!" - -Besides being built into the compiler, the builtin modules are different from other modules in that: - -- They are always imported. You never need to add them to `imports`. -- All their types are imported unqualified automatically. So you never need to write `Num.Nat`, because it's as if the `Num` module was imported using `imports [Num.{ Nat }]` (the same is true for all the other types in the `Num` module. - -### [App Module Header](#app-module-header) {#app-module-header} - -Let's take a closer look at the part of `main.roc` above the `main` def: - -```roc -app "hello" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout] - provides [main] to pf -``` - -This is known as a _module header_. Every `.roc` file is a _module_, and there are different types of modules. We know this particular one is an _application module_ because it begins with the `app` keyword. - -The line `app "hello"` states that this module defines a Roc application, and that building this application should produce an executable named `hello`. This means when you run `roc dev`, the Roc compiler will build an executable named `hello` (or `hello.exe` on Windows) and run it. You can also build the executable without running it by running `roc build`. - -The remaining lines all involve the [platform](https://github.com/roc-lang/roc/wiki/Roc-concepts-explained#platform) this application is built on: - -```roc -packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout] - provides [main] to pf -``` - -The `packages { pf: "https://...tar.br" }` part says three things: - -- We're going to be using a _package_ (a collection of modules) that can be downloaded from the URL `"https://...tar.br"` -- That package's [base64](https://en.wikipedia.org/wiki/Base64#URL_applications)\-encoded [BLAKE3]() cryptographic hash is the long string at the end (before the `.tar.br` file extension). Once the file has been downloaded, its contents will be verified against this hash, and it will only be installed if they match. This way, you can be confident the download was neither corrupted nor changed since it was originally published. -- We're going to name that package `pf` so we can refer to it more concisely in the future. - -The `imports [pf.Stdout]` line says that we want to import the `Stdout` module from the `pf` package, and make it available in the current module. - -This import has a direct interaction with our definition of `main`. Let's look at that again: - -```roc -main = Stdout.line "I'm a Roc application!" -``` - -Here, `main` is calling a function called `Stdout.line`. More specifically, it's calling a function named `line` which is exposed by a module named `Stdout`. - -When we write `imports [pf.Stdout]`, it specifies that the `Stdout` module comes from the package we named `pf` in the `packages { pf: ... }` section. - -If we would like to include other modules in our application, say `AdditionalModule.roc` and `AnotherModule.roc`, then they can be imported directly in `imports` like this: - -```roc -imports [pf.Stdout, AdditionalModule, AnotherModule] -``` - -You can find documentation for the `Stdout.line` function in the [Stdout](https://www.roc-lang.org/packages/basic-cli/Stdout#line) module documentation. - -### [Package Modules](#interface-modules) {#interface-modules} - -Package modules enable Roc code to be easily re-used and shared. This is achieved by organizing code into different Interface modules and then including these in the `exposes` field of the package file structure, `package "name" exposes [ MyInterface ] packages {}`. The modules that are listed in the `exposes` field are then available for use in applications, platforms, or other packages. Internal modules that are not listed will be unavailable for use outside of the package. - -See [Parser Package](https://github.com/roc-lang/roc/tree/main/examples/parser/package) for an example. - -Package documentation can be generated using the Roc cli with `roc docs /package/*.roc`. - -Build a package for distribution with `roc build --bundle .tar.br /package/main.roc`. This will create a single tarball that can then be easily shared online using a URL. - -You can import a package that is available either locally, or from a URL into a Roc application or platform. This is achieved by specifying the package in the `packages` section of the application or platform file structure. For example, `packages { .., parser: "" }` is an example that imports a parser module from a URL. - -How does the Roc cli import and download a package from a URL? - -1. First it checks to see whether the relevant folder already exists in the local filesystem and if not, creates it. If there is a package already downloaded then there is no need to download or extract anything. Packages are cached in a directory, typically `~/.cache/roc` on UNIX, and `%APPDATA%\\Roc` on Windows. -2. It then downloads the file at that URL and verifies that the hash of the file matches the hash at the end of the URL. -3. If the hash of the file matches the hash in the URL, then decompress and extract its contents into the cache folder so that it can be used. - -Why is a Roc package URL so long? - -Including the hash solves a number of problems: - -1. The package at the URL can not suddenly change and cause different behavior. -2. Because of 1. there is no need to check the URL on every compilation to see if we have the latest version. -3. If the domain of the URL expires, a malicious actor can change the package but the hash will not match so the roc cli will reject it. - -### [Interface Modules](#interface-modules) {#interface-modules} - -\[This part of the tutorial has not been written yet. Coming soon!\] - -See [Html Interface](https://github.com/roc-lang/roc/blob/main/examples/virtual-dom-wip/platform/Html.roc) for an example. - -### [Platform Modules](#interface-modules) {#interface-modules} - -\[This part of the tutorial has not been written yet. Coming soon!\] - -See [Platform Switching Rust](https://github.com/roc-lang/roc/blob/main/examples/platform-switching/rust-platform/main.roc) for an example. - -## [Tasks](#tasks) {#tasks} - -Tasks are technically not part of the Roc language, but they're very common in platforms. Let's continue using the [basic-cli](https://github.com/roc-lang/basic-cli) platform we've been using up to this point as an example! - -In the `basic-cli` platform, we have four operations we can do: - -- Write a string to the terminal -- Read a string from user input -- Write a string to a file -- Read a string from a file - -We'll use these four operations to learn about tasks. - -Let's start with a basic "Hello World" program. - -```roc -app "cli-tutorial" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout] - provides [main] to pf - -main = - Stdout.line "Hello, World!" -``` - -The `Stdout.line` function takes a `Str` and writes it to [standard output](). It has this type: - -```roc -Stdout.line : Str -> Task {} * -``` - -A `Task` represents an _effect_; an interaction with state outside your Roc program, such as the terminal's standard output, or a file. - -When we set `main` to be a `Task`, the task will get run when we run our program. Here, we've set `main` to be a task that writes `"Hello, World!"` to `stdout` when it gets run, so that's what our program does! - -`Task` has two type parameters: the type of value it produces when it finishes running, and any errors that might happen when running it. `Stdout.line` has the type `Task {} *` because it doesn't produce any values when it finishes (hence the `{}`) and there aren't any errors that can happen when it runs (hence the `*`). - -In contrast, `Stdin.line` produces a `Str` when it finishes reading from [standard input](). That `Str` is reflected in its type: - -```roc -Stdin.line : Task Str * -``` - -Let's change `main` to read a line from `stdin`, and then print it back out again: - -```roc -app "cli-tutorial" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout, pf.Stdin, pf.Task] - provides [main] to pf - -main = - Task.await Stdin.line \text -> - Stdout.line "You just entered: \(text)" -``` - -If you run this program, at first it won't do anything. It's waiting for you to type something in and press Enter! Once you do, it should print back out what you entered. - -The `Task.await` function combines two tasks into one bigger `Task` which first runs one of the given tasks and then the other. In this case, it's combining a `Stdin.line` task with a `Stdout.line` task into one bigger `Task`, and then setting `main` to be that bigger task. - -The type of `Task.await` is: - -```roc -Task.await : Task a err, (a -> Task b err) -> Task b err -``` - -The second argument to `Task.await` is a "callback function" which runs after the first task completes. This callback function receives the output of that first task, and then returns the second task. This means the second task can make use of output from the first task, like we did in our `\text -> ...` callback function here: - -```roc -\text -> - Stdout.line "You just entered: \(text)" -``` - -Notice that, just like before, we're still building `main` from a single `Task`. This is how we'll always do it! We'll keep building up bigger and bigger `Task`s out of smaller tasks, and then setting `main` to be that one big `Task`. - -For example, we can print a prompt before we pause to read from `stdin`, so it no longer looks like the program isn't doing anything when we start it up: - -```roc -task = - Task.await (Stdout.line "Type something press Enter:") \_ -> - Task.await Stdin.line \text -> - Stdout.line "You just entered: \(text)" -``` - -This works, but we can make it a little nicer to read. Let's change it to the following: - -```roc -app "cli-tutorial" - packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } - imports [pf.Stdout, pf.Stdin, pf.Task.{ await }] - provides [main] to pf - -main = - await (Stdout.line "Type something press Enter:") \_ -> - await Stdin.line \text -> - Stdout.line "You just entered: \(text)" -``` - -Here we've changed how we're importing the `Task` module. Before it was `pf.Task` and now it's `pf.Task.{ await }`. The difference is that we're importing `await` in an _unqualified_ way, meaning that whenever we write `await` in this module, it will refer to `Task.await`. Now we no longer need to write `Task.` every time we want to use `await`. - -It's most common in Roc to call functions from other modules in a _qualified_ way (`Task.await`) rather than unqualified (`await`) like this, but it can be nice for a function with an uncommon name (like "await") which often gets called repeatedly across a small number of lines of code. - -Speaking of calling `await` repeatedly, if we keep calling it more and more on this code, we'll end up doing a lot of indenting. If we'd rather not indent so much, we can rewrite `task` into this style which looks different but does the same thing: - -```roc -task = - _ <- await (Stdout.line "Type something press Enter:") - text <- await Stdin.line - - Stdout.line "You just entered: \(text)" -``` - -## [Backpassing](#backpassing) {#backpassing} - -This `<-` syntax is called _backpassing_. The `<-` is a way to define an anonymous function, just like `\ ... ->` is. - -Here, we're using backpassing to define two anonymous functions. Here's one of them: - -```roc -text <- - -Stdout.line "You just entered: \(text)" -``` - -It may not look like it, but this code is defining an anonymous function! You might remember it as the anonymous function we previously defined like this: - -```roc -\text -> - Stdout.line "You just entered: \(text)" -``` - -These two anonymous functions are the same, just defined using different syntax. - -The reason the `<-` syntax is called _backpassing_ is because it both defines a function and passes that function _back_ as an argument to whatever comes after the `<-` (which in this case is `await Stdin.line`). - -Let's look at these two complete expressions side by side. They are both saying exactly the same thing, with different syntax! - -Here's the original: - -```roc -await Stdin.line \text -> - Stdout.line "You just entered: \(text)" -``` - -And here's the equivalent expression with backpassing syntax: - -```roc -text <- await Stdin.line - -Stdout.line "You just entered: \(text)" -``` - -Here's the other function we're defining with backpassing: - -```roc -_ <- -text <- await Stdin.line - -Stdout.line "You just entered: \(text)" -``` - -We could also have written that function this way if we preferred: - -```roc -_ <- - -await Stdin.line \text -> - Stdout.line "You just entered: \(text)" -``` - -This is using a mix of a backpassing function `_ <-` and a normal function `\text ->`, which is totally allowed! Since backpassing is nothing more than syntax sugar for defining a function and passing back as an argument to another function, there's no reason we can't mix and match if we like. - -That said, the typical style in which this `task` would be written in Roc is using backpassing for all the `await` calls, like we had above: - -```roc -task = - _ <- await (Stdout.line "Type something press Enter:") - text <- await Stdin.line - - Stdout.line "You just entered: \(text)" -``` - -This way, it reads like a series of instructions: - -1. First, run the `Stdout.line` task and await its completion. Ignore its output (hence the underscore in `_ <-`) -2. Next, run the `Stdin.line` task and await its completion. Name its output `text`. -3. Finally, run the `Stdout.line` task again, using the `text` value we got from the `Stdin.line` effect. - -Some important things to note about backpassing and `await`: - -- `await` is not a language keyword in Roc! It's referring to the `Task.await` function, which we imported unqualified by writing `Task.{ await }` in our module imports. (That said, it is playing a similar role here to the `await` keyword in languages that have `async`/`await` keywords, even though in this case it's a function instead of a special keyword.) -- Backpassing syntax does not need to be used with `await` in particular. It can be used with any function. -- Roc's compiler treats functions defined with backpassing exactly the same way as functions defined the other way. The only difference between `\text ->` and `text <-` is how they look, so feel free to use whichever looks nicer to you! - -## [Abilities](#abilities) {#abilities} - -\[This part of the tutorial has not been written yet. Coming soon!\] - -## [Appendix: Advanced Concepts](#appendix-advanced-concepts) {#appendix-advanced-concepts} - -Here are some concepts you likely won't need as a beginner, but may want to know about eventually. This is listed as an appendix rather than the main tutorial, to emphasize that it's totally fine to stop reading here and go build things! - -### [Open Records and Closed Records](#open-records-and-closed-records) {#open-records-and-closed-records} - -Let's say I write a function which takes a record with a `firstName` and `lastName` field, and puts them together with a space in between: - -```roc -fullName = \user -> - "\(user.firstName) \(user.lastName)" -``` - -I can pass this function a record that has more fields than just `firstName` and `lastName`, as long as it has _at least_ both of those fields (and both of them are strings). So any of these calls would work: - -- `fullName { firstName: "Sam", lastName: "Sample" }` -- `fullName { firstName: "Sam", lastName: "Sample", email: "blah@example.com" }` -- `fullName { age: 5, firstName: "Sam", things: 3, lastName: "Sample", role: Admin }` - -This `user` argument is an _open record_ - that is, a description of a minimum set of fields on a record, and their types. When a function takes an open record as an argument, it's okay if you pass it a record with more fields than just the ones specified. - -In contrast, a _closed record_ is one that requires an exact set of fields (and their types), with no additional fields accepted. - -If we add a type annotation to this `fullName` function, we can choose to have it accept either an open record or a closed record: - -```roc -# Closed record -fullName : { firstName : Str, lastName : Str } -> Str -fullName = \user -> - "\(user.firstName) \(user.lastName)" -``` - -```roc -# Open record (because of the `*`) -fullName : { firstName : Str, lastName : Str }* -> Str -fullName = \user -> - "\(user.firstName) \(user.lastName)" -``` - -The `*` in the type `{ firstName : Str, lastName : Str }*` is what makes it an open record type. This `*` is the _wildcard type_ we saw earlier with empty lists. (An empty list has the type `List *`, in contrast to something like `List Str` which is a list of strings.) - -This is because record types can optionally end in a type variable. Just like how we can have `List *` or `List a -> List a`, we can also have `{ first : Str, last : Str }*` or `{ first : Str, last : Str }a -> { first : Str, last : Str }a`. The differences are that in `List a`, the type variable is required and appears with a space after `List`; in a record, the type variable is optional, and appears (with no space) immediately after `}`. - -If the type variable in a record type is a `*` (such as in `{ first : Str, last : Str }*`), then it's an open record. If the type variable is missing, then it's a closed record. You can also specify a closed record by putting a `{}` as the type variable (so for example, `{ email : Str }{}` is another way to write `{ email : Str }`). In practice, closed records are basically always written without the `{}` on the end, but later on we'll see a situation where putting types other than `*` in that spot can be useful. - -### [Constrained Records](#constrained-records) {#constrained-records} - -The type variable can also be a named type variable, like so: - -```roc -addHttps : { url : Str }a -> { url : Str }a -addHttps = \record -> - { record & url: "https://\(record.url)" } -``` - -This function uses _constrained records_ in its type. The annotation is saying: - -- This function takes a record which has at least a `url` field, and possibly others -- That `url` field has the type `Str` -- It returns a record of exactly the same type as the one it was given - -So if we give this function a record with five fields, it will return a record with those same five fields. The only requirement is that one of those fields must be `url: Str`. - -In practice, constrained records appear in type annotations much less often than open or closed records do. - -Here's when you can typically expect to encounter these three flavors of type variables in records: - -- _Open records_ are what the compiler infers when you use a record as an argument, or when destructuring it (for example, `{ x, y } =`). -- _Closed records_ are what the compiler infers when you create a new record (for example, `{ x: 5, y: 6 }`) -- _Constrained records_ are what the compiler infers when you do a record update (for example, `{ user & email: newEmail }`) - -Of note, you can pass a closed record to a function that accepts a smaller open record, but not the reverse. So a function `{ a : Str, b : Bool }* -> Str` can accept an `{ a : Str, b : Bool, c : Bool }` record, but a function `{ a : Str, b : Bool, c : Bool } -> Str` would not accept an `{ a : Str, b : Bool }*` record. - -This is because if a function accepts `{ a : Str, b : Bool, c : Bool }`, that means it might access the `c` field of that record. So if you passed it a record that was not guaranteed to have all three of those fields present (such as an `{ a : Str, b : Bool }*` record, which only guarantees that the fields `a` and `b` are present), the function might try to access a `c` field at runtime that did not exist! - -### [Type Variables in Record Annotations](#type-variables-in-record-annotations) {#type-variables-in-record-annotations} - -You can add type annotations to make record types less flexible than what the compiler infers, but not more flexible. For example, you can use an annotation to tell the compiler to treat a record as closed when it would be inferred as open (or constrained), but you can't use an annotation to make a record open when it would be inferred as closed. - -If you like, you can always annotate your functions as accepting open records. However, in practice this may not always be the nicest choice. For example, let's say you have a `User` type alias, like so: - -```roc -User : { - email : Str, - firstName : Str, - lastName : Str, -} -``` - -This defines `User` to be a closed record, which in practice is the most common way records named `User` tend to be defined. - -If you want to have a function take a `User`, you might write its type like so: - -```roc -isValid : User -> Bool -``` - -If you want to have a function return a `User`, you might write its type like so: - -```roc -userFromEmail : Str -> User -``` - -A function which takes a user and returns a user might look like this: - -```roc -capitalizeNames : User -> User -``` - -This is a perfectly reasonable way to write all of these functions. However, I might decide that I really want the `isValid` function to take an open record; a record with _at least_ the fields of this `User` record, but possibly others as well. - -Since open records have a type variable (like `*` in `{ email : Str }*` or `a` in `{ email : Str }a -> { email : Str }a`), in order to do this I'd need to add a type variable to the `User` type alias: - -```roc -User a : { - email : Str - firstName : Str - lastName : Str -}a -``` - -Notice that the `a` type variable appears not only in `User a` but also in `}a` at the end of the record type! - -Using `User a` type alias, I can still write the same three functions, but now their types need to look different. This is what the first one would look like: - -```roc -isValid : User * -> Bool -``` - -Here, the `User *` type alias substitutes `*` for the type variable `a` in the type alias, which takes it from `{ email : Str, ... }a` to `{ email : Str, ... }*`. Now I can pass it any record that has at least the fields in `User`, and possibly others as well, which was my goal. - -```roc -userFromEmail : Str -> User {} -``` - -Here, the `User {}` type alias substitutes `{}` for the type variable `a` in the type alias, which takes it from `{ email : Str, ... }a` to `{ email : Str, ... }{}`. As noted earlier, this is another way to specify a closed record: putting a `{}` after it, in the same place that you'd find a `*` in an open record. - -> **Aside:** This works because you can form new record types by replacing the type variable with other record types. For example, `{ a : Str, b : Str }` can also be written `{ a : Str }{ b : Str }`. You can chain these more than once, e.g. `{ a : Str }{ b : Str }{ c : Str, d : Str }`. This is more useful when used with type annotations; for example, `{ a : Str, b : Str }User` describes a closed record consisting of all the fields in the closed record `User`, plus `a : Str` and `b : Str`. - -This function still returns the same record as it always did, it just needs to be annotated as `User {}` now instead of just `User`, because the `User` type alias has a variable in it that must be specified. - -The third function might need to use a named type variable: - -```roc -capitalizeNames : User a -> User a -``` - -If this function does a record update on the given user, and returns that - for example, if its definition were `capitalizeNames = \user -> { user & email: "blah" }` - then it needs to use the same named type variable for both the argument and return value. - -However, if returns a new `User` that it created from scratch, then its type could instead be: - -```roc -capitalizeNames : User * -> User {} -``` - -This says that it takes a record with at least the fields specified in the `User` type alias, and possibly others...and then returns a record with exactly the fields specified in the `User` type alias, and no others. - -These three examples illustrate why it's relatively uncommon to use open records for type aliases: it makes a lot of types need to incorporate a type variable that otherwise they could omit, all so that `isValid` can be given something that has not only the fields `User` has, but some others as well. (In the case of a `User` record in particular, it may be that the extra fields were included due to a mistake rather than on purpose, and accepting an open record could prevent the compiler from raising an error that would have revealed the mistake.) - -That said, this is a useful technique to know about if you want to (for example) make a record type that accumulates more and more fields as it progresses through a series of operations. - -### [Open and Closed Tag Unions](#open-and-closed-tag-unions) {#open-and-closed-tag-unions} - -Just like how Roc has open records and closed records, it also has open and closed tag unions. - -The _open tag union_ (or _open union_ for short) `[Foo Str, Bar Bool]*` represents a tag that might be `Foo Str` and might be `Bar Bool`, but might also be some other tag whose type isn't known at compile time. - -Because an open union represents possibilities that are impossible to know ahead of time, any `when` I use on a `[Foo Str, Bar Bool]*` value must include a catch-all `_ ->` branch. Otherwise, if one of those unknown tags were to come up, the `when` would not know what to do with it! For example: - -```roc -example : [Foo Str, Bar Bool]* -> Bool -example = \tag -> - when tag is - Foo str -> Str.isEmpty str - Bar bool -> bool - _ -> Bool.false -``` - -In contrast, a _closed tag union_ (or _closed union_) like `[Foo Str, Bar Bool]` (without the `*`) represents the set of all possible tags. If I use a `when` on one of these, I can match on `Foo` only and then on `Bar` only, with no need for a catch-all branch. For example: - -```roc -example : [Foo Str, Bar Bool] -> Bool -example = \tag -> - when tag is - Foo str -> Str.isEmpty str - Bar bool -> bool -``` - -If we were to remove the type annotations from the previous two code examples, Roc would infer the same types for them anyway. - -It would infer `tag : [Foo Str, Bar Bool]` for the latter example because the `when tag is` expression only includes a `Foo Str` branch and a `Bar Bool` branch, and nothing else. Since the `when` doesn't handle any other possibilities, these two tags must be the only possible ones. - -It would infer `tag : [Foo Str, Bar Bool]*` for the former example because the `when tag is` expression includes a `Foo Str` branch and a `Bar Bool` branch but also a `_ ->` branch, indicating that there may be other tags we don't know about. Since the `when` is flexible enough to handle all possible tags, `tag` gets inferred as an open union. - -Putting these together, whether a tag union is inferred to be open or closed depends on which possibilities the implementation actually handles. - -> **Aside:** As with open and closed records, we can use type annotations to make tag union types less flexible than what would be inferred. If we added a `_ ->` branch to the second example above, the compiler would still accept `example : [Foo Str, Bar Bool] -> Bool` as the type annotation, even though the catch-all branch would permit the more flexible `example : [Foo Str, Bar Bool]* -> Bool` annotation instead. - -### [Combining Open Unions](#combining-open-unions) {#combining-open-unions} - -When we make a new record, it's inferred to be a closed record. For example, in `foo { a: "hi" }`, the type of `{ a: "hi" }` is inferred to be `{ a : Str }`. In contrast, when we make a new tag, it's inferred to be an open union. So in `foo (Bar "hi")`, the type of `Bar "hi"` is inferred to be `[Bar Str]*`. - -This is because open unions can accumulate additional tags based on how they're used in the program, whereas closed unions cannot. For example, let's look at this conditional: - -```roc -if x > 5 then - "foo" -else - 7 -``` - -This will be a type mismatch because the two branches have incompatible types. Strings and numbers are not type-compatible! Now let's look at another example: - -```roc -if x > 5 then - Ok "foo" -else - Err "bar" -``` - -This shouldn't be a type mismatch, because we can see that the two branches are compatible; they are both tags that could easily coexist in the same tag union. But if the compiler inferred the type of `Ok "foo"` to be the closed union `[Ok Str]`, and likewise for `Err "bar"` and `[Err Str]`, then this would have to be a type mismatch - because those two closed unions are incompatible. - -Instead, the compiler infers `Ok "foo"` to be the open union `[Ok Str]*`, and `Err "bar"` to be the open union `[Err Str]*`. Then, when using them together in this conditional, the inferred type of the conditional becomes `[Ok Str, Err Str]*` - that is, the combination of the unions in each of its branches. (Branches in a `when` work the same way with open unions.) - -Earlier we saw how a function which accepts an open union must account for more possibilities, by including catch-all `_ ->` patterns in its `when` expressions. So _accepting_ an open union means you have more requirements. In contrast, when you already _have_ a value which is an open union, you have fewer requirements. A value which is an open union (like `Ok "foo"`, which has the type `[Ok Str]*`) can be provided to anything that's expecting a tag union (no matter whether it's open or closed), as long as the expected tag union includes at least the tags in the open union you're providing. - -So if I have an `[Ok Str]*` value, I can pass it to functions with any of these types (among others): - -| Function Type | Can it receive `[Ok Str]*`? | -| --------------------------------------- | --------------------------- | -| `[Ok Str]* -> Bool` | Yes | -| `[Ok Str] -> Bool` | Yes | -| `[Ok Str, Err Bool]* -> Bool` | Yes | -| `[Ok Str, Err Bool] -> Bool` | Yes | -| `[Ok Str, Err Bool, Whatever]* -> Bool` | Yes | -| `[Ok Str, Err Bool, Whatever] -> Bool` | Yes | -| `Result Str Bool -> Bool` | Yes | -| `[Err Bool, Whatever]* -> Bool` | Yes | - -That last one works because a function accepting an open union can accept any unrecognized tag (including `Ok Str`) even though it is not mentioned as one of the tags in `[Err Bool, Whatever]*`! Remember, when a function accepts an open tag union, any `when` branches on that union must include a catch-all `_ ->` branch, which is the branch that will end up handling the `Ok Str` value we pass in. - -However, I could not pass an `[Ok Str]*` to a function with a _closed_ tag union argument that did not mention `Ok Str` as one of its tags. So if I tried to pass `[Ok Str]*` to a function with the type `[Err Bool, Whatever] -> Str`, I would get a type mismatch - because a `when` in that function could be handling the `Err Bool` possibility and the `Whatever` possibility, and since it would not necessarily have a catch-all `_ ->` branch, it might not know what to do with an `Ok Str` if it received one. - -> **Note:** It wouldn't be accurate to say that a function which accepts an open union handles "all possible tags." For example, if I have a function `[Ok Str]* -> Bool` and I pass it `Ok 5`, that will still be a type mismatch. If you think about it, a `when` in that function might have the branch `Ok str ->` which assumes there's a string inside that `Ok`, and if `Ok 5` type-checked, then that assumption would be false and things would break! -> -> So `[Ok Str]*` is more restrictive than `[]*`. It's basically saying "this may or may not be an `Ok` tag, but if it is an `Ok` tag, then it's guaranteed to have a payload of exactly `Str`." - -In summary, here's a way to think about the difference between open unions in a value you have, compared to a value you're accepting: - -- If you _have_ a closed union, that means it has all the tags it ever will, and can't accumulate more. -- If you _have_ an open union, that means it can accumulate more tags through conditional branches. -- If you _accept_ a closed union, that means you only have to handle the possibilities listed in the union. -- If you _accept_ an open union, that means you have to handle the possibility that it has a tag you can't know about. - -### [Type Variables in Tag Unions](#type-variables-in-tag-unions) {#type-variables-in-tag-unions} - -Earlier we saw these two examples, one with an open tag union and the other with a closed one: - -```roc -example : [Foo Str, Bar Bool]* -> Bool -example = \tag -> - when tag is - Foo str -> Str.isEmpty str - Bar bool -> bool - _ -> Bool.false -``` - -```roc -example : [Foo Str, Bar Bool] -> Bool -example = \tag -> - when tag is - Foo str -> Str.isEmpty str - Bar bool -> bool -``` - -Similarly to how there are open records with a `*`, closed records with nothing, and constrained records with a named type variable, we can also have _constrained tag unions_ with a named type variable. Here's an example: - -```roc -example : [Foo Str, Bar Bool]a -> [Foo Str, Bar Bool]a -example = \tag -> - when tag is - Foo str -> Bar (Str.isEmpty str) - Bar bool -> Bar Bool.false - other -> other -``` - -This type says that the `example` function will take either a `Foo Str` tag, or a `Bar Bool` tag, or possibly another tag we don't know about at compile time and it also says that the function's return type is the same as the type of its argument. - -So if we give this function a `[Foo Str, Bar Bool, Baz (List Str)]` argument, then it will be guaranteed to return a `[Foo Str, Bar Bool, Baz (List Str)]` value. This is more constrained than a function that returned `[Foo Str, Bar Bool]*` because that would say it could return _any_ other tag (in addition to the `Foo Str` and `Bar Bool` we already know about). - -If we removed the type annotation from `example` above, Roc's compiler would infer the same type anyway. This may be surprising if you look closely at the body of the function, because: - -- The return type includes `Foo Str`, but no branch explicitly returns `Foo`. Couldn't the return type be `[Bar Bool]a` instead? -- The argument type includes `Bar Bool` even though we never look at `Bar`'s payload. Couldn't the argument type be inferred to be `Bar *` instead of `Bar Bool`, since we never look at it? - -The reason it has this type is the `other -> other` branch. Take a look at that branch, and ask this question: "What is the type of `other`?" There has to be exactly one answer! It can't be the case that `other` has one type before the `->` and another type after it; whenever you see a named value in Roc, it is guaranteed to have the same type everywhere it appears in that scope. - -For this reason, any time you see a function that only runs a `when` on its only argument, and that `when` includes a branch like `x -> x` or `other -> other`, the function's argument type and return type must necessarily be equivalent. - -> **Note:** Just like with records, you can also replace the type variable in tag union types with a concrete type. For example, `[Foo Str][Bar Bool][Baz (List Str)]` is equivalent to `[Foo Str, Bar Bool, Baz (List Str)]`. -> -> Also just like with records, you can use this to compose tag union type aliases. For example, you can write `NetworkError : [Timeout, Disconnected]` and then `Problem : [InvalidInput, UnknownFormat]NetworkError` - -### [Phantom Types](#phantom-types) {#phantom-types} - -\[This part of the tutorial has not been written yet. Coming soon!\] - -### [Operator Desugaring Table](#operator-desugaring-table) {#operator-desugaring-table} - -Here are various Roc expressions involving operators, and what they desugar to. - -| Expression | Desugars To | -| ----------------------------- | ------------------ | -| `a + b` | `Num.add a b` | -| `a - b` | `Num.sub a b` | -| `a * b` | `Num.mul a b` | -| `a / b` | `Num.div a b` | -| `a // b` | `Num.divTrunc a b` | -| `a ^ b` | `Num.pow a b` | -| `a % b` | `Num.rem a b` | -| `-a` | `Num.neg a` | -| `a == b` | `Bool.isEq a b` | -| `a != b` | `Bool.isNotEq a b` | -| `a && b` | `Bool.and a b` | -| a \|\| b | `Bool.or a b` | -| `!a` | `Bool.not a` | -| a \|> b | `b a` | -| a b c \|> f x y | `f (a b c) x y` | - - ### [Language Keywords](#language-keywords) {#language-keywords} - -These are all of the language keywords supported by Roc; - -`if`,`then`,`else`,`when`,`as`,`is`,`dbg`,`expect`,`expect-fx`,`crash`,`interface`,`app`,`package`,`platform`,`hosted`,`exposes`,`imports`,`with`,`generates`,`packages`,`requires`,`provides`,`to` diff --git a/www/generate_tutorial/src/tutorial.roc b/www/generate_tutorial/src/tutorial.roc deleted file mode 100644 index fda98a3400..0000000000 --- a/www/generate_tutorial/src/tutorial.roc +++ /dev/null @@ -1,116 +0,0 @@ -app "roc-tutorial" - packages { pf: "../../../examples/static-site-gen/platform/main.roc" } - imports [ - pf.Html.{ html, head, body, header, footer, script, div, main, p, section, h1, h2, label, ol, input, text, nav, a, li, link, meta }, - pf.Html.Attributes.{ content, name, for, id, type, href, rel, lang, title, charset, src }, - ] - provides [transformFileContent] to pf - -transformFileContent : Str, Str -> Str -transformFileContent = \_, htmlContent -> - Html.render (view htmlContent) - -view : Str -> Html.Node -view = \htmlContent -> - html [lang "en"] [ - head [] [ - meta [charset "utf-8"], - Html.title [] [text "Roc Tutorial"], - meta [name "description", content "Learn how to use the Roc programming language."], - meta [name "viewport", content "width=device-width"], - link [rel "stylesheet", href "/site.css"], - link [rel "icon", href "/favicon.svg"], - ], - body [] [ - viewNavbar, - main [] [ - viewTutorialStart, - text htmlContent, - ], - footer [] [ - text "Made by people who like to make nice things.", - ], - script [src "/site.js"] [], - ], - ] - -viewNavbar : Html.Node -viewNavbar = - header [id "top-bar"] [ - nav [] [ - a [id "nav-home-link", href "/", title "The Roc Programming Language"] [text "roc"], - div [id "header-links"] [ - a [href "/tutorial"] [text "tutorial"], - a [href "https://github.com/roc-lang/roc/tree/main/getting_started"] [text "install"], - a [href "/repl"] [text "repl"], - a [href "/builtins"] [text "docs"], - ], - ], - ] - -viewTutorialStart : Html.Node -viewTutorialStart = - div [id "tutorial-start"] [ - input [id "tutorial-toc-toggle", name "tutorial-toc-toggle", type "checkbox"] [], - nav [id "tutorial-toc", ariaLabel "Table of Contents"] [ - label [id "close-tutorial-toc", for "tutorial-toc-toggle"] [text "close"], - # TODO fix search: input [id "toc-search", type "text", placeholder "Search"] [], - ol [] tocLinks, - ], - tutorialIntro, - ] - -tocLinks = - { tag, value } <- List.map [ - { tag: "#installation", value: "Installation" }, - { tag: "#strings-and-numbers", value: "Strings and Numbers" }, - { tag: "#building-an-application", value: "Building an Application" }, - { tag: "#defining-functions", value: "Defining Functions" }, - { tag: "#if-then-else", value: "if-then-else" }, - { tag: "#debugging", value: "Debugging" }, - { tag: "#records", value: "Records" }, - { tag: "#tags", value: "Tags & Pattern Matching" }, - { tag: "#booleans", value: "Booleans" }, - { tag: "#lists", value: "Lists" }, - { tag: "#types", value: "Types" }, - { tag: "#numeric-types", value: "Numeric Types" }, - { tag: "#crashing", value: "Crashing" }, - { tag: "#tests-and-expectations", value: "Tests and Expectations" }, - { tag: "#modules", value: "Modules" }, - { tag: "#tasks", value: "Tasks" }, - { tag: "#abilities", value: "Abilities" }, - { tag: "#appendix-advanced-concepts", value: "Advanced Concepts" }, - { tag: "#operator-desugaring-table", value: "Operator Desugaring Table" }, - ] - - li [] [ - a [href tag] [text value], - ] - -tutorialIntro = - div [id "tutorial-intro"] [ - section [] [ - h1 [] [ - text "Tutorial", - label [id "tutorial-toc-toggle-label", for "tutorial-toc-toggle"] [text "contents"], - ], - p [] [text "Welcome to Roc!"], - p [] [text "This tutorial will teach you how to build Roc applications. Along the way, you'll learn how to write tests, use the REPL, and more!"], - ], - section [] [ - h2 [id "installation"] [ - a [href "#installation"] [text "Installation"], - ], - p [] [ - text "Roc doesn’t have a numbered release or an installer yet, but you can follow the install instructions for your OS", - a [href "https://github.com/roc-lang/roc/tree/main/getting_started#installation"] [text " here "], - text ". If you get stuck, friendly people will be happy to help if you open a topic in", - a [href "https://roc.zulipchat.com/#narrow/stream/231634-beginners"] [text " #beginners "], - text "on", - a [href "https://roc.zulipchat.com/"] [text " Roc Zulip Chat "], - text "and ask for assistance!", - ], - ], - ] - -ariaLabel = Html.attribute "aria-label" diff --git a/www/wip_new_website/main.roc b/www/main.roc similarity index 91% rename from www/wip_new_website/main.roc rename to www/main.roc index 82ce4a31fd..6b23318ad5 100644 --- a/www/wip_new_website/main.roc +++ b/www/main.roc @@ -1,5 +1,5 @@ app "roc-website" - packages { pf: "../../examples/static-site-gen/platform/main.roc" } + packages { pf: "../examples/static-site-gen/platform/main.roc" } imports [ pf.Html.{ Node, html, head, body, header, footer, div, span, main, text, nav, a, link, meta, script }, pf.Html.Attributes.{ attribute, content, name, id, href, rel, lang, class, title, charset, color, ariaLabel, ariaHidden, type }, @@ -74,7 +74,7 @@ view = \page, htmlContent -> preloadWoff2 "/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff2", preloadWoff2 "/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2", link [rel "prefetch", href "/repl/roc_repl_wasm.js"], - link [rel "stylesheet", href "/wip/site.css"], + link [rel "stylesheet", href "/site.css"], # Safari ignores rel="icon" and only respects rel="mask-icon". It will render the SVG with # fill="#000" unless this `color` attribute here is hardcoded (not a CSS `var()`) to override it. link [rel "mask-icon", href "/favicon.svg", color "#7d59dd"], @@ -103,19 +103,19 @@ viewNavbar = \page -> isHomepage = page == "index.html" homeLinkAttrs = - [id "nav-home-link", href "/wip/", title "The Roc Programming Language Homepage"] + [id "nav-home-link", href "/", title "The Roc Programming Language Homepage"] |> List.concat (if isHomepage then [ariaHidden "true"] else []) header [id "top-bar"] [ nav [ariaLabel "primary"] [ a homeLinkAttrs [rocLogo, span [class "home-link-text"] [text "Roc"]], div [id "top-bar-links"] [ - a [href "/wip/tutorial"] [text "tutorial"], - a [href "/wip/install"] [text "install"], - a [href "/wip/examples"] [text "examples"], - a [href "/wip/community"] [text "community"], - a [href "/wip/docs"] [text "docs"], - a [href "/wip/donate"] [text "donate"], + a [href "/tutorial"] [text "tutorial"], + a [href "/install"] [text "install"], + a [href "/examples"] [text "examples"], + a [href "/community"] [text "community"], + a [href "/docs"] [text "docs"], + a [href "/donate"] [text "donate"], ], ], ] diff --git a/www/wip_new_website/optimize.sh b/www/optimize.sh similarity index 83% rename from www/wip_new_website/optimize.sh rename to www/optimize.sh index a61500a351..1fae5b8981 100755 --- a/www/wip_new_website/optimize.sh +++ b/www/optimize.sh @@ -43,11 +43,11 @@ done popd # Minify the CSS file, and let esbuild add a content hash to the file name -npm exec --yes esbuild -- --minify dist/wip/site.css --outdir=dist/wip/ --entry-names='[name]-[hash]' +npm exec --yes esbuild -- --minify dist/site.css --outdir=dist/ --entry-names='[name]-[hash]' # Remove unused original file -rm dist/wip/site.css +rm dist/site.css # Find the new filename -css_with_hash=$(basename dist/wip/site-*.css) +css_with_hash=$(basename dist/site-*.css) # Replace all occurances in the html -sed -i "s:/wip/site.css:/wip/${css_with_hash}:g" dist/wip/*.html +sed -i "s:/wip/site.css:/wip/${css_with_hash}:g" dist/*.html diff --git a/www/public/homepage.css b/www/public/homepage.css deleted file mode 100644 index c251974bc0..0000000000 --- a/www/public/homepage.css +++ /dev/null @@ -1,15 +0,0 @@ -html { - font-family: sans-serif; - line-height: 145%; -} - -li { - margin-bottom: 0.5rem; -} - -@media only screen and (min-device-width: 900px) { - body { - width: 900px; - margin: 24px auto; - } -} \ No newline at end of file diff --git a/www/public/index.html b/www/public/index.html deleted file mode 100644 index a47315b204..0000000000 --- a/www/public/index.html +++ /dev/null @@ -1,316 +0,0 @@ - - - - - - - - The Roc Programming Language - - - - - - - -

    The Roc Programming Language

    -

    Roc's goal is to be a fast, friendly, functional language. It's very much a work in progress; - below, you can see the current progress towards this goal. This website is intentionally unstyled - as a way to emphasize the language's current level of incompleteness. The website will become - more polished after the language itself becomes more polished!

    - -

    Roc compiles to machine code or to WebAssembly. Eventually - you'll be able to use Roc to build high-quality servers, command-line applications, graphical - native desktop user interfaces, among other classes of applications. Today, only command-line interfaces have - support beyond the - proof-of-concept stage; the other use cases will mature over time.

    - -

    Like Lua, Roc's automatic memory management doesn't require - a virtual machine, and it's possible to call Roc functions directly from any language that can - call C functions. This makes - Roc additionally useful as a language for implementing plugins, and gives you a way to - incrementally transition a legacy code base from another language to Roc.

    - -

    So far, the Roc compiler has progressed past the "proof of concept" stage, but there are - currently lots of known bugs and unimplemented features, and the documentation for both the - language and the standard library is incomplete. The overall ecosystem is in its infancy, and - the compiler is neither battle-tested nor fuzz-tested yet, so we don't recommend relying on Roc - for critical projects until its development is further along.

    - -

    With all that context in mind, if you'd like to try it out or to get involved with contributing, - the source code repository has - nightly builds you can download, - and a tutorial. -

    - -

    If you'd like to learn more about Roc, you can continue reading here, or check out one of these videos:

    - - -

    A Fast Language

    - -

    Goal

    - -

    We want Roc to run faster than any non-systems language (like C, C++, Rust, or Zig) - that sees mainstream use in industry. The goal is that nobody should find themselves - thinking "I should rewrite my Roc program in [some mainstream garbage-collected language] - because that will make it run significantly faster." -

    - -

    When benchmarking Roc code against similarly-optimized programs written in - Go, - Swift, Java, - C#, or - JavaScript, - we generally aim for Roc to outperform all of those languages. Outperforming systems - languages like Rust, Zig, C, D, and C++ is a non-goal, as is outperforming research languages - that see little or no use in industry. (Realistically, there will always be certain specific - benchmarks where some popular non-systems-level languages outperform Roc, but the goal is to - usually be at the front of that pack.) -

    - -

    Current progress

    - -

    Progress towards this performance goal is already quite far along.

    - -

    Roc already uses unboxed data structures and unboxed closures, monomorphizes polymorphic code, - and uses LLVM as a compiler backend. These optimizations, especially unboxed closures and - monomorphization, can be found in several systems-level languages (like C++ and Rust), but not - in any mainstream garbage-collected languages. Roc closures in particular have the distinction - of being as ergonomic as the closures found in garbage-collected languages - (where they are typically boxed), but have the performance of systems language closures - (which are typically unboxed, but have more complicated types). - -

    Because of these optimizations, in many cases Roc code already - compiles to the same machine instructions that the equivalent code written in one of these - systems languages would. Something we do regularly is to compare the LLVM instructions generated - by Roc's compiler and by these systems languages' compilers, to check whether we're generating - equivalent instructions.

    - -

    That said, there are also cases where Roc has strictly more runtime overhead than languages - like C, C++, Zig, and Rust do. The most costly is automatic memory management, which Roc - implements using automatic reference counting. Static reference count optimizations like - elision and reuse (thanks to Morphic and - Perceus) - improve things, but significant runtime overhead remains. -

    - -

    Eliminating this overhead altogether would require sacrificing other design goals - (e.g. it would require introducing memory-unsafe operations, or compile-time lifetime errors), - and there isn't much overhead left to remove outside of automatic memory management. For example, - smaller sources of overhead include mandatory array bounds checks, disallowing cyclic references - (which rules out a certain niche of efficient graph data structures), and automatic opportunistic - in-place mutation instead of direct mutation. Even if all of these sources of overhead were - completely eliminated, it seems unlikely that typical Roc programs would see a particularly big - performance boost.

    - -

    Overall, we expect Roc's performance in the use cases mentioned above (servers, CLIs, GUIs, etc.) - to be about the same as the equivalent C++ code would be, if all that C++ code - (including its dependencies) were written in a restricted subset of C++ which always did array - bounds checks and used shared pointers for all heap allocations. - The Roc code might even run somewhat faster, because its reference counts are non-atomic by default, - and can be statically optimized away in some cases—but then again, Roc also has a bit of overhead - to perform opportunistic in-place mutation instead of direct mutation.

    - -

    To be clear, we don't expect this because we've benchmarked a bunch of programs written in Roc - and in this restricted C++ subset, and found that the numbers were about the same (although if - you know C++ well enough and want to do such experiments, we'd happy to help and would be - interested to see the results!) but rather because Roc's compiler and - clang should both be generating essentially the same - LLVM instructions when the C++ is restricted to that subset. -

    - -

    Of course, unrestricted C++ code can certainly run faster than unrestricted Roc code. - The same is true when comparing other such minimal-overhead systems languages to Roc, including - Rust, Zig, C, and D. The point of the comparison is to give you a general idea of what Roc - compiles to, since it is quite different from the VMs and JITted bytecode interpreters found in - today's most popular garbage-collected languages!

    - -

    The talk Outperforming Imperative with Pure Functional Languages - discusses some early results from Roc's optimizations, and - Roc at Handmade Seattle gets into - low-level details of how Roc's compiler generates programs similarly to how clang does. -

    - -

    A Friendly Language

    - -

    Goals

    - -

    Roc aims to be a user-friendly language with a friendly community of users.

    - -

    A programming language can be much more than a tool for writing software, it can also be a way - for people to come together through shared experiences, to teach and to learn from one another, - and to make new friends.

    - -

    No community is perfect, but a community where people show kindness to each another by default - can be a true joy to participate in. That all starts with friendliness, especially towards - beginners, and including towards people who prefer other programming languages. - After all, languages are tools people use to create software, and there's no need for us - to create artificial divisions between ourselves based on the tools we use!

    - -

    On a technical level, Roc aims to ship a toolset where user-friendliness is a major priority. - This includes everything from helpful error messages (aiming to meet the bar set by - Elm) to quality-of-life improvements inspired by dynamic - languages (always being able to run your program even if there are compile errors, automatic - serialization and deserialization using schemas determined by type inference, reliable hot - code loading that's always enabled and requires no configuration to set up, etc.) to accessibility - features in the included editor. -

    - -

    Roc also aims to ship a single binary that includes not only a compiler, but also a - REPL, - package manager, test runner, debugger, static analyzer, code formatter, and a full-featured - editor, all of which are designed to work seamlessly together. -

    - -

    Current Progress

    - -

    Work has not yet started on the package manager, static analyzer, debugger, or hot code loading - system, and although work has started on the editor, it's not yet far enough along to be usable - for practical purposes. The standard library is perhaps 80 percent complete in terms of - functionality, but a lot of operations do not yet have documentation.

    - -

    The REPL fully supports entering arbitrary expressions, and will evaluate them and print the - results. It remembers recent expressions entered in the current session (if you press the up arrow), - but it can't yet execute effects. You can try out the REPL in a browser at - roc-lang.org/repl - it uses a WebAssembly build of Roc's - compiler, and compiles the code you write to WebAssembly on the fly, which it then executes in - the browser to display the answer. -

    - -

    The compiler works well enough on a basic level to build things with it, but some error messages - could use significant improvement, and it has a lot of known bugs and missing features. You can - currently use it on macOS (either Intel or Apple Silicon), Linux (only x86-64 machines at the moment), - and Windows (only recently supported; debugging and testing features don't work on it yet, and - there are likely bugs we haven't encountered yet due to lack of battle testing). Support for other - operating systems has not yet been discussed.

    - -

    The compiler doesn't yet support incremental compilation or hot code loading, and build times vary - based on what machine you're building for.

    - -

    For example, suppose you run `roc check`, which reports errors it finds (type mismatches, naming - errors, and so on) but doesn't actually build an executable, on a code base that's under a thousand - lines of code. On an M1 MacBook Pro, this typically takes about 10 milliseconds.

    - -

    In contrast, if you do `roc build` (or `roc run`) on that same machine, it will take closer to 500 - milliseconds instead. Almost all that extra time is spent waiting for LLVM to generate (unoptimized) - machine code, and then for the system linker to assemble an executable from it.

    - -

    Fortunately, we can eliminate almost all of those extra 490 millisconds of build time by using - Roc's (work in progress) development backend instead of LLVM. This compiles directly from Roc's - internal representation to machine code, like most compilers did before LLVM. (LLVM can optimize - code into running very fast, but even when it performs no optimization at all, LLVM itself takes a lot - longer to run than generating unoptimized machine code directly.)

    - -

    The LLVM backend is currently the most feature-complete, followed closely by the WebAssembly backend - (which the online REPL uses exclusively, instead of LLVM). The x86 and ARM backends still have a - ways to go, but improving them can be done by anyone with the patience to read some documentation; - we have issues split up for them, and are happy to help new contributors get up and running!

    - -

    Builds on Linux and Windows also use Roc's surgical linker instead of the system linker, which - runs so fast that linking essentially disappears from the performance profile altogether. The - surgical linker currently only works on Linux and Windows, and it currently supports building - executables but not (yet) dynamic libraries, which is relevant if you're using Roc to create - plugins or want to call Roc functions from existing code bases in other languages. Work has started - on macOS surgical linking, but it isn't usable yet. If you're interested in working on that, - please get in touch on Roc Zulip!

    - -

    The test runner currently has first-class support for running standard non-effectful tests. - It does not yet have first-class support for effectful tests, property-based tests, snapshot tests, - or "simulation tests" (where effects are replaced by hardcoded values during the test - similar to - "mocking" in other languages), although these are all planned for the future.

    - -

    The code formatter is nearly feature-complete, although occasionally it will report an error - - usually due to a comment being placed somewhere it doesn't yet know how to handle. Unlike most of - the rest of the compiler, the formatter is one place where the number of known bugs is so small - that fuzzing would be very helpful as a way to surface bugs we don't yet know about. (If you're - interested in working on setting up fuzzing for the formatter, please let us know in - the #contributing channel - on Zulip! Separately, we're also very interested in fuzzing the compiler, even though we already - have a sizable list of known bugs there.)

    - -

    On the community side, so far the community is a friendly bunch, and we want to keep it that way - as it grows! We hope to do that by encouraging a culture of kindness and helping one another out, - especially by being welcoming towards beginners.

    - -

    If you'd like to join in, the best place to do that is in our Zulip chat. Feel free to drop by the - introductions - topic - and introduce yourself! -

    - -

    A Functional Language

    - -

    Goals

    - -

    Roc aims to be a purely functional programming language. This means all Roc functions are - pure functions, and all effects are - managed effects - instead of side effects. -

    - -

    A major motivating reason for this is to facilitate tooling. For example, in the future the goal - is that Roc's test runner won't bother re-running tests whose outcomes could not possibly have - changed (because they were pure functions whose inputs did not change). Tests that contain only - pure functions can be trivially run in parallel, and they will never flake. - Additionally, having the guarantee that the application contains only pure functions can also make - certain debugging tools more reliable, such as time travel and retroactive tracing. -

    - -

    Roc also takes a novel approach to managed effects. In most programming languages, the standard - library contains both data structures and I/O primitives (e.g. for using the file system or the - network), and then you might decide to use a framework - on top of that standard library.

    - -

    In Roc, every application is built on a platform. A platform is like a framework except - that it also provides I/O primitives and behind-the-scenes memory management. (Roc's standard - library only contains data structures.) In practice, this means that using Roc feels similar to - using any other programming language where you've chosen to use a framework, except that the - documentation for your I/O primitives comes from the framework instead of the standard library.

    - -

    This might sound like a minor distinction, but it turns out there are a lot of surprising benefits - to organizing things this way, which would be impossible to achieve without having platforms as a - first-class language concept. The Edges of Cutting-Edge Languages - goes into more detail about some of these benefits. -

    - -

    Current Progress

    - -

    Today, platforms as a concept already exist, and there are a few different ones implemented. - You can find them in the examples/ - directory in the source code repository. The platform for building command-line interfaces is the - most fully featured; the others are mostly in the proof-of-concept stage. -

    - -

    Roc's built-in tooling is not yet far enough along to take advantage of pure functions. For - example, there is a built-in test runner, but it does not yet run tests in parallel or skip - running tests whose outcomes could not possibly have changed. -

    - -

    Roc is already a purely functional programming language, though, so all of these benefits - are ready to be unlocked as the tooling implementations progress! -

    - -

    The Roc Programming Language Foundation

    - -

    We've created a nonprofit to support Roc, you can learn more about it here.

    - - - - - diff --git a/www/public/repl/index.html b/www/public/repl/index.html deleted file mode 100644 index 878ed8a2cd..0000000000 --- a/www/public/repl/index.html +++ /dev/null @@ -1,39 +0,0 @@ - - - - - - - - REPL - - - - - - - - - -
    -

    The rockin' Roc REPL

    - -
    -
    Loading REPL WebAssembly module…please wait!
    -     - - -
    - - - - diff --git a/www/public/repl/repl.css b/www/public/repl/repl.css deleted file mode 100644 index 6ffe10237b..0000000000 --- a/www/public/repl/repl.css +++ /dev/null @@ -1,173 +0,0 @@ -main { - display: flex; - flex-direction: column; -} - -h1 { - font-family: "Lato"; - font-size: 48px; - line-height: 48px; - padding: 48px 0; - margin: 0; - color: var(--header-link-color); -} - -#source-input-wrapper { - position: relative; - width: 100%; - box-sizing: border-box; -} - -#source-input-wrapper::before { - content: "» "; - position: absolute; - left: 15px; - top: 18px; - line-height: 16px; - height: 16px; - z-index: 2; - font-family: var(--font-mono); - color: var(--cyan); - /* Let clicks pass through to the textarea */ - pointer-events: none; -} - -#source-input { - width: 100%; - font-family: var(--font-mono); - color: var(--code-color); - background-color: var(--code-bg); - display: inline-block; - height: 76px; - padding: 16px; - padding-left: 36px; - border: 1px solid transparent; - margin: 0; - margin-bottom: 2em; - box-sizing: border-box; -} - -#source-input:focus { - border: 1px solid var(--cyan); - box-sizing: border-box; - outline: none; -} - -li { - margin: 8px; -} - -.history { - padding: 1em; - padding-bottom: 0; -} - -#help-text, -#history-text { - white-space: pre-wrap; - -} - -#history-text { - margin-top: 16px; -} - -#loading-message { - text-align: center; - /* approximately match height after loading and printing help message */ - height: 96px; -} - -.history-item { - margin-bottom: 24px; -} - -.history-item .input { - margin: 0; - margin-bottom: 8px; -} - -.history-item .output { - margin: 0; -} - -.panic { - color: red; -} - -.input-line-prefix { - color: var(--cyan); -} - -.color-red { - color: red; -} - -.color-green { - color: var(--green); -} - -.color-yellow { - color: var(--orange); -} - -.color-blue { - color: var(--cyan); -} - -.color-magenta { - color: var(--magenta); -} - -.color-cyan { - color: var(--cyan); -} - -.color-white { - /* Really this isn't white so much as "default text color." For the repl, this should be black - in a light color scheme, and only white in dark mode. The name could be better! */ - color: black; -} - -@media (prefers-color-scheme: dark) { - .color-white { - color: white; - } -} - -.bold { - font-weight: bold; -} - -.underline { - text-decoration: underline; -} - - -/* Mobile-friendly screen width */ -@media only screen and (max-width: 767px) { - h1 { - font-size: 24px !important; - margin: 0; - padding: 16px 0; - text-align: center; - } - - #repl { - margin: 0; - padding: 0; - min-height: calc(100vh - var(--top-bar-height)); - } - - code.history { - flex-grow: 1; - } - - #source-input { - margin: 0 - } - - #loading-message { - margin: 0; - } -} diff --git a/www/public/repl/repl.js b/www/public/repl/repl.js deleted file mode 100644 index 009b4d523c..0000000000 --- a/www/public/repl/repl.js +++ /dev/null @@ -1,307 +0,0 @@ -// The only way we can provide values to wasm_bindgen's generated code is to set globals -window.js_create_app = js_create_app; -window.js_run_app = js_run_app; -window.js_get_result_and_memory = js_get_result_and_memory; - -// The only place we use console.error is in wasm_bindgen, where it gets a single string argument. -console.error = function displayErrorInHistoryPanel(string) { - const html = `
    ${string}
    `; - updateHistoryEntry(repl.inputHistoryIndex, false, html); -}; - -import * as roc_repl_wasm from "/repl/roc_repl_wasm.js"; - -// ---------------------------------------------------------------------------- -// REPL state -// ---------------------------------------------------------------------------- - -const repl = { - elemHistory: document.getElementById("history-text"), - elemSourceInput: document.getElementById("source-input"), - - inputQueue: [], - inputHistory: [], - inputHistoryIndex: 0, - inputStash: "", // stash the user input while we're toggling through history with up/down arrows - - textDecoder: new TextDecoder(), - textEncoder: new TextEncoder(), - - compiler: null, - app: null, - - // Temporary storage for the address of the result of running the user's code. - // Used while control flow returns to Rust to allocate space to copy the app's memory buffer. - result_addr: 0, -}; - -// Initialise -repl.elemSourceInput.value = ""; // Some browsers remember the input across refreshes -resetSourceInputHeight(); -repl.elemSourceInput.addEventListener("input", resetSourceInputHeight); -repl.elemSourceInput.addEventListener("keydown", onInputKeydown); -repl.elemSourceInput.addEventListener("keyup", onInputKeyup); -roc_repl_wasm.default("/repl/roc_repl_wasm_bg.wasm").then(async (instance) => { - repl.elemHistory.querySelector("#loading-message").remove(); - repl.elemSourceInput.disabled = false; - repl.elemSourceInput.placeholder = "Enter some Roc code here."; - repl.elemSourceInput.focus(); - repl.compiler = instance; - - // Get help text from the compiler, and display it at top of the history panel - try { - const helpText = await roc_repl_wasm.entrypoint_from_js(":help"); - const helpElem = document.getElementById("help-text"); - helpElem.innerHTML = helpText.trim(); - } catch (e) { - // Print error for Roc devs. Don't use console.error, we overrode that above to display on the page! - console.warn(e); - } -}); - -// ---------------------------------------------------------------------------- -// Handle inputs -// ---------------------------------------------------------------------------- - -function resetSourceInputHeight() { - repl.elemSourceInput.style.height = repl.elemSourceInput.scrollHeight + 2 + "px"; // +2 for the border -} - -function onInputKeydown(event) { - const ENTER = 13; - - const { keyCode } = event; - - if (keyCode === ENTER) { - if (!event.shiftKey && !event.ctrlKey && !event.altKey) { - // Don't advance the caret to the next line - event.preventDefault(); - - const inputText = repl.elemSourceInput.value.trim(); - - repl.elemSourceInput.value = ""; - repl.elemSourceInput.style.height = ""; - - repl.inputQueue.push(inputText); - if (repl.inputQueue.length === 1) { - processInputQueue(); - } - } - } -} - -function onInputKeyup(event) { - const UP = 38; - const DOWN = 40; - - const { keyCode } = event; - - const el = repl.elemSourceInput; - - switch (keyCode) { - case UP: - if (repl.inputHistory.length === 0) { - return; - } - if (repl.inputHistoryIndex == repl.inputHistory.length - 1) { - repl.inputStash = el.value; - } - setInput(repl.inputHistory[repl.inputHistoryIndex]); - - if (repl.inputHistoryIndex > 0) { - repl.inputHistoryIndex--; - } - break; - - case DOWN: - if (repl.inputHistory.length === 0) { - return; - } - if (repl.inputHistoryIndex === repl.inputHistory.length - 1) { - setInput(repl.inputStash); - } else { - repl.inputHistoryIndex++; - setInput(repl.inputHistory[repl.inputHistoryIndex]); - } - break; - - default: - break; - } -} - -function setInput(value) { - const el = repl.elemSourceInput; - el.value = value; - el.selectionStart = value.length; - el.selectionEnd = value.length; -} - -// Use a queue just in case we somehow get inputs very fast -// We want the REPL to only process one at a time, since we're using some global state. -// In normal usage we shouldn't see this edge case anyway. Maybe with copy/paste? -async function processInputQueue() { - while (repl.inputQueue.length) { - const inputText = repl.inputQueue[0]; - repl.inputHistoryIndex = createHistoryEntry(inputText); - repl.inputStash = ""; - - let outputText = ""; - let ok = true; - if (inputText) { - try { - outputText = await roc_repl_wasm.entrypoint_from_js(inputText); - } catch (e) { - outputText = `${e}`; - ok = false; - } - } - - updateHistoryEntry(repl.inputHistoryIndex, ok, outputText); - repl.inputQueue.shift(); - } -} - -// ---------------------------------------------------------------------------- -// Callbacks to JS from Rust -// ---------------------------------------------------------------------------- - -var ROC_PANIC_INFO = null; - -function send_panic_msg_to_js(rocstr_ptr, panic_tag) { - const { memory } = repl.app.exports; - - const rocStrBytes = new Int8Array(memory.buffer, rocstr_ptr, 12); - const finalByte = rocStrBytes[11] - - let stringBytes = ""; - if (finalByte < 0) { - // small string - - // bitwise ops on negative JS numbers are weird. This clears the bit that we - // use to indicate a small string. In rust it's `finalByte as u8 ^ 0b1000_0000` - const length = finalByte + 128; - stringBytes = new Uint8Array(memory.buffer, rocstr_ptr, length); - } else { - // big string - const rocStrWords = new Uint32Array(memory.buffer, rocstr_ptr, 3); - const [ptr, len, _cap] = rocStrWords; - - const SEAMLESS_SLICE_BIT = 1 << 31; - const length = len & (~SEAMLESS_SLICE_BIT); - - stringBytes = new Uint8Array(memory.buffer, ptr, length); - } - - const decodedString = repl.textDecoder.decode(stringBytes); - - ROC_PANIC_INFO = { - msg: decodedString, - panic_tag: panic_tag, - }; -} - -// Load Wasm code into the browser's virtual machine, so we can run it later. -// This operation is async, so we call it before entering any code shared -// with the command-line REPL, which is sync. -async function js_create_app(wasm_module_bytes) { - const { instance } = await WebAssembly.instantiate(wasm_module_bytes, { - env: { - send_panic_msg_to_js: send_panic_msg_to_js, - } - }); - - // Keep the instance alive so we can run it later from shared REPL code - repl.app = instance; -} - -// Call the `main` function of the user app, via the `wrapper` function. -function js_run_app() { - const { wrapper, memory } = repl.app.exports; - - // Run the user code, and remember the result address - // We'll pass it to Rust in the next callback - try { - repl.result_addr = wrapper(); - } catch (e) { - // an exception could be that roc_panic was invoked, - // or some other crash (likely a compiler bug) - if (ROC_PANIC_INFO === null) { - throw e; - } else { - // when roc_panic set an error message, display it - const { msg, panic_tag } = ROC_PANIC_INFO; - ROC_PANIC_INFO = null; - - console.error(format_roc_panic_message(msg, panic_tag)); - } - } - - // Tell Rust how much space to reserve for its copy of the app's memory buffer. - // We couldn't know that size until we actually ran the app. - return memory.buffer.byteLength; -} - -function format_roc_panic_message(msg, panic_tag) { - switch (panic_tag) { - case 0: { - return `Roc failed with message: "${msg}"`; - } - case 1: { - return `User crash with message: "${msg}"`; - } - default: { - return `Got an invalid panic tag: "${panic_tag}"`; - } - } -} - -// After Rust has allocated space for the app's memory buffer, -// we copy it, and return the result address too -function js_get_result_and_memory(buffer_alloc_addr) { - const appMemory = new Uint8Array(repl.app.exports.memory.buffer); - const compilerMemory = new Uint8Array(repl.compiler.memory.buffer); - compilerMemory.set(appMemory, buffer_alloc_addr); - return repl.result_addr; -} - -// ---------------------------------------------------------------------------- -// Rendering -// ---------------------------------------------------------------------------- - -function createHistoryEntry(inputText) { - const historyIndex = repl.inputHistory.length; - repl.inputHistory.push(inputText); - - const firstLinePrefix = '» '; - const otherLinePrefix = '
    … '; - const inputLines = inputText.split("\n"); - if (inputLines[inputLines.length - 1] === "") { - inputLines.pop(); - } - const inputWithPrefixes = firstLinePrefix + inputLines.join(otherLinePrefix); - - const inputElem = document.createElement("div"); - inputElem.innerHTML = inputWithPrefixes; - inputElem.classList.add("input"); - - const historyItem = document.createElement("div"); - historyItem.appendChild(inputElem); - historyItem.classList.add("history-item"); - - repl.elemHistory.appendChild(historyItem); - - return historyIndex; -} - -function updateHistoryEntry(index, ok, outputText) { - const outputElem = document.createElement("div"); - outputElem.innerHTML = outputText; - outputElem.classList.add("output", ok ? "output-ok" : "output-error"); - - const historyItem = repl.elemHistory.children[index]; - historyItem.appendChild(outputElem); - - // Scroll the page to the bottom so you can see the most recent output. - window.scrollTo(0, document.body.scrollHeight); -} diff --git a/www/public/site.css b/www/public/site.css index ff97750576..3e3550e7e6 100644 --- a/www/public/site.css +++ b/www/public/site.css @@ -1,42 +1,44 @@ :root { /* WCAG AAA Compliant colors */ - --code-bg: #f4f8f9; + --gray-bg: #f4f8f9; --gray: #717171; - --orange: #BF5000; - --green: #0B8400; - --cyan: #067C94; + --orange: #bf5000; + --green: #0b8400; + --light-cyan: #8af4e6; + --dark-cyan: #4eefd9; --blue: #05006d; - --magenta: #a20031; + --violet: #7c38f5; + --violet-bg: #ece2fd; + --magenta: #ff32cf; - --body-max-width: 900px; - --text-color: #121212; - --top-bar-bg: #222; - --top-bar-fg: #eee; - --top-bar-logo-hover: #8055E4; - --top-bar-height: 50px; - --header-link-color: #107F79; - --header-link-hover: #222; - --link-color: #7546e2; - --h1-color: #8055E4; - --repl-prompt: #0064ff; - --body-bg: #fff; + --primary-1: #9b6bf2; + --primary-2: #7c38f5; + --highlight: #1bd6bd; + --code-color: white; + --link-color: var(--primary-2); + --code-link-color: var(--primary-2); + --text-color: #000; + --heading-color: #333; + --text-hover-color: var(--primary-2); + --body-bg-color: #ffffff; + --border-color: #717171; + --faded-color: #4c4c4c; + --font-sans: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, + sans-serif; + --font-mono: "Source Code Pro", SFMono-Regular, Consolas, "Liberation Mono", + Menlo, Courier, monospace; + --top-header-height: 67px; + --sidebar-width: 280px; - --code-color: #303030; - --toc-background: var(--code-bg); - --toc-border: var(--gray); - --toc-search-bg: #fcfcfc; - --toc-search-border: var(--gray); - --font-mono: "Source Code Pro", monospace; + --font-size-normal: 18px; + --body-max-width: 1024px; + --dark-code-bg: #202746; } html { line-height: 1.5rem; - background: var(--body-bg); + background: var(--body-bg-color); color: var(--text-color); -} - -html, -#tutorial-toc-toggle-label { font-family: "Lato", sans-serif; } @@ -44,14 +46,132 @@ html, body { margin: 0; padding: 0; + width: 100%; height: 100%; + box-sizing: border-box; + overflow-x: hidden; /* This shouldn't be necessary, but without it, mobile has a right gutter. */ +} + +p { + margin-top: 0; +} + +p, li { + max-width: 720px; } footer { - max-width: 1024px; + width: 100%; + color: var(--text-color); + text-align: center; + font-size: var(--font-size-normal); + padding: 20px; + box-sizing: border-box; + margin-top: 24px; +} + +#footer { + max-width: var(--body-max-width); margin: 0 auto; - font-size: 14px; - padding: 16px; +} + + +hr { + color: var(--primary-1); + margin-bottom: 1rem; +} + +.svg-text { + fill: #000; +} + +.logo-dark { + fill: #612bde; +} + +.logo-light { + fill: #8257e5; +} + +.btn-small { + white-space: nowrap; + background: #7c38f5; + border: 4px solid #9b6bf2; + color: #fff !important; + cursor: pointer; + text-decoration: none !important; + padding: 12px; +} + +.btn-small .roc-logo { + fill: #fff; + position: relative; + left: -4px; + top: 11px; +} + +.btn-small:hover { + background: #9b6bf2; + border-color: #7c38f5; +} + +#individual-sponsors { + list-style-type: none; + padding: 24px 40px; + max-width: 720px; +} + +#individual-sponsors li { + display: inline; + white-space: nowrap; + margin: 0.2rem; +} + +#individual-sponsors li::after { + content: ","; + white-space: pre; /* Preserve the space after the comma */ +} + +#individual-sponsors li:last-child::after { + content: ""; /* No comma after the last one */ +} + +#sponsor-logos { + padding: 24px 36px; + padding-bottom: 36px; + min-width: 308px; /* Widest logo plus padding - Firefox on Android needs this */ + max-width: none !important; +} + +#sponsor-logos svg { + height: 54px; + margin-right: 72px; +} + +#sponsor-logos .logo-rwx { + position: relative; + top: 6px; +} + +#sponsor-logos .logo-tweede-golf { + position: relative; + top: 14px; + height: 4.5rem; +} + +#sponsor-logos + p { + margin-bottom: 3em; +} + +/* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile. + * When we think we're on mobile (based on max-width), we can switch the instruction. +*/ +.desktop { + display: inline; +} + +.mobile { + display: none; } section p:last-child { @@ -75,60 +195,128 @@ li { margin-bottom: 0.5rem; } +h1, +h2, +h3, +h4 { + font-weight: bold; +} + +h1 { + font-size: 5rem; +} + +h2 { + display: inline-block; + font-size: 2.5rem; + line-height: 5rem; + border-bottom: 4px solid var(--dark-cyan); + padding: 0; + margin: 0; + margin-bottom: 2rem; + color: var(--heading-color); +} + +.article-layout main { + max-width: 720px; +} + +.article-layout p, .article-layout li, .article-layout pre { + font-size: 20px; +} + +#homepage-main h2 { + margin-top: 60px; /* On the homepage, these need to be spaced out more. */ +} + +#homepage-main #nav-home-link { + visibility: hidden; +} + +h2 a, h3 a { + color: var(--heading-color); +} + +h2:hover a { + color: var(--link-color); + text-decoration: none; +} + +h3 { + font-size: 1.5rem; +} + +#top-bar, #top-bar nav { + background-color: var(--gray-bg); +} + #top-bar { - background-color: var(--top-bar-bg); + box-sizing: border-box; width: 100%; - height: var(--top-bar-height); } #top-bar nav { - max-width: 1024px; + max-width: var(--body-max-width); margin: 0 auto; display: flex; justify-content: space-between; + padding-right: 9px; } #nav-home-link { - display: flex; + display: inline-block; color: var(--top-bar-fg); font-size: 1.8rem; - padding: 10px; + padding: 4px; } -#top-bar-links { - display: flex; +.home-link-text { + padding: 8px; + font-size: 24px; + position: relative; + top: -0.6rem; +} + +.home-examples-title { + margin-bottom: 4px; } #top-bar-links a, #top-bar-links label { box-sizing: border-box; color: var(--top-bar-fg); - font-size: 1.1rem; - display: block; - height: 100%; + display: inline-block; padding: 12px 16px; margin: 0 2px; } main { max-width: var(--body-max-width); - margin: 36px auto; - padding: 0 12px; + margin: auto; + padding: 12px; + box-sizing: border-box; +} + +.welcome-to-roc { + white-space: nowrap; + overflow-x: hidden; + padding-right: 60px; + margin-bottom: 12px; } code, samp { font-family: var(--font-mono); - color: var(--code-color); - background-color: var(--code-bg); + color: var(--text-color); + background-color: var(--gray-bg); display: inline-block; + padding: 5px; } p code, td code, li code, -th code, -samp { +th code { padding: 0 8px; } @@ -148,19 +336,86 @@ a:visited code { pre { position: relative; margin-bottom: 16px; - padding: 8px 16px; + padding: 0 0.35rem; box-sizing: border-box; - background-color: var(--code-bg); + background-color: var(--gray-bg); overflow-x: hidden; word-wrap: normal; - font-size: 1.2rem; + font-size: var(--font-size-normal); line-height: 1.76em; white-space: pre; + background-color: var(--dark-code-bg); } -pre>samp { +pre > samp, +pre > code { overflow-x: auto; display: block; + background-color: var(--dark-code-bg); + color: var(--code-color); +} + +/* The repl won't work at all if you have JS disabled. */ +.no-js #try-roc { + display: none !important; +} + +#repl-container { + display: flex; + flex-direction: row-reverse; +} + +#repl-container #repl-description { + padding: 0 30px; + margin-top: 2px; + flex: 1; +} + +#repl-container #repl-description a { + color: inherit; + text-decoration: underline; +} + +#repl-container #repl-description a:hover { + color: var(--primary-1); +} + +#repl-container #repl { + flex: 1; + border: 2px solid #444; + font-size: var(--font-size-normal); + min-height: 0; /* On /repl on mobile, this expands to fill the screen, which we don't want */ + margin-right: 6px; + max-width: 50%; +} + +#repl-container #repl, +#repl-container #repl code { + color: white; + background-color: var(--dark-code-bg); +} + +#repl-container #source-input { + margin-bottom: 0; + margin-top: 6px; + font-size: var(--font-size-normal); + height: 57px; +} + +#repl-container p { + position: relative; /* Needed for the repl arrow's position: absolute */ +} + +#repl-container #repl-arrow { + cursor: default; + font-weight: bold; + font-size: 48px; + position: absolute; + top: -9px; + left: -79px; + text-shadow: 1px 1px 1px #444; + z-index: 3; + fill: var(--primary-1); } .repl-err { @@ -173,6 +428,7 @@ table { border-collapse: collapse; overflow-x: auto; border: 2px solid #f0f0f0; + margin-bottom: 1rem; } thead { @@ -200,117 +456,119 @@ td:last-child { border-right: none; } -#integer-types { - width: 100%; -} - -#integer-types th:first-of-type, -#integer-types td:first-of-type { - text-align: right; -} - -#integer-types td:first-of-type code { - background-color: inherit; -} - -#integer-types th:last-of-type, -#integer-types td:last-of-type { - text-align: left; -} - -/* Tutorial Specific */ - -#tutorial-start { - display: flex; - flex-direction: row-reverse; -} - -#tutorial-intro { - flex: 1; -} - -#tutorial-toc { - margin-top: 18px; - background: var(--code-bg); - padding: 12px 24px; - margin-left: 64px; -} - -#tutorial-toc code { - background: none; - color: inherit; - margin: 0; - padding: 0; -} - -#tutorial-toc ol { - padding: 3px; - margin: 8px 0; - list-style: none; - padding-bottom: 0; - margin-bottom: 0; -} - -#tutorial-toc h2 { - font-family: inherit; - font-size: 2em; - text-shadow: none; - margin: 0; - padding: 16px 0; -} - -#toc-search { - background-color: var(--toc-search-bg); - border: 1px solid var(--toc-search-border); - color: inherit; - padding: 6px 8px; - margin-top: 16px; - margin-bottom: 4px; - box-sizing: border-box; - width: 100%; - font-size: inherit; -} - -#tutorial-toc-toggle, -#tutorial-toc-toggle-label, -#close-tutorial-toc { - display: none; - /* This may be overridden on mobile-friendly screen widths */ -} - -#tutorial-toc-toggle, -#tutorial-toc-toggle-label { - font-size: 1.1rem; - float: right; -} - -#close-tutorial-toc { - position: absolute; - top: 20px; - right: 8px; - font-size: 18px; - padding: 12px 24px; -} - p, aside, -li, -footer { - font-size: 1.2rem; +li { + font-size: var(--font-size-normal); line-height: 1.85rem; } -/* Mobile-friendly screen width */ -@media only screen and (max-device-width: 480px) and (orientation: portrait) { +/* Homepage */ +#homepage-intro-outer { + margin: 60px auto; + text-align: center; +} - p, - aside, - li, - footer, - code, - samp, - .code-snippet { - font-size: 16px; +#homepage-intro-box { + position: relative; + display: inline-block; + text-align: left; +} + +#homepage-h1 { + color: #222; + text-shadow: none; + font-family: inherit; + font-size: 64px; + padding: 0; + padding-top: 60px; + position: relative; + left: -5px; +} + +#homepage-logo { + height: 176px; + width: auto; + position: absolute; + left: -200px; + top: -100px; +} + +#first-code-sample { + margin-top: 60px; + line-height: 1.85em; + color: #fcf9fd; +} + +#first-code-sample .kw, +#first-code-sample .punctuation, +.interactive-example .kw, +.interactive-example .punctuation { + color: #9c7cea; +} + +#first-code-sample, +#first-code-sample .code-snippet { + background-color: var(--dark-code-bg); +} + +#homepage-tagline { + font-size: 20px; +} + +.nowrap { + white-space: nowrap; +} + +/* Mobile-friendly screen width */ +@media only screen and (max-width: 1023px) { + :root { + --font-size-normal: 16px; + --body-max-width: none; + } + + #homepage-logo { + /* The bird runs off the screen unless we shrink it */ + height: 80px; + width: auto; + position: absolute; + left: 227px; + top: -28px; + } + + #homepage-main #nav-home-link { + display: none; + } + + #sponsor-logos { + padding: 4px; + } + + .home-examples-column { + padding-right: 0 !important; + border-right: none !important; + } + + /* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile. */ + .desktop { + display: none; + } + + .mobile { + display: inline; + } + + .close-desc { + display: block !important; + } + + h2 { + margin-top: 48px; + padding: 12px 0; + } + + .home-link-text { + display: none; /* Don't show "Roc" in the header next to the logo, to save space */ } h1 code, @@ -325,26 +583,40 @@ footer { white-space: normal; } - #tutorial-toc-toggle-label, - #close-tutorial-toc { - display: block; + /* Homepage */ + + #homepage-intro-box { + margin: 30px auto; } - #tutorial-toc-toggle:checked+#tutorial-toc { - display: block; + #homepage-tagline { + margin-top: 0; } - #tutorial-toc { - display: none; - position: fixed; - top: 0; - left: 0; - right: 0; - bottom: 0; - overflow-y: auto; + #homepage-h1 { + /* TODO remove !important from repl.css (increasing specificity instead), and then this one too. */ + font-size: 48px !important; + padding: 0; margin: 0; - padding-right: 120px; - border: 0; + text-align: left; + } + + #first-code-sample { + margin: 64px auto; + margin-bottom: 0; + } + + #homepage-tagline { + font-size: 16px; + } + + .home-goals-container, + .home-examples-container { + /* It's unclear why this !important is necessary, since its specificity + should theoretically be higher than what it's overriding. In practice, + at least in Chrome, removing the !important breaks this. */ + display: grid !important; + grid-template-columns: 1fr; } h1, @@ -367,152 +639,50 @@ footer { font-size: 2rem !important; } + #top-bar-links { + width: 100%; + display: grid; + grid-template-columns: 1fr 1fr 1fr; /* Three equal-width columns */ + grid-template-rows: auto auto; /* Two rows */ + } + + /* Left-align the first link in each row, right-align the last one, and center the middle one. */ + #top-bar-links > :nth-child(3n+1) { + text-align: left; + } + + #top-bar-links > :nth-child(3n+2) { + text-align: center; + } + + #top-bar-links > :nth-child(3n+3) { + text-align: right; + } + #top-bar-links a, #top-bar-links label { - padding: 12px 8px; + font-size: 1.2rem; + padding: 12px 0.5rem; margin: 0; } + + #repl-container #repl { + max-width: none; + } } -/* Used on on the different-names page. */ +/* iPhone SE and similar */ +@media only screen and (max-width: 320px) { + #homepage-logo { + /* The bird runs off the screen unless we shrink it */ + left: 188px; + top: -30px; + } -th, -td { - text-align: left; - padding-right: 24px; -} - -#different-names-body a, -#different-names-body li { - font-family: monospace; - font-size: 16px; -} - -#different-names-body li { - display: inline; -} - -#different-names-body li:not(:last-of-type)::after { - /* This is injected via CSS for accessibility, so to a screen reader it's a normal
  • */ - content: ","; -} - -#different-names-body ul { - padding: 0; - list-style-type: none; -} - -h1, -h2, -h3, -h4, -h5 { - font-family: "Permanent Marker"; - line-height: 1rem; - margin-top: 1.75rem; - margin-bottom: 0; -} - -#tutorial-toc-toggle-label, -#close-tutorial-toc { - color: var(--header-link-color); -} - -#tutorial-toc-toggle-label:hover, -#close-tutorial-toc:hover { - color: var(--header-link-hover); - cursor: pointer; -} - -h1 a, -h2 a, -h3 a, -h4 a, -h5 a { - color: var(--header-link-color); -} - -h1 a:hover, -h2 a:hover, -h3 a:hover, -h4 a:hover, -h5 a:hover { - text-decoration: none; - color: var(--header-link-hover); -} - -h1 code, -h2 code, -h3 code, -h4 code, -h5 code { - color: inherit; - background-color: inherit; - padding: 0; - margin: 0; -} - -h1 { - font-size: 7rem; - line-height: 7rem; - color: var(--h1-color); - margin-top: 0; - margin-bottom: 1.75rem; - text-shadow: 1px 1px 1px #010101; -} - -h2 { - font-size: 4rem; - line-height: 4rem; - text-shadow: 1px 1px 1px #010101; -} - -h3 { - font-size: 3rem; - line-height: 3rem; - text-shadow: 1px 1px 1px #010101; -} - -h4 { - font-size: 2rem; - text-shadow: 1px 1px 1px #010101; -} - -@font-face { - font-family: "Permanent Marker"; - font-style: normal; - font-weight: 400; - font-display: swap; - src: url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2") format("woff2"), - url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff") format("woff"); - unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, - U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, - U+2215, U+FEFF, U+FFFD; -} - -/* latin-ext */ -@font-face { - font-family: "Merriweather"; - font-style: normal; - font-weight: 400; - font-display: swap; - src: url("/fonts/merriweather-v30-latin-ext_latin/merriweather-v30-latin-ext_latin-regular.woff2") format("woff2"), - url("/fonts/merriweather-v30-latin-ext_latin/merriweather-v30-latin-ext_latin-regular.woff") format("woff"); - unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, - U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; -} - -/* latin */ -@font-face { - font-family: "Merriweather"; - font-style: normal; - font-weight: 400; - font-display: swap; - src: url("/fonts/merriweather-v30-latin/merriweather-v30-latin-regular.woff2") format("woff2"), - url("/fonts/merriweather-v30-latin/merriweather-v30-latin-regular.woff") format("woff"); - unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, - U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, - U+2215, U+FEFF, U+FFFD; + :root { + --font-size-normal: 14px; + --body-max-width: 320px; + } } /* latin-ext */ @@ -521,8 +691,10 @@ h4 { font-style: normal; font-weight: 400; font-display: swap; - src: url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff2") format("woff2"), - url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff") format("woff"); + src: url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff2") + format("woff2"), + url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff") + format("woff"); unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; } @@ -533,7 +705,8 @@ h4 { font-style: normal; font-weight: 400; font-display: swap; - src: url("/fonts/lato-v23-latin/lato-v23-latin-regular.woff2") format("woff2"), + src: url("/fonts/lato-v23-latin/lato-v23-latin-regular.woff2") + format("woff2"), url("/fonts/lato-v23-latin/lato-v23-latin-regular.woff") format("woff"); unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, @@ -546,8 +719,10 @@ h4 { font-style: normal; font-weight: 400; font-display: swap; - src: url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff2") format("woff2"), - url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff") format("woff"); + src: url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff2") + format("woff2"), + url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff") + format("woff"); unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB, U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF; } @@ -558,8 +733,10 @@ h4 { font-style: normal; font-weight: 400; font-display: swap; - src: url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff2") format("woff2"), - url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff") format("woff"); + src: url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff2") + format("woff2"), + url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff") + format("woff"); unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD; @@ -568,28 +745,46 @@ h4 { @media (prefers-color-scheme: dark) { :root { /* WCAG AAA Compliant colors */ - --code-bg: #202746; + /* WCAG AAA Compliant colors */ + --gray-bg: #202746; --gray: #b6b6b6; --orange: #fd6e08; --green: #8ecc88; --cyan: #12c9be; --blue: #b1afdf; + --violet-bg: #332944; --magenta: #f39bac; - --text-color: #cdcdcd; - --top-bar-bg: #2a2a2a; - --header-link-color: #9C7CEA; - --header-link-hover: #ddd; - --h1-color: #1bc6bd; - --link-color: #1bc6bd; - --repl-prompt: #1bc6bd; - --body-bg: #0e0e0f; - --code-snippet-border: #444; - --code-color: #cdcdcd; - --toc-background: var(--code-bg); - --toc-border: var(--code-snippet-border); - --toc-search-bg: #333; - --toc-search-border: var(--gray); + --primary-1: #9c7cea; + --primary-2: #1bd6bd; + --text-color: #ccc; + --body-bg-color: #151517; + --border-color: var(--gray); + --code-color: #eeeeee; + --logo-solid: #8f8f8f; + --faded-color: #bbbbbb; + --gray: #6e6e6e; + --heading-color: #eee; + } + + .logo-dark { + fill: #6c3bdc; + } + + .logo-light { + fill: #8a66de; + } + + .svg-text { + fill: #fff; + } + + #homepage-h1 { + color: #fcf9fd; + } + + h3 { + color: #fff; } h1, @@ -610,12 +805,21 @@ h4 { td { border-color: var(--gray); } + + #first-code-sample, + #repl-container #repl { + border: 1px solid #ddd; + } + + .home-goals-content:hover { + background-color: #481870 !important; + } } /* Comments `#` and Documentation comments `##` */ samp .comment, code .comment { - color: var(--green); + color: #ccc; } /* Number, String, Tag literals */ @@ -631,7 +835,7 @@ samp .constant, code .constant, samp .literal, code .literal { - color: var(--cyan); + color: var(--dark-cyan); } /* Keywords and punctuation */ @@ -645,7 +849,7 @@ samp .punctuation.terminator, code .punctuation.terminator, samp .kw, code .kw { - color: var(--magenta); + color: var(--primary-1); } /* Operators */ @@ -653,13 +857,13 @@ samp .op, code .op, samp .keyword.operator, code .keyword.operator { - color: var(--orange); + color: var(--primary-1); } /* Delimieters */ samp .delimeter, code .delimeter { - color: var(--gray); + color: var(--primary-1); } /* Variables modules and field names */ @@ -671,7 +875,12 @@ samp .meta.block, code .meta.block, samp .lowerident, code .lowerident { - color: var(--blue); + color: white; +} + +samp .error, +code .error { + color: hsl(0, 96%, 67%); } /* Types, Tags, and Modules */ @@ -681,7 +890,7 @@ samp .meta.path, code .meta.path, samp .upperident, code .upperident { - color: var(--green); + color: var(--dark-cyan); } samp .dim, @@ -696,15 +905,226 @@ code .dim { } .copy-button { - background: var(--code-bg); - border: 1px solid var(--magenta); - color: var(--magenta); + background: var(--dark-code-bg); + border: 1px solid var(--dark-cyan); + color: var(--dark-cyan); display: inline-block; cursor: pointer; margin: 8px; } .copy-button:hover { - border-color: var(--green); - color: var(--green); + border-color: var(--code-color); + color: var(--code-color); +} + +.roc-logo { + width: 40px; + height: 40px; + margin: 0 auto; + fill: var(--primary-1); + text-shadow: 1px 1px 1px #010101; + position: relative; + top: -2px; +} + +/* HOME GOALS */ + +.home-goals-container { + display: flex; + flex-direction: row; + justify-content: space-between; + gap: 45px; + width: 100%; +} + +.home-goals-column { + display: flex; + flex-direction: column; + flex: 1; + width: 100%; +} + +.home-goals-content { + flex: 1; + display: flex; + flex-direction: column; + padding: 20px; + border: 4px solid var(--light-cyan); + color: inherit; + cursor: pointer; +} + +.home-goals-content:hover { + text-decoration: none; + cursor: pointer; + background-color: var(--light-cyan); +} + +.home-goals-learn-more { + text-decoration: underline; +} + +.home-examples-container { + display: flex; + flex-direction: row; + justify-content: space-between; + gap: 24px; + width: 100%; +} + +.home-examples-column { + display: flex; + flex-direction: column; + flex: 1; + width: 100%; +} + +.home-examples-column:not(:last-of-type) { + padding-right: 24px; + border-right: 2px solid var(--primary-1); +} + +/* Wider screens */ +@media only screen and (min-width: 768px) { + .home-goals-column { + margin-bottom: 0; + } + + .home-goals-column:last-child { + margin-right: 0; + } +} + +.home-goals-learn-more { + margin-top: auto; + white-space: nowrap; +} + +.home-goals-title { + padding: 0; + font-weight: bold; + margin-bottom: 10px; + font-size: 32px; + border-bottom: none; + font-family: inherit; + text-transform: lowercase; + padding-bottom: 42px; + padding-top: 2px; + font-style: italic; + letter-spacing: 1px; + word-spacing: 3px; + margin: 0; + color: var(--text-color); +} + +.home-goals-description { + line-height: 1.5; + margin-bottom: 2em; +} + +/* Interactive example on homepage */ + +.interactive-example { + font-size: var(--font-size-normal); +} + +.interactive-example, +.interactive-example samp { + background-color: #202746; + color: white; +} + +.interactive-example samp { + position: relative; + display: block; + width: 100%; + height: 580px; + padding-right: 300px; + cursor: default; +} + +.interactive-example label:hover, +.interactive-radio:checked + label { + background-color: #000; + cursor: pointer; +} + +.interactive-desc { + display: none; + position: absolute; + top: 0; + right: 300px; + width: 300px; + background-color: #ede6ff; + border: 1px solid black; + color: black; + padding: 0 16px; + padding-top: 12px; + margin-top: 9px; + cursor: text; + white-space: normal; + font-family: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial; +} + +.interactive-desc a { + color: #7c38f5; +} + +.interactive-radio { + display: none; +} + +.interactive-radio:checked + label + .interactive-desc { + display: block; +} + +.close-desc { + display: none; + position: absolute; + height: 40px; + width: 40px; + font-size: 24px; + top: -12px; + right: -12px; + color: #fff; + background: #9b6bf2; + border: 2px solid #7c38f5; + border-radius: 100%; + z-index: 4; +} + +.close-desc:hover { + color: #222; + background: var(--light-cyan); + border-color: var(--light-cyan); +} + +/* Tutorial Table of Contents */ + +#tutorial-toc { + background-color: var(--gray-bg); +} + +#tutorial-toc > ul { + display: flex; + flex-wrap: wrap; + list-style-type: none; + padding: 16px 16px; + margin: 0px; +} + +#tutorial-toc > ul > li { + flex: 1 1 50%; /* Adjust the percentage to control how many items per row */ + margin-bottom: 0; /* Reset the margin as they are now side by side */ + white-space: nowrap; + overflow: hidden; /* Ensures content doesn't overflow its container */ + text-overflow: ellipsis; /* Adds an ellipsis if the content overflows */ +} + +/* for larger screens */ +@media only screen and (min-width: 768px) { + #tutorial-toc > ul > li { + flex: 1 1 33%; /* Adjust the percentage to control how many items per row */ + } } diff --git a/www/public/site.js b/www/public/site.js index 89da8ce7b5..e93910f1f5 100644 --- a/www/public/site.js +++ b/www/public/site.js @@ -1,72 +1,515 @@ -const tutorialTocToggle = document.querySelector("#tutorial-toc-toggle"); +const isOnMobile = window.innerWidth <= 1024; -document.querySelectorAll("#tutorial-toc li a").forEach((elem) => { - // Clicking any of the ToC links closes the ToC - elem.addEventListener("click", (event) => { - tutorialTocToggle.checked = false; - }) -}); +// The only way we can provide values to wasm_bindgen's generated code is to set globals +window.js_create_app = js_create_app; +window.js_run_app = js_run_app; +window.js_get_result_and_memory = js_get_result_and_memory; -document.addEventListener("keydown", (event) => { - // Escape closes the ToC - if (event.key == "Escape") { - tutorialTocToggle.checked = false; +// The only place we use console.error is in wasm_bindgen, where it gets a single string argument. +console.error = function displayErrorInHistoryPanel(string) { + const html = `
    ${string}
    `; + updateHistoryEntry(repl.inputHistoryIndex, false, html); +}; + +import * as roc_repl_wasm from "./repl/roc_repl_wasm.js"; + +const isHomepage = document.getElementById("homepage-repl-container") != null; + +const tutorialButtonSvg = ``; + +// ---------------------------------------------------------------------------- +// REPL state +// ---------------------------------------------------------------------------- + +const repl = { + elemHistory: document.getElementById("history-text"), + elemSourceInput: document.getElementById("source-input"), + description: document.getElementById("repl-description"), + + inputQueue: [], + inputHistory: [], + inputHistoryIndex: 0, + inputStash: "", // stash the user input while we're toggling through history with up/down arrows + + // Current progress through the repl tutorial + tutorialStep: 0, + tutorialSteps: [ + { + match: (input) => input.replace(/ /g, "") === "0.1+0.2", + show: '

    Was this the answer you expected? (If so, try this in other programming languages and see what their answers are.)

    Roc has a decimal type as well as floating-point for when performance is more important than decimal precision.

    Next, enter name = "(put your name here)"

    ', + }, + { + match: (input) => input.replace(/ /g, "").match(/^name="/i), + show: '

    This created a new definition—name is now defined to be equal to the string you entered.

    Try using this definition by entering "Hi, \\(name)!"

    ', + }, + { + match: (input) => input.match(/^["][^\\]+\\\(name\)/i), + show: `

    Nicely done! This is an example of string interpolation, which replaces part of a string with whatever you put inside the parentheses after a \\.

    Now that you’ve written a few expressions, you can either continue exploring in this REPL, or move on to the tutorial to learn how to make full programs.

    Welcome to Roc! ${tutorialButtonSvg} Start Tutorial

    `, + }, + ], + + textDecoder: new TextDecoder(), + textEncoder: new TextEncoder(), + + compiler: null, + app: null, + + // Temporary storage for the address of the result of running the user's code. + // Used while control flow returns to Rust to allocate space to copy the app's memory buffer. + result_addr: 0, +}; + +// Initialise +repl.elemSourceInput.value = ""; // Some browsers remember the input across refreshes +resetSourceInputHeight(); +repl.elemSourceInput.addEventListener("input", resetSourceInputHeight); +repl.elemSourceInput.addEventListener("keydown", onInputKeydown); +repl.elemSourceInput.addEventListener("keyup", onInputKeyup); +roc_repl_wasm.default("/repl/roc_repl_wasm_bg.wasm").then(async (instance) => { + const loadingMessage = repl.elemHistory.querySelector("#loading-message"); + + if (loadingMessage != null) { + loadingMessage.remove(); + } + + repl.elemSourceInput.placeholder = "Enter some Roc code here."; + repl.compiler = instance; + + // Get help text from the compiler, and display it at top of the history panel + try { + const helpText = await roc_repl_wasm.entrypoint_from_js(":help"); + const helpElem = document.getElementById("help-text"); + + if (helpElem != null) { + helpElem.innerHTML = helpText.trim(); } + } catch (e) { + // Print error for Roc devs. Don't use console.error, we overrode that above to display on the page! + console.warn(e); + } }); -const isTouchSupported = () => { - try{ document.createEvent("TouchEvent"); return true; } - catch(e){ return false; } +// Focus the repl input the first time it scrolls into view +// (but not on mobile, because that would pop up the whole keyboard abruptly) +if (!isOnMobile) { + // Function to be called when the input enters the viewport + function handleIntersect(entries, observer) { + entries.forEach((entry) => { + // Check if the input is intersecting + if (entry.isIntersecting) { + // Apply focus to it, then unobserve it because we only want to do this once. + entry.target.focus(); + observer.unobserve(entry.target); + } + }); + } + + // Set up the Intersection Observer + let observer = new IntersectionObserver(handleIntersect, { + // Use the whole viewport for the intersection + root: null, + // Trigger the callback when the input is fully visible + threshold: 1.0, + }); + + observer.observe(repl.elemSourceInput); } -// Select all elements that are children of 
     elements
-const codeBlocks = document.querySelectorAll("pre > samp");
+// ----------------------------------------------------------------------------
+// Handle inputs
+// ----------------------------------------------------------------------------
 
-// Iterate over each code block
-codeBlocks.forEach((codeBlock) => {
-  // Create a "Copy" button
-  const copyButton = document.createElement("button");
-  copyButton.classList.add("copy-button");
-  copyButton.textContent = "Copy";
+function resetSourceInputHeight() {
+  repl.elemSourceInput.style.height =
+    repl.elemSourceInput.scrollHeight + 2 + "px"; // +2 for the border
+}
 
-  // Add event listener to copy button
-  copyButton.addEventListener("click", () => {
-    const codeText = codeBlock.innerText;
-    navigator.clipboard.writeText(codeText);
-    copyButton.textContent = "Copied!";
-    copyButton.classList.add("copy-button-copied");
-    copyButton.addEventListener("mouseleave", () => {
-        copyButton.textContent = "Copy";
-        copyButton.classList.remove('copy-button-copied');
+function onInputKeydown(event) {
+  const ENTER = 13;
+
+  const { keyCode } = event;
+
+  if (keyCode === ENTER) {
+    if (!event.shiftKey && !event.ctrlKey && !event.altKey) {
+      // Don't advance the caret to the next line
+      event.preventDefault();
+
+      const inputText = repl.elemSourceInput.value.trim();
+
+      repl.elemSourceInput.value = "";
+      repl.elemSourceInput.style.height = "";
+
+      repl.inputQueue.push(inputText);
+      if (repl.inputQueue.length === 1) {
+        processInputQueue();
+      }
+
+      // Hide the arrow on the homepage that prompts you to enter something
+      const replArrow = document.getElementById("repl-arrow");
+
+      if (replArrow != null) {
+        replArrow.style.display = "none";
+      }
+    }
+  }
+}
+
+function onInputKeyup(event) {
+  const UP = 38;
+  const DOWN = 40;
+
+  const { keyCode } = event;
+
+  const el = repl.elemSourceInput;
+
+  switch (keyCode) {
+    case UP:
+      if (repl.inputHistory.length === 0) {
+        return;
+      }
+      if (repl.inputHistoryIndex == repl.inputHistory.length - 1) {
+        repl.inputStash = el.value;
+      }
+      setInput(repl.inputHistory[repl.inputHistoryIndex]);
+
+      if (repl.inputHistoryIndex > 0) {
+        repl.inputHistoryIndex--;
+      }
+      break;
+
+    case DOWN:
+      if (repl.inputHistory.length === 0) {
+        return;
+      }
+      if (repl.inputHistoryIndex === repl.inputHistory.length - 1) {
+        setInput(repl.inputStash);
+      } else {
+        repl.inputHistoryIndex++;
+        setInput(repl.inputHistory[repl.inputHistoryIndex]);
+      }
+      break;
+
+    default:
+      break;
+  }
+}
+
+function setInput(value) {
+  const el = repl.elemSourceInput;
+  el.value = value;
+  el.selectionStart = value.length;
+  el.selectionEnd = value.length;
+}
+
+function showNextReplTutorialEntry(inputText) {
+  const nextStep = repl.tutorialSteps[repl.tutorialStep];
+
+  if (typeof nextStep === "object" && nextStep.match(inputText)) {
+    repl.description.innerHTML =
+      repl.description.innerHTML + "
    " + nextStep.show;
+
+    repl.tutorialStep = repl.tutorialStep + 1;
+  }
+}
+
+// Use a queue just in case we somehow get inputs very fast
+// We want the REPL to only process one at a time, since we're using some global state.
+// In normal usage we shouldn't see this edge case anyway. Maybe with copy/paste?
+async function processInputQueue() {
+  while (repl.inputQueue.length) {
+    const inputText = repl.inputQueue[0];
+
+    if (inputText) {
+      repl.inputHistoryIndex = createHistoryEntry(inputText);
+      repl.inputStash = "";
+
+      let outputText = "";
+      let ok = true;
+      try {
+        outputText = await roc_repl_wasm.entrypoint_from_js(inputText);
+      } catch (e) {
+        outputText = `${e}`;
+        ok = false;
+      }
+
+      updateHistoryEntry(repl.inputHistoryIndex, ok, outputText);
+      showNextReplTutorialEntry(inputText);
+    }
+
+    repl.inputQueue.shift();
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Callbacks to JS from Rust
+// ----------------------------------------------------------------------------
+
+var ROC_PANIC_INFO = null;
+
+function send_panic_msg_to_js(rocstr_ptr, panic_tag) {
+  const { memory } = repl.app.exports;
+
+  const rocStrBytes = new Int8Array(memory.buffer, rocstr_ptr, 12);
+  const finalByte = rocStrBytes[11];
+
+  let stringBytes = "";
+  if (finalByte < 0) {
+    // small string
+
+    // bitwise ops on negative JS numbers are weird. This clears the bit that we
+    // use to indicate a small string. In rust it's `finalByte as u8 ^ 0b1000_0000`
+    const length = finalByte + 128;
+    stringBytes = new Uint8Array(memory.buffer, rocstr_ptr, length);
+  } else {
+    // big string
+    const rocStrWords = new Uint32Array(memory.buffer, rocstr_ptr, 3);
+    const [ptr, len, _cap] = rocStrWords;
+
+    const SEAMLESS_SLICE_BIT = 1 << 31;
+    const length = len & ~SEAMLESS_SLICE_BIT;
+
+    stringBytes = new Uint8Array(memory.buffer, ptr, length);
+  }
+
+  const decodedString = repl.textDecoder.decode(stringBytes);
+
+  ROC_PANIC_INFO = {
+    msg: decodedString,
+    panic_tag: panic_tag,
+  };
+}
+
+// Load Wasm code into the browser's virtual machine, so we can run it later.
+// This operation is async, so we call it before entering any code shared
+// with the command-line REPL, which is sync.
+async function js_create_app(wasm_module_bytes) {
+  const { instance } = await WebAssembly.instantiate(wasm_module_bytes, {
+    env: {
+      send_panic_msg_to_js: send_panic_msg_to_js,
+    },
+  });
+
+  // Keep the instance alive so we can run it later from shared REPL code
+  repl.app = instance;
+}
+
+// Call the `main` function of the user app, via the `wrapper` function.
+function js_run_app() {
+  const { wrapper, memory } = repl.app.exports;
+
+  // Run the user code, and remember the result address
+  // We'll pass it to Rust in the next callback
+  try {
+    repl.result_addr = wrapper();
+  } catch (e) {
+    // an exception could be that roc_panic was invoked,
+    // or some other crash (likely a compiler bug)
+    if (ROC_PANIC_INFO === null) {
+      throw e;
+    } else {
+      // when roc_panic set an error message, display it
+      const { msg, panic_tag } = ROC_PANIC_INFO;
+      ROC_PANIC_INFO = null;
+
+      console.error(format_roc_panic_message(msg, panic_tag));
+    }
+  }
+
+  // Tell Rust how much space to reserve for its copy of the app's memory buffer.
+  // We couldn't know that size until we actually ran the app.
+  return memory.buffer.byteLength;
+}
+
+function format_roc_panic_message(msg, panic_tag) {
+  switch (panic_tag) {
+    case 0: {
+      return `Roc failed with message: "${msg}"`;
+    }
+    case 1: {
+      return `User crash with message: "${msg}"`;
+    }
+    default: {
+      return `Got an invalid panic tag: "${panic_tag}"`;
+    }
+  }
+}
+
+// After Rust has allocated space for the app's memory buffer,
+// we copy it, and return the result address too
+function js_get_result_and_memory(buffer_alloc_addr) {
+  const appMemory = new Uint8Array(repl.app.exports.memory.buffer);
+  const compilerMemory = new Uint8Array(repl.compiler.memory.buffer);
+  compilerMemory.set(appMemory, buffer_alloc_addr);
+  return repl.result_addr;
+}
+
+// ----------------------------------------------------------------------------
+// Rendering
+// ----------------------------------------------------------------------------
+
+function createHistoryEntry(inputText) {
+  const historyIndex = repl.inputHistory.length;
+  repl.inputHistory.push(inputText);
+
+  const firstLinePrefix = '» ';
+  const otherLinePrefix = '
    … ';
+  const inputLines = inputText.split("\n");
+  if (inputLines[inputLines.length - 1] === "") {
+    inputLines.pop();
+  }
+  const inputWithPrefixes = firstLinePrefix + inputLines.join(otherLinePrefix);
+
+  const inputElem = document.createElement("div");
+  inputElem.innerHTML = inputWithPrefixes;
+  inputElem.classList.add("input");
+
+  const historyItem = document.createElement("div");
+  historyItem.appendChild(inputElem);
+  historyItem.classList.add("history-item");
+
+  repl.elemHistory.appendChild(historyItem);
+
+  return historyIndex;
+}
+
+function updateHistoryEntry(index, ok, outputText) {
+  const outputElem = document.createElement("div");
+  outputElem.innerHTML = outputText;
+  outputElem.classList.add("output", ok ? "output-ok" : "output-error");
+
+  const historyItem = repl.elemHistory.children[index];
+  historyItem.appendChild(outputElem);
+
+  if (isHomepage) {
+    // Scroll the input element into view so you can see the most recent output.
+    // Only do this if it's currently out of view though!
+    const bounds = repl.elemSourceInput.getBoundingClientRect();
+    const isInView =
+      bounds.top >= 0 &&
+      bounds.left >= 0 &&
+      bounds.bottom <=
+        (window.innerHeight || document.documentElement.clientHeight) &&
+      bounds.right <=
+        (window.innerWidth || document.documentElement.clientWidth);
+
+    if (!isInView) {
+      repl.elemSourceInput.scrollIntoView({
+        behavior: "instant",
+        block: "end",
+        inline: "nearest",
+      });
+    }
+  } else {
+    // Scroll the page to the bottom so you can see the most recent output.
+    window.scrollTo(0, document.body.scrollHeight);
+  }
+}
+
+// TUTORIAL //
+
+const tutorialTocToggle = document.querySelector("#tutorial-toc-toggle");
+
+if (tutorialTocToggle != null) {
+  document.querySelectorAll("#tutorial-toc li a").forEach((elem) => {
+    // Clicking any of the ToC links closes the ToC
+    elem.addEventListener("click", (event) => {
+      tutorialTocToggle.checked = false;
     });
   });
 
-  // Create a container for the copy button and append it to the document
-  const buttonContainer = document.createElement("div");
-  buttonContainer.classList.add("button-container");
-  buttonContainer.appendChild(copyButton);
-  codeBlock.parentNode.insertBefore(buttonContainer, codeBlock);
+  document.addEventListener("keydown", (event) => {
+    // Escape closes the ToC
+    if (event.key == "Escape") {
+      tutorialTocToggle.checked = false;
+    }
+  });
 
-  // Hide the button container by default
-  buttonContainer.style.display = "none";
+  const isTouchSupported = () => {
+    try {
+      document.createEvent("TouchEvent");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
 
-  if (isTouchSupported()) {
-    // Show the button container on click for touch support (e.g. mobile)
-    document.addEventListener("click", (event) => {
-      if (event.target.closest("pre > samp") !== codeBlock) {
-        buttonContainer.style.display = "none";
-      } else {
+  // Select all  elements that are children of 
     elements
+  const codeBlocks = document.querySelectorAll("pre > samp");
+
+  // Iterate over each code block
+  codeBlocks.forEach((codeBlock) => {
+    // Create a "Copy" button
+    const copyButton = document.createElement("button");
+    copyButton.classList.add("copy-button");
+    copyButton.textContent = "Copy";
+
+    // Add event listener to copy button
+    copyButton.addEventListener("click", () => {
+      const codeText = codeBlock.innerText;
+      navigator.clipboard.writeText(codeText);
+      copyButton.textContent = "Copied!";
+      copyButton.classList.add("copy-button-copied");
+      copyButton.addEventListener("mouseleave", () => {
+        copyButton.textContent = "Copy";
+        copyButton.classList.remove("copy-button-copied");
+      });
+    });
+
+    // Create a container for the copy button and append it to the document
+    const buttonContainer = document.createElement("div");
+    buttonContainer.classList.add("button-container");
+    buttonContainer.appendChild(copyButton);
+    codeBlock.parentNode.insertBefore(buttonContainer, codeBlock);
+
+    // Hide the button container by default
+    buttonContainer.style.display = "none";
+
+    if (isTouchSupported()) {
+      // Show the button container on click for touch support (e.g. mobile)
+      document.addEventListener("click", (event) => {
+        if (event.target.closest("pre > samp") !== codeBlock) {
+          buttonContainer.style.display = "none";
+        } else {
+          buttonContainer.style.display = "block";
+        }
+      });
+    } else {
+      // Show the button container on hover for non-touch support (e.g. desktop)
+      codeBlock.parentNode.addEventListener("mouseenter", () => {
         buttonContainer.style.display = "block";
-      }
+      });
+
+      codeBlock.parentNode.addEventListener("mouseleave", () => {
+        buttonContainer.style.display = "none";
+      });
+    }
+  });
+}
+
+// HOMEPAGE //
+
+if (isOnMobile) {
+  const hideDesc = () => {
+    document.querySelectorAll(".interactive-radio").forEach((radio) => {
+      radio.checked = false;
     });
-  } else {
-    // Show the button container on hover for non-touch support (e.g. desktop)
-    codeBlock.parentNode.addEventListener("mouseenter", () => {
-      buttonContainer.style.display = "block";
+  };
+
+  hideDesc(); // On mobile, start out with all the descriptions hidden.
+
+  document.querySelectorAll(".interactive-example").forEach((example) => {
+    example.querySelectorAll("label").forEach((label) => {
+      label.addEventListener("click", (event) => {
+        const desc = label.nextSibling; // The description node always comes next
+
+        // Set the position of the target element
+        desc.style.top = label.offsetTop + label.offsetHeight + "px"; // Position below the button
+        desc.style.left = label.offsetLeft + "px"; // Align with the left of the button
+      });
     });
 
-    codeBlock.parentNode.addEventListener("mouseleave", () => {
-      buttonContainer.style.display = "none";
-    });  
-  }
-});
\ No newline at end of file
+    example.querySelectorAll(".close-desc").forEach((button) => {
+      button.addEventListener("click", hideDesc);
+    });
+  });
+}
diff --git a/www/public/styles.css b/www/public/styles.css
deleted file mode 100644
index 0c398e375b..0000000000
--- a/www/public/styles.css
+++ /dev/null
@@ -1,487 +0,0 @@
-:root {
-  --link-color: #612bde;
-  --code-link-color: #5721d4;
-  --text-color: #333333;
-  --code-color: #222222;
-  --code-bg-color: #eeeeee;
-  --body-bg-color: #fdfdfd;
-  --border-color: #e9e9e9;
-  --faded-color: #4c4c4c;
-  --font-sans: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial, sans-serif;
-  --font-mono: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
-  --top-header-height: 67px;
-  --sidebar-width: 280px;
-  --top-bar-bg: #8257e5;
-  --top-bar-fg: #ffffff;
-  --nav-link-hover-color: #000000;
-}
-
-a {
-  color: #972395;
-}
-
-.logo {
-  padding: 2px 8px;
-}
-
-.logo svg {
-  height: 48px;
-  width: 48px;
-  fill: var(--top-bar-fg);
-}
-
-.logo:hover {
-  text-decoration: none;
-}
-
-.logo svg:hover {
-  fill: var(--nav-link-hover-color);
-}
-
-.pkg-full-name {
-  color: var(--text-color);
-  display: flex;
-  align-items: center;
-  font-size: 32px;
-  margin: 0 8px;
-  font-weight: normal;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  height: 100%;
-}
-
-.pkg-full-name a {
-  padding-top: 12px;
-  padding-bottom: 16px;
-}
-
-a {
-  text-decoration: none;
-}
-
-a:hover {
-  text-decoration: underline;
-}
-
-.pkg-and-logo {
-  min-width: 0;
-  /* necessary for text-overflow: ellipsis to work in descendants */
-  display: flex;
-  align-items: center;
-  height: 100%;
-  background-color: var(--top-bar-bg);
-}
-
-.pkg-and-logo a,
-.pkg-and-logo a:visited {
-  color: var(--top-bar-fg);
-}
-
-.pkg-and-logo a:hover {
-  color: var(--nav-link-hover-color);
-  text-decoration: none;
-}
-
-.main-container {
-  min-width: 0;
-  /* necessary for text-overflow: ellipsis to work in descendants */
-}
-
-.search-button {
-  flex-shrink: 0;
-  /* always shrink the package name before these; they have a relatively constrained length */
-  padding: 12px 18px;
-  margin-right: 42px;
-  display: none;
-  /* only show this in the mobile view */
-}
-
-.version {
-  padding: 18px 10px;
-  min-width: 48px;
-  margin-right: 8px;
-}
-
-body {
-  display: grid;
-  grid-template-columns: [before-sidebar] 1fr [sidebar] var(--sidebar-width) [main-content] fit-content(calc(1280px - var(--sidebar-width))) [end] 1fr;
-  grid-template-rows: [top-header] var(--top-header-height) [above-footer] auto [footer] auto;
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-  font-family: var(--font-sans);
-  color: var(--text-color);
-  background-color: var(--body-bg-color);
-}
-
-main {
-  grid-column-start: main-content;
-  grid-column-end: main-content;
-  grid-row-start: above-footer;
-  grid-row-end: above-footer;
-  box-sizing: border-box;
-  position: relative;
-  font-size: 18px;
-  line-height: 1.85em;
-  margin-top: 2px;
-  padding: 48px;
-}
-
-#sidebar-nav {
-  grid-column-start: sidebar;
-  grid-column-end: sidebar;
-  grid-row-start: above-footer;
-  grid-row-end: above-footer;
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  box-sizing: border-box;
-  padding-left: 56px;
-  padding-top: 6px;
-  width: 100%;
-}
-
-.top-header-extension {
-  grid-column-start: before-sidebar;
-  grid-column-end: sidebar;
-  grid-row-start: top-header;
-  grid-row-end: top-header;
-  background-color: var(--top-bar-bg);
-}
-
-.top-header {
-  grid-column-start: sidebar;
-  grid-column-end: end;
-  grid-row-start: top-header;
-  grid-row-end: top-header;
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  flex-wrap: nowrap;
-  flex-grow: 1;
-  box-sizing: border-box;
-  font-family: var(--font-sans);
-  font-size: 24px;
-  height: 100%;
-  /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants, but we want this anyway. */
-  min-width: 1024px;
-}
-
-.top-header-triangle {
-  /* This used to be a clip-path, but Firefox on Android (at least as of early 2020)
-   * rendered the page extremely slowly in that version. With this approach it's super fast.
-   */
-  width: 0;
-  height: 0;
-  border-style: solid;
-  border-width: var(--top-header-height) 0 0 48px;
-  border-color: transparent transparent transparent var(--top-bar-bg);
-}
-
-p {
-  overflow-wrap: break-word;
-  margin: 24px 0;
-}
-
-footer {
-  grid-column-start: main-content;
-  grid-column-end: main-content;
-  grid-row-start: footer;
-  grid-row-end: footer;
-  max-width: var(--main-content-max-width);
-  font-size: 14px;
-  box-sizing: border-box;
-  padding: 16px;
-}
-
-footer p {
-  display: inline-block;
-  margin-top: 0;
-  margin-bottom: 8px;
-}
-
-.content {
-  box-sizing: border-box;
-  display: flex;
-  flex-direction: row;
-  justify-content: space-between;
-}
-
-.sidebar-entry ul {
-  list-style-type: none;
-  margin: 0;
-}
-
-.sidebar-entry a {
-  box-sizing: border-box;
-  min-height: 48px;
-  min-width: 48px;
-  padding: 12px 16px;
-  font-family: var(--font-mono);
-}
-
-.sidebar-sub-entries a {
-  display: block;
-  line-height: 24px;
-  width: 100%;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  padding-left: 36px;
-}
-
-.module-name {
-  font-size: 56px;
-  line-height: 1em;
-  font-family: var(--font-mono);
-  font-weight: bold;
-  margin-top: 18px;
-  margin-bottom: 48px;
-}
-
-.module-name a,
-.module-name a:visited {
-  color: inherit;
-}
-
-.sidebar-module-link {
-  box-sizing: border-box;
-  font-size: 18px;
-  line-height: 24px;
-  font-family: var(--font-mono);
-  font-weight: bold;
-  display: block;
-  width: 100%;
-  padding: 8px 0;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-a,
-a:visited {
-  color: var(--link-color);
-}
-
-h3 {
-  font-size: 32px;
-  margin: 48px 0 24px 0;
-}
-
-h4 {
-  font-size: 24px;
-}
-
-.type-def {
-  font-size: 24px;
-  color: var(--link-color);
-}
-
-.code-snippet {
-  padding: 12px 16px;
-  display: block;
-  box-sizing: border-box;
-  font-family: var(--font-mono);
-  background-color: var(--code-bg-color);
-}
-
-code {
-  font-family: var(--font-mono);
-  color: var(--code-color);
-  background-color: var(--code-bg-color);
-  display: inline-block;
-  line-height: 28px;
-}
-
-code a {
-  color: var(--code-link-color);
-}
-
-code a:visited {
-  color: var(--code-link-color);
-}
-
-pre {
-  margin: 36px 0;
-  padding: 8px;
-  box-sizing: border-box;
-  background-color: var(--code-bg-color);
-  overflow-x: auto;
-}
-
-.hidden {
-  /* Use !important to win all specificity fights. */
-  display: none !important;
-}
-
-.syntax-comment {
-  color: #ff0000;
-}
-
-#module-search:placeholder-shown {
-  padding: 0;
-  opacity: 0;
-  height: 0;
-}
-
-#module-search,
-#module-search:focus {
-  opacity: 1;
-  padding: 12px 16px;
-  height: 48px;
-}
-
-/* Show the "Search" label link when the text input has a placeholder */
-#module-search:placeholder-shown+#search-link {
-  display: flex;
-}
-
-/* Hide the "Search" label link when the text input has focus */
-#module-search:focus+#search-link {
-  display: none;
-}
-
-#module-search {
-  display: block;
-  box-sizing: border-box;
-  background-color: var(--code-bg-color);
-  width: 100%;
-  box-sizing: border-box;
-  font-size: 18px;
-  line-height: 18px;
-  margin-top: 6px;
-  border: none;
-  color: var(--faded-color);
-  background-color: var(--code-bg-color);
-  font-family: var(--font-serif);
-}
-
-#module-search::placeholder {
-  color: var(--faded-color);
-  opacity: 1;
-}
-
-#search-link {
-  box-sizing: border-box;
-  display: none;
-  align-items: center;
-  font-size: 18px;
-  line-height: 18px;
-  padding: 12px 16px;
-  height: 48px;
-  cursor: pointer;
-  color: var(--link-color);
-}
-
-#search-link:hover {
-  text-decoration: underline;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --body-bg-color: #303030;
-    --code-bg-color: #393939;
-    --border-color: #555555;
-    --code-color: #eeeeee;
-    --text-color: #cccccc;
-    --logo-solid: #777777;
-    --faded-color: #bbbbbb;
-    --link-color: #c5a8ff;
-    --code-link-color: #b894ff;
-    --top-bar-bg: #6845b9;
-    --top-bar-fg: #eeeeee;
-  }
-
-  html {
-    scrollbar-color: #444444 #2f2f2f;
-  }
-}
-
-@media only screen and (max-device-width: 480px) {
-  .search-button {
-    display: block;
-    /* This is only visible in mobile. */
-  }
-
-  .pkg-full-name {
-    margin-left: 8px;
-    margin-right: 12px;
-    font-size: 24px;
-    padding-bottom: 14px;
-  }
-
-  .pkg-full-name a {
-    vertical-align: middle;
-    padding: 18px 0;
-  }
-
-  .logo {
-    padding-left: 2px;
-    width: 50px;
-    height: 54px;
-  }
-
-  .version {
-    margin: 0;
-    font-weight: normal;
-    font-size: 18px;
-    padding-bottom: 16px;
-  }
-
-  .module-name {
-    font-size: 36px;
-    margin-top: 8px;
-    margin-bottom: 8px;
-    max-width: calc(100% - 18px);
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-
-  main {
-    padding: 18px;
-    font-size: 16px;
-  }
-
-  .container {
-    margin: 0;
-    min-width: 320px;
-    max-width: 100%;
-  }
-
-  .content {
-    flex-direction: column;
-  }
-
-  .sidebar {
-    margin-top: 0;
-    padding-left: 0;
-    width: auto;
-  }
-
-  #sidebar-heading {
-    font-size: 24px;
-    margin: 16px;
-  }
-
-  h3 {
-    font-size: 18px;
-    margin: 0;
-    padding: 0;
-  }
-
-  h4 {
-    font-size: 16px;
-  }
-
-  .top-header {
-    width: auto;
-    justify-content: space-between;
-    /* min-width must be set to something (even 0) for text-overflow: ellipsis to work in descendants. */
-    min-width: 0;
-  }
-
-  .content {
-    /* Display the sidebar below 
     without affecting tab index */
-    flex-direction: column-reverse;
-  }
-}
diff --git a/www/wip_new_website/.gitignore b/www/wip_new_website/.gitignore
deleted file mode 100644
index 9884a9c30e..0000000000
--- a/www/wip_new_website/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-roc-website
-dist/
-website-builder
-main
diff --git a/www/wip_new_website/README.md b/www/wip_new_website/README.md
deleted file mode 100644
index e2c50f32ca..0000000000
--- a/www/wip_new_website/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-
-# Getting Started
-
-## Prerequisites
-
-- Linux or MacOS operating system, Windows users can use linux through WSL.
-- Install [git](https://chat.openai.com/share/71fb3ae6-80d7-478c-8a27-a36aaa5ba921)
-- Install [nix](https://nixos.org/download.html)
-
-## Building the website from scratch
-
-```bash
-git clone https://github.com/roc-lang/roc.git
-cd roc
-nix develop
-./www/build.sh
-# make the roc command available 
-export PATH="$(pwd)/target/release/:$PATH"
-cd www/wip_new_website
-bash build-dev-local.sh
-```
-
-Open http://0.0.0.0:8080/wip in your browser.
-
-## After you've made a change
-
-In the terminal where the web server is running:
-1. kill the server with Ctrl+C
-2. re-run the build script 
-3. refresh the page in your browser
\ No newline at end of file
diff --git a/www/wip_new_website/static/site.css b/www/wip_new_website/static/site.css
deleted file mode 100644
index 444cbf2464..0000000000
--- a/www/wip_new_website/static/site.css
+++ /dev/null
@@ -1,1462 +0,0 @@
-:root {
-    /* WCAG AAA Compliant colors */
-    --code-bg: #f4f8f9;
-    --gray-bg: #f4f8f9;
-    --gray: #717171;
-    --orange: #bf5000;
-    --green: #0b8400;
-    --light-cyan: #8af4e6;
-    --dark-cyan: #4eefd9;
-    --blue: #05006d;
-    --violet: #7c38f5;
-    --violet-bg: #ece2fd;
-    --magenta: #ff32cf;
-
-    --primary-1: #9b6bf2;
-    --primary-2: #7c38f5;
-    --highlight: #1bd6bd;
-    --code-color: white;
-    --link-color: var(--primary-2);
-    --code-link-color: var(--primary-2);
-    --text-color: #000;
-    --heading-color: #333;
-    --text-hover-color: var(--primary-2);
-    --body-bg-color: #ffffff;
-    --border-color: #717171;
-    --faded-color: #4c4c4c;
-    --font-sans: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial,
-        sans-serif;
-    --font-mono: "Source Code Pro", SFMono-Regular, Consolas, "Liberation Mono",
-        Menlo, Courier, monospace;
-    --top-header-height: 67px;
-    --sidebar-width: 280px;
-
-    --font-size-normal: 18px;
-    --body-max-width: 1024px;
-    --dark-code-bg: #202746;
-
-    /* Tutorial */
-    --header-link-color: #107F79;
-    --header-link-hover: #222;
-    --h1-color: #8055E4;
-}
-
-html {
-    line-height: 1.5rem;
-    background: var(--body-bg-color);
-    color: var(--text-color);
-    font-family: "Lato", sans-serif;
-}
-
-html,
-body {
-    margin: 0;
-    padding: 0;
-    width: 100%;
-    height: 100%;
-    box-sizing: border-box;
-    overflow-x: hidden; /* This shouldn't be necessary, but without it, mobile has a right gutter. */
-}
-
-p {
-    margin-top: 0;
-}
-
-p, li {
-    max-width: 720px;
-}
-
-footer {
-    width: 100%;
-    color: var(--text-color);
-    text-align: center;
-    font-size: var(--font-size-normal);
-    padding: 20px;
-    box-sizing: border-box;
-    margin-top: 24px;
-}
-
-#footer {
-    max-width: var(--body-max-width);
-    margin: 0 auto;
-}
-
-
-hr {
-    color: var(--primary-1);
-    margin-bottom: 1rem;
-}
-
-.svg-text {
-    fill: #000;
-}
-
-.logo-dark {
-    fill: #612bde;
-}
-
-.logo-light {
-    fill: #8257e5;
-}
-
-.btn-small {
-    white-space: nowrap;
-    background: #7c38f5;
-    border: 4px solid #9b6bf2;
-    color: #fff !important;
-    cursor: pointer;
-    text-decoration: none !important;
-    padding: 12px;
-}
-
-.btn-small .roc-logo {
-    fill: #fff;
-    position: relative;
-    left: -4px;
-    top: 11px;
-}
-
-.btn-small:hover {
-    background: #9b6bf2;
-    border-color: #7c38f5;
-}
-
-#individual-sponsors {
-    list-style-type: none;
-    padding: 24px 40px;
-    max-width: 720px;
-}
-
-#individual-sponsors li {
-    display: inline;
-    white-space: nowrap;
-    margin: 0.2rem;
-}
-
-#individual-sponsors li::after {
-    content: ",";
-    white-space: pre; /* Preserve the space after the comma */
-}
-
-#individual-sponsors li:last-child::after {
-    content: ""; /* No comma after the last one */
-}
-
-#sponsor-logos {
-    padding: 24px 36px;
-    padding-bottom: 36px;
-    min-width: 308px; /* Widest logo plus padding - Firefox on Android needs this */
-    max-width: none !important;
-}
-
-#sponsor-logos svg {
-    height: 54px;
-    margin-right: 72px;
-}
-
-#sponsor-logos .logo-rwx {
-    position: relative;
-    top: 6px;
-}
-
-#sponsor-logos .logo-tweede-golf {
-    position: relative;
-    top: 14px;
-    height: 4.5rem;
-}
-
-#sponsor-logos + p {
-    margin-bottom: 3em;
-}
-
-/* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile.
- * When we think we're on mobile (based on max-width), we can switch the instruction.
-*/
-.desktop {
-    display: inline;
-}
-
-.mobile {
-    display: none;
-}
-
-section p:last-child {
-    margin-bottom: 0;
-}
-
-aside {
-    margin-left: 4rem;
-}
-
-a {
-    text-decoration: none;
-    color: var(--link-color);
-}
-
-a:hover {
-    text-decoration: underline;
-}
-
-li {
-    margin-bottom: 0.5rem;
-}
-
-h1,
-h2,
-h3,
-h4 {
-    font-weight: bold;
-}
-
-h1 {
-    font-size: 5rem;
-}
-
-h2 {
-    display: inline-block;
-    font-size: 2.5rem;
-    line-height: 5rem;
-    border-bottom: 4px solid var(--dark-cyan);
-    padding: 0;
-    margin: 0;
-    margin-bottom: 2rem;
-    color: var(--heading-color);
-}
-
-.article-layout main, .article-layout pre {
-    max-width: 720px;
-}
-
-.article-layout p, .article-layout li, .article-layout pre {
-    font-size: 20px;
-}
-
-#homepage-main h2 {
-    margin-top: 60px; /* On the homepage, these need to be spaced out more. */
-}
-
-#homepage-main #nav-home-link {
-    visibility: hidden;
-}
-
-h2 a, h3 a {
-    color: var(--heading-color);
-}
-
-h2:hover a {
-    color: var(--link-color);
-    text-decoration: none;
-}
-
-h3 {
-    font-size: 1.5rem;
-}
-
-#top-bar, #top-bar nav {
-    background-color: var(--gray-bg);
-}
-
-#top-bar {
-    box-sizing: border-box;
-    width: 100%;
-}
-
-#top-bar nav {
-    max-width: var(--body-max-width);
-    margin: 0 auto;
-    display: flex;
-    justify-content: space-between;
-    padding-right: 9px;
-}
-
-#nav-home-link {
-    display: inline-block;
-    color: var(--top-bar-fg);
-    font-size: 1.8rem;
-    padding: 4px;
-}
-
-.home-link-text {
-    padding: 8px;
-    font-size: 24px;
-    position: relative;
-    top: -0.6rem;
-}
-
-.home-examples-title {
-    margin-bottom: 4px;
-}
-
-#top-bar-links a,
-#top-bar-links label {
-    box-sizing: border-box;
-    color: var(--top-bar-fg);
-    display: inline-block;
-    padding: 12px 16px;
-    margin: 0 2px;
-}
-
-main {
-    max-width: var(--body-max-width);
-    margin: auto;
-    padding: 12px;
-    box-sizing: border-box;
-}
-
-.welcome-to-roc {
-    white-space: nowrap;
-    overflow-x: hidden;
-    padding-right: 60px;
-    margin-bottom: 12px;
-}
-
-code,
-samp {
-    font-family: var(--font-mono);
-    color: var(--text-color);
-    background-color: var(--gray-bg);
-    display: inline-block;
-    padding: 5px;
-}
-
-p code,
-td code,
-li code,
-th code {
-    padding: 0 8px;
-}
-
-code a,
-a code {
-    text-decoration: none;
-    color: var(--code-link-color);
-    background: none;
-    padding: 0;
-}
-
-code a:visited,
-a:visited code {
-    color: var(--code-link-color);
-}
-
-pre {
-    position: relative;
-    margin-bottom: 16px;
-    padding: 0 0.35rem;
-    box-sizing: border-box;
-    background-color: var(--gray-bg);
-    overflow-x: hidden;
-    word-wrap: normal;
-    font-size: var(--font-size-normal);
-    line-height: 1.76em;
-    white-space: pre;
-    background-color: var(--dark-code-bg);
-}
-
-pre > samp,
-pre > code {
-    overflow-x: auto;
-    display: block;
-    background-color: var(--dark-code-bg);
-    color: var(--code-color);
-}
-
-
-/* REPL */
-
-#repl {
-    position: relative;
-    display: flex;
-    flex-direction: column;
-    font-size: 18px;
-}
-
-#repl-prompt {
-    position: relative;
-    left: 16px;
-    top: 1.25rem;
-    font-size: 1.25rem;
-    height: 0;
-    z-index: 2;
-    font-family: var(--font-mono);
-    color: var(--light-cyan);
-    /* Let clicks pass through to the textarea */
-    pointer-events: none;
-    user-select: none;
-}
-
-#source-input {
-    width: 100%;
-    font-family: var(--font-mono);
-    color: var(--code-color);
-    background-color: var(--code-bg);
-    display: inline-block;
-    height: 78px;
-    padding: 16px;
-    padding-left: 36px;
-    border: 1px solid transparent;
-    margin: 0;
-    margin-bottom: 2em;
-    box-sizing: border-box;
-    font-size: 18px;
-    resize: none;
-}
-
-#source-input:focus {
-    outline: 2px solid var(--primary-1);
-    box-sizing: border-box;
-}
-
-.history {
-    padding: 1em;
-    padding-bottom: 0;
-    flex: 1;
-}
-
-#help-text,
-#history-text {
-    white-space: pre-wrap;
-}
-
-#history-text {
-    margin-top: 16px;
-    min-height: 26px;
-}
-
-#loading-message {
-    text-align: center;
-    /* approximately match height after loading and printing help message */
-    height: 96px;
-}
-
-.history-item {
-    margin-bottom: 24px;
-    overflow-x: hidden;
-}
-
-.history-item .input {
-    margin: 0;
-    margin-bottom: 8px;
-}
-
-.history-item .output {
-    margin: 0;
-}
-
-.panic {
-    color: #ff6666;
-}
-
-.input-line-prefix {
-    color: var(--cyan);
-}
-
-.color-red {
-    color: #ff6666;
-}
-
-.color-green {
-    color: var(--green);
-}
-
-.color-yellow {
-    color: var(--orange);
-}
-
-.color-blue {
-    color: var(--cyan);
-}
-
-.color-magenta {
-    color: var(--primary-1);
-}
-
-.color-cyan {
-    color: var(--cyan);
-}
-
-.color-white {
-    /* Really this isn't white so much as "default text color." For the repl, this should be black
-    in a light color scheme, and only white in dark mode. The name could be better! */
-    color: black;
-}
-
-@media (prefers-color-scheme: dark) {
-    .color-white {
-        color: white;
-    }
-}
-
-.bold {
-    font-weight: bold;
-}
-
-.underline {
-    text-decoration: underline;
-}
-
-/* Mobile-friendly screen width */
-@media only screen and (max-width: 767px) {
-    #repl {
-        margin: 0;
-        padding: 0;
-        min-height: calc(100vh - var(--top-bar-height));
-    }
-
-    code.history {
-        flex-grow: 1;
-    }
-
-    #source-input {
-        margin: 0;
-    }
-
-    #loading-message {
-        margin: 0;
-    }
-
-    #homepage-repl-container {
-        flex-direction: column;
-    }
-
-    #homepage-repl-container #repl-description {
-        padding: 0;
-        margin-bottom: 1.5em;
-    }
-
-    #repl-arrow {
-        display: none;
-    }
-}
-
-
-/* Homepage */
-
-/* The repl won't work at all if you have JS disabled. */
-.no-js #try-roc {
-    display: none !important;
-}
-
-#homepage-repl-container {
-    display: flex;
-    flex-direction: row-reverse;
-}
-
-#homepage-repl-container #repl-description {
-    padding: 0 30px;
-    margin-top: 2px;
-    flex: 1;
-}
-
-#homepage-repl-container #repl-description a {
-    color: inherit;
-    text-decoration: underline;
-}
-
-#homepage-repl-container #repl-description a:hover {
-    color: var(--primary-1);
-}
-
-#homepage-repl-container #repl {
-    flex: 1;
-    border: 2px solid #444;
-    font-size: var(--font-size-normal);
-    min-height: 0; /* On /repl on mobile, this expands to fill the screen, which we don't want */
-    margin-right: 6px;
-    max-width: 50%;
-}
-
-#homepage-repl-container #repl,
-#homepage-repl-container #repl code,
-#homepage-repl-container #source-input {
-    color: white;
-    background-color: var(--dark-code-bg);
-}
-
-#homepage-repl-container #source-input {
-    margin-bottom: 0;
-    margin-top: 6px;
-    font-size: var(--font-size-normal);
-    height: 57px;
-}
-
-#homepage-repl-container p {
-    position: relative; /* Needed for the repl arrow's position: absolute */
-}
-
-#homepage-repl-container #repl-arrow {
-    cursor: default;
-    font-weight: bold;
-    font-size: 48px;
-    position: absolute;
-    top: -9px;
-    left: -79px;
-    text-shadow: 1px 1px 1px #444;
-    z-index: 3;
-    fill: var(--primary-1);
-}
-
-.repl-err {
-    color: var(--magenta);
-}
-
-/* Tables */
-
-table {
-    border-collapse: collapse;
-    overflow-x: auto;
-    border: 2px solid #f0f0f0;
-    margin-bottom: 1rem;
-}
-
-thead {
-    border: none;
-}
-
-tbody {
-    border: none;
-}
-
-tr {
-    border: none;
-    border-top: 2px solid #f0f0f0;
-}
-
-th,
-td {
-    border: none;
-    border-right: 2px solid #f0f0f0;
-    padding: 12px;
-}
-
-th:last-child,
-td:last-child {
-    border-right: none;
-}
-
-p,
-aside,
-li {
-    font-size: var(--font-size-normal);
-    line-height: 1.85rem;
-}
-
-/* Homepage */
-#homepage-intro-outer {
-    margin: 60px auto;
-    text-align: center;
-}
-
-#homepage-intro-box {
-    position: relative;
-    display: inline-block;
-    text-align: left;
-}
-
-#homepage-h1 {
-    color: #222;
-    text-shadow: none;
-    font-family: inherit;
-    font-size: 64px;
-    padding: 0;
-    padding-top: 60px;
-    position: relative;
-    left: -5px;
-}
-
-#homepage-logo {
-    height: 176px;
-    width: auto;
-    position: absolute;
-    left: -200px;
-    top: -100px;
-}
-
-#first-code-sample {
-    margin-top: 60px;
-    line-height: 1.85em;
-    color: #fcf9fd;
-}
-
-#first-code-sample .kw,
-#first-code-sample .punctuation,
-.interactive-example .kw,
-.interactive-example .punctuation {
-    color: #9c7cea;
-}
-
-#first-code-sample,
-#first-code-sample .code-snippet {
-    background-color: var(--dark-code-bg);
-}
-
-#homepage-tagline {
-    font-size: 20px;
-}
-
-.nowrap {
-    white-space: nowrap;
-}
-
-/* Mobile-friendly screen width */
-@media only screen and (max-width: 1023px) {
-    :root {
-        --font-size-normal: 16px;
-        --body-max-width: none;
-    }
-
-    #tutorial-main main {
-        max-width: none;
-    }
-
-    #homepage-logo {
-        /* The bird runs off the screen unless we shrink it */
-        height: 80px;
-        width: auto;
-        position: absolute;
-        left: 227px;
-        top: -28px;
-    }
-
-    #homepage-main #nav-home-link {
-        display: none;
-    }
-
-    #sponsor-logos {
-        padding: 4px;
-    }
-
-    .home-examples-column {
-        padding-right: 0 !important;
-        border-right: none !important;
-    }
-
-    /* Used for e.g. displaying the instruction "Click" on desktop and "Touch" on mobile. */
-    .desktop {
-        display: none;
-    }
-
-    .mobile {
-        display: inline;
-    }
-
-    .close-desc {
-        display: block !important;
-    }
-
-    h2 {
-        margin-top: 48px;
-        padding: 12px 0;
-    }
-
-    .home-link-text {
-        display: none; /* Don't show "Roc" in the header next to the logo, to save space */
-    }
-
-    h1 code,
-    h2 code,
-    h3 code,
-    h4 code,
-    h5 code {
-        font-size: inherit;
-    }
-
-    code {
-        white-space: normal;
-    }
-
-    /* Homepage */
-
-    #homepage-intro-box {
-        margin: 30px auto;
-    }
-
-    #homepage-tagline {
-        margin-top: 0;
-    }
-
-    #homepage-h1 {
-        /* TODO remove !important from repl.css (increasing specificity instead), and then this one too. */
-        font-size: 48px !important;
-        padding: 0;
-        margin: 0;
-        text-align: left;
-    }
-
-    #first-code-sample {
-        margin: 64px auto;
-        margin-bottom: 0;
-    }
-
-    #homepage-tagline {
-        font-size: 16px;
-    }
-
-    .home-goals-container,
-    .home-examples-container {
-        /* It's unclear why this !important is necessary, since its specificity
-         should theoretically be higher than what it's overriding. In practice,
-         at least in Chrome, removing the !important breaks this. */
-        display: grid !important;
-        grid-template-columns: 1fr;
-    }
-
-    h1,
-    h2,
-    h3,
-    h4,
-    h5,
-    h6,
-    p,
-    code {
-        word-break: break-word !important;
-    }
-
-    h1,
-    h2,
-    h3,
-    h4,
-    h5 {
-        line-height: 1.2em !important;
-        font-size: 2rem !important;
-        width: auto;
-    }
-
-    #top-bar-links {
-        width: 100%;
-        display: grid;
-        grid-template-columns: 1fr 1fr 1fr; /* Three equal-width columns */
-        grid-template-rows: auto auto; /* Two rows */
-    }
-
-    /* Left-align the first link in each row, right-align the last one, and center the middle one. */
-    #top-bar-links > :nth-child(3n+1) {
-        text-align: left;
-    }
-
-    #top-bar-links > :nth-child(3n+2) {
-        text-align: center;
-    }
-
-    #top-bar-links > :nth-child(3n+3) {
-        text-align: right;
-    }
-
-    #top-bar-links a,
-    #top-bar-links label {
-        font-size: 1.2rem;
-        padding: 12px 0.5rem;
-        margin: 0;
-    }
-
-    #homepage-repl-container #repl {
-        max-width: none;
-    }
-}
-
-/* iPhone SE and similar */
-@media only screen and (max-width: 320px) {
-    #homepage-logo {
-        /* The bird runs off the screen unless we shrink it */
-        left: 188px;
-        top: -30px;
-    }
-
-    :root {
-        --font-size-normal: 14px;
-        --body-max-width: 320px;
-    }
-}
-
-
-@font-face {
-    font-family: "Permanent Marker";
-    font-style: normal;
-    font-weight: 400;
-    font-display: swap;
-    src: url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2") format("woff2"),
-        url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff") format("woff");
-    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
-        U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212,
-        U+2215, U+FEFF, U+FFFD;
-}
-
-/* latin-ext */
-@font-face {
-    font-family: "Lato";
-    font-style: normal;
-    font-weight: 400;
-    font-display: swap;
-    src: url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff2")
-            format("woff2"),
-        url("/fonts/lato-v23-latin-ext_latin/lato-v23-latin-ext_latin-regular.woff")
-            format("woff");
-    unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB,
-        U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
-}
-
-/* latin */
-@font-face {
-    font-family: "Lato";
-    font-style: normal;
-    font-weight: 400;
-    font-display: swap;
-    src: url("/fonts/lato-v23-latin/lato-v23-latin-regular.woff2")
-            format("woff2"),
-        url("/fonts/lato-v23-latin/lato-v23-latin-regular.woff") format("woff");
-    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
-        U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212,
-        U+2215, U+FEFF, U+FFFD;
-}
-
-/* latin-ext */
-@font-face {
-    font-family: "Source Code Pro";
-    font-style: normal;
-    font-weight: 400;
-    font-display: swap;
-    src: url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff2")
-            format("woff2"),
-        url("/fonts/source-code-pro-v22-latin-ext_latin/source-code-pro-v22-latin-ext_latin-regular.woff")
-            format("woff");
-    unicode-range: U+0100-024F, U+0259, U+1E00-1EFF, U+2020, U+20A0-20AB,
-        U+20AD-20CF, U+2113, U+2C60-2C7F, U+A720-A7FF;
-}
-
-/* latin */
-@font-face {
-    font-family: "Source Code Pro";
-    font-style: normal;
-    font-weight: 400;
-    font-display: swap;
-    src: url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff2")
-            format("woff2"),
-        url("/fonts/source-code-pro-v22-latin/source-code-pro-v22-latin-regular.woff")
-            format("woff");
-    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
-        U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212,
-        U+2215, U+FEFF, U+FFFD;
-}
-
-@media (prefers-color-scheme: dark) {
-    :root {
-        /* WCAG AAA Compliant colors */
-        --code-bg: #202746;
-        --gray-bg: #202746;
-        --gray: #b6b6b6;
-        --orange: #fd6e08;
-        --green: #8ecc88;
-        --cyan: #12c9be;
-        --blue: #b1afdf;
-        --violet-bg: #332944;
-        --magenta: #f39bac;
-
-        --primary-1: #9c7cea;
-        --primary-2: #1bd6bd;
-        --text-color: #ccc;
-        --body-bg-color: #151517;
-        --border-color: var(--gray);
-        --code-color: #eeeeee;
-        --logo-solid: #8f8f8f;
-        --faded-color: #bbbbbb;
-        --gray: #6e6e6e;
-        --heading-color: #eee;
-
-        /* Tutorial */
-        --header-link-color: #9C7CEA;
-        --header-link-hover: #ddd;
-        --h1-color: #1bc6bd;
-    }
-
-    .logo-dark {
-        fill: #6c3bdc;
-    }
-
-    .logo-light {
-        fill: #8a66de;
-    }
-
-    .svg-text {
-        fill: #fff;
-    }
-
-    #homepage-h1 {
-        color: #fcf9fd;
-    }
-
-    h3 {
-        color: #fff;
-    }
-
-    h1,
-    h2,
-    h3,
-    h4,
-    h5 {
-        text-shadow: none;
-    }
-
-    html {
-        scrollbar-color: #444444 #2f2f2f;
-    }
-
-    table,
-    tr,
-    th,
-    td {
-        border-color: var(--gray);
-    }
-
-    #first-code-sample,
-    #homepage-repl-container #repl {
-        border: 1px solid #ddd;
-    }
-
-    .home-goals-content:hover {
-        background-color: #481870 !important;
-    }
-}
-
-/* Comments `#` and Documentation comments `##` */
-samp .comment,
-code .comment {
-    color: #ccc;
-}
-
-/* Number, String, Tag literals */
-samp .storage.type,
-code .storage.type,
-samp .string,
-code .string,
-samp .string.begin,
-code .string.begin,
-samp .string.end,
-code .string.end,
-samp .constant,
-code .constant,
-samp .literal,
-code .literal {
-    color: var(--dark-cyan);
-}
-
-/* Keywords and punctuation */
-samp .keyword,
-code .keyword,
-samp .punctuation.section,
-code .punctuation.section,
-samp .punctuation.separator,
-code .punctuation.separator,
-samp .punctuation.terminator,
-code .punctuation.terminator,
-samp .kw,
-code .kw {
-    color: var(--primary-1);
-}
-
-/* Operators */
-samp .op,
-code .op,
-samp .keyword.operator,
-code .keyword.operator {
-    color: var(--primary-1);
-}
-
-/* Delimieters */
-samp .delimeter,
-code .delimeter {
-    color: var(--primary-1);
-}
-
-/* Variables modules and field names */
-samp .function,
-code .function,
-samp .meta.group,
-code .meta.group,
-samp .meta.block,
-code .meta.block,
-samp .lowerident,
-code .lowerident {
-    color: white;
-}
-
-samp .error,
-code .error {
-    color: hsl(0, 96%, 67%);
-}
-
-/* Types, Tags, and Modules */
-samp .type,
-code .type,
-samp .meta.path,
-code .meta.path,
-samp .upperident,
-code .upperident {
-    color: var(--dark-cyan);
-}
-
-samp .dim,
-code .dim {
-    opacity: 0.55;
-}
-
-.button-container {
-    position: absolute;
-    top: 0;
-    right: 0;
-}
-
-.copy-button {
-    background: var(--dark-code-bg);
-    border: 1px solid var(--dark-cyan);
-    color: var(--dark-cyan);
-    display: inline-block;
-    cursor: pointer;
-    margin: 8px;
-}
-
-.copy-button:hover {
-    border-color: var(--code-color);
-    color: var(--code-color);
-}
-
-.roc-logo {
-    width: 40px;
-    height: 40px;
-    margin: 0 auto;
-    fill: var(--primary-1);
-    text-shadow: 1px 1px 1px #010101;
-    position: relative;
-    top: -2px;
-}
-
-/* HOME GOALS */
-
-.home-goals-container {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-    gap: 45px;
-    width: 100%;
-}
-
-.home-goals-column {
-    display: flex;
-    flex-direction: column;
-    flex: 1;
-    width: 100%;
-}
-
-.home-goals-content {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    padding: 20px;
-    border: 4px solid var(--light-cyan);
-    color: inherit;
-    cursor: pointer;
-}
-
-.home-goals-content:hover {
-    text-decoration: none;
-    cursor: pointer;
-    background-color: var(--light-cyan);
-}
-
-.home-goals-learn-more {
-    text-decoration: underline;
-}
-
-.home-examples-container {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-    gap: 24px;
-    width: 100%;
-}
-
-.home-examples-column {
-    display: flex;
-    flex-direction: column;
-    flex: 1;
-    width: 100%;
-}
-
-.home-examples-column:not(:last-of-type) {
-    padding-right: 24px;
-    border-right: 2px solid var(--primary-1);
-}
-
-/* Wider screens */
-@media only screen and (min-width: 768px) {
-    .home-goals-column {
-        margin-bottom: 0;
-    }
-
-    .home-goals-column:last-child {
-        margin-right: 0;
-    }
-}
-
-.home-goals-learn-more {
-    margin-top: auto;
-    white-space: nowrap;
-}
-
-.home-goals-title {
-    padding: 0;
-    font-weight: bold;
-    margin-bottom: 10px;
-    font-size: 32px;
-    border-bottom: none;
-    font-family: inherit;
-    text-transform: lowercase;
-    padding-bottom: 42px;
-    padding-top: 2px;
-    font-style: italic;
-    letter-spacing: 1px;
-    word-spacing: 3px;
-    margin: 0;
-    color: var(--text-color);
-}
-
-.home-goals-description {
-    line-height: 1.5;
-    margin-bottom: 2em;
-}
-
-/* Interactive example on homepage */
-
-.interactive-example {
-    font-size: var(--font-size-normal);
-}
-
-.interactive-example,
-.interactive-example samp {
-    background-color: #202746;
-    color: white;
-}
-
-.interactive-example samp {
-    position: relative;
-    display: block;
-    width: 100%;
-    height: 580px;
-    padding-right: 300px;
-    cursor: default;
-}
-
-.interactive-example label:hover,
-.interactive-radio:checked + label {
-    background-color: #000;
-    cursor: pointer;
-}
-
-.interactive-desc {
-    display: none;
-    position: absolute;
-    top: 0;
-    right: 300px;
-    width: 300px;
-    background-color: #ede6ff;
-    border: 1px solid black;
-    color: black;
-    padding: 0 16px;
-    padding-top: 12px;
-    margin-top: 9px;
-    cursor: text;
-    white-space: normal;
-    font-family: -apple-system, BlinkMacSystemFont, Roboto, Helvetica, Arial;
-}
-
-.interactive-desc a {
-    color: #7c38f5;
-}
-
-.interactive-radio {
-    display: none;
-}
-
-.interactive-radio:checked + label + .interactive-desc {
-    display: block;
-}
-
-.close-desc {
-    display: none;
-    position: absolute;
-    height: 40px;
-    width: 40px;
-    font-size: 24px;
-    top: -12px;
-    right: -12px;
-    color: #fff;
-    background: #9b6bf2;
-    border: 2px solid #7c38f5;
-    border-radius: 100%;
-    z-index: 4;
-}
-
-.close-desc:hover {
-    color: #222;
-    background: var(--light-cyan);
-    border-color: var(--light-cyan);
-}
-
-/* Tutorial */
-
-#tutorial-main main {
-    display: flex;
-    flex-direction: row-reverse;
-    max-width: 1024px;
-}
-
-#tutorial-main h1,
-#tutorial-main h2,
-#tutorial-main h3,
-#tutorial-main h4,
-#tutorial-main h5 {
-    font-family: "Permanent Marker";
-    line-height: 1rem;
-    margin-top: 1.75rem;
-    margin-bottom: 0;
-    border: none;
-}
-
-#tutorial-main h1 a,
-#tutorial-main h2 a,
-#tutorial-main h3 a,
-#tutorial-main h4 a,
-#tutorial-main h5 a {
-    color: var(--header-link-color);
-}
-
-#tutorial-main h1 a:hover,
-#tutorial-main h2 a:hover,
-#tutorial-main h3 a:hover,
-#tutorial-main h4 a:hover,
-#tutorial-main h5 a:hover {
-    text-decoration: none;
-    color: var(--header-link-hover);
-}
-
-#tutorial-main h1 {
-    font-size: 7rem;
-    line-height: 7rem;
-    color: var(--h1-color);
-    margin-top: 24px;
-    margin-bottom: 1.75rem;
-    text-shadow: 1px 1px 1px #010101;
-}
-
-#tutorial-main h2 {
-    font-size: 4rem;
-    line-height: 4rem;
-    text-shadow: 1px 1px 1px #010101;
-    padding: 0.8rem 0;
-    margin-top: 2.5rem;
-    width: 60rem; /* Without this, "Building an application" wraps and looks awkward */
-}
-
-#tutorial-main h3 {
-    font-size: 3rem;
-    line-height: 3rem;
-    text-shadow: 1px 1px 1px #010101;
-    margin-bottom: 0.5rem;
-}
-
-#tutorial-main h4 {
-    font-size: 2rem;
-    text-shadow: 1px 1px 1px #010101;
-}
-
-#tutorial-body, #tutorial-body pre {
-    max-width: 646px;
-}
-
-#tutorial-toc {
-    background-color: var(--gray-bg);
-    flex: 0 0 auto; /* Take up as much space as it needs */
-    margin-top: 30px;
-    background: var(--code-bg);
-    padding: 12px 24px;
-    margin-left: 64px;
-    align-self: flex-start; /* Aligns to the start, not stretching in height */
-}
-
-#tutorial-toc > ul {
-    display: flex;
-    flex-wrap: wrap;
-    list-style-type: none;
-    padding: 16px 16px;
-    margin: 0px;
-}
-
-#tutorial-toc > ul > li {
-    flex: 1 1 50%; /* Adjust the percentage to control how many items per row */
-    margin-bottom: 0; /* Reset the margin as they are now side by side */
-    white-space: nowrap;
-    overflow: hidden; /* Ensures content doesn't overflow its container */
-    text-overflow: ellipsis; /* Adds an ellipsis if the content overflows */
-}
-
-#tutorial-toc code {
-    background: none;
-    color: inherit;
-    margin: 0;
-    padding: 0;
-}
-
-#tutorial-toc ol {
-    padding: 3px;
-    margin: 8px 0;
-    list-style: none;
-    padding-bottom: 0;
-    margin-bottom: 0;
-}
-
-#tutorial-toc h2 {
-    font-family: inherit;
-    font-size: 2em;
-    text-shadow: none;
-    margin: 0;
-    padding: 16px 0;
-}
-
-#toc-search {
-    background-color: var(--toc-search-bg);
-    border: 1px solid var(--toc-search-border);
-    color: inherit;
-    padding: 6px 8px;
-    margin-top: 16px;
-    margin-bottom: 4px;
-    box-sizing: border-box;
-    width: 100%;
-    font-size: inherit;
-}
-
-#tutorial-toc-toggle,
-#tutorial-toc-toggle-label,
-#close-tutorial-toc {
-    display: none;
-    /* This may be overridden on mobile-friendly screen widths */
-}
-
-#tutorial-toc-toggle,
-#tutorial-toc-toggle-label {
-    font-size: 1.1rem;
-    float: right;
-}
-
-#close-tutorial-toc {
-    position: absolute;
-    top: 20px;
-    right: 8px;
-    font-size: 18px;
-    padding: 12px 24px;
-}
-
-/* for larger screens */
-@media only screen and (min-width: 768px) {
-    #tutorial-toc > ul > li {
-        flex: 1 1 33%; /* Adjust the percentage to control how many items per row */
-    }
-}
diff --git a/www/wip_new_website/static/site.js b/www/wip_new_website/static/site.js
deleted file mode 100644
index 2553f3c144..0000000000
--- a/www/wip_new_website/static/site.js
+++ /dev/null
@@ -1,515 +0,0 @@
-const isOnMobile = window.innerWidth <= 1024;
-
-// The only way we can provide values to wasm_bindgen's generated code is to set globals
-window.js_create_app = js_create_app;
-window.js_run_app = js_run_app;
-window.js_get_result_and_memory = js_get_result_and_memory;
-
-// The only place we use console.error is in wasm_bindgen, where it gets a single string argument.
-console.error = function displayErrorInHistoryPanel(string) {
-  const html = `
    ${string}
    `;
-  updateHistoryEntry(repl.inputHistoryIndex, false, html);
-};
-
-import * as roc_repl_wasm from "/repl/roc_repl_wasm.js";
-
-const isHomepage = document.getElementById("homepage-repl-container") != null;
-
-const tutorialButtonSvg = ``;
-
-// ----------------------------------------------------------------------------
-// REPL state
-// ----------------------------------------------------------------------------
-
-const repl = {
-  elemHistory: document.getElementById("history-text"),
-  elemSourceInput: document.getElementById("source-input"),
-  description: document.getElementById("repl-description"),
-
-  inputQueue: [],
-  inputHistory: [],
-  inputHistoryIndex: 0,
-  inputStash: "", // stash the user input while we're toggling through history with up/down arrows
-
-  // Current progress through the repl tutorial
-  tutorialStep: 0,
-  tutorialSteps: [
-    {
-      match: (input) => input.replace(/ /g, "") === "0.1+0.2",
-      show: '
    Was this the answer you expected? (If so, try this in other programming languages and see what their answers are.)
    Roc has a decimal type as well as floating-point for when performance is more important than decimal precision.
    Next, enter name = "(put your name here)"
    ',
-    },
-    {
-      match: (input) => input.replace(/ /g, "").match(/^name="/i),
-      show: '
    This created a new definition—name is now defined to be equal to the string you entered.
    Try using this definition by entering "Hi, \\(name)!"
    ',
-    },
-    {
-      match: (input) => input.match(/^["][^\\]+\\\(name\)/i),
-      show: `
    Nicely done! This is an example of string interpolation, which replaces part of a string with whatever you put inside the parentheses after a \\.
    Now that you've written a few expressions, you can either continue exploring in this REPL, or move on to the tutorial to learn how to make full programs.
    Welcome to Roc! ${tutorialButtonSvg} Start Tutorial
    `,
-    },
-  ],
-
-  textDecoder: new TextDecoder(),
-  textEncoder: new TextEncoder(),
-
-  compiler: null,
-  app: null,
-
-  // Temporary storage for the address of the result of running the user's code.
-  // Used while control flow returns to Rust to allocate space to copy the app's memory buffer.
-  result_addr: 0,
-};
-
-// Initialise
-repl.elemSourceInput.value = ""; // Some browsers remember the input across refreshes
-resetSourceInputHeight();
-repl.elemSourceInput.addEventListener("input", resetSourceInputHeight);
-repl.elemSourceInput.addEventListener("keydown", onInputKeydown);
-repl.elemSourceInput.addEventListener("keyup", onInputKeyup);
-roc_repl_wasm.default("/repl/roc_repl_wasm_bg.wasm").then(async (instance) => {
-  const loadingMessage = repl.elemHistory.querySelector("#loading-message");
-
-  if (loadingMessage != null) {
-    loadingMessage.remove();
-  }
-
-  repl.elemSourceInput.placeholder = "Enter some Roc code here.";
-  repl.compiler = instance;
-
-  // Get help text from the compiler, and display it at top of the history panel
-  try {
-    const helpText = await roc_repl_wasm.entrypoint_from_js(":help");
-    const helpElem = document.getElementById("help-text");
-
-    if (helpElem != null) {
-      helpElem.innerHTML = helpText.trim();
-    }
-  } catch (e) {
-    // Print error for Roc devs. Don't use console.error, we overrode that above to display on the page!
-    console.warn(e);
-  }
-});
-
-// Focus the repl input the first time it scrolls into view
-// (but not on mobile, because that would pop up the whole keyboard abruptly)
-if (!isOnMobile) {
-  // Function to be called when the input enters the viewport
-  function handleIntersect(entries, observer) {
-    entries.forEach((entry) => {
-      // Check if the input is intersecting
-      if (entry.isIntersecting) {
-        // Apply focus to it, then unobserve it because we only want to do this once.
-        entry.target.focus();
-        observer.unobserve(entry.target);
-      }
-    });
-  }
-
-  // Set up the Intersection Observer
-  let observer = new IntersectionObserver(handleIntersect, {
-    // Use the whole viewport for the intersection
-    root: null,
-    // Trigger the callback when the input is fully visible
-    threshold: 1.0,
-  });
-
-  observer.observe(repl.elemSourceInput);
-}
-
-// ----------------------------------------------------------------------------
-// Handle inputs
-// ----------------------------------------------------------------------------
-
-function resetSourceInputHeight() {
-  repl.elemSourceInput.style.height =
-    repl.elemSourceInput.scrollHeight + 2 + "px"; // +2 for the border
-}
-
-function onInputKeydown(event) {
-  const ENTER = 13;
-
-  const { keyCode } = event;
-
-  if (keyCode === ENTER) {
-    if (!event.shiftKey && !event.ctrlKey && !event.altKey) {
-      // Don't advance the caret to the next line
-      event.preventDefault();
-
-      const inputText = repl.elemSourceInput.value.trim();
-
-      repl.elemSourceInput.value = "";
-      repl.elemSourceInput.style.height = "";
-
-      repl.inputQueue.push(inputText);
-      if (repl.inputQueue.length === 1) {
-        processInputQueue();
-      }
-
-      // Hide the arrow on the homepage that prompts you to enter something
-      const replArrow = document.getElementById("repl-arrow");
-
-      if (replArrow != null) {
-        replArrow.style.display = "none";
-      }
-    }
-  }
-}
-
-function onInputKeyup(event) {
-  const UP = 38;
-  const DOWN = 40;
-
-  const { keyCode } = event;
-
-  const el = repl.elemSourceInput;
-
-  switch (keyCode) {
-    case UP:
-      if (repl.inputHistory.length === 0) {
-        return;
-      }
-      if (repl.inputHistoryIndex == repl.inputHistory.length - 1) {
-        repl.inputStash = el.value;
-      }
-      setInput(repl.inputHistory[repl.inputHistoryIndex]);
-
-      if (repl.inputHistoryIndex > 0) {
-        repl.inputHistoryIndex--;
-      }
-      break;
-
-    case DOWN:
-      if (repl.inputHistory.length === 0) {
-        return;
-      }
-      if (repl.inputHistoryIndex === repl.inputHistory.length - 1) {
-        setInput(repl.inputStash);
-      } else {
-        repl.inputHistoryIndex++;
-        setInput(repl.inputHistory[repl.inputHistoryIndex]);
-      }
-      break;
-
-    default:
-      break;
-  }
-}
-
-function setInput(value) {
-  const el = repl.elemSourceInput;
-  el.value = value;
-  el.selectionStart = value.length;
-  el.selectionEnd = value.length;
-}
-
-function showNextReplTutorialEntry(inputText) {
-  const nextStep = repl.tutorialSteps[repl.tutorialStep];
-
-  if (typeof nextStep === "object" && nextStep.match(inputText)) {
-    repl.description.innerHTML =
-      repl.description.innerHTML + "
    " + nextStep.show;
-
-    repl.tutorialStep = repl.tutorialStep + 1;
-  }
-}
-
-// Use a queue just in case we somehow get inputs very fast
-// We want the REPL to only process one at a time, since we're using some global state.
-// In normal usage we shouldn't see this edge case anyway. Maybe with copy/paste?
-async function processInputQueue() {
-  while (repl.inputQueue.length) {
-    const inputText = repl.inputQueue[0];
-
-    if (inputText) {
-      repl.inputHistoryIndex = createHistoryEntry(inputText);
-      repl.inputStash = "";
-
-      let outputText = "";
-      let ok = true;
-      try {
-        outputText = await roc_repl_wasm.entrypoint_from_js(inputText);
-      } catch (e) {
-        outputText = `${e}`;
-        ok = false;
-      }
-
-      updateHistoryEntry(repl.inputHistoryIndex, ok, outputText);
-      showNextReplTutorialEntry(inputText);
-    }
-
-    repl.inputQueue.shift();
-  }
-}
-
-// ----------------------------------------------------------------------------
-// Callbacks to JS from Rust
-// ----------------------------------------------------------------------------
-
-var ROC_PANIC_INFO = null;
-
-function send_panic_msg_to_js(rocstr_ptr, panic_tag) {
-  const { memory } = repl.app.exports;
-
-  const rocStrBytes = new Int8Array(memory.buffer, rocstr_ptr, 12);
-  const finalByte = rocStrBytes[11];
-
-  let stringBytes = "";
-  if (finalByte < 0) {
-    // small string
-
-    // bitwise ops on negative JS numbers are weird. This clears the bit that we
-    // use to indicate a small string. In rust it's `finalByte as u8 ^ 0b1000_0000`
-    const length = finalByte + 128;
-    stringBytes = new Uint8Array(memory.buffer, rocstr_ptr, length);
-  } else {
-    // big string
-    const rocStrWords = new Uint32Array(memory.buffer, rocstr_ptr, 3);
-    const [ptr, len, _cap] = rocStrWords;
-
-    const SEAMLESS_SLICE_BIT = 1 << 31;
-    const length = len & ~SEAMLESS_SLICE_BIT;
-
-    stringBytes = new Uint8Array(memory.buffer, ptr, length);
-  }
-
-  const decodedString = repl.textDecoder.decode(stringBytes);
-
-  ROC_PANIC_INFO = {
-    msg: decodedString,
-    panic_tag: panic_tag,
-  };
-}
-
-// Load Wasm code into the browser's virtual machine, so we can run it later.
-// This operation is async, so we call it before entering any code shared
-// with the command-line REPL, which is sync.
-async function js_create_app(wasm_module_bytes) {
-  const { instance } = await WebAssembly.instantiate(wasm_module_bytes, {
-    env: {
-      send_panic_msg_to_js: send_panic_msg_to_js,
-    },
-  });
-
-  // Keep the instance alive so we can run it later from shared REPL code
-  repl.app = instance;
-}
-
-// Call the `main` function of the user app, via the `wrapper` function.
-function js_run_app() {
-  const { wrapper, memory } = repl.app.exports;
-
-  // Run the user code, and remember the result address
-  // We'll pass it to Rust in the next callback
-  try {
-    repl.result_addr = wrapper();
-  } catch (e) {
-    // an exception could be that roc_panic was invoked,
-    // or some other crash (likely a compiler bug)
-    if (ROC_PANIC_INFO === null) {
-      throw e;
-    } else {
-      // when roc_panic set an error message, display it
-      const { msg, panic_tag } = ROC_PANIC_INFO;
-      ROC_PANIC_INFO = null;
-
-      console.error(format_roc_panic_message(msg, panic_tag));
-    }
-  }
-
-  // Tell Rust how much space to reserve for its copy of the app's memory buffer.
-  // We couldn't know that size until we actually ran the app.
-  return memory.buffer.byteLength;
-}
-
-function format_roc_panic_message(msg, panic_tag) {
-  switch (panic_tag) {
-    case 0: {
-      return `Roc failed with message: "${msg}"`;
-    }
-    case 1: {
-      return `User crash with message: "${msg}"`;
-    }
-    default: {
-      return `Got an invalid panic tag: "${panic_tag}"`;
-    }
-  }
-}
-
-// After Rust has allocated space for the app's memory buffer,
-// we copy it, and return the result address too
-function js_get_result_and_memory(buffer_alloc_addr) {
-  const appMemory = new Uint8Array(repl.app.exports.memory.buffer);
-  const compilerMemory = new Uint8Array(repl.compiler.memory.buffer);
-  compilerMemory.set(appMemory, buffer_alloc_addr);
-  return repl.result_addr;
-}
-
-// ----------------------------------------------------------------------------
-// Rendering
-// ----------------------------------------------------------------------------
-
-function createHistoryEntry(inputText) {
-  const historyIndex = repl.inputHistory.length;
-  repl.inputHistory.push(inputText);
-
-  const firstLinePrefix = '» ';
-  const otherLinePrefix = '
    … ';
-  const inputLines = inputText.split("\n");
-  if (inputLines[inputLines.length - 1] === "") {
-    inputLines.pop();
-  }
-  const inputWithPrefixes = firstLinePrefix + inputLines.join(otherLinePrefix);
-
-  const inputElem = document.createElement("div");
-  inputElem.innerHTML = inputWithPrefixes;
-  inputElem.classList.add("input");
-
-  const historyItem = document.createElement("div");
-  historyItem.appendChild(inputElem);
-  historyItem.classList.add("history-item");
-
-  repl.elemHistory.appendChild(historyItem);
-
-  return historyIndex;
-}
-
-function updateHistoryEntry(index, ok, outputText) {
-  const outputElem = document.createElement("div");
-  outputElem.innerHTML = outputText;
-  outputElem.classList.add("output", ok ? "output-ok" : "output-error");
-
-  const historyItem = repl.elemHistory.children[index];
-  historyItem.appendChild(outputElem);
-
-  if (isHomepage) {
-    // Scroll the input element into view so you can see the most recent output.
-    // Only do this if it's currently out of view though!
-    const bounds = repl.elemSourceInput.getBoundingClientRect();
-    const isInView =
-      bounds.top >= 0 &&
-      bounds.left >= 0 &&
-      bounds.bottom <=
-        (window.innerHeight || document.documentElement.clientHeight) &&
-      bounds.right <=
-        (window.innerWidth || document.documentElement.clientWidth);
-
-    if (!isInView) {
-      repl.elemSourceInput.scrollIntoView({
-        behavior: "instant",
-        block: "end",
-        inline: "nearest",
-      });
-    }
-  } else {
-    // Scroll the page to the bottom so you can see the most recent output.
-    window.scrollTo(0, document.body.scrollHeight);
-  }
-}
-
-// TUTORIAL //
-
-const tutorialTocToggle = document.querySelector("#tutorial-toc-toggle");
-
-if (tutorialTocToggle != null) {
-  document.querySelectorAll("#tutorial-toc li a").forEach((elem) => {
-    // Clicking any of the ToC links closes the ToC
-    elem.addEventListener("click", (event) => {
-      tutorialTocToggle.checked = false;
-    });
-  });
-
-  document.addEventListener("keydown", (event) => {
-    // Escape closes the ToC
-    if (event.key == "Escape") {
-      tutorialTocToggle.checked = false;
-    }
-  });
-
-  const isTouchSupported = () => {
-    try {
-      document.createEvent("TouchEvent");
-      return true;
-    } catch (e) {
-      return false;
-    }
-  };
-
-  // Select all  elements that are children of 
     elements
-  const codeBlocks = document.querySelectorAll("pre > samp");
-
-  // Iterate over each code block
-  codeBlocks.forEach((codeBlock) => {
-    // Create a "Copy" button
-    const copyButton = document.createElement("button");
-    copyButton.classList.add("copy-button");
-    copyButton.textContent = "Copy";
-
-    // Add event listener to copy button
-    copyButton.addEventListener("click", () => {
-      const codeText = codeBlock.innerText;
-      navigator.clipboard.writeText(codeText);
-      copyButton.textContent = "Copied!";
-      copyButton.classList.add("copy-button-copied");
-      copyButton.addEventListener("mouseleave", () => {
-        copyButton.textContent = "Copy";
-        copyButton.classList.remove("copy-button-copied");
-      });
-    });
-
-    // Create a container for the copy button and append it to the document
-    const buttonContainer = document.createElement("div");
-    buttonContainer.classList.add("button-container");
-    buttonContainer.appendChild(copyButton);
-    codeBlock.parentNode.insertBefore(buttonContainer, codeBlock);
-
-    // Hide the button container by default
-    buttonContainer.style.display = "none";
-
-    if (isTouchSupported()) {
-      // Show the button container on click for touch support (e.g. mobile)
-      document.addEventListener("click", (event) => {
-        if (event.target.closest("pre > samp") !== codeBlock) {
-          buttonContainer.style.display = "none";
-        } else {
-          buttonContainer.style.display = "block";
-        }
-      });
-    } else {
-      // Show the button container on hover for non-touch support (e.g. desktop)
-      codeBlock.parentNode.addEventListener("mouseenter", () => {
-        buttonContainer.style.display = "block";
-      });
-
-      codeBlock.parentNode.addEventListener("mouseleave", () => {
-        buttonContainer.style.display = "none";
-      });
-    }
-  });
-}
-
-// HOMEPAGE //
-
-if (isOnMobile) {
-  const hideDesc = () => {
-    document.querySelectorAll(".interactive-radio").forEach((radio) => {
-      radio.checked = false;
-    });
-  };
-
-  hideDesc(); // On mobile, start out with all the descriptions hidden.
-
-  document.querySelectorAll(".interactive-example").forEach((example) => {
-    example.querySelectorAll("label").forEach((label) => {
-      label.addEventListener("click", (event) => {
-        const desc = label.nextSibling; // The description node always comes next
-
-        // Set the position of the target element
-        desc.style.top = label.offsetTop + label.offsetHeight + "px"; // Position below the button
-        desc.style.left = label.offsetLeft + "px"; // Align with the left of the button
-      });
-    });
-
-    example.querySelectorAll(".close-desc").forEach((button) => {
-      button.addEventListener("click", hideDesc);
-    });
-  });
-}

From 9cf46f3fd29a35168d87cab0d6c7d8a467a5f9b3 Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Sun, 19 Nov 2023 00:43:43 -0500
Subject: [PATCH 094/129] Fix sed command on macOS

---
 www/build.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/www/build.sh b/www/build.sh
index 77248c6332..adcda2075c 100755
--- a/www/build.sh
+++ b/www/build.sh
@@ -25,7 +25,7 @@ unzip examples-main.zip
 cp -R examples-main/examples/ content/examples/
 
 # relace links in content/examples/index.md to work on the WIP site
-sed -i '' 's|](/|](/examples/|' content/examples/index.md
+sed -i'' 's|](/|](/examples/|' content/examples/index.md
 
 # clean up examples artifacts
 rm -rf examples-main examples-main.zip

From 9e7598d86c1e1cda8de18f702758aaf2935ae05d Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Sun, 19 Nov 2023 01:05:01 -0500
Subject: [PATCH 095/129] Update site.css to latest

---
 www/public/site.css | 190 ++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 175 insertions(+), 15 deletions(-)

diff --git a/www/public/site.css b/www/public/site.css
index 3e3550e7e6..ba5e7845ee 100644
--- a/www/public/site.css
+++ b/www/public/site.css
@@ -1,5 +1,6 @@
 :root {
     /* WCAG AAA Compliant colors */
+    --code-bg: #f4f8f9;
     --gray-bg: #f4f8f9;
     --gray: #717171;
     --orange: #bf5000;
@@ -33,6 +34,11 @@
     --font-size-normal: 18px;
     --body-max-width: 1024px;
     --dark-code-bg: #202746;
+
+    /* Tutorial */
+    --header-link-color: #107F79;
+    --header-link-hover: #222;
+    --h1-color: #8055E4;
 }
 
 html {
@@ -217,7 +223,7 @@ h2 {
     color: var(--heading-color);
 }
 
-.article-layout main {
+.article-layout main, .article-layout pre {
     max-width: 720px;
 }
 
@@ -360,27 +366,27 @@ pre > code {
     display: none !important;
 }
 
-#repl-container {
+#homepage-repl-container {
     display: flex;
     flex-direction: row-reverse;
 }
 
-#repl-container #repl-description {
+#homepage-repl-container #repl-description {
     padding: 0 30px;
     margin-top: 2px;
     flex: 1;
 }
 
-#repl-container #repl-description a {
+#homepage-repl-container #repl-description a {
     color: inherit;
     text-decoration: underline;
 }
 
-#repl-container #repl-description a:hover {
+#homepage-repl-container #repl-description a:hover {
     color: var(--primary-1);
 }
 
-#repl-container #repl {
+#homepage-repl-container #repl {
     flex: 1;
     border: 2px solid #444;
     font-size: var(--font-size-normal);
@@ -389,24 +395,24 @@ pre > code {
     max-width: 50%;
 }
 
-#repl-container #repl,
-#repl-container #repl code {
+#homepage-repl-container #repl,
+#homepage-repl-container #repl code {
     color: white;
     background-color: var(--dark-code-bg);
 }
 
-#repl-container #source-input {
+#homepage-repl-container #source-input {
     margin-bottom: 0;
     margin-top: 6px;
     font-size: var(--font-size-normal);
     height: 57px;
 }
 
-#repl-container p {
+#homepage-repl-container p {
     position: relative; /* Needed for the repl arrow's position: absolute */
 }
 
-#repl-container #repl-arrow {
+#homepage-repl-container #repl-arrow {
     cursor: default;
     font-weight: bold;
     font-size: 48px;
@@ -527,6 +533,10 @@ li {
         --body-max-width: none;
     }
 
+    #tutorial-main main {
+        max-width: none;
+    }
+
     #homepage-logo {
         /* The bird runs off the screen unless we shrink it */
         height: 80px;
@@ -637,6 +647,7 @@ li {
     h5 {
         line-height: 1.2em !important;
         font-size: 2rem !important;
+        width: auto;
     }
 
     #top-bar-links {
@@ -666,7 +677,7 @@ li {
         margin: 0;
     }
 
-    #repl-container #repl {
+    #homepage-repl-container #repl {
         max-width: none;
     }
 }
@@ -685,6 +696,19 @@ li {
     }
 }
 
+
+@font-face {
+    font-family: "Permanent Marker";
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff2") format("woff2"),
+        url("/fonts/permanent-marker-v16-latin/permanent-marker-v16-latin-regular.woff") format("woff");
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA,
+        U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212,
+        U+2215, U+FEFF, U+FFFD;
+}
+
 /* latin-ext */
 @font-face {
     font-family: "Lato";
@@ -745,7 +769,7 @@ li {
 @media (prefers-color-scheme: dark) {
     :root {
         /* WCAG AAA Compliant colors */
-        /* WCAG AAA Compliant colors */
+        --code-bg: #202746;
         --gray-bg: #202746;
         --gray: #b6b6b6;
         --orange: #fd6e08;
@@ -765,6 +789,11 @@ li {
         --faded-color: #bbbbbb;
         --gray: #6e6e6e;
         --heading-color: #eee;
+
+        /* Tutorial */
+        --header-link-color: #9C7CEA;
+        --header-link-hover: #ddd;
+        --h1-color: #1bc6bd;
     }
 
     .logo-dark {
@@ -807,7 +836,7 @@ li {
     }
 
     #first-code-sample,
-    #repl-container #repl {
+    #homepage-repl-container #repl {
         border: 1px solid #ddd;
     }
 
@@ -1100,10 +1129,85 @@ code .dim {
     border-color: var(--light-cyan);
 }
 
-/* Tutorial Table of Contents */
+/* Tutorial */
+
+#tutorial-main main {
+    display: flex;
+    flex-direction: row-reverse;
+    max-width: 1024px;
+}
+
+#tutorial-main h1,
+#tutorial-main h2,
+#tutorial-main h3,
+#tutorial-main h4,
+#tutorial-main h5 {
+    font-family: "Permanent Marker";
+    line-height: 1rem;
+    margin-top: 1.75rem;
+    margin-bottom: 0;
+    border: none;
+}
+
+#tutorial-main h1 a,
+#tutorial-main h2 a,
+#tutorial-main h3 a,
+#tutorial-main h4 a,
+#tutorial-main h5 a {
+    color: var(--header-link-color);
+}
+
+#tutorial-main h1 a:hover,
+#tutorial-main h2 a:hover,
+#tutorial-main h3 a:hover,
+#tutorial-main h4 a:hover,
+#tutorial-main h5 a:hover {
+    text-decoration: none;
+    color: var(--header-link-hover);
+}
+
+#tutorial-main h1 {
+    font-size: 7rem;
+    line-height: 7rem;
+    color: var(--h1-color);
+    margin-top: 24px;
+    margin-bottom: 1.75rem;
+    text-shadow: 1px 1px 1px #010101;
+}
+
+#tutorial-main h2 {
+    font-size: 4rem;
+    line-height: 4rem;
+    text-shadow: 1px 1px 1px #010101;
+    padding: 0.8rem 0;
+    margin-top: 2.5rem;
+    width: 60rem; /* Without this, "Building an application" wraps and looks awkward */
+}
+
+#tutorial-main h3 {
+    font-size: 3rem;
+    line-height: 3rem;
+    text-shadow: 1px 1px 1px #010101;
+    margin-bottom: 0.5rem;
+}
+
+#tutorial-main h4 {
+    font-size: 2rem;
+    text-shadow: 1px 1px 1px #010101;
+}
+
+#tutorial-body, #tutorial-body pre {
+    max-width: 646px;
+}
 
 #tutorial-toc {
     background-color: var(--gray-bg);
+    flex: 0 0 auto; /* Take up as much space as it needs */
+    margin-top: 30px;
+    background: var(--code-bg);
+    padding: 12px 24px;
+    margin-left: 64px;
+    align-self: flex-start; /* Aligns to the start, not stretching in height */
 }
 
 #tutorial-toc > ul {
@@ -1122,6 +1226,62 @@ code .dim {
     text-overflow: ellipsis; /* Adds an ellipsis if the content overflows */
 }
 
+#tutorial-toc code {
+    background: none;
+    color: inherit;
+    margin: 0;
+    padding: 0;
+}
+
+#tutorial-toc ol {
+    padding: 3px;
+    margin: 8px 0;
+    list-style: none;
+    padding-bottom: 0;
+    margin-bottom: 0;
+}
+
+#tutorial-toc h2 {
+    font-family: inherit;
+    font-size: 2em;
+    text-shadow: none;
+    margin: 0;
+    padding: 16px 0;
+}
+
+#toc-search {
+    background-color: var(--toc-search-bg);
+    border: 1px solid var(--toc-search-border);
+    color: inherit;
+    padding: 6px 8px;
+    margin-top: 16px;
+    margin-bottom: 4px;
+    box-sizing: border-box;
+    width: 100%;
+    font-size: inherit;
+}
+
+#tutorial-toc-toggle,
+#tutorial-toc-toggle-label,
+#close-tutorial-toc {
+    display: none;
+    /* This may be overridden on mobile-friendly screen widths */
+}
+
+#tutorial-toc-toggle,
+#tutorial-toc-toggle-label {
+    font-size: 1.1rem;
+    float: right;
+}
+
+#close-tutorial-toc {
+    position: absolute;
+    top: 20px;
+    right: 8px;
+    font-size: 18px;
+    padding: 12px 24px;
+}
+
 /* for larger screens */
 @media only screen and (min-width: 768px) {
     #tutorial-toc > ul > li {

From 35df5dca0089f7cc23d060a128da7f47f4ea4973 Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Mon, 20 Nov 2023 00:57:40 -0500
Subject: [PATCH 096/129] Fix some build.sh stuff

---
 www/build.sh | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/www/build.sh b/www/build.sh
index adcda2075c..78a2244682 100755
--- a/www/build.sh
+++ b/www/build.sh
@@ -20,12 +20,13 @@ cp -r public/ build/
 
 # download the latest code for the examples
 echo 'Downloading latest examples...'
-curl -fLJO https://github.com/roc-lang/examples/archive/refs/heads/main.zip
-unzip examples-main.zip
+curl -fL -o examples-main.zip https://github.com/roc-lang/examples/archive/refs/heads/main.zip
+rm -rf examples-main/
+unzip -o examples-main.zip
 cp -R examples-main/examples/ content/examples/
 
 # relace links in content/examples/index.md to work on the WIP site
-sed -i'' 's|](/|](/examples/|' content/examples/index.md
+perl -pi -e 's|\]\(/|\]\(/examples/|g' content/examples/index.md
 
 # clean up examples artifacts
 rm -rf examples-main examples-main.zip

From 8377a487ea515e25532b5e55f9d7c8040d41dd4b Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Mon, 20 Nov 2023 01:03:08 -0500
Subject: [PATCH 097/129] Don't show the Close button when window resizes

---
 www/public/site.css | 4 ----
 www/public/site.js  | 1 +
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/www/public/site.css b/www/public/site.css
index ba5e7845ee..6b1b8587f2 100644
--- a/www/public/site.css
+++ b/www/public/site.css
@@ -568,10 +568,6 @@ li {
         display: inline;
     }
 
-    .close-desc {
-        display: block !important;
-    }
-
     h2 {
         margin-top: 48px;
         padding: 12px 0;
diff --git a/www/public/site.js b/www/public/site.js
index e93910f1f5..6b256eff44 100644
--- a/www/public/site.js
+++ b/www/public/site.js
@@ -509,6 +509,7 @@ if (isOnMobile) {
     });
 
     example.querySelectorAll(".close-desc").forEach((button) => {
+      button.style.display = "block";
       button.addEventListener("click", hideDesc);
     });
   });

From 9cd4a83f52ec75a331659c65426d0e13b0a8bec5 Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Mon, 20 Nov 2023 01:07:08 -0500
Subject: [PATCH 098/129] Improve tutorial light theme header color

---
 www/public/site.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/www/public/site.css b/www/public/site.css
index 6b1b8587f2..216a9b519e 100644
--- a/www/public/site.css
+++ b/www/public/site.css
@@ -36,7 +36,7 @@
     --dark-code-bg: #202746;
 
     /* Tutorial */
-    --header-link-color: #107F79;
+    --header-link-color: #1bbcb3;
     --header-link-hover: #222;
     --h1-color: #8055E4;
 }

From edfba00ec33b2a5b8a785513f21ace5e083d045e Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Mon, 20 Nov 2023 01:15:42 -0500
Subject: [PATCH 099/129] Fix tutorial layout and ToC on mobile

---
 www/content/tutorial.md |  5 ++++-
 www/public/site.css     | 41 +++++++++++++++++++++++++++++++++++------
 2 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/www/content/tutorial.md b/www/content/tutorial.md
index ca78769139..c0e49aa5c4 100644
--- a/www/content/tutorial.md
+++ b/www/content/tutorial.md
@@ -1,4 +1,7 @@
-
    
         
    You can use Roc to create scripts and command-line interfaces (CLIs). The compiler produces binary executables, so Roc programs can run on devices that don't have Roc itself installed.
    
         
    As an example, the HTML for this website is generated using a simple Roc script. You can see the code for it in the main Roc code repository.
    
-        
    If you’re looking for a starting point for building a command-line program in Roc, basic-cli is a popular platform to check out.
    
+        
    If you’re looking for a starting point for building a command-line program in Roc, basic-cli is a popular platform to check out.