00:47 <postmodern> is there a way of getting the encoding of a String ? I noticed you can call String#encode to encode the String into another encoding, but how do I determine the encoding of a String

00:49 <FromGitter> <Blacksmoke16> wouldnt it always be UTF-8

00:50 <FromGitter> <Blacksmoke16> `#encode` returns `Bytes` so yea...

00:53 <postmodern> hmm

00:54 <postmodern> so when you encode a String or create a String.new with an encoding, it really just converts back down to UTF-8 again?

00:54 <postmodern> also does String#tr not support "^\xHH-\xHH" char ranges?

00:55 <postmodern> trying to do `string.tr("^\x20-\x7e", ".")`

00:59 <FromGitter> <Blacksmoke16> idk about the converting part, is possible it just wouldnt be valid

01:00 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/String.html#non-utf-8-valid-strings

01:14 <postmodern> is there a better way than /[^[:print:]]/ for determining if a UTF-8 char is a printable char?

01:23 <FromGitter> <Blacksmoke16> what is the definition of `[:print:]`?

01:24 <FromGitter> <Blacksmoke16> i think you could just do like `!chr.control?`

01:24 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/Char.html#control?:Bool-instance-method

02:06 <postmodern> ah interesting

02:06 <postmodern> https://github.com/crystal-lang/crystal/blob/6d9a1d5830db5f276bf3df37fceeb0d5333e7e14/src/unicode/unicode.cr#L199 what does this check for?

02:09 <FromGitter> <Blacksmoke16> checks if the char is in any unicode control category

02:10 <postmodern> would that also include unknown unicode code points?

03:30 <FromGitter> <HertzDevil> what do you mean by "unknown"

03:32 <FromGitter> <HertzDevil> the General_Category of a code point is always "known" in the sense that all unassigned code points and non-characters have the value Cn

03:35 <FromGitter> <HertzDevil> though of course the same codepoint's General_Category could be changed as `Unicode::VERSION` increments (as we did a few days ago)

03:38 <FromGitter> <Dan-Do> when compiling a project with C binding, compiler said `undefined fun 'ejdb_init' for EJdb::LibEjdb` ⏎ The function is there in the lib `fun init = ejdb_init : Iwrc`. What else should be investigated?

04:11 <FromGitter> <Dan-Do> When compiling a project with C binding, it said ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ What should be investigated? [https://gitter.im/crystal-lang/crystal?at=6155390529ddcd0293f70dbb]

09:26 <FromGitter> <naqvis> you need to find which library have this method , then link that as well

09:28 <FromGitter> <naqvis> all you have to do is look into how your target library compiles or have external dependencies, then link them together

09:32 <FromGitter> <Dan-Do> That's so great! I solve it, we need to add more static files, like this ⏎ `@[Link(ldflags: "#{__DIR__}/lib_1.a #{__DIR__}/lib_2.a #{__DIR__}/.....a")]`

09:36 <FromGitter> <naqvis> 👍

09:47 <FromGitter> <Dan-Do> dump question ⏎ ⏎ ```code paste, see link``` ⏎ ⏎ error `argument 'ejdbp' of 'LibEjdb#close' must be Pointer(LibEjdb::Ejdb), not LibEjdb::Ejdb` [https://gitter.im/crystal-lang/crystal?at=615587c998c13e7550abce84]

09:50 <FromGitter> <Dan-Do> If I added `pointerof` to `LibEjdb.close(pointerof(@db))` the error went. This question is, in the lib, those two function's parameter `ejdbp` is declared the same `ejdbp : Ejdb*`, why in crystal we have to add `pointerof` at the `close`?

09:51 <FromGitter> <Dan-Do> The question is, in the lib, those two function's parameter `ejdbp` is declared the same `ejdbp : Ejdb*`, why in crystal we have to add `pointerof` at the `close`?

10:02 <FromGitter> <Dan-Do> Oops, found the answer at this link https://crystal-lang.org/reference/syntax_and_semantics/c_bindings/out.html

10:03 <FromGitter> <Dan-Do> out = pointerof

10:23 <FromGitter> <DRVTiny> How can i do this? ⏎ def proc1; end ⏎ puts proc1.class ⏎ ⏎ If all is an instance/class in Crystal - why named method is not object and... what is it in such case? [https://gitter.im/crystal-lang/crystal?at=6155903e7db1e3753e1505e9]

10:25 <FromGitter> <DRVTiny> I expect to have syntax like &procedure.class or &procedure.call(*arguments) , but that seems not possible at all

10:26 <FromGitter> <HertzDevil> `puts (->proc1).class`

10:26 <FromGitter> <HertzDevil> https://crystal-lang.org/reference/syntax_and_semantics/literals/proc.html#from-methods

10:28 <FromGitter> <DRVTiny> But Proc is a new object created from method. And what is method itself?

10:28 <FromGitter> <HertzDevil> what's the problem with that

10:32 <FromGitter> <DRVTiny> I want some proc that accepts name of other procs to call, such as ⏎ call_this_procs(proc1, proc2, proc3) ⏎ It is very frustraing syntax call_this_procs((->proc1), (->proc2), (->proc3)) for such simple thing ⏎ But... i can use macroses eventually... [https://gitter.im/crystal-lang/crystal?at=61559235ee6c260cf7f1c325]

10:33 <FromGitter> <DRVTiny> For example, in golang i can ⏎ func call_fns(fns ...func(int) int) { } ⏎ call_fns(func1, func2, func3)

10:34 <FromGitter> <HertzDevil> that's because they are functions, and methods are not functions

10:36 <FromGitter> <DRVTiny> But if Crystal is totally OOP-driven, then method of class is an instance of some class itself by definition ⏎ For example ⏎ class A; end ⏎ puts A.class ⏎ => Class [https://gitter.im/crystal-lang/crystal?at=61559327f2cedf67f95be33b]

10:36 <FromGitter> <DRVTiny> class itself is an instance of class "Class" :)

10:37 <FromGitter> <DRVTiny> But what is method? ;)

10:39 <FromGitter> <HertzDevil> but crystal never purports to be "totally oop-driven" in the first place

10:40 <FromGitter> <HertzDevil> such a method would not be quite the same thing as ruby's `Method` and `UnboundMethod`, as we have overloading

10:59 <FromGitter> <HertzDevil> in ruby it's even more cumbersome as you have to do `x.method(:f)` instead of `->x.f`

15:09 <FromGitter> <postmodern:matrix.org> er I meant unicode codepoints that do not map any visible character, but instead get printed as that square with the numbers in it. For example codepoint 888 or `͸`. Appears that `888.chr.control?` returns `false`, so I guess control only covers explicit control characters.

15:46 <postmodern> why can't you define a range of Chars in macros?

15:47 <postmodern> https://carc.in/#/r/bzau

15:55 <FromGitter> <jwaldrip:matrix.org> Any idea why generating a sha takes significantly more time on mac than it does in a dockerized version of crystal?

16:02 <FromGitter> <asterite> postmodern: because I didn't think someone would need that

16:06 <postmodern> got another one for you

16:06 <postmodern> why doesn't '☃' =~ /[[:print:]]/ match?

16:06 <postmodern> aka the unicode snowman character for those not using utf8 aware IRC clients

16:19 <FromGitter> <asterite> is that a string or a char?

16:19 <FromGitter> <asterite> it would only work for strings, char doesn't override `=~`

16:19 <postmodern> oh damn

16:23 <postmodern> to_s'ing the char doesn't seem to work. https://carc.in/#/r/bzbc

16:28 <FromGitter> <asterite> strange, maybe it's a pcre thing

16:30 <FromGitter> <asterite> "If the PCRE_UCP option is set, the ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=6155e61038377967f427e303]

16:30 <FromGitter> <asterite> Maybe we are not passing an option...

16:31 <FromGitter> <asterite> Yup, that's it

16:32 <FromGitter> <asterite> Could you report a bug? Mentioning that we need to use `PCRE_UCP` when compiling regexes (maybe when matching too, I don't know)

16:40 <postmodern> done