1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
//// Syntax test file for Gleam
////
//// This is a dummy example file and should not be taken as a reference of
//// well written Gleam, but it does compile correctly appart from an error
//// for the absent file "./ffi.mjs" and some warnings.
////
////
////
//// ## Top module documentation comment with markdown formatting
////
//// Formats: _italic text_, **bold text**, `monospace text`, ~~strikeout~~
////
//// Bullet list:
////
//// - item 1
//// - item 2
////
//// Numbered list:
////
//// 1. item 1
//// 2. item 2
////
//// [link](https://example.com)
// SPDX-FileCopyrightText: 2024 Louis Guichard <kde@glpda.net>
// SPDX-License-Identifier: MIT
import gleam/bit_array as bit_string
import gleam/bool
import gleam/dict.{type Dict, delete, get, insert}
import gleam/io
// BEGIN
pub fn main() {
let assert Ok(prefix) = bit_string.to_string(prefix)
let name: String = "Kate \u{1F3F3}\u{FE0F}\u{200D}\u{1F308} "
let assert Ok(suffix) = get(mascots(), "Lucy")
echo prefix <> name <> suffix
}
const prefix = <<"Hello":utf8, 44:size(8), 32:int>>
fn number(int) {
use <- bool.guard(when: int < 0, return: False)
let dec = 123_456_789
let bin = 0b10011011
let oct = 0o1234567
let hex = 0x8337_BEEF
let _float = -3.1415 *. 1.0e-4
let roof = { { dec + oct } * bin - hex } / 4
// 4_246_851_061
case int {
_ if int < roof -> True
_ -> False
}
}
/// Documentation for a custom type with 3 variants
pub opaque type CustomType(a) {
/// first variant
Var1(x: a)
/// second variant
Var2(x: a, y: a)
/// third variant
Var3(x: a, y: a, z: a)
}
pub fn first(ct: CustomType(a)) -> a {
ct.x
}
@deprecated("Use last instead")
pub fn third(ct: CustomType(a)) -> a {
// let assert Var3(_, _, z) = ct z
case ct {
Var3(_, _, z) -> z
_ -> panic
}
}
pub fn last(ct: CustomType(a)) -> a {
case ct {
Var1(x) -> x
Var2(_, y) -> y
Var3(_, _, z) -> z
}
}
pub type ListError {
EmptyList
ListTooLong
}
/// Converts a `List(a)` to a `Result(CustomType(a))`, empty list and list
/// longer than 3 will return an error.
///
/// ## Examples
///
/// ```gleam
/// from_list([1, 2, 3])
/// // -> Ok(Var3(1, 2, 3))
///
/// from_list([1, 2, 3, 4, 5])
/// // -> Error(ListTooLong)
/// ```
///
pub fn from_list(l: List(a)) -> Result(CustomType(a), ListError) {
case l {
[x] -> Ok(Var1(x))
[x, y] -> Ok(Var2(x, y))
[x, y, z] -> Ok(Var3(x, y, z))
[] -> Error(EmptyList)
_ -> Error(ListTooLong)
}
}
fn mascots() -> Dict(String, String) {
let old_mascots = dict.from_list([#("Konqi", "🐉"), #("Kandalf", "🧙")])
let new_mascots =
old_mascots
|> delete("Kandalf")
|> insert("Kate", "🐦")
|> insert("Katie", "🐉")
|> insert("Lucy", "🌟")
new_mascots
}
type UserId =
Int
@external(javascript, "./ffi.mjs", "call")
fn call(id: UserId) -> String {
todo as "call not implemented for this target"
}
// END
|
