first pass at cheatsheet for scala #348
Draft
+1,320
−0
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
24 tasks
lpil
reviewed
Jul 25, 2024
| /** | ||
| * a very special trait. | ||
| */ | ||
| trait Foo {} |
There was a problem hiding this comment.
Could you remove the foobar references please.
| size2 = 1 | ||
| ``` | ||
|
|
||
| Scala uses `val` for immutable bindings and `var` for mutable bindings. |
There was a problem hiding this comment.
Let's remove explanations and examples of var and the scoping rule below, as we don't need to teach Scala and there's no equivalent in Gleam.
| In Gleam, `let` and `=` can be used for pattern matching, but you'll get | ||
| compile errors if there's a type mismatch, and a runtime error if there's | ||
| a value mismatch. For assertions, the equivalent `let assert` keyword is | ||
| preferred. |
There was a problem hiding this comment.
let assert is required, not preferred. let does not result in a runtime error as it does not permit value mismatches
Comment on lines
+236
to
+243
| For methods with no arguments, you may omit the parenthesis | ||
|
|
||
| ```scala | ||
|
|
||
| def noArgs = "Surprise." | ||
|
|
||
| ``` | ||
|
|
There was a problem hiding this comment.
Suggested change
| For methods with no arguments, you may omit the parenthesis | |
| ```scala | |
| def noArgs = "Surprise." | |
| ``` |
We don't need to teach Scala
Comment on lines
+472
to
+494
| ```scala | ||
| def main() = { | ||
| val x = { | ||
| someFunction(1) | ||
| 2 | ||
| } | ||
| // Parenthesis are used to change precedence of arithmetic operators | ||
| // Although curly braces would work here too. | ||
| val y = x * (x + 10) | ||
| y | ||
| } | ||
| ``` | ||
|
|
||
| or using indentation in Scala 3 | ||
|
|
||
| ```scala | ||
| def main() = | ||
| val x = | ||
| someFunction(1) | ||
| 2 | ||
| val y = x * (x + 10) | ||
| y | ||
| ``` |
There was a problem hiding this comment.
Suggested change
| ```scala | |
| def main() = { | |
| val x = { | |
| someFunction(1) | |
| 2 | |
| } | |
| // Parenthesis are used to change precedence of arithmetic operators | |
| // Although curly braces would work here too. | |
| val y = x * (x + 10) | |
| y | |
| } | |
| ``` | |
| or using indentation in Scala 3 | |
| ```scala | |
| def main() = | |
| val x = | |
| someFunction(1) | |
| 2 | |
| val y = x * (x + 10) | |
| y | |
| ``` | |
| ```scala | |
| def main() = { | |
| val x = { | |
| someFunction(1) | |
| 2 | |
| } | |
| val y = x * (x + 10) | |
| y | |
| } |
Can drop some of the info on Scala
| } | ||
| ``` | ||
|
|
||
| As all expressions the case expression will return the matched value. |
| _ if is_confirmed_by_mail == True -> "allow access" | ||
| _ -> "deny access" | ||
| } | ||
| ``` |
| Exhaustiveness checking at compile time, which is in the works, will make | ||
| certain that you must check for all possible values. A lazy and common way is | ||
| to check of expected values and have a catchall clause with a single underscore | ||
| `_`: |
| try { | ||
| println("this line will be executed and thus printed") | ||
| aFunctionThatFails() | ||
| println("this line will not be executed and thus not printed") |
| However, this is not considered idiomatic Scala in most cases. Many libraries | ||
| provide more functional approaches to error-handling. The standard library | ||
| also includes such a structure which can wrap code that throws exceptions | ||
| and return the success or exception as a value. |
There was a problem hiding this comment.
We can remove this bit as we don't need to teach Scala
|
Thanks for the thorough review! I'll try to get these edits done soon |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Hello,
For your consideration, I've written a cheatsheet for Scala programmers. I think by most measures Scala is the most mainstream fp language in industry and has a lot of similarity with Gleam. Both are highly influenced by ML family of languages but use a more C-style syntax.
I'm not sure how you decide which languages deserve a dedicated cheatsheet, and I realize this is more (basically untestable) code that needs to be maintained. So I will be understanding if you're not accepting these types of contributions.
There's also probably some mistakes, I based this off of the PHP cheatsheet but read several others to get ideas for what else to cover. I tried to keep in mind the audience should be Scala programmers looking into Gleam and not as much the other direction, so there's tons of omissions about Scala's huge type system.
Additionally, I think it would make sense to draw a comparison between the
useexpressions and Scala'sforcomprehensions, but I didn't see an obvious spot for that. Another minor thing to add is thetodovs Scala's???(which seems to have inspiredtodo) but that seems less important for real-world code.