|
01:49
discord-raku-bot left,
discord-raku-bot joined
01:53
gfldex left
01:57
gfldex joined
03:05
frost joined
04:21
frost left
04:37
guifa joined
05:23
frost joined
06:37
frost left
06:40
frost joined
07:16
frost left
07:28
frost joined
07:34
frost left
08:07
dakkar joined
10:21
qorg11 left
12:46
destroycomputers left,
discord-raku-bot left,
discord-raku-bot joined,
destroycomputers joined
16:39
dakkar left
|
|||
| stevied | what is the comma doing in this line? `my @out = [ [@in.shift], ];` | 20:07 | |
| MasterDuke | make a list of lists, see the single arg rule in the docs | 20:08 | |
| stevied | it's creating an array within an array but I'm not sure how | 20:09 | |
| MasterDuke | the , | ||
| stevied | ok, this here: docs.raku.org/syntax/Single%20Argument%20Rule | 20:13 | |
| haven't seen this before | |||
| why doesn't `my @array = [ 1, ];` create an array within the @array? | 20:19 | ||
| MasterDuke | there's only one level there, `my @array = [ [1], ];` would make two | 20:21 | |
| m: my @a = [ [1,2], ]; say @a.elems; say @a[0].elems | 20:22 | ||
| camelia | 1 2 |
||
| stevied | i'm confused. why doesn't [ [ 1 ] ] create an array in an array? | 20:25 | |
| MasterDuke | because commas create lists/arrays, not [] or () | 20:27 | |
| stevied | no matter how many square brackets I use, it's always just on element in an array | ||
| ok, i see my confusion now. the outer brackets in `[ [@in.shift], ]` are superfluous | 20:29 | ||
| don't need them | |||
| thanks | 20:30 | ||
| MasterDuke | np | ||
|
20:43
qorg11 joined
|
|||
| Nemokosch | interesting | 21:01 | |
| stevied | ok, got this: | 23:03 | |
| ``` | |||
| multi blah ($string) { | |||
| $string = 3; | |||
| } | |||
| multi blah (@array) { | |||
| @array.shift; | |||
| } | |||
| my @array = 1, 2, 3; | |||
| blah @array; | |||
| say @array; | |||
| my $string = 'old'; | |||
| blah $string; | |||
| say $string; | |||
| the @array is actually changed by the function, which was unexpected | 23:04 | ||
| the string is immutable unless I do `is copy` | |||
| why is the array mutable and the string isn't? | |||
| guifa | that $string = 3 there should fail | 23:11 | |
| stevied | right, it does | ||
| guifa | @array.shift doesn't change the array in @array, it just tells @array to do something | 23:12 | |
| m: sub foo(@a) { @a.shift }; my @a = 1,2,3; say @a.WHICH; foo @a; say @a.WHICH; | 23:13 | ||
| camelia | Array|5485619587248 Array|5485619587248 |
||
| stevied | the `say @arrary` will print out [2, 3] | ||
| so it changed | |||
| guifa | If I put three balls in a bag, and take one out, is it the same bag? | ||
| stevied | yes. but why doesn't the bag stop you from taking balls out like with the string? | 23:15 | |
| the string is read only. I'm wondering why there is a different rule for the array. I can do anything I want to it and it changes outside the function. | |||
| I can do @array = 7 inside the `blah` function and it works | 23:17 | ||
| guifa | So it's a two part answer. | 23:19 | |
| But it revolves around the question of what we're changing. | 23:20 | ||
| And then also the assignment type (determined by the sigil) | |||
| MasterDuke | a very short answer is that an array is a container. you can't change the container itself, it's immutable like the string is in your example, but you can change its contents | 23:22 | |
| stevied | but I thought scalars were also containers | 23:23 | |
| Nemokosch | well, it seems like this abstraction is more disturbing than useful here | ||
| at the end of the day, the behavior is exactly the same as it would be in Javascript or Python | |||
| guifa | Nemokosch: almost | ||
| stevied | well, it's much different from perl | ||
| which is what I'm used to | |||
| guifa | m: sub foo (@x) { @x = 4,5,6 }; my @y = 1,2,3; foo @y; say @y; | 23:24 | |
| camelia | [4 5 6] | ||
| Nemokosch | an array is composit, even if you take it as a literal | ||
| guifa | ^^ that would be different in Javascript or Python, I believe | ||
| because they don't distinguish different types of assignments | 23:25 | ||
| Nemokosch | I don't think that could change with any sigil | ||
| and tbh I wouldn't consider this a feature in this context, more an anomaly | |||
| guifa | m: sub foo ($x) { $x = 4,5,6 }; my @y = 1,2,3; foo @y; say @y; | 23:26 | |
| camelia | Cannot assign to a readonly variable or a value in sub foo at <tmp> line 1 in block <unit> at <tmp> line 1 |
||
| Nemokosch | implicit "is rw" | ||
| the compiler does warn you about it of course, I mean that the @ sigil is always rw | 23:27 | ||
| is it even possible to make it readonly or something? | |||
| guifa | You can pass a list | ||
| m: sub foo (@x) { @x = 4,5,6 }; my @y is List = 1,2,3; foo @y; say @y; | 23:28 | ||
| camelia | Cannot modify an immutable Int (1) in sub foo at <tmp> line 1 in block <unit> at <tmp> line 1 |
||
| Nemokosch | okay but this fails because of the data passed, right? | 23:29 | |
| not because of the parameter | |||
| guifa | @x is read only regardless. The question is whether what's passed into X well allow itself to do anything. | 23:30 | |
| Nemokosch | if it's read only, how come you assign a value to it which it even keeps? | 23:31 | |
| stevied | that was my question, too | ||
| Nemokosch | which is btw in accordance with what Rakudo says | 23:32 | |
| guifa | Because @foo = is list assignment, and $foo = is scalar assignment, and they're subtly different | ||
| well, subtly different except here | |||
| Nemokosch | ie "you don't have to mark is rw on @ sigilled parameters" | 23:33 | |
| list assignment again... don't get me started | |||
| stevied | gotta go eat. I'll check back later. | 23:34 | |
| Nemokosch | eating is caring | ||
| I'm yet to see list assignment written down in a positive context | 23:36 | ||
| remember switching @a and @b? | 23:38 | ||
| m: my @a = 1, 2; my @b = 3, 4; (@a, @b) = (@b, @a); dd @a, @b; | 23:40 | ||
| big yikes | |||
| and unlike the famous JS [] == ![], this is a perfectly realistic scenario | 23:44 | ||
| m: my $a = [1, 2]; my $b = [3, 4]; ($a, $b) = ($b, $a); dd $a, $b; | 23:50 | ||
| see, it can be done | |||