[gleam] complete tracks-on-tracks-on-tracks

gleam/tracks-on-tracks-on-tracks/.gitignore

@@ -0,0 +1,4 @@
+*.beam
+*.ez
+build
+erl_crash.dump

gleam/tracks-on-tracks-on-tracks/HELP.md

@@ -0,0 +1,32 @@
+# Help
+
+## Running the tests
+
+To run the tests, run the command `gleam test` from within the exercise directory.
+
+## Submitting your solution
+
+You can submit your solution using the `exercism submit src/tracks_on_tracks_on_tracks.gleam` command.
+This command will upload your solution to the Exercism website and print the solution page's URL.
+
+It's possible to submit an incomplete solution which allows you to:
+
+- See how others have completed the exercise
+- Request help from a mentor
+
+## Need to get help?
+
+If you'd like help solving the exercise, check the following pages:
+
+- The [Gleam track's documentation](https://exercism.org/docs/tracks/gleam)
+- The [Gleam track's programming category on the forum](https://forum.exercism.org/c/programming/gleam)
+- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
+- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
+
+Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
+
+To get help if you're having trouble, you can use one of the following resources:
+
+- [gleam.run](https://gleam.run/documentation/) is the gleam official documentation.
+- [Discord](https://discord.gg/Fm8Pwmy) is the discord channel.
+- [StackOverflow](https://stackoverflow.com/questions/tagged/gleam) can be used to search for your problem and see if it has been answered already. You can also ask and answer questions.

gleam/tracks-on-tracks-on-tracks/HINTS.md

@@ -0,0 +1,28 @@
+# Hints
+
+## 1. Create a new list
+
+- An empty list can be created using the `[]` syntax.
+
+## 2. Define an existing list
+
+- Lists with multiple elements can be created using the `["a", "b", "c"]` syntax.
+
+## 3. Add a new language to a list
+
+- The spread syntax (`[x, ..list]`) can be used to add an element to the beginning of a list.
+
+## 4. Count the languages in the list
+
+- There is a function in the `gleam/list` module to [count the elements in a list][length].
+
+## 5. Reverse the list
+
+- There is a function in the `gleam/list` module to [reverse a list][reverse].
+
+## 6. Check if list is exciting
+
+- You can use pattern matching using the list and list spread patterns to match on specific list structures.
+
+[reverse]: https://hexdocs.pm/gleam_stdlib/gleam/list.html#reverse
+[length]: https://hexdocs.pm/gleam_stdlib/gleam/list.html#length

gleam/tracks-on-tracks-on-tracks/README.md

@@ -0,0 +1,141 @@
+# Tracks on Tracks on Tracks
+
+Welcome to Tracks on Tracks on Tracks on Exercism's Gleam Track.
+If you need help running the tests or submitting your code, check out `HELP.md`.
+If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)
+
+## Introduction
+
+## Lists
+
+A list in Gleam is an immutable collection of zero or more values. The values in a list must all have the same type. As lists are immutable, once a list has been constructed, its value can never change. Any functions/operators that appear to modify a list (such as adding an element), will actually return a new list.
+
+Lists can be defined as follows:
+
+```gleam
+let empty = []
+let singleValue = [5]
+let threeValues = ["a", "b", "c"]
+```
+
+The most common way to add an element to a list is through the spread syntax:
+
+```gleam
+let two_to_four = [2, 3, 4]
+let one_to_four = [1, ..two_to_four]
+// -> [1, 2, 3, 4]
+```
+
+The [`gleam/list`](https://hexdocs.pm/gleam_stdlib/gleam/list.html) module in the Gleam standard library contains many useful functions for working with lists. This module is very commonly used in Gleam code so it is good to be familiar with it.
+
+Lists patterns can be used in case expressions to match on lists and assign contained values to variables:
+
+```gleam
+pub fn describe(list: List(String)) -> String {
+  case list {
+    [] -> "Empty list"
+    [x] -> "List with one item: " <> x
+    [x, y] -> "List with two items: " <> x <> " and " <> y
+    _ -> "List with three or more items"
+  }
+}
+```
+
+As well as matching on exact length lists, the spread syntax can be used to match on lists of at-least a certain length:
+
+```gleam
+pub fn describe(list: List(String)) -> String {
+  case list {
+    [_, _, ..] -> "List with at least two items"
+    [_] -> "List with one item"
+    [] -> "Empty list"
+  }
+}
+```
+
+The spread syntax can also be used to assign the rest of the list to a variable:
+
+```gleam
+pub fn remove_first_item(list: List(String)) -> List(String) {
+  case list {
+    // Return the list without the first item
+    [_, ..rest] -> rest
+
+    // There's no first item to remove, return an empty list
+    _ -> []
+  }
+}
+```
+
+Case expressions should have a pattern for every possible value of the type being matched on, so a final discard pattern (`_`) is often used to handle any remaining values.
+
+## Instructions
+
+In this exercise you'll be writing code to keep track of a list of programming languages you want to learn on Exercism.
+
+You have six tasks, which will all involve dealing with lists.
+
+## 1. Create a new list
+
+To keep track of the languages you want to learn, you'll need to create a new list. Define the `new_list` function that returns a new, empty list.
+
+```gleam
+new_list()
+// -> []
+```
+
+## 2. Define an existing list
+
+Currently, you have a piece of paper listing the languages you want to learn: Gleam, Go, and TypeScript. Define the `existing_list` function to return this list.
+
+```gleam
+existing_list()
+// -> ["Gleam", "Go", "TypeScript"]
+```
+
+## 3. Add a new language to a list
+
+As you explore Exercism and find more interesting languages, you want to add them to your list. Implement the `add_language` function to add a new language to the beginning of your list.
+
+```gleam
+add_language(["OCaml", "Elixir"], "Scheme")
+// -> ["Scheme", "OCaml", "Elixir"]
+```
+
+## 4. Count the languages in the list
+
+Counting the languages one-by-one is inconvenient. Implement the `count_languages` function to count the number of languages on your list.
+
+```gleam
+count_languages(["jq", "Elm", "Rust", "Kotlin"])
+// -> 4
+```
+
+## 5. Reverse the list
+
+At some point, you realize that your list is actually ordered backwards! Implement the `reverse_list` function to reverse your list.
+
+```gleam
+reverse_list(["Python", "Julia", "Idris", "COBOL"])
+// -> ["COBOL", "Idris", "Julia", "Python"]
+```
+
+## 6. Check if list is exciting
+
+While you love all languages, Gleam has a special place in your heart. As such, you're really excited about a list of languages if:
+
+- The first on the list is Gleam.
+- The second item on the list is Gleam and the list contain either two or three languages.
+
+Implement the `exciting_list` function to check if a list of languages is exciting:
+
+```gleam
+exciting_list(["Lua", "Gleam"])
+// -> True
+```
+
+## Source
+
+### Created by
+
+- @lpil

gleam/tracks-on-tracks-on-tracks/gleam.toml

@@ -0,0 +1,12 @@
+name = "tracks_on_tracks_on_tracks"
+version = "0.1.0"
+
+[dependencies]
+gleam_bitwise = "~> 1.2"
+gleam_otp = "~> 0.7 or ~> 1.0"
+gleam_stdlib = "~> 0.32 or ~> 1.0"
+simplifile = "~> 1.0"
+gleam_erlang = ">= 0.25.0 and < 1.0.0"
+
+[dev-dependencies]
+exercism_test_runner = "~> 1.4"

gleam/tracks-on-tracks-on-tracks/manifest.toml

@@ -0,0 +1,27 @@
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "argv", version = "1.0.1", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "A6E9009E50BBE863EB37D963E4315398D41A3D87D0075480FC244125808F964A" },
+  { name = "exercism_test_runner", version = "1.7.0", build_tools = ["gleam"], requirements = ["argv", "gap", "glance", "gleam_community_ansi", "gleam_erlang", "gleam_json", "gleam_stdlib", "simplifile"], otp_app = "exercism_test_runner", source = "hex", outer_checksum = "2FC1BADB19BEC2AE77BFD2D3A606A014C85412A7B874CAFC4BA8CF04B0B257CD" },
+  { name = "gap", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_community_ansi", "gleam_stdlib"], otp_app = "gap", source = "hex", outer_checksum = "2EE1B0A17E85CF73A0C1D29DA315A2699117A8F549C8E8D89FA8261BE41EDEB1" },
+  { name = "glance", version = "0.8.2", build_tools = ["gleam"], requirements = ["gleam_stdlib", "glexer"], otp_app = "glance", source = "hex", outer_checksum = "ACF09457E8B564AD7A0D823DAFDD326F58263C01ACB0D432A9BEFDEDD1DA8E73" },
+  { name = "gleam_bitwise", version = "1.3.1", build_tools = ["gleam"], requirements = [], otp_app = "gleam_bitwise", source = "hex", outer_checksum = "B36E1D3188D7F594C7FD4F43D0D2CE17561DE896202017548578B16FE1FE9EFC" },
+  { name = "gleam_community_ansi", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "FE79E08BF97009729259B6357EC058315B6FBB916FAD1C2FF9355115FEB0D3A4" },
+  { name = "gleam_community_colour", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_community_colour", source = "hex", outer_checksum = "A49A5E3AE8B637A5ACBA80ECB9B1AFE89FD3D5351FF6410A42B84F666D40D7D5" },
+  { name = "gleam_erlang", version = "0.25.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "054D571A7092D2A9727B3E5D183B7507DAB0DA41556EC9133606F09C15497373" },
+  { name = "gleam_json", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "thoas"], otp_app = "gleam_json", source = "hex", outer_checksum = "8B197DD5D578EA6AC2C0D4BDC634C71A5BCA8E7DB5F47091C263ECB411A60DF3" },
+  { name = "gleam_otp", version = "0.10.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "0B04FE915ACECE539B317F9652CAADBBC0F000184D586AAAF2D94C100945D72B" },
+  { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
+  { name = "glexer", version = "0.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glexer", source = "hex", outer_checksum = "4484942A465482A0A100936E1E5F12314DB4B5AC0D87575A7B9E9062090B96BE" },
+  { name = "simplifile", version = "1.5.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "EB9AA8E65E5C1E3E0FDCFC81BC363FD433CB122D7D062750FFDF24DE4AC40116" },
+  { name = "thoas", version = "0.4.1", build_tools = ["rebar3"], requirements = [], otp_app = "thoas", source = "hex", outer_checksum = "4918D50026C073C4AB1388437132C77A6F6F7C8AC43C60C13758CC0ADCE2134E" },
+]
+
+[requirements]
+exercism_test_runner = { version = "~> 1.4" }
+gleam_bitwise = { version = "~> 1.2" }
+gleam_erlang = { version = ">= 0.25.0 and < 1.0.0"}
+gleam_otp = { version = "~> 0.7 or ~> 1.0" }
+gleam_stdlib = { version = "~> 0.32 or ~> 1.0" }
+simplifile = { version = "~> 1.0" }

gleam/tracks-on-tracks-on-tracks/src/tracks_on_tracks_on_tracks.gleam

@@ -0,0 +1,30 @@
+import gleam/list
+
+pub fn new_list() -> List(String) {
+  []
+}
+
+pub fn existing_list() -> List(String) {
+  ["Gleam", "Go", "TypeScript"]
+}
+
+pub fn add_language(languages: List(String), language: String) -> List(String) {
+  [language, ..languages]
+}
+
+pub fn count_languages(languages: List(String)) -> Int {
+  list.length(languages)
+}
+
+pub fn reverse_list(languages: List(String)) -> List(String) {
+  list.reverse(languages)
+}
+
+pub fn exciting_list(languages: List(String)) -> Bool {
+  case languages {
+    ["Gleam", ..] -> True
+    [_, "Gleam"] -> True
+    [_, "Gleam", _] -> True
+    _ -> False
+  }
+}