mirror of https://github.com/exaloop/codon.git
135 lines
4.3 KiB
Markdown
135 lines
4.3 KiB
Markdown
Collections are largely the same as in Python:
|
|
|
|
``` python
|
|
l = [1, 2, 3] # type: List[int]; a list of integers
|
|
s = {1.1, 3.3, 2.2, 3.3} # type: Set[float]; a set of floats
|
|
d = {1: 'hi', 2: 'ola', 3: 'zdravo'} # type: Dict[int, str]; a dictionary of int to str
|
|
|
|
ln = [] # an empty list whose type is inferred based on usage
|
|
ln = List[int]() # an empty list with explicit element type
|
|
dn = {} # an empty dict whose type is inferred based on usage
|
|
dn = Dict[int, float]() # an empty dictionary with explicit element types
|
|
sn = set() # an empty set whose type is inferred based on usage
|
|
sn = Set[str]() # an empty set with explicit element type
|
|
```
|
|
|
|
Lists also take an optional `capacity` constructor argument, which can be useful
|
|
when creating large lists:
|
|
|
|
``` python
|
|
squares = list(capacity=1_000_000) # list with room for 1M elements
|
|
|
|
# Fill the list
|
|
for i in range(1_000_000):
|
|
squares.append(i ** 2)
|
|
```
|
|
|
|
{% hint style="info" %}
|
|
Dictionaries and sets are unordered and are based on [klib](https://github.com/attractivechaos/klib).
|
|
{% endhint %}
|
|
|
|
# Comprehensions
|
|
|
|
Comprehensions are a nifty, Pythonic way to create collections, and are fully
|
|
supported by Codon:
|
|
|
|
``` python
|
|
l = [i for i in range(5)] # type: List[int]; l is [0, 1, 2, 3, 4]
|
|
l = [i for i in range(15) if i % 2 == 1 if i > 10] # type: List[int]; l is [11, 13]
|
|
l = [i * j for i in range(5) for j in range(5) if i == j] # l is [0, 1, 4, 9, 16]
|
|
|
|
s = {abs(i - j) for i in range(5) for j in range(5)} # s is {0, 1, 2, 3, 4}
|
|
d = {i: f'item {i+1}' for i in range(3)} # d is {0: "item 1", 1: "item 2", 2: "item 3"}
|
|
```
|
|
|
|
You can also use generators to create collections:
|
|
|
|
``` python
|
|
g = (i for i in range(10))
|
|
print(list(g)) # prints list of integers from 0 to 9, inclusive
|
|
```
|
|
|
|
# Tuples
|
|
|
|
``` python
|
|
t = (1, 2.3, 'hi') # type: Tuple[int, float, str]
|
|
t[1] # type: float
|
|
u = (1, ) # type: Tuple[int]
|
|
```
|
|
|
|
As all types must be known at compile time, tuple indexing works only if
|
|
a tuple is homogenous (all types are the same) or if the value of the
|
|
index is known at compile time.
|
|
|
|
You can, however, iterate over heterogenous tuples in Codon. This is
|
|
achieved behind the scenes by unrolling the loop to accommodate the
|
|
different types.
|
|
|
|
``` python
|
|
t = (1, 2.3, 'hi')
|
|
t[1] # works because 1 is a constant int
|
|
|
|
x = int(argv[1])
|
|
t[x] # compile error: x is not known at compile time
|
|
|
|
# This is a homogenous tuple (all member types are the same)
|
|
u = (1, 2, 3) # type: Tuple[int, int, int]
|
|
u[x] # works because tuple members share the same type regardless of x
|
|
for i in u: # works
|
|
print(i)
|
|
|
|
# Also works
|
|
v = (42, 'x', 3.14)
|
|
for i in v:
|
|
print(i)
|
|
```
|
|
|
|
{% hint style="warning" %}
|
|
Just like in Python, tuples are immutable, so `a = (1, 2); a[1] = 1` will not compile.
|
|
{% endhint %}
|
|
|
|
Codon supports most of Python's tuple unpacking syntax:
|
|
|
|
``` python
|
|
x, y = 1, 2 # x is 1, y is 2
|
|
(x, (y, z)) = 1, (2, 3) # x is 1, y is 2, z is 3
|
|
[x, (y, z)] = (1, [2, 3]) # x is 1, y is 2, z is 3
|
|
|
|
l = range(1, 8) # l is [1, 2, 3, 4, 5, 6, 7]
|
|
a, b, *mid, c = l # a is 1, b is 2, mid is [3, 4, 5, 6], c is 7
|
|
a, *end = l # a is 1, end is [2, 3, 4, 5, 6, 7]
|
|
*beg, c = l # c is 7, beg is [1, 2, 3, 4, 5, 6]
|
|
(*x, ) = range(3) # x is [0, 1, 2]
|
|
*x = range(3) # error: this does not work
|
|
|
|
*sth, a, b = (1, 2, 3, 4) # sth is (1, 2), a is 3, b is 4
|
|
*sth, a, b = (1.1, 2, 3.3, 4) # error: this only works on homogenous tuples for now
|
|
|
|
(x, y), *pff, z = [1, 2], 'this'
|
|
print(x, y, pff, z) # x is 1, y is 2, pff is an empty tuple --- () ---, and z is "this"
|
|
|
|
s, *q = 'XYZ' # works on strings as well; s is "X" and q is "YZ"
|
|
```
|
|
|
|
# Strong typing
|
|
|
|
Because Codon is strongly typed, these won't compile:
|
|
|
|
``` python
|
|
l = [1, 's'] # is it a List[int] or List[str]? you cannot mix-and-match types
|
|
d = {1: 'hi'}
|
|
d[2] = 3 # d is a Dict[int, str]; the assigned value must be a str
|
|
|
|
t = (1, 2.2) # Tuple[int, float]
|
|
lt = list(t) # compile error: t is not homogenous
|
|
|
|
lp = [1, 2.1, 3, 5] # compile error: Codon will not automatically cast a float to an int
|
|
```
|
|
|
|
This will work, though:
|
|
|
|
``` python
|
|
u = (1, 2, 3)
|
|
lu = list(u) # works: u is homogenous
|
|
```
|