[gleam] complete lasagna

gleam/lasagna/.gitignore

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

gleam/lasagna/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/lasagna.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/lasagna/HINTS.md

@@ -0,0 +1,42 @@
+# Hints
+
+## General
+
+- An [int value][ints] can be defined as one or more consecutive digits.
+- [String][string] literals are a sequence of characters surrounded by double quotes.
+
+## 1. Define the expected oven time in minutes
+
+- You need to define a [function][functions] without any arguments.
+- You need to return an [int][ints].
+
+## 2. Calculate the remaining oven time in minutes
+
+- You need to define a [function][functions] with a single argument.
+- You have to return an int from a function.
+- The function's argument is an [int][ints].
+- You can use the [mathematical operator for subtraction][ints] to subtract values.
+
+## 3. Calculate the preparation time in minutes
+
+- You need to define a [function][functions] with a single argument.
+- You have to return an int from a function.
+- The function's argument is an [int][ints].
+- You can use the [mathematical operator for multiplication][ints] to multiply values.
+
+## 4. Calculate the total working time in minutes
+
+- You need to define a [function][functions] with two arguments.
+- You have to return an int from a function.
+- The function's argument is an [int][ints].
+- You can invoke one of the other functions you've defined previously.
+- You can use the [mathematical operator for addition][ints] to add values.
+
+## 5. Create a notification that the lasagna is ready
+
+- You need to define a [function][functions] without any arguments.
+- You need to return a [string][string].
+
+[functions]: https://gleam.run/book/tour/functions.html
+[ints]: https://gleam.run/book/tour/ints-and-floats.html
+[string]: https://gleam.run/book/tour/strings.html

gleam/lasagna/README.md

@@ -0,0 +1,134 @@
+# Lasagna
+
+Welcome to Lasagna 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
+
+## Basics
+
+### Functions
+
+In Gleam functions are defined using the `pub fn` syntax.
+
+```gleam
+pub fn add(x: Int, y: Int) -> Int {
+  x + y
+}
+```
+
+This function takes two arguments, both of type `Int`, and returns a value of type `Int`. There is no `return` keyword in Gleam, the value of the last expression in a function is always _implicitly returned_.
+
+The type annotations for arguments and the return type are optional, and Gleam will always fully type check your code. Typically Gleam programmers will give their functions type annotations for clarity, but you may omit them if you wish.
+
+```gleam
+pub fn add(x, y) {
+  x + y
+}
+```
+
+A function can be called using the `function_name(argument1, argument2)` syntax.
+
+```gleam
+pub fn double(x: Int) -> Int {
+  // Call the add function defined above
+  add(x, x)
+}
+```
+
+### Variables
+
+In Gleam variables are defined using the `let name = expression` syntax.
+
+```gleam
+pub fn main() {
+  let count = 1
+}
+```
+
+Variables can be declared with type annotations. Like function arguments these are optional, though most Gleam programmers will omit type annotations for variables for brevity.
+
+```gleam
+pub fn main() {
+  let count: Int = 1
+}
+```
+
+### String literals
+
+In Gleam strings are written using double quotes.
+
+```gleam
+pub fn greeting() {
+  "Hello, world!"
+}
+```
+
+### Code comments
+
+Comments can be used to leave notes for other developers reading the source code. Comments in Gleam are single lines preceeded by `//`.
+
+```gleam
+pub fn main() {
+  // This is a comment
+  let x = 1
+}
+```
+
+## Instructions
+
+In this exercise you're going to write some code to help you cook a brilliant lasagna from your favorite cooking book.
+
+You have five tasks, all related to the time spent cooking the lasagna.
+
+## 1. Define the expected oven time in minutes
+
+Define the `expected_minutes_in_oven` function that does not take any arguments and returns how many minutes the lasagna should be in the oven. According to the cooking book, the expected oven time in minutes is 40:
+
+```gleam
+expected_minutes_in_oven()
+// -> 40
+```
+
+## 2. Calculate the remaining oven time in minutes
+
+Define the `remaining_minutes_in_oven` function that takes the actual minutes the lasagna has been in the oven as an argument and returns how many minutes the lasagna still has to remain in the oven, based on the expected oven time in minutes from the previous task.
+
+```gleam
+remaining_minutes_in_oven(30)
+// -> 10
+```
+
+## 3. Calculate the preparation time in minutes
+
+Define the `preparation_time_in_minutes` function that takes the number of layers you added to the lasagna as an argument and returns how many minutes you spent preparing the lasagna, assuming each layer takes you 2 minutes to prepare.
+
+```gleam
+preparation_time_in_minutes(2)
+// -> 4
+```
+
+## 4. Calculate the total working time in minutes
+
+Define the `total_time_in_minutes` function that takes two arguments: the first argument is the number of layers you added to the lasagna, and the second argument is the number of minutes the lasagna has been in the oven. The function should return how many minutes in total you've worked on cooking the lasagna, which is the sum of the preparation time in minutes, and the time in minutes the lasagna has spent in the oven at the moment.
+
+```gleam
+total_time_in_minutes(3, 20)
+// -> 26
+```
+
+## 5. Create a notification that the lasagna is ready
+
+Define the `alarm` function that does not take any arguments and returns a message indicating that the lasagna is ready to eat.
+
+```gleam
+alarm()
+// -> "Ding!"
+```
+
+## Source
+
+### Created by
+
+- @lpil

gleam/lasagna/gleam.toml

@@ -0,0 +1,11 @@
+name = "lasagna"
+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"
+
+[dev-dependencies]
+exercism_test_runner = "~> 1.4"

gleam/lasagna/manifest.toml

@@ -0,0 +1,26 @@
+# 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.24.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "26BDB52E61889F56A291CB34167315780EE4AA20961917314446542C90D1C1A0" },
+  { 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_otp = { version = "~> 0.7 or ~> 1.0" }
+gleam_stdlib = { version = "~> 0.32 or ~> 1.0" }
+simplifile = { version = "~> 1.0" }

gleam/lasagna/src/lasagna.gleam

@@ -0,0 +1,22 @@
+pub fn expected_minutes_in_oven() {
+  40
+}
+
+pub fn remaining_minutes_in_oven(minutes: Int) {
+  expected_minutes_in_oven() - minutes
+}
+
+pub fn preparation_time_in_minutes(number_of_layers: Int) -> Int {
+  number_of_layers * 2
+}
+
+pub fn total_time_in_minutes(
+  number_of_layers: Int,
+  actual_minutes_in_oven: Int,
+) -> Int {
+  preparation_time_in_minutes(number_of_layers) + actual_minutes_in_oven
+}
+
+pub fn alarm() {
+  "Ding!"
+}

gleam/lasagna/test/lasagna_test.gleam

@@ -0,0 +1,42 @@
+import exercism/should
+import exercism/test_runner
+import lasagna
+
+pub fn main() {
+  test_runner.main()
+}
+
+pub fn expected_minutes_in_oven_test() {
+  lasagna.expected_minutes_in_oven()
+  |> should.equal(40)
+}
+
+pub fn remaining_minutes_in_oven_test() {
+  lasagna.remaining_minutes_in_oven(25)
+  |> should.equal(15)
+}
+
+pub fn preparation_time_in_minutes_for_one_layer_test() {
+  lasagna.preparation_time_in_minutes(1)
+  |> should.equal(2)
+}
+
+pub fn preparation_time_in_minutes_for_multiple_layers_test() {
+  lasagna.preparation_time_in_minutes(4)
+  |> should.equal(8)
+}
+
+pub fn total_time_in_minutes_for_one_layer_test() {
+  lasagna.total_time_in_minutes(1, 30)
+  |> should.equal(32)
+}
+
+pub fn total_time_in_minutes_for_multiple_layers_test() {
+  lasagna.total_time_in_minutes(4, 8)
+  |> should.equal(16)
+}
+
+pub fn notification_message_test() {
+  lasagna.alarm()
+  |> should.equal("Ding!")
+}