firefly-compiler 0.5.35 → 0.5.36

package/fireflysite/assets/markdown/reference/UserDefinedTypes.md

@@ -1,184 +1,184 @@
-# User defined types
-
-Named types can be defined at the top level, using one of four keywords: `data`, `class`, `capability` or `newtype`.
-
-
-# data
-
-To define an immutable type, you can use the `data` keyword.
-
-```firefly
-data Shape {
-    Circle(x: Float, y: Float, radius: Float)
-    Rectangle(x: Float, y: Float, width: Float, height: Float)
-}
-```
-
-This defines a type called `Shape` with two variants `Circle` and `Rectangle`. 
-The `Circle` variant has three named fields of type `Float`, while the `Rectangle` variant has four.
-
-Type and variant names must start with a capital letter.
-
-No `class` or `capability` types can occur in the definition of a `data` type.
-
-A value of type `Shape` is either a `Circle` or a `Rectangle`, and they can be constructed as follows:
-
-```firefly
-Circle(0.0, 0.0, 1.0)           // Variant, : Shape
-Rectangle(5.0, 7.0, 3.0, 2.0)   // Variant, : Shape
-```
-
-Above the variants are constructed using positional arguments, whose order must coincide with the order of the parameters in the type definition.
-
-Named arguments are supported as well:
-
-```firefly
-Circle(x = 0.0, y = 0.0, radius = 1.0)
-```
-
-Named parameters don't have to be in order, and can be mixed with positional arguments:
-
-```firefly
-Circle(radius = 1.0, 0.0, 0.0)
-```
-
-To branch on the specific variant of a type, use [pattern matching](pattern-matching).
-
-
-# Common fields
-
-When all the variants share a set of fields, they can be moved to the common fields section of the declaration:
-
-```firefly
-data Shape(x: Float, y: Float) {
-    Circle(radius: Float)
-    Rectangle(width: Float, height: Float)
-}
-```
-
-This is similar to the `Shape` definition above, but the `x` and `y` fields have been pulled out as common fields. 
-Given a value of a type, e.g. `shape: Shape`, common fields can be accessed without knowing which specific variant it is:
-
-```firefly
-shape.x     // Returns a Float
-shape.y     // Returns a Float
-```
-
-When there is only one variant of a type, and its name coincides with the name of the type, we can use a shorthand definition:
-
-```firefly
-data Point(x: Float, y: Float)
-```
-
-This defines a type called `Point` with a single variant, also named `Point`, and two common fields of type `Float`.
-
-
-# Copying
-
-If you have a value and want to construct a variant, you can copy each field explicitly:
-
-```firefly
-Rectangle(x = point.x, y = point.y, width = 2.0, height = 1.5)
-```
-
-There's a shorthand for doing this, however:
-
-```firefly
-point.Rectangle(width = 2.0, height = 1.5)
-```
-
-Using this shorthand, the fields of `Rectangle` that aren't specified will be copied from `point`.
-
-
-
-# class
-
-Types defined with the `class` keyword work like `data` types, except for the differences noted here.
-
-Fields of `class` types may be declared `mutable`:
-
-```firefly
-class FruitBasket(
-    mutable apples: Int
-    mutable oranges: Int
-    mutable bananas: Int
-)
-```
-
-Mutable fields can be updated. Given a value `basket: FruitBasket`, its fields can be assigned to:
-
-```firefly
-basket.apples = 42      // The apples field now holds the value 42
-basket.oranges += 1     // The oranges field is now one greater
-basket.bananas -= 1     // The bananas field is now one less
-```
-
-Except for `capability` types, all types can occur in the definition of a `class` type.
-
-
-# capability
-
-Types defined with the `capability` keyword work like `class` types, except for the differences noted here.
-
-```firefly
-capability EventHandler(
-    onEvent: () => Unit
-)
-```
-
-The `onEvent` field here contains a first class function, which may have captured other capabilities or classes in its closure.
-Therefore, calling the function contained in this field may cause side effects.
-
-In particular, it may have captured the `system` argument that's passed to the main function, or other capabilities that allow it to do I/O.
-
-There are no restrictions on the types of fields that `capability` types can have.
-
-Function types `=>` are considered `capability` types.
-
-
-# newtype
-
-Types defined with the `newtype` keyword work like `data` types, except that they must have exactly one common field and no explicitly listed variants.
-
-```firefly
-newtype UserId(id: Int)
-```
-
-At runtime, they are represented as values of the field type.
-In this case, it means that `UserId(42)` is represented as the `Int` value `42` at runtime, with zero overhead.
-
-
-# Generic types
-
-Whether you use `data`, `class`, `capability` or `newtype` to define a type, it may have type parameters.
-
-```firefly
-data Basket[T](
-    items: List[T]
-)
-```
-
-Here the `T` in `Basket[T]` is a type parameter, and it's used as a type argument in `List[T]`.
-
-An unbounded type parameter can be instantiated to any type. 
-We can have a `Basket[Shape]`, which has a field `items: List[Shape]`, and a different type `Basket[EventHandler]`, which has a field `items: List[EventHandler]`.
-
-Note that type parameters are not concrete types, and are thus not subject to the field type restrictions stated earlier.
-
-
-# Anonymous records
-
-An anonymous record is not defined anywhere, but consists of zero or more fields. The fields may have any type, but can't be reassigned after creation.
-
-```firefly
-(red = 255, green = 255, blue = 0)
-```
-
-This constructs an anonymous record.
-If you have an anonymous record value, e.g. `color: (red: Int, green: Int, blue: Int)`, you can access its fields:
-
-```firefly
-color.red       // Returns an Int
-color.green     // Returns an Int
-color.blue      // Returns an Int
-```
+# User defined types
+
+Named types can be defined at the top level, using one of four keywords: `data`, `class`, `capability` or `newtype`.
+
+
+# data
+
+To define an immutable type, you can use the `data` keyword.
+
+```firefly
+data Shape {
+    Circle(x: Float, y: Float, radius: Float)
+    Rectangle(x: Float, y: Float, width: Float, height: Float)
+}
+```
+
+This defines a type called `Shape` with two variants `Circle` and `Rectangle`. 
+The `Circle` variant has three named fields of type `Float`, while the `Rectangle` variant has four.
+
+Type and variant names must start with a capital letter.
+
+No `class` or `capability` types can occur in the definition of a `data` type.
+
+A value of type `Shape` is either a `Circle` or a `Rectangle`, and they can be constructed as follows:
+
+```firefly
+Circle(0.0, 0.0, 1.0)           // Variant, : Shape
+Rectangle(5.0, 7.0, 3.0, 2.0)   // Variant, : Shape
+```
+
+Above the variants are constructed using positional arguments, whose order must coincide with the order of the parameters in the type definition.
+
+Named arguments are supported as well:
+
+```firefly
+Circle(x = 0.0, y = 0.0, radius = 1.0)
+```
+
+Named parameters don't have to be in order, and can be mixed with positional arguments:
+
+```firefly
+Circle(radius = 1.0, 0.0, 0.0)
+```
+
+To branch on the specific variant of a type, use [pattern matching](pattern-matching).
+
+
+# Common fields
+
+When all the variants share a set of fields, they can be moved to the common fields section of the declaration:
+
+```firefly
+data Shape(x: Float, y: Float) {
+    Circle(radius: Float)
+    Rectangle(width: Float, height: Float)
+}
+```
+
+This is similar to the `Shape` definition above, but the `x` and `y` fields have been pulled out as common fields. 
+Given a value of a type, e.g. `shape: Shape`, common fields can be accessed without knowing which specific variant it is:
+
+```firefly
+shape.x     // Returns a Float
+shape.y     // Returns a Float
+```
+
+When there is only one variant of a type, and its name coincides with the name of the type, we can use a shorthand definition:
+
+```firefly
+data Point(x: Float, y: Float)
+```
+
+This defines a type called `Point` with a single variant, also named `Point`, and two common fields of type `Float`.
+
+
+# Copying
+
+If you have a value and want to construct a variant, you can copy each field explicitly:
+
+```firefly
+Rectangle(x = point.x, y = point.y, width = 2.0, height = 1.5)
+```
+
+There's a shorthand for doing this, however:
+
+```firefly
+point.Rectangle(width = 2.0, height = 1.5)
+```
+
+Using this shorthand, the fields of `Rectangle` that aren't specified will be copied from `point`.
+
+
+
+# class
+
+Types defined with the `class` keyword work like `data` types, except for the differences noted here.
+
+Fields of `class` types may be declared `mutable`:
+
+```firefly
+class FruitBasket(
+    mutable apples: Int
+    mutable oranges: Int
+    mutable bananas: Int
+)
+```
+
+Mutable fields can be updated. Given a value `basket: FruitBasket`, its fields can be assigned to:
+
+```firefly
+basket.apples = 42      // The apples field now holds the value 42
+basket.oranges += 1     // The oranges field is now one greater
+basket.bananas -= 1     // The bananas field is now one less
+```
+
+Except for `capability` types, all types can occur in the definition of a `class` type.
+
+
+# capability
+
+Types defined with the `capability` keyword work like `class` types, except for the differences noted here.
+
+```firefly
+capability EventHandler(
+    onEvent: () => Unit
+)
+```
+
+The `onEvent` field here contains a first class function, which may have captured other capabilities or classes in its closure.
+Therefore, calling the function contained in this field may cause side effects.
+
+In particular, it may have captured the `system` argument that's passed to the main function, or other capabilities that allow it to do I/O.
+
+There are no restrictions on the types of fields that `capability` types can have.
+
+Function types `=>` are considered `capability` types.
+
+
+# newtype
+
+Types defined with the `newtype` keyword work like `data` types, except that they must have exactly one common field and no explicitly listed variants.
+
+```firefly
+newtype UserId(id: Int)
+```
+
+At runtime, they are represented as values of the field type.
+In this case, it means that `UserId(42)` is represented as the `Int` value `42` at runtime, with zero overhead.
+
+
+# Generic types
+
+Whether you use `data`, `class`, `capability` or `newtype` to define a type, it may have type parameters.
+
+```firefly
+data Basket[T](
+    items: List[T]
+)
+```
+
+Here the `T` in `Basket[T]` is a type parameter, and it's used as a type argument in `List[T]`.
+
+An unbounded type parameter can be instantiated to any type. 
+We can have a `Basket[Shape]`, which has a field `items: List[Shape]`, and a different type `Basket[EventHandler]`, which has a field `items: List[EventHandler]`.
+
+Note that type parameters are not concrete types, and are thus not subject to the field type restrictions stated earlier.
+
+
+# Anonymous records
+
+An anonymous record is not defined anywhere, but consists of zero or more fields. The fields may have any type, but can't be reassigned after creation.
+
+```firefly
+(red = 255, green = 255, blue = 0)
+```
+
+This constructs an anonymous record.
+If you have an anonymous record value, e.g. `color: (red: Int, green: Int, blue: Int)`, you can access its fields:
+
+```firefly
+color.red       // Returns an Int
+color.green     // Returns an Int
+color.blue      // Returns an Int
+```

package/fireflysite/assets/markdown/scratch/ControlFlow.md

@@ -1,136 +1,136 @@
-# Control flow
-
-Firefly provides several ways to implement branching. Pattern matching is the most powerful, built directly into the language. `if`, `elseIf` and `else` do what you expect and are functions and methods in the standard library, implemented using the `Option` type. An then finally, there are [exceptions](#Exceptions).
-
-# Pattern matching
-
-Pattern matching allows you to check a given data structure against a pattern. For example, if we want to parse the command line arguments provided by the user, we could do it like this:
-
-```firefly
-let pair = system.arguments().{
-    | [host] => Pair(host, 80)
-    | ["localhost", port] => Pair("localhost", port.grabInt())
-    | _ => 
-        system.writeErrorLine("Usage: 'localhost' | (host port)")
-        system.exit(0)
-}  
-```
-
-In Firefly you construct a list of strings (`List[String]`) like this `["example.com", "80"]`, and using pattern matching you can de-construct in the same way.
-
-```firefly
-data.{
-    | pattern1 => // case 1
-    | pattern2 => // case N
-    ...
-}
-```
-
-The patterns must be exhaustive, that is, for any possible value of the given type, there must be a matching pattern. In the example above, there are no value for the empty list `[]` , list with two values, where the first is not `"localhost"` or lists with more than 2 arguments. That's why we need the wildcard case at the end. Without this last case, the compiler would produce a compile-time error, stating that the patterns must be exhaustive.
-
-Here are more examples — all exhaustive. Let's start with records:
-
-```firefly
-pair.{
-    | Pair(first, second) => 
-}
-```
-
-Numbers
-
-```firefly
-n.{
-    | 1 => 
-    | 2 => 
-    | n => 
-}
-```
-
-Booleans
-
-```firefly
-n.{
-    | True => 
-    | False => 
-}
-```
-
-And you can combine pattern as needed. Imagine you have a pair of type `Pair[List[Bool], Pair(Int, String)]`
-
-
-```firefly
-pair.{
-    | Pair([True, False], Pair(42, "foo")) => 
-    | other => 
-}
-```
-
-
-# Option
-
-Sometimes you don't have a value. Other languages uses null for this purpose, but Firefly does not have null. Instead, we have `Option` from the core package.
-
-
-```firefly
-data Option[T] {
-    None
-    Some(value: T)
-}
-```
-
-For some type `T`, say `String`, `Option[String]` is either some string or no value `None`. This way, the type system guides you to check for no-value.
-
-Many functions and methods returns an `Option` in Firefly. For instance the `getInt` method on `String`. This method returns `Some[Int]` when the string consists only of digits and `None` otherwise. We can perform pattern matching on Option like this:
-
-```firefly
-port.getInt().{
-    | None => 80
-    | Some(p) => p
-}
-```
-
-Many methods like `getInt` have a non-total counterpart `grabInt`, which returns an `Int`. But it will throw an exception when the input cannot be parsed. Options let's you code in an exception-safe manner.
-
-
-# if - elseIf - else
-
-You write if-statements in Firefly like this:
-
-```firefly
-if(path == "/") {
-    response.writeText("<!doctype html>")
-} elseIf {path.startsWith("/js/")} {
-    response.writeText("<script>")
-} else {
-    response.writeStatus("404 Not found")
-}
-```
-
-You can also use it as an expression like this
-
-
-```firefly
-let contentType = if(path == "/") {
-    "text/html; charset=UTF-8"
-} elseIf(directory2.exists) {
-    "text/javascript; charset=UTF-8"
-} else {
-    "text/plain; charset=UTF-8"
-}
-```
-
-`if`, `elseIf` and `else` are not keywords or construct build into Firefly. `if` is just a function defined like this: 
-
-
-```firefly
-if[T](condition: Bool, body: () => T): Option[T] {
-    condition.{
-        | False => None
-        | True => Some(body())
-    }
-}
-```
-
-# Exceptions
-
-...
+# Control flow
+
+Firefly provides several ways to implement branching. Pattern matching is the most powerful, built directly into the language. `if`, `elseIf` and `else` do what you expect and are functions and methods in the standard library, implemented using the `Option` type. An then finally, there are [exceptions](#Exceptions).
+
+# Pattern matching
+
+Pattern matching allows you to check a given data structure against a pattern. For example, if we want to parse the command line arguments provided by the user, we could do it like this:
+
+```firefly
+let pair = system.arguments().{
+    | [host] => Pair(host, 80)
+    | ["localhost", port] => Pair("localhost", port.grabInt())
+    | _ => 
+        system.writeErrorLine("Usage: 'localhost' | (host port)")
+        system.exit(0)
+}  
+```
+
+In Firefly you construct a list of strings (`List[String]`) like this `["example.com", "80"]`, and using pattern matching you can de-construct in the same way.
+
+```firefly
+data.{
+    | pattern1 => // case 1
+    | pattern2 => // case N
+    ...
+}
+```
+
+The patterns must be exhaustive, that is, for any possible value of the given type, there must be a matching pattern. In the example above, there are no value for the empty list `[]` , list with two values, where the first is not `"localhost"` or lists with more than 2 arguments. That's why we need the wildcard case at the end. Without this last case, the compiler would produce a compile-time error, stating that the patterns must be exhaustive.
+
+Here are more examples — all exhaustive. Let's start with records:
+
+```firefly
+pair.{
+    | Pair(first, second) => 
+}
+```
+
+Numbers
+
+```firefly
+n.{
+    | 1 => 
+    | 2 => 
+    | n => 
+}
+```
+
+Booleans
+
+```firefly
+n.{
+    | True => 
+    | False => 
+}
+```
+
+And you can combine pattern as needed. Imagine you have a pair of type `Pair[List[Bool], Pair(Int, String)]`
+
+
+```firefly
+pair.{
+    | Pair([True, False], Pair(42, "foo")) => 
+    | other => 
+}
+```
+
+
+# Option
+
+Sometimes you don't have a value. Other languages uses null for this purpose, but Firefly does not have null. Instead, we have `Option` from the core package.
+
+
+```firefly
+data Option[T] {
+    None
+    Some(value: T)
+}
+```
+
+For some type `T`, say `String`, `Option[String]` is either some string or no value `None`. This way, the type system guides you to check for no-value.
+
+Many functions and methods returns an `Option` in Firefly. For instance the `getInt` method on `String`. This method returns `Some[Int]` when the string consists only of digits and `None` otherwise. We can perform pattern matching on Option like this:
+
+```firefly
+port.getInt().{
+    | None => 80
+    | Some(p) => p
+}
+```
+
+Many methods like `getInt` have a non-total counterpart `grabInt`, which returns an `Int`. But it will throw an exception when the input cannot be parsed. Options let's you code in an exception-safe manner.
+
+
+# if - elseIf - else
+
+You write if-statements in Firefly like this:
+
+```firefly
+if(path == "/") {
+    response.writeText("<!doctype html>")
+} elseIf {path.startsWith("/js/")} {
+    response.writeText("<script>")
+} else {
+    response.writeStatus("404 Not found")
+}
+```
+
+You can also use it as an expression like this
+
+
+```firefly
+let contentType = if(path == "/") {
+    "text/html; charset=UTF-8"
+} elseIf(directory2.exists) {
+    "text/javascript; charset=UTF-8"
+} else {
+    "text/plain; charset=UTF-8"
+}
+```
+
+`if`, `elseIf` and `else` are not keywords or construct build into Firefly. `if` is just a function defined like this: 
+
+
+```firefly
+if[T](condition: Bool, body: () => T): Option[T] {
+    condition.{
+        | False => None
+        | True => Some(body())
+    }
+}
+```
+
+# Exceptions
+
+...