00:11 <raz> hmm, scala 3 looks quite tempting

00:11 <raz> just that java baggage.. ugh

00:12 <FromGitter> <mjfiano:matrix.org> It's a nice language, though not very usable for my domain

05:17 <FromGitter> <mjfiano:matrix.org> I remember reading in the docs or one of the tutorials a concise way to swap two bindings...anyone know?

05:20 <FromGitter> <mjfiano:matrix.org> Nevermind, found it

06:04 <FromGitter> <mjfiano:matrix.org> Anyone know what this means for a method? ⏎ ⏎ ```Metrics/CyclomaticComplexity: Cyclomatic complexity too high [12/10]``` [https://gitter.im/crystal-lang/crystal?at=6100f37ff4d1dc69f30ba78f]

08:25 <FromGitter> <mjfiano:matrix.org> Matrix math is tedious sometimes https://gist.github.com/mfiano/3ca4b4417cf8e818b68e14200e4e8742

08:25 <FromGitter> <mjfiano:matrix.org> insert @Blacksmoke16 emoji here

09:15 <yxhuvud> I'm .. fairly certain someone has implemented matrix math in some shard.

12:49 <FromGitter> <Blacksmoke16> Oof, i feel like there's a better way

13:03 <FromGitter> <Blacksmoke16> @mjfiano:matrix.org and that means that a method is too complex. See https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Metrics/CyclomaticComplexity

13:04 <FromGitter> <Blacksmoke16> is usually a sign that a method may need broken up into multiple methods, but some cases it's unavoidable so can manually disable that rule on the specific method

14:41 <FromGitter> <rayandfz> https://github.com/rayandfz/gazetteadmin/blob/dev/src/gazetteadmin/controllers/contact.cr how refacto this ? i learn crystal

14:41 <FromGitter> <Blacksmoke16> wew, gotta love a kemal controller :P

14:42 <FromGitter> <RespiteSage> @raz Where you asking why I'm restricting the generic type of `Saline::Saturating(T)` to `T < Number`?

14:42 <FromGitter> <RespiteSage> *were

15:44 <raz> already forgot what that was about, n/m

15:49 <riza> I did some fun matrix stuff in my experiments with qr codes a few years back https://github.com/tumblerlock/crystal_qr/tree/master/src/qr

15:49 <riza> not handy for arithmetic though

15:50 <riza> it allows you to do maxtrix[rowN..rowM][colA..colB] and get a reference matrix which can be iterated in a few different ways

15:50 <riza> the map for how data is injected into a qr code is a bit strange, but this allowed me to build a nice concise language to fill the matrix

15:51 <riza> https://github.com/tumblerlock/crystal_qr/blob/master/src/qr/code.cr#L50-L90

16:01 <riza> oh I forgot you could also do matrix[rowN..rowM, rowQ..rowR] too

20:03 <FromGitter> <MrSorcus> https://crystal-lang.org/conference/ - wow, so much videos from conference. Look like i found what to watch on next weekends 😆

20:33 <FromGitter> <mjfiano:matrix.org> @Blacksmoke16: How to manually disable that rule? Also, believe it or not, that warning is not for the method I linked, but a much less complex one

20:33 <FromGitter> <Blacksmoke16> something like `# ameba:disable Metrics/CyclomaticComplexity`

20:34 <FromGitter> <mjfiano:matrix.org> Interesting, though this warning didnt come from ameba

20:34 <FromGitter> <Blacksmoke16> are you sure

20:34 <FromGitter> <mjfiano:matrix.org> No, but it came from crystalline

20:34 <FromGitter> <Blacksmoke16> because thats deff an ameba warning

20:34 <FromGitter> <Blacksmoke16> sure its just not running ameba on change or something?

20:34 <FromGitter> <mjfiano:matrix.org> it shows up in my editor

20:35 <FromGitter> <mjfiano:matrix.org> not sure how it would call ameba unless it is built in to crystalline

20:37 <FromGitter> <Blacksmoke16> :shrug: i never used it

20:37 <FromGitter> <Blacksmoke16> but im pretty certain thats an ameba thing

21:19 <FromGitter> <HertzDevil> random thought: if some 1.0.0 code defines a type called `::Steppable`, wouldn't its addition in the stdlib be a breaking change

21:20 <FromGitter> <mjfiano:matrix.org> I wouldn't say so.

21:21 <FromGitter> <HertzDevil> from which it follows we cannot add *any* top-level type to the stdlib (if they reside in a namespace we could call them monkeypatching)

21:21 <straight-shoota> It's definitely a breaking change because it can break code that previously worked.

21:21 <FromGitter> <HertzDevil> starting to think this is why languages like c++ put everything under std

21:22 <FromGitter> <mjfiano:matrix.org> I think of breaking changes as API changes, not any monkey patching the user might do. Putting your own types in your own namespaces should be considered the good practice, if at all possible.

21:22 <FromGitter> <mjfiano:matrix.org> But it does break existing code

21:22 <FromGitter> <HertzDevil> "your own namespaces" still have a chance to conflict with crystal stdlib's top-level types

21:23 <straight-shoota> mjfiano: If you have a shard called `steppable`, it's not monkey patching. You would actually be a good citizen by putting everything in the `Steppable` namespace.

21:23 <FromGitter> <mjfiano:matrix.org> I do agree, and I found it odd that Crystal didn't have a stdlib namespace.

21:24 <FromGitter> <HertzDevil> more specifically, stdlib types defined in the default prelude

21:24 <straight-shoota> Yeah, that's an inheritance from Ruby

21:25 <straight-shoota> It's not just Ruby though. Many languages have stdlib types defined in the default namespace

21:26 <FromGitter> <HertzDevil> like if we add `::Quaternion` in the stdlib but don't require it in prelude.cr, it is unlikely any 1.0 code will break

21:26 <FromGitter> <mjfiano:matrix.org> Such as where I come from, Common Lisp, where it is (usually, depending on the implementation) a compile-time error for the user to use any toplevel symbols defined in that namespace in a user definition.

21:28 <straight-shoota> @HertzDevil: It's only safe if it's not related to any existing stdlib code. If it's required by `http.cr`, code that has `require "http"` could still break.

21:29 <straight-shoota> It might be easier to work around than if it's in the prelude. But not if `require "http"` is in a dependency.

21:42 <FromGitter> <RespiteSage> @mjfiano:matrix.org The problem with doing that in Crystal is that we can reopen classes and modify them (usually just to add methods). It's just really nice and convenient sometimes. One of the Crystal libraries I use most (currently internal to my company, unfortunately) lets you define physical quantities without having to keep track of the units, and I really love being able to define `length =

21:42 <FromGitter> ... 50.meters`.

21:43 <FromGitter> <mjfiano:matrix.org> Yes, I understand. CL can get away with it because it uses multiple dispatch : methods don't belong to types/classes.

21:44 <FromGitter> <RespiteSage> But there's definitely the tradeoff, because you (or any upstream or downstream dependencies) can really mess stuff up or (in the worst case) inject malicious logic into standard library calls.

21:44 <FromGitter> <mjfiano:matrix.org> That is a nice API though (units)

21:45 <FromGitter> <RespiteSage> Yeah, it is. A long-term goal I have is convincing my company to open-source it or writing my own version of it myself (since there are some quality-of-life features that I think would be nice for users in general but aren't necessary for our use cases).

21:46 <FromGitter> <RespiteSage> And it's *so* much better than using a naming scheme (e.g. `length_nm = 50`).

21:46 <FromGitter> <mjfiano:matrix.org> Scala iirc has a way to seal classes, though not sure how that might tie into a language like Crystal.

21:46 <FromGitter> <RespiteSage> I think there's an RFC about adding that to Crystal.

21:47 <FromGitter> <RespiteSage> I think there's some optimization or type inference benefit that was brought up.

21:48 <FromGitter> <mjfiano:matrix.org> Does that unit library do conversions, because domain analysis can often be difficult

21:48 <FromGitter> <mjfiano:matrix.org> ?

21:49 <FromGitter> <mjfiano:matrix.org> So many times I messed up distance/time conversions, like angular velocity

21:52 <FromGitter> <HertzDevil> if a user defines `Number#meters`, that's definitely considered monkeypatching by stdlib so the stdlib defining it would not be a breaking change

21:54 <FromGitter> <RespiteSage> Yeah. Currently we just define our own conversions (e.g. `Length#/(value : Timespan) : Velocity`), but eventually I'd like to support arbitrary derived units, since some values can have the same unit derivation but different meanings (e.g. `m**2/s` is identified as "Kinematic Viscosity" on Wikipedia, but that would also be the SI base unit for how fast someone painting a wall is working).

21:55 <FromGitter> <RespiteSage> @HertzDevil Yeah, I know. I was just using it as an example of why Crystal wouldn't want to suddenly disallow redefinition of standard library types.

21:56 <FromGitter> <RespiteSage> I.e. monkey patching isn't encouraged in general, but it's a useful feature in specific circumstances, so even apart from it being a huge breaking change we (or at least I) wouldn't want to disallow it on stdlib types.

21:58 <FromGitter> <mjfiano:matrix.org> I look forward to the open-sourcing/rewrite. Sounds like a nice tool

21:58 <FromGitter> <RespiteSage> Re the arbitrary derived units, that's just hard because it's important to me that the conversions between arbitrary derived units and specific derived units be type-safe, and that means doing some wacky stuff with generic types.

22:00 <FromGitter> <RespiteSage> If you're interested, this is as far as I got with the derived units a while back: https://carc.in/#/r/bnri

22:01 <FromGitter> <RespiteSage> The interface I have there is pretty ugly, but ideally it would mostly be under the hood in practice.

22:02 <FromGitter> <mjfiano:matrix.org> Yeah, I really wish that methods in macroland issue was resolved. Even if it is under the hood, code is read much more often than written, and it would make it a lot easier to understand imo.

22:03 <FromGitter> <RespiteSage> Also, here's that rfc I was talking about for sealed types: https://github.com/crystal-lang/crystal/issues/9116

22:03 <FromGitter> <mjfiano:matrix.org> In CL, it is considered bad practice to have large macros, since macros can call arbitrary methods at macro expansion time.