<FromGitter>
<Blacksmoke16> sometimes i wish the type system would be a bit more forgiving in these cases
<FromGitter>
<Blacksmoke16> suppose you could do `Range(Float64?, Float64?).new(5.0, nil)` but :/
<FromGitter>
<watzon> Yeah that's kinda stupid
DTZUZO has quit [Ping timeout: 248 seconds]
ht_ has joined #crystal-lang
gangstacat has quit [Quit: Ĝis!]
<FromGitter>
<watzon> Well I just got cadmium separated into its own org (https://github.com/cadmiumcr). Now to get the main repo split into smaller pieces.
Vexatos has joined #crystal-lang
gangstacat has joined #crystal-lang
DTZUZO has joined #crystal-lang
alex`` has joined #crystal-lang
DTZUZO has quit [Ping timeout: 258 seconds]
DTZUZO has joined #crystal-lang
kazooie___ has joined #crystal-lang
kazooie___ has quit [Remote host closed the connection]
<FromGitter>
<asterite> suppose we made range mutable. In your code you would be able to put a nil inside that range. But in the range you pass that would be invalid. That's why the compiler will never allow that, unless we have a way to say that ranges can't mutate
kazooie___ has joined #crystal-lang
kazooie___ has quit [Client Quit]
kazooie___ has joined #crystal-lang
<livcd>
congrats @ multithreading PR
kazooie___ has left #crystal-lang [#crystal-lang]
kazooie___ has joined #crystal-lang
kazooie___ has quit [Client Quit]
kazooie___ has joined #crystal-lang
kazooie___ has quit [Client Quit]
kazooie___ has joined #crystal-lang
<FromGitter>
<kniknoo> Wait, so I CAN define a range's type? I was about to ask about this. I was doing a collatz up to 10_000_000 and it took me a bit to realize my input was overflowing silently. Casting worked fine, but it seems an overflow error should happen then.
kazooie___ has quit [Quit: Leaving]
<FromGitter>
<kniknoo> And speaking of which, I could use a hint of help with an exercism I'm doing. It's the Collatz. ⏎ Problem: I'm not used to class variables at all, I only use them when I WANT persistence. I'm running into "instance_vars not yet allowed..." . I'm following the advice to use class_vars but what I need is a counter for a single recursive call that will reset. What is my mindset here, figure out an intantiation
<FromGitter>
... trick or clear the variable based on a hook?
<FromGitter>
<tenebrousedge> I wouldn't use a class variable for that problem. I'm not sure what you're using it for
<FromGitter>
<tenebrousedge> I would normally work to avoid using them
<FromGitter>
<kniknoo> I am used to instance variables for what I want, but ⏎ "instance_vars are not yet allowed in metaclasses: use class_vars instead"
<FromGitter>
<kniknoo> If it wasn't for that it works perfect. A single pass yields the correct answer up to a U64, verified against other resources.
<FromGitter>
<kniknoo> I will study this. The "next" approach is definitely one I need to develop so that I can use the StringReader without approaching it wrong. Thank you!
<FromGitter>
<tenebrousedge> `Iterator` is a really nice part of Crystal. Do you use `Enumerator.new` in Ruby?
<FromGitter>
<kniknoo> I'm still very new to the approach, no. I'm still at that point where those are kind of magic so I only use them in their proscribed forms in blocks. My friend is strongarming me into clojure so I know I need to have the functional part of rb/cr down pat.
<FromGitter>
<tenebrousedge> well, my knee-jerk reaction / rule of thumb is that I want to be able to treat code like that as a collection. So the generating code may be complex, but the outside code can just take values as they come. It's also nice for lazily-evaluated code
<FromGitter>
<kniknoo> Ok, I see now. One sec, because I'd like a critique on a similar thing I did when I first started but I should make sure I add anything I've learned to it.
<FromGitter>
<kniknoo> This is how I talked people into checking out crystal. I showed doing 1 billion iterations of this and printing out the palindromes and showed it running in millisecond.
<FromGitter>
<tenebrousedge> that seems fine. You could turn that into an iterator
<FromGitter>
<kniknoo> Ok, I'll strt from there to get my head around the context. I appreciate it!
<FromGitter>
<tenebrousedge> and then do `random_words.take(10_000_000)`
<FromGitter>
<kniknoo> Ah, neat! Thanks again, I think I have my morning planned. :)
<FromGitter>
<tenebrousedge> or `random_words.select {|word| word == word.reverse}.take(10_000_000)`
<FromGitter>
<kniknoo> Here's the full script, minus the input for passes and word length. https://play.crystal-lang.org/#/r/7g4i You can tell I've mostly done rb/cr imperatively until recently. :D
sorcus has quit [Quit: WeeChat 2.5]
<FromGitter>
<tenebrousedge> `times` and `each` are iterators of last resort, for when there is no return value that could be useful
sorcus has joined #crystal-lang
<FromGitter>
<kniknoo> That's probably the worst habit I picked up from sonic pi. Because of how it's constructed, it precludes the use of any custom iterator or proc... or object for that matter. A shock to me when I wanted to try out the OOP I've been picking up.
<FromGitter>
<tenebrousedge> well, just take a minute when you use them and think, what else could be useful here? `each_with_object`/`reduce` being first up
<FromGitter>
<kniknoo> BUT, when you're generating music, you don't have time to see return values with 1000 lines of events. :D
<FromGitter>
<tenebrousedge> if you're working with I/O, you will be using `each`
<FromGitter>
<kniknoo> Yeah, that's been what I've been having to really start to grok since getting into exercism, it's helped, but I still have work to do to think in terms of functions.
<FromGitter>
<tenebrousedge> I'm not active as a Crystal mentor on Exercism right now, but do ping me if you want any input
<FromGitter>
<kniknoo> I have to remind myself to favor reduce over map in ruby now so I'm not caught up when map doesn't work.
<FromGitter>
<tenebrousedge> eh?
<FromGitter>
<kniknoo> Word, I submitted my bob last night. FINALLY...
<FromGitter>
<tenebrousedge> did you use regexes?
<FromGitter>
<kniknoo> map and reduce are equivalent, yeah?
<FromGitter>
<kniknoo> I did
<FromGitter>
<kniknoo> Most of what I know about regex has come from either Bob or parsing.
<FromGitter>
<tenebrousedge> `reduce` can be used to write any higher-level iterator
<FromGitter>
<kniknoo> Noted, I feel like Ruby teaches you they are interchangeable, but I'll not go with that mentality any further.
<FromGitter>
<kniknoo> I tried all day to understand string reader to maker a parser the other day, but in the end I had to resort to nexting out what I didn't want.
<FromGitter>
<tenebrousedge> try the `Forth` next, if you want a good weekend project (with some regex)
<FromGitter>
<kniknoo> ACTUALLY!!!
<FromGitter>
<tenebrousedge> it's an opportunity to use `Iterator` too
<FromGitter>
<kniknoo> My friend asked me to make a lisp to forth transpiler for her, so it's funny that that's a project. I just learned it the other day,nice little stack abstraction.
<FromGitter>
<kniknoo> Awesome! I was planning to do that today anyway because interpreting/transpiling is right where I'm focusing right now.
<FromGitter>
<tenebrousedge> I suppose lisp in forth would be better than the other way around
<FromGitter>
<tenebrousedge> my recommendation is to use a single hash as your dictionary
livcd has quit [Remote host closed the connection]
<FromGitter>
<kniknoo> Yep. She's arguing up and down that lisp is better because math and now I'm on a wild goose chase to build a lisp machine on a xilinx to show here that you need a real stack or more if you want lisp to matter on the hardware side.
<FromGitter>
<kniknoo> We're arguing over clojure vs ruby. The timeless battle...?
<FromGitter>
<tenebrousedge> Lisp would be perfect if everything in the world was made out of Lisp
<FromGitter>
<kniknoo> Yep
<FromGitter>
<kniknoo> That's my assesment. And then JVM is just an annoying abstraction vs getting LLVM everywhere.
<FromGitter>
<kniknoo> BUT, I slept to clojure tutorials all night and I could not distinguish much from ruby. :D
<FromGitter>
<kniknoo> YES, I tried to send it to her.
<FromGitter>
<kniknoo> She's a bit stubborn, close friend of Rich Hickie.
<FromGitter>
<kniknoo> She's coming around the more I show her metaprogramming ideas and how everything can be functional.
<FromGitter>
<Blacksmoke16> > suppose we made range mutable. In your code you would be able to put a nil inside that range. But in the range you pass that would be invalid. That's why the compiler will never allow that, unless we have a way to say that ranges can't mutate ⏎ ⏎ @asterite i wasn't proposing to make it mutable. just that if its typed to `Rante(Float64?, Float64?)` then it should allow `10.0..nil` since each of
<FromGitter>
... those is an allowed type within the union `Float64 | Nil`
<FromGitter>
<tenebrousedge> @kniknoo what do you like about Ruby's metaprogramming over Clojure? Where do you think Crystal stacks up?
<FromGitter>
<kniknoo> By that same token, I'm starting to appreciate our macros for what they are. Still some learning to go.
<FromGitter>
<kniknoo> Mostly the syntactic freedom. I understand the interest in homoiconicity, but it isn't the way I prefer to language.
<FromGitter>
<kniknoo> BUT, I'm very new to both, so my impressoin is cmpletely linguistic vs practical.
<FromGitter>
<tenebrousedge> have you read *Metaprogramming Ruby* ?
<FromGitter>
<kniknoo> No, I need to find a copy.
<FromGitter>
<kniknoo> I mean... I know I can and just did... adding to collection with a note to reimburse when I'm more gainfully employed. Thank you for he suggestion.
<FromGitter>
<tenebrousedge> @kniknoo are you planning on doing a bimodal interpreter or doing a first pass to expand symbols?
<FromGitter>
<asterite> Blacksmoke should that work if you pass a variable of that type instead?
<FromGitter>
<asterite> I mean, if you assign that first to a local variable and then pass it
<FromGitter>
<asterite> Nevermind, I guess it would make sense for that to work with literals, but it's hard to implement
<FromGitter>
<kalinon> Quick question. What does `!!` do?
<FromGitter>
<Blacksmoke16> Casts something to a boil
<FromGitter>
<Blacksmoke16> Bool
<FromGitter>
<kalinon> k thats what i figured, but wanted to double check
<FromGitter>
<kalinon> thank
<FromGitter>
<Blacksmoke16> @asterite yea, is minorly annoying. Oh well
<FromGitter>
<asterite> just not twice
<FromGitter>
<Blacksmoke16> Hm?
<FromGitter>
<asterite> !! is not twice, not a special operator
<FromGitter>
<asterite> oh, that reminded me to optimize that
livcd has joined #crystal-lang
dannyAAM has quit [Quit: znc.saru.moe : ZNC 1.6.2 - http://znc.in]
dannyAAM has joined #crystal-lang
DTZUZU has quit [Ping timeout: 245 seconds]
DTZUZU has joined #crystal-lang
<livcd>
Is that crystal multithreading usable in any way ?
<FromGitter>
<Blacksmoke16> dunno, maybe wait until the blog post?
<livcd>
ah ok
Groogy has joined #crystal-lang
<FromGitter>
<lagerfeuer> hi, I am new to Crystal and playing around with rn, and I have a question. ⏎ `ambiguous call, implicit cast of 5 matches all of Int64, Float64`. Can I somehow tell the compiler to not match für Float64 when I provide 5 as argument? ⏎ I tried to define a variable like `variable : String | Int64 | Float64`. ⏎ Or is this not possible and I have to use a union? [http
<FromGitter>
<watzon> Int literals default to Int32, while Floats default to Float64
<FromGitter>
<Blacksmoke16> defaults to int32
<FromGitter>
<watzon> There is some talk about changing this behavior
<FromGitter>
<watzon> I think @waj made an issue about it
<FromGitter>
<Blacksmoke16> so in this case when providing `5`, since it can be casted to two things, you have to be more specific
<FromGitter>
<sam0x17> imo if it defaulted to int64, i'd pretty much never have to convert int types
<FromGitter>
<lagerfeuer> ahhh okay, I see, thank you guys so much, you've been very helpful, I appreciate it :)
<FromGitter>
<watzon> Yeah the idea I think is to have the default type just be`Int` and then have `Int` be system specific, so on 32 bit systems it would be `Int32` and 64 bit systems would be `Int64` and then eventually have it default to `Int128`
<FromGitter>
<Blacksmoke16> np
<FromGitter>
<watzon> @lagerfeuer that's what we're here for :)
<FromGitter>
<lagerfeuer> > Yeah the idea I think is to have the default type just be`Int` and then have `Int` be system specific, so on 32 bit systems it would be `Int32` and 64 bit systems would be `Int64` and then eventually have it default to `Int128` ⏎ ⏎ that's why I thought it was gonna default to `Int64`, no biggie tho
<FromGitter>
<watzon> Yeah it just makes sense. Someday soon hopefully. Maybe by version 0.32.0 or something.
<FromGitter>
<watzon> Or maybe we'll finally get 1.0 before the end of next year 😂
<FromGitter>
<lagerfeuer> I've known about Crystal for a while but finally gave it a try with a new hobby project, since I've written ruby in the past, so far I like it so I'm excited what you guys are doing with it :)
<FromGitter>
<sam0x17> @watzon i hate when that's a thing tho -- I very much like having them as separate types, but the pain points for me are: ⏎ ⏎ 1) usually I want an `Int64` (solved by changing default type) ⏎ 2) I want `.to_i` to detect what it should be based on context, otherwise defaulting to `Int64` ⏎ 3) I still want separate `Int64` and `Int32` types that I know will have a certain number of bytes ...
<FromGitter>
<sam0x17> like I'm sure if someone is actually on a 32-bit system doing something weird, they won't mind explicitly using `Int32`
<FromGitter>
<sam0x17> would also be interesting to make the default type be user-configurable via a macro
<FromGitter>
<sam0x17> but that could mess up libraries
<FromGitter>
<watzon> Yeah I personally always think it's better if the behavior is predictable
<FromGitter>
<sam0x17> yup
<FromGitter>
<watzon> Having a system-specific type does mess with that
<FromGitter>
<watzon> As does having it be configurable
<FromGitter>
<sam0x17> but yeah like in a perfect world imo it would be like `to_i` => converts to int32 or int64 depending on context (defined via a macro, looks at how value is used to determine which type, otherwise defaults to Int64, formal type of the method would be `Int`), `to_i32` => `Int32`, `to_i64` => `Int64`, and `Int` = `Int64 | Int32` with really good autoboxing
<FromGitter>
<sam0x17> if I recall, VB.NET had my favorite handling of int types and operators ever, since you could overload / define any operator you want with different type parameters to define exactly how different situations are handled, like define what happens with `Int64` + `Int32` etc
<FromGitter>
<Blacksmoke16> pretty sure you can do that in crystal
<FromGitter>
<sam0x17> that's sort of what I thought
<FromGitter>
<Blacksmoke16> overloads with diff type restrictions
<FromGitter>
<Blacksmoke16> i.e.
<FromGitter>
<sam0x17> well that I know, but can you do that when defining `+` for example?
<FromGitter>
<sam0x17> so I should just define a ton of those and make it a shard xD
<FromGitter>
<sam0x17> and add an `alias Int = Int64 | Int32` type
rohitpaulk has joined #crystal-lang
<FromGitter>
<sam0x17> that would be compatible with all those overloads
<FromGitter>
<Blacksmoke16> not sure i see the point
<FromGitter>
<watzon> Is anyone aware of a webserver project in Crystal? Not like Kemal, but something like Apache, Nginx, and Caddy
<FromGitter>
<sam0x17> I think the philosophy so far has been "crystal is fast, so we don't need a meta web server"
<FromGitter>
<sam0x17> but I dunno
<FromGitter>
<watzon> Well even with speed there are certain things web servers like that are good for, like acting as a transparent proxy for multiple other servers
<FromGitter>
<watzon> I use Caddy on my VPS to proxy requests to the correct port, and to automatically manage SSL certificates using LetsEncrypt
<FromGitter>
<tenebrousedge> I like traefik as a proxy
<FromGitter>
<watzon> Oooh
<FromGitter>
<tenebrousedge> @watzon do you have a fairly docker-centric workflow?
<FromGitter>
<absolutejam_gitlab> traefik is nice for local testing
<FromGitter>
<absolutejam_gitlab> it's what i've set up for our local development environments
<FromGitter>
<absolutejam_gitlab> automatic proxying based on labels
<FromGitter>
<absolutejam_gitlab> Can't wait for traefik2 to be mature. tcp & udp proxying
<FromGitter>
<absolutejam_gitlab> I tried it and it requires TLS and SNI verification for TCP which I find a bit weird
<FromGitter>
<watzon> @tenebrousedge I don't, but I could definitely change that. Currently I'm doing deploys pretty manually and docker could definitely help me.
<FromGitter>
<absolutejam_gitlab> I've finally caved and I'm writing Golang
<FromGitter>
<absolutejam_gitlab> and i don't hate it
<FromGitter>
<absolutejam_gitlab> Yeah, I hate no collection methods
<FromGitter>
<tenebrousedge> I thought there was a similar package from hashicorp
<FromGitter>
<tenebrousedge> can't find it though
rohitpaulk has quit [Ping timeout: 248 seconds]
<FromGitter>
<absolutejam_gitlab> I kinda like it because it is what it is
<FromGitter>
<absolutejam_gitlab> It's powerful and the ecosystem is amazing
<FromGitter>
<absolutejam_gitlab> Docker, kubernetes, etc.
<FromGitter>
<absolutejam_gitlab> Libs, guides, info, etc. for everything
<FromGitter>
<absolutejam_gitlab> but at the same time, it's so super rigid
<FromGitter>
<tenebrousedge> I will go to any lengths to avoid writing `for` loops
<FromGitter>
<absolutejam_gitlab> like, you can declare a function type, but if you want to instantiate it, you have to instantiate the function via. its signature
<FromGitter>
<absolutejam_gitlab> not the type
<FromGitter>
<absolutejam_gitlab> and the 'whole capital first letter' for exported
<FromGitter>
<absolutejam_gitlab> seems lazy if anything
<FromGitter>
<absolutejam_gitlab> Even nim's `*` for exported is better
teardown has quit [Ping timeout: 258 seconds]
<FromGitter>
<absolutejam_gitlab> I have found myself falling into the trap of needless classes in Crystal
<FromGitter>
<absolutejam_gitlab> When a module & functions will do
<FromGitter>
<tenebrousedge> yes
<FromGitter>
<absolutejam_gitlab> I prefer a more functional style, unless I really want the tightly coupled state
<FromGitter>
<absolutejam_gitlab> it's an easy trap to fall into and hard to unravel once you have a lot of dependent state via. properties & methods
ht_ has quit [Quit: ht_]
<FromGitter>
<j8r> in fact there is no perfect language, and will never be
<FromGitter>
<tenebrousedge> Lisp is perfect, it's the real world that's the problem. Someone needs to rewrite reality in Lisp
<FromGitter>
<j8r> we have to take advantage of what the language is good to
<FromGitter>
<absolutejam_gitlab> Yeah, I'm not debating there's a perfect language
<FromGitter>
<absolutejam_gitlab> But there'd part of a lot of languages that are great and it's worth seeing if the can be incorporated
<FromGitter>
<absolutejam_gitlab> I'd love to use Crystal for everything if it was up there in the leagues of compatibility like python and go
<FromGitter>
<absolutejam_gitlab> As I think there's a lot more to it than serving http
alex`` has quit [Ping timeout: 248 seconds]
<FromGitter>
<sam0x17> I've been waiting to see if some figures out how to, say, make a library that automatically generates crystal bindings for packages in [insert more popular compiled ecosystem here]
<FromGitter>
<sam0x17> *someone
<FromGitter>
<sam0x17> and I dont mean like the way crystal lib works, I mean like include a reference to a cargo package and it gets "adapted" to be usable from crystal automatically via the tooling of this shard
<FromGitter>
<absolutejam_gitlab> the dream
<FromGitter>
<Blacksmoke16> Good luck
<FromGitter>
<Blacksmoke16> hmm, any other useful assertions i should add for initial release?