🦋 Welcome to the MAIN() IRC channel of the Raku Programming Language (raku.org). Log available at irclogs.raku.org/raku/live.html . If you're a beginner, you can also check out the #raku-beginner channel! Set by lizmat on 6 September 2022. |
|||
00:00
reportable6 left
00:02
reportable6 joined,
guifa joined
00:33
jmcgnh joined
01:03
xinming__ left
01:05
xinming__ joined
01:16
rf joined
|
|||
jaguart | ugexe: I have windows native, virtualbox, so can spin up a WIN vm if you want me to | 01:27 | |
ugexe | are you able to replicate any of these issues on them, i.e. not just on github actions? | 01:28 | |
jaguart | tonyo: there is a common but intermittant error installing TAP on 2022.12 | ||
I will give it a spin over the next couple of days and get back with the findings | 01:29 | ||
one fix at least we coud raise is the silent exception failure - i.e. there was no message as to why state was bad | 01:30 | ||
on a seperate question - anyone experience with running Raku on a Rocky Linux system with lots of cores? | 01:32 | ||
I think Rocky is RHEL community derivative | 01:33 | ||
rf | I have experience running on a SUSE machine | ||
If that's similar enough haha | |||
01:33
deoac left
|
|||
rf | They're both RHEL derivatives | 01:34 | |
jaguart | I have Debian'ed for years - but only with up to 64 cores, 128 threads. I'm thinking more a 180,000 core machine | 01:35 | |
hardware at one of the Uni's I'm looking at | |||
rf | Oof, is that GPU or cluster machines? | ||
Man TIL that you can chain that many CPUs together | 01:37 | ||
jaguart | checking spec: 145,000 CPU, 640 GPU, 560TB RAM | ||
01:37
perlbot left
|
|||
jaguart | but other papers say more cores now | 01:38 | |
rf | Run 145,000 instances of humming bird | ||
01:38
perlbot joined,
simcop2387 left
01:40
simcop2387 joined
|
|||
Nemokosch | 😼 | 01:42 | |
tonyo | jaguart: i don't have rocky but opensuse and my computer is a 24 core machine | 02:37 | |
oh, nvm, you're an order of magnitude past | 02:38 | ||
02:40
linkable6 left,
evalable6 left
02:42
evalable6 joined,
linkable6 joined
02:48
razetime joined
02:53
jgaz left
03:44
rf left
03:54
razetime left
04:38
heartburn left
04:39
razetime joined
04:41
heartburn joined
05:17
jaguart left
05:33
perlbot left
05:34
perlbot joined
06:00
reportable6 left,
reportable6 joined
06:12
jaguart joined
|
|||
jaguart | m: my Str $a="a"; given $a { default { say "def" }; when Str { say "str" } }; | 06:17 | |
camelia | def | ||
jaguart | this surprised me a bit - expected `default` to be checked last | ||
is it just sugar for `True`? | 06:18 | ||
Geth | ecosystem/main: 435f38edad | (Márton Polgár)++ (committed using GitHub Web editor) | META.list Time::Duration moved to fez Related to the discussion of github.com/dagurval/p6-Time-Duration/issues/14. @masukomi has taken over the module, updated the file to META6.json among other things, and published it on the "zef ecosystem". |
06:24 | |
ecosystem/main: 673510668e | (Juan Julián Merelo Guervós)++ (committed using GitHub Web editor) | META.list Merge pull request #612 from 2colours/patch-1 Time::Duration moved to fez |
|||
06:57
jmcgnh left
07:04
jmcgnh joined
07:21
abraxxa joined
07:26
abraxxa left,
abraxxa joined
|
|||
jaguart | inspecting an Attribute shows a method called `.dimensions` - can't find in docs - anyone know? | 07:46 | |
07:56
synthmeat1 left,
synthmeat joined
08:17
explorer joined
08:28
Sgeo left
|
|||
Voldenet | .dimensions sounds like something related to shaped arrays | 08:31 | |
jaguart | it's a method on Attribute... | 08:38 | |
09:05
ab5tract joined
09:14
dakkar joined
09:15
jpn joined
|
|||
Nemokosch | well, we could do some sourcery, no? | 09:26 | |
not saying that I'm moving mountains to recover File::Find but in addition to that discussion on Twitter in november, I did try to reach out to Tadeusz by email as well - no avail | 09:28 | ||
at this point I'm thinking that maybe I could just fork it? do you have any additional idea? | 09:29 | ||
09:52
razetime left
10:09
ab5tract left
10:32
ircuser joined
11:32
linkable6 left
11:34
linkable6 joined
12:00
reportable6 left,
reportable6 joined
13:00
reportable6 left,
unicodable6 left,
linkable6 left,
committable6 left,
shareable6 left,
benchable6 left,
notable6 left,
coverable6 left,
greppable6 left,
quotable6 left,
sourceable6 left,
squashable6 left,
bloatable6 left,
releasable6 left,
tellable6 left,
statisfiable6 left,
evalable6 left,
bisectable6 left
13:01
coverable6 joined,
releasable6 joined,
bloatable6 joined
|
|||
ugexe | Hmm, trying to install rakudo on Win11 ARM gives a gmake error after doing a bunch of stuff with gmake that makes it appear like it would have kept working - pastebin.com/Y6iePLsw | 13:01 | |
13:02
tellable6 joined,
shareable6 joined,
statisfiable6 joined,
evalable6 joined,
greppable6 joined,
unicodable6 joined
13:03
bisectable6 joined,
committable6 joined,
squashable6 joined,
reportable6 joined,
quotable6 joined,
benchable6 joined,
linkable6 joined,
sourceable6 joined,
notable6 joined
|
|||
ugexe | actually im guess I need to install nmake, and that gmake is only getting found from installing git | 13:09 | |
13:10
jgaz joined
13:13
david_ left
13:24
TieUpYourCamel joined
13:36
explorer left
13:37
explorer joined
13:46
Shaeto joined
13:48
razetime joined
14:01
razetime left
|
|||
Skarsnik | nmake is to work only with msvc I think? | 14:03 | |
15:01
linkable6 left,
evalable6 left,
rf joined,
evalable6 joined
|
|||
rf | Does anyone know if closures and blocks in Raku are boxed? | 15:02 | |
15:03
linkable6 joined
|
|||
Nemokosch | I for one don't know what boxing means 😅 | 15:05 | |
rf | Heap allocated basically | 15:06 | |
Just wondering how much performance I can expect using an effect driven system in Raku | |||
Mainly because Humming-Bird uses closures a lot | 15:07 | ||
15:16
epony left
|
|||
Nemokosch | this question probably requires some runtime-specific knowledge. All I know is that the best thing that can happen is inlining | 15:18 | |
rf | Yeah, I'm going to take a look at Moar this weekend and see if I can figure it out | 15:27 | |
15:34
Sgeo joined
|
|||
[Coke] | jaguart: I suspect that's a very particular attribute. Do you know what type it is? | 15:45 | |
ah, no, Attribute class itself has an attribute dimensions | 15:46 | ||
Looking at the source, I don't see that it *does* anything, though. :P | 15:47 | ||
16:08
jgaz left
|
|||
[Coke] | getting a segfault on a script that does "use JSON::Tiny; use lib '../raku-lib/'; use <a thing>; use <second thing>;' | 16:35 | |
all three modules seem to be required. | |||
this is on windows 2022.07 | |||
local stuff isn't using nativecall, pretty sure JSON::Tiny isn't | 16:38 | ||
had to remove the .precomp dir! | 16:39 | ||
Haven't had that situation in a while. Might have been due to a temporary upgrade to 2022.12 that I had to back out? | |||
ugexe | generally i think you'd want to have the `use lib '...'` first, although i dunno if thats related | 16:42 | |
16:43
razetime joined
|
|||
ugexe | otherwise you're loading a module, changing the repo chain, then trying to load other modules which themselves might try to load JSON::Tiny but now potentially from the `use lib '...'` source unlike the original import | 16:43 | |
rf | How is native call code distributed? If I want to ship some C code with Raku would I just use zef? | 16:55 | |
16:58
cfa joined
|
|||
cfa | 👋 | 16:59 | |
drakonis | humming-bird? | 17:00 | |
rf | ? | ||
drakonis | what's humming-bird again? | 17:01 | |
doesnt seem like you explained what that is | |||
rf | My web framework :^) | ||
drakonis | oh i see | ||
fair enough | |||
17:10
explorer left
17:36
razetime left
17:37
dakkar left
|
|||
ugexe | jaguart: github.com/rakudo/rakudo/issues/5168 | 17:51 | |
p6steve | rf: the raku module scheme, particularly Build.pm, offers some help with NativeCall and libraries docs.raku.org/language/modules | 17:53 | |
class Build { method build($dist-path) { chdir 'dan'; warn ' Building Rust Polars library (may take a few minutes).'; my $proc = Proc::Async.new: <cargo build>; $proc.bind-stdout($*ERR); my $promise = $proc.start; await $promise; chdir '..'; mkdir 'resources'; mkdir 'resources/libraries'; move | |||
'dan/target/debug/libdan.so', 'resources/libraries/libdan.so'; warn 'Build successful'; exit 0 } } | |||
this is my latest effort from github.com/p6steve/raku-Dan-Polars...n/Build.pm | 17:54 | ||
ugexe | Build.pm might go away one day (we've been saying forever). ideally one does what Inline::Perl5 does and uses github.com/niner/Inline-Perl5/blob...on#L58-L68 | ||
p6steve | so it calls 'cargo build' (since this is rust) and then sticks the newly minted SO into the right dir | 17:55 | |
ugexe | this way its declarative, i.e. an installer like zef can look at the meta data without having to extract the archive just to determine if there is a build step | ||
rf | I see, thanks for this! | 17:56 | |
p6steve | ugexe: looks very nice - maybe you could say it in the docs? since some of us haven't heard the message | 17:57 | |
ugexe | github.com/ugexe/zef#build-paths | 17:58 | |
p6steve | ugexe: since it takes a few minutes to build my SO would your method echo out line by line status...? | ||
ugexe | off the top of my head i dunno, but probably if --verbose or --debug | 17:59 | |
18:00
reportable6 left
|
|||
rf | Gonna play around and see if I can get a C++ FFI working, i'll make a repo for reference | 18:01 | |
18:01
reportable6 joined
|
|||
ugexe | if Distribution::Builder::MakeFromJSON doesn't do exactly what you need you can always create a new Distribution::Builder:: module that does | 18:03 | |
p6steve | yeah - or PR it ... look I made an issue in my own module (but probably will be a while before it gets to the top of the list) github.com/p6steve/raku-Dan-Polars/issues/9 | 18:04 | |
github.com/Raku/doc/issues/4186 | 18:07 | ||
rf | Is there a security problem regarding the fact that installing a module via fez is case-sensitive? | ||
Sorry for random, just thought of this while failing to install Mi6 on my new machine | 18:08 | ||
ugexe | how would that be a security issue and not the other way around? | 18:09 | |
rf | What if I make a module on zef that's app::mi6 that deletes your files? | ||
Nemokosch | also, there can be (and there are) dists with only a case difference | ||
rf | Or is uploading case sensitive? | ||
insensitive* | |||
ugexe | you can have two modules Foo and FOO, and they are treated as different | 18:10 | |
rf | So if app::mi6 were to come around vs. App::Mi6, I think this could be a security problem | 18:11 | |
ugexe | i mean in the same way that app::m6 is a security problem | ||
or App::M6 | |||
rf | I'm not sure those are the same | 18:12 | |
ugexe | you have to explicitly ask for "app::mi6" | ||
Nemokosch | it all boils down to how you feel about it | ||
ugexe | you cant ask for App::MI6 and maybe get app::mi6 | ||
Nemokosch | seems like quite a voluntaristic "security challenge" | ||
rf | Yeah I guess there is some give and take | 18:13 | |
18:14
Shaeto left
|
|||
rf | Just food for thought | 18:16 | |
[Coke] | ugexe: I tend to write 'use zef installed modules', 'use lib', 'use local stuff that isn't installed | ||
... see your line two. ok, makes sense. Was trying to do the right thing, but I see that it does potentially cause issues. | |||
ugexe | [Coke]: thats how i naturally do it as well, but i force myself to do what i described when i do catch myself | 18:17 | |
[Coke] | what about having something like { use JSON...; } later in the file to restrict scope of the included module? | 18:19 | |
ugexe | that doesn't change which one gets loaded | 18:20 | |
in both cases its essentially the same module, but loaded by a different repo | 18:23 | ||
tonyo | uploading is case sensitive | 18:39 | |
rf: fez addresses half of that issue. because the ecosystem is case sensitive and can have the same dist by multiple authors (eg three modules with the name `JSON` all with different dist strs: `JSON:auth<zef:tony-o>`,`JSON:auth<zef:tonyo>`...), the strictness in auth strs becomes more important | 18:42 | ||
rf | Makes sense! | 18:43 | |
tonyo | there was some talk of wiring in the module loaders to look at the meta json to determine stricter required dist strings and so you don' | 18:45 | |
t have to type `use JSON:auth<xxx>:ver<xxx>...` everywhere you want to use JSON in your lib but i don't know where that went | |||
rf | If I want to use native call does the library need to be compiled as a shared object? | 18:47 | |
My first time ever using any sort of FFI, so may be a dumb question | 18:48 | ||
tonyo: I like that, but more for selecting the install candidate | |||
tonyo | i don't believe so | 18:49 | |
rf | Missed a good pun, "I don't believe .so" ;D | 18:51 | |
p6steve | rf: yes | 18:54 | |
rf | ugexe: So for building via META6.json, can I just make it run a command or do I have to make a builder module for it | 19:00 | |
p6steve | rf: longer answer is that (i) i don't know, (ii) the POSIX example in the docs doesn't seem to need an explicit SO (I guess that linux has some defaults) and (iii) what I mean is that if you are writing code on the C side, then an SO seems like the obvious way to call it | 19:03 | |
rf | Yeah I'm writing C++, I'll give both a try and report back | ||
p6steve | docs.raku.org/language/nativecall#...rd_library | 19:13 | |
19:14
linkable6 left,
evalable6 left
19:16
linkable6 joined,
evalable6 joined
19:29
jpn left
19:42
cfa left
19:47
n1to joined
|
|||
tonyo | rf: heh, nice one | 19:53 | |
rf: this repo has an example of building from src during install github.com/tony-o/perl6-libyaml | 19:55 | ||
19:58
abraxxa left
|
|||
[Coke] is so happy his segfault was just a precomp issue. | 20:06 | ||
(I mean, still shouldn't happen, but at least I can run my code again) | 20:07 | ||
20:13
lichtkind joined
20:19
MoC joined
20:35
jgaz joined
20:49
Kernspin joined
20:55
Kernspin left
20:56
jpn joined
21:01
jpn left
|
|||
p6steve | anyone here with SO privileges | 21:07 | |
stackoverflow.com/questions/444174...puseragent | |||
i would vote for formal removal of that post and that author | |||
21:08
MoC left
|
|||
^ tonyo++ | 21:13 | ||
fwiw I'm a bit sceptical about a declarative build approach | 21:14 | ||
tonyo | that question was asked in 2017 | 21:17 | |
p6steve: in what way? | |||
tellable6 | tonyo, I'll pass your message to p6steve | ||
p6steve | seems like a lot of subtle steps needed to do a build ... | 21:23 | |
Distribution::Builder::MakeFromJSON uses information from your META6.json and the running system to fill variables in a Makefile.in template and build your distribution. | |||
BUT .. I am doing a cargo build | 21:24 | ||
21:25
jpn joined
|
|||
ugexe | is cargo the lowest common denominator we must support? | 21:26 | |
in that sense it doesn't really matter what you are doing outside of raku | |||
otherwise just include some script with your e.g. Distribution::Builder:: that can fill in a makefile.in | 21:27 | ||
then you run that to package your stuff for e.g. debian, cargo, whatever | |||
Here is what Build.pm is: download this archive file, and you also have to open that archive file to even know if you can install it because it might have a Build.pm and that Build.pm itself might do all sorts of random stuff | 21:28 | ||
that is somewhat the case with Distribution::Builder:: stuff as well in that it can do all sorts of random stuff, but we can potentially know some/all of it before extracting and authors can converge on known safe Distribution::Builder::s | 21:29 | ||
21:30
jpn left
|
|||
ugexe | building a Build.pm isn't straight forward either | 21:33 | |
rf | Speaking of those, I am writing one for CMake because I thought it would be fun | 21:34 | |
ugexe | it exists in the same directory as a META6.json but isn't declared as provided (because it isnt), so `raku -I. -e 'use Build; Build.new.build("whatever")'` wouldnt work | ||
rf | p6steve: It does need to be a .so, in the case of C++ at least | 21:35 | |
tellable6 | rf, I'll pass your message to p6steve | ||
ugexe | in short: Build.pm is great for module authors to easily do whatever they want on your system. its terrible for everyone else (module users, packagers, etc) | ||
p6steve | hmmm - I think that you are trying to solve a problem that doesn't exist | 21:37 | |
ugexe | i think you're confused; multiple people came together to solve this problem and come up with this solution. i actually implemented very little of it | ||
p6steve | if you want the author to build stuff to make a module reasonably easy, then use the module, otherwise, don't | 21:38 | |
Distribution::Builder:: is just moving the issue around | |||
ugexe | i find it hard to believe that in the last day you needed to figure out how to do this for the first time, and already you are certain the problem a given solution was designed to fix doesn't exist | 21:39 | |
21:40
jpn joined
|
|||
p6steve | I am not certain - and I defer to the judgement of those that know better | 21:42 | |
ugexe | design.raku.org/S22.html#Dependency_hints | 21:43 | |
mispaste^ | |||
Nemokosch | well the same design documents contained the concept of a "module recommender" or what it was, also they contained the concept of smartmatch on matches as "pick the rhs" and possibly other things that just don't seem to be worth protecting | 22:31 | |
cfa: are you around by any chance? | |||
22:33
Homer_Simpson joined
|
|||
Homer_Simpson | anyone know why this: my $fp = open "data.ldr", :r; | 22:33 | |
my @myarray = $fp.lines.map(*.comb.lines); | |||
prints 3 spaces when the file only has 1 | |||
print(ords(@myarray[0][])); # 49 32 32 32 54 | 22:34 | ||
22:36
jgaz left
|
|||
Nemokosch | pretty sure you converted a list to a string some way | 22:36 | |
Homer_Simpson | removin .lines doesnt help | 22:37 | |
removing* | |||
Nemokosch | you have a two-dimensional list, right? | 22:38 | |
ords operates on strings, not lists | |||
Homer_Simpson | i think so | ||
print is doing the same thing | |||
I used ords to try to print it as decimal | |||
because I didnt know how else to do that | 22:39 | ||
tonyo | we do have build requirements in the META iirc, warthog ended up in the META resolution, no ugexe ? | ||
Nemokosch | you should rather call ord on the individual elements | 22:40 | |
Homer_Simpson | I would like print to just print: 1 6 then newline | ||
not 1 6 then newline | |||
I thought the code was converting 1 6 into ('1',' ','6','\n') | 22:44 | ||
then thats one dimention, the next line would be the next dimention | |||
so that way I could index everything seperate as well as just do @myarray to print the whole array | 22:45 | ||
trying to print each element seperatley with ords give me a nil error | 22:46 | ||
Use of Nil in string context | |||
tonyo | Homer_Simpson: what's the data.ldr look like? | 22:50 | |
22:50
jpn left
22:51
cm left
|
|||
Homer_Simpson | 1 6 | 22:52 | |
3 8 | |||
5 10 | |||
tonyo | actually, ugexe , does it make sense for me tolook at extending the META resolution to also include build steps? | ||
m: my @array = "1 6\n3 8\n5 10".lines.map(*.comb.lines); dd @array; | |||
camelia | Array @array = [("1 6",).Seq, ("3 8",).Seq, ("5 1 0",).Seq] | ||
tonyo | m: my @array = "1 6\n3 8\n5 10".lines; dd @array; | 22:53 | |
camelia | Array @array = ["1 6", "3 8", "5 10"] | ||
tonyo | seems more like what you want | 22:54 | |
Homer_Simpson | the array is from a file | 22:55 | |
tonyo | so do $fp.lines | 22:57 | |
22:58
cm joined
|
|||
Homer_Simpson | I dont understand | 22:59 | |
my @myarray2 = $fp.lines; | 23:01 | ||
print(@myarray2[0][0]); # Use of uninitialized value element[0] of type Any in string context. | |||
tonyo | m: my @array = "1 6\n3 8\n5 10".lines.map(*.split(' ', 2)); dd @array; | 23:11 | |
camelia | Array @array = [("1", "6").Seq, ("3", "8").Seq, ("5", "10").Seq] | ||
tonyo | use $fp.lines.map(*.split(' ', 2)) | 23:12 | |
Homer_Simpson | well now you've just removed the spaces all together | 23:15 | |
so how is raku supposed to know the difference between 1 6 and 11 6 | 23:16 | ||
if theres no space | |||
and how does it differentiate between 1 6 without a space and 16 | 23:17 | ||
where tf is @lizmat | 23:19 | ||
this is going round in circles | |||
lizmat | you rang ? | 23:20 | |
Homer_Simpson | yeah | 23:21 | |
<Homer_Simpson> | |||
I would like print to just print: 1 6 then newline | |||
lizmat | please state the nature of the medical emergency | ||
Homer_Simpson | but the code is printing 1 6 (3 spaces) | 23:22 | |
lizmat | say "1 6" | ||
evalable6 | 1 6 | ||
Homer_Simpson | hold on | ||
tonyo | well, you're not being clear about what exactly you'd like, you want an array of numbers or an array of each ord or ... | ||
Homer_Simpson | my $fp = open "data.ldr", :r; | 23:23 | |
my @myarray = $fp.lines.map(*.comb.lines); | |||
print(ords(@myarray[0][])); # 49 32 32 32 54 | |||
I was using ords to make sure they were spaces indeed | |||
I was using print before | |||
lizmat | what do you think *.comb.lines does ? | 23:24 | |
Homer_Simpson | I assume it is chopping every character (*) into an array element | 23:25 | |
per line | |||
each line is another dimension in the array | 23:26 | ||
lizmat | first of all: you don't need if you're just reading lines | ||
Homer_Simpson | err wait | ||
lizmat | my @myarray = "data.ldr".IO.lines.map(*.comb) | ||
Homer_Simpson | the lines are in the 0th dimention the chars are in the 1st dimention | ||
lizmat | that would create an array with each character of each line (without newlines) | 23:27 | |
aha... ok | 23:29 | ||
my @myarray = "data.ldr".IO.lines.map(*.comb.List) | |||
disregard my first response :-) | 23:30 | ||
m: my @a = "abc\ndef\n".lines.map(*.comb.List); dd @a | 23:31 | ||
camelia | Array @a = [("a", "b", "c"), ("d", "e", "f")] | ||
lizmat | like that ? | ||
m: my @a = "abc\ndef\n".lines.map(*.comb.List); dd @a[0,1] | |||
camelia | ($("a", "b", "c"), $("d", "e", "f")) | ||
lizmat | m: my @a = "abc\ndef\n".lines.map(*.comb.List); dd @a[0;1] | ||
camelia | "b" | ||
Homer_Simpson | that works thx | 23:32 | |
but I need the newlines in | 23:33 | ||
and doing print(@array) prints 3 spaces again | 23:34 | ||
lizmat | m: my @a = "abc\ndef\n".lines(:!chomp).map(*.comb.List); dd @a[0;3] | ||
camelia | "\n" | ||
lizmat | m: my @a = "abc\ndef\n".lines(:!chomp).map(*.comb.List); print @a | 23:35 | |
camelia | a b c d e f |
||
lizmat | I don't see 3 spaces ? | ||
I see a space / newline / space | |||
but that's because you wanted the newlines | |||
Homer_Simpson | ill screendump | 23:36 | |
i.imgur.com/jKtxpag_d.webp?maxwidt...lity=grand | 23:38 | ||
lizmat | sorry, my system doesn't understand .webp | 23:39 | |
Homer_Simpson | ok 2 mins | ||
tonyo | if you just want the chars, why not split on '' | 23:40 | |
m: my @array = "1 6\n3 8\n5 10".lines.map(*.split('')); dd @array; | |||
camelia | Array @array = [("", "1", " ", "6", "").Seq, ("", "3", " ", "8", "").Seq, ("", "5", " ", "1", "0", "").Seq] | ||
tonyo | m: my @array = "1 6\n3 8\n5 10".lines.map(*.split('', :skip-empty)); dd @array; | 23:41 | |
camelia | Array @array = [("1", " ", "6").Seq, ("3", " ", "8").Seq, ("5", " ", "1", "0").Seq] | ||
Homer_Simpson | usercontent.irccloud-cdn.com/file/...j/hell.png | ||
tonyo | m: my @array = "1 6\n3 8\n5 10".lines.map(*.split('', :skip-empty)); dd @array; dd @array[0][0]; | ||
camelia | Array @array = [("1", " ", "6").Seq, ("3", " ", "8").Seq, ("5", " ", "1", "0").Seq] "1" |
||
tonyo | Homer_Simpson: if you want spaces preserved in the array try $fp.lines.map(*.split('',:skip-empty)) | ||
lizmat | this isn't about spaces in the source, but spaces in the output right ? | 23:42 | |
I wonder whether it is Comma is sort HTMLizing the output, so that the newline is just another whitespace ? | 23:43 | ||
Homer_Simpson | yes | ||
23:43
ispyhumanfly left
|
|||
Homer_Simpson | i think comma is being stupid | 23:43 | |
23:44
ispyhumanfly joined
|
|||
lizmat | what does the "data.ldr" file look like ? | 23:44 | |
Homer_Simpson | 1 6 | 23:45 | |
3 8 | |||
5 10 | |||
lizmat | m: aha, ok | ||
camelia | ===SORRY!=== Error while compiling <tmp> Undeclared routines: aha used at line 1 ok used at line 1 |
||
lizmat | m: my @a = "1 6\n3 8\n5 10\n".lines(*.comb.List); say @a | 23:46 | |
camelia | [1 6 3 8 5 10] | ||
lizmat | m: my @a = "1 6\n3 8\n5 10\n".lines(*.comb.List); print @a | ||
camelia | 1 6 3 8 5 10 | ||
lizmat | m: my @a = "1 6\n3 8\n5 10\n".lines(*.comb.List); dd @a | ||
camelia | Array @a = ["1 6", "3 8", "5 10"] | ||
Homer_Simpson | Cannot resolve caller Numeric(WhateverCode:D: ); none of these signatures matches: | 23:47 | |
(Mu:U \v: *%_) | |||
in block <unit> at .\new.raku line 2 | |||
lizmat | hmmm | ||
m: my @a = "1 6\n3 8\n5 10\n".lines.map(*.comb.List); print @a | 23:48 | ||
camelia | 1 6 3 8 5 1 0 | ||
lizmat | so that's the 3 spaces you were talking about | ||
Homer_Simpson | yeah that still prints it weird like before | 23:49 | |
i.e like in my screenshot | |||
lizmat | m: my @a = "1 6\n3 8\n5 10\n".lines.map(*.split(" ").List); say @a | ||
camelia | [(1 6) (3 8) (5 10)] | ||
lizmat | m: my @a = "1 6\n3 8\n5 10\n".lines.map(*.split(" ").List); print @a | 23:50 | |
camelia | 1 6 3 8 5 10 | ||
lizmat | sleep& | ||
Homer_Simpson | now I get 1 6 3 8 5 10 | 23:51 | |
my file is UTF8 I dont think that should be a problem though | 23:52 | ||
tonyo | guess it only works if lizmat types it | 23:53 | |
23:53
n1to left
|