-
Notifications
You must be signed in to change notification settings - Fork 1
/
tour.fn
145 lines (101 loc) · 2.61 KB
/
tour.fn
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
139
140
141
142
143
144
145
###### FN
###### Feature Tour
### Numbers
# Integers and floats are unified as a Number type.
1
0.5
3.14
1 + 2 # => 3
5 - 3.5 # => 1.5
0.5 * 4 # => 2
5 / 2 # => 2.5
### Strings
"string"
### Booleans
true
false
# Following on from Python, Ruby, et al.:
# - `or` will return the first true argument, or false is all are false.
# - `and` will return the last true argument, or false if any are false.
true and false # => false
false or true # => true
# The not operator is a function. (More on functions later.)
not(true) # => false
not(false) and true # => true
### Variables
# 'Variables' cannot be redefined. This is declarative programming, yo.
a = 1
# a = 2 would throw an error.
### Equality
x = 1
y = 2
z = 1
x eq y # => false
x eq z # => true
### Functions
# Functions are assigned to variables.
# Function prototypes are values.
add = fn (a,b) { a + b }
add(2,3) # => 5
add(4,5) # => 9
### Built-in Functions
# print() outputs to the console.
print("Hello, world!")
### Complex Data Structures: The Block
# A Block is an object with attributes.
block = {
foo = "foo"
bar = "bar"
}
# Attributes can be accessed using the dereference operator.
block.foo
block.bar
# A block can be extended from outside.
# block.baz = "baz"
# block.baz
# A block can nest other blocks.
Utils = {
Math = {
pi = 3
area = fn (diameter) { pi * diameter }
}
}
print(Utils.Math.area(3)) # => 9
### Infix Operators
# The following infix operators are defined (in order of precedence):
# . --- Dereference operator
# = --- Assignment operator
# eq --- Equality comparison
# and or --- Logical operators
# + - * / --- Mathematical operations
### Lists
list = List(1, "two", true)
# Lists are accessed by calling it as if it were a function.
print(list(1)) # => "two"
# Lists can be iterated over with the map() function.
list.map(fn (item) {
print(item)
})
### Conditions
# Only one structure exists for conditions: `when`.
# This serves the purpose of `if/unless/else` as well as `case`.
#
# A `when` includes a collection of branches, with a condition and a block.
# `when` runs the first block whose condition is true.
#
# It is useful to add a `true` clause at the end to catch the case
# where no branches are matched.
guessMyNumber = fn (guess) {
when {
guess eq 42 { "You win!" }
true { "Sorry, try again" }
}
}
print(guessMyNumber(42)) # => "You win!"
### Importing Other Files
# Use load()!
imported = load("tour-import.fn")
print(imported.importedX) # 1
# Combine it with include() to add all attributes to the current namespace.
include(load("tour-import.fn"))
print(importedY) # 2